OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [varobj.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Implementation of the GDB variable objects API.
2
 
3
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4
   2009, 2010 Free Software Foundation, 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 "exceptions.h"
21
#include "value.h"
22
#include "expression.h"
23
#include "frame.h"
24
#include "language.h"
25
#include "wrapper.h"
26
#include "gdbcmd.h"
27
#include "block.h"
28
#include "valprint.h"
29
 
30
#include "gdb_assert.h"
31
#include "gdb_string.h"
32
#include "gdb_regex.h"
33
 
34
#include "varobj.h"
35
#include "vec.h"
36
#include "gdbthread.h"
37
#include "inferior.h"
38
 
39
#if HAVE_PYTHON
40
#include "python/python.h"
41
#include "python/python-internal.h"
42
#else
43
typedef int PyObject;
44
#endif
45
 
46
/* Non-zero if we want to see trace of varobj level stuff.  */
47
 
48
int varobjdebug = 0;
49
static void
50
show_varobjdebug (struct ui_file *file, int from_tty,
51
                  struct cmd_list_element *c, const char *value)
52
{
53
  fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
54
}
55
 
56
/* String representations of gdb's format codes */
57
char *varobj_format_string[] =
58
  { "natural", "binary", "decimal", "hexadecimal", "octal" };
59
 
60
/* String representations of gdb's known languages */
61
char *varobj_language_string[] = { "unknown", "C", "C++", "Java" };
62
 
63
/* True if we want to allow Python-based pretty-printing.  */
64
static int pretty_printing = 0;
65
 
66
void
67
varobj_enable_pretty_printing (void)
68
{
69
  pretty_printing = 1;
70
}
71
 
72
/* Data structures */
73
 
74
/* Every root variable has one of these structures saved in its
75
   varobj. Members which must be free'd are noted. */
76
struct varobj_root
77
{
78
 
79
  /* Alloc'd expression for this parent. */
80
  struct expression *exp;
81
 
82
  /* Block for which this expression is valid */
83
  struct block *valid_block;
84
 
85
  /* The frame for this expression.  This field is set iff valid_block is
86
     not NULL.  */
87
  struct frame_id frame;
88
 
89
  /* The thread ID that this varobj_root belong to.  This field
90
     is only valid if valid_block is not NULL.
91
     When not 0, indicates which thread 'frame' belongs to.
92
     When 0, indicates that the thread list was empty when the varobj_root
93
     was created.  */
94
  int thread_id;
95
 
96
  /* If 1, the -var-update always recomputes the value in the
97
     current thread and frame.  Otherwise, variable object is
98
     always updated in the specific scope/thread/frame  */
99
  int floating;
100
 
101
  /* Flag that indicates validity: set to 0 when this varobj_root refers
102
     to symbols that do not exist anymore.  */
103
  int is_valid;
104
 
105
  /* Language info for this variable and its children */
106
  struct language_specific *lang;
107
 
108
  /* The varobj for this root node. */
109
  struct varobj *rootvar;
110
 
111
  /* Next root variable */
112
  struct varobj_root *next;
113
};
114
 
115
/* Every variable in the system has a structure of this type defined
116
   for it. This structure holds all information necessary to manipulate
117
   a particular object variable. Members which must be freed are noted. */
118
struct varobj
119
{
120
 
121
  /* Alloc'd name of the variable for this object.. If this variable is a
122
     child, then this name will be the child's source name.
123
     (bar, not foo.bar) */
124
  /* NOTE: This is the "expression" */
125
  char *name;
126
 
127
  /* Alloc'd expression for this child.  Can be used to create a
128
     root variable corresponding to this child.  */
129
  char *path_expr;
130
 
131
  /* The alloc'd name for this variable's object. This is here for
132
     convenience when constructing this object's children. */
133
  char *obj_name;
134
 
135
  /* Index of this variable in its parent or -1 */
136
  int index;
137
 
138
  /* The type of this variable.  This can be NULL
139
     for artifial variable objects -- currently, the "accessibility"
140
     variable objects in C++.  */
141
  struct type *type;
142
 
143
  /* The value of this expression or subexpression.  A NULL value
144
     indicates there was an error getting this value.
145
     Invariant: if varobj_value_is_changeable_p (this) is non-zero,
146
     the value is either NULL, or not lazy.  */
147
  struct value *value;
148
 
149
  /* The number of (immediate) children this variable has */
150
  int num_children;
151
 
152
  /* If this object is a child, this points to its immediate parent. */
153
  struct varobj *parent;
154
 
155
  /* Children of this object.  */
156
  VEC (varobj_p) *children;
157
 
158
  /* Whether the children of this varobj were requested.  This field is
159
     used to decide if dynamic varobj should recompute their children.
160
     In the event that the frontend never asked for the children, we
161
     can avoid that.  */
162
  int children_requested;
163
 
164
  /* Description of the root variable. Points to root variable for children. */
165
  struct varobj_root *root;
166
 
167
  /* The format of the output for this object */
168
  enum varobj_display_formats format;
169
 
170
  /* Was this variable updated via a varobj_set_value operation */
171
  int updated;
172
 
173
  /* Last print value.  */
174
  char *print_value;
175
 
176
  /* Is this variable frozen.  Frozen variables are never implicitly
177
     updated by -var-update *
178
     or -var-update <direct-or-indirect-parent>.  */
179
  int frozen;
180
 
181
  /* Is the value of this variable intentionally not fetched?  It is
182
     not fetched if either the variable is frozen, or any parents is
183
     frozen.  */
184
  int not_fetched;
185
 
186
  /* Sub-range of children which the MI consumer has requested.  If
187
     FROM < 0 or TO < 0, means that all children have been
188
     requested.  */
189
  int from;
190
  int to;
191
 
192
  /* The pretty-printer constructor.  If NULL, then the default
193
     pretty-printer will be looked up.  If None, then no
194
     pretty-printer will be installed.  */
195
  PyObject *constructor;
196
 
197
  /* The pretty-printer that has been constructed.  If NULL, then a
198
     new printer object is needed, and one will be constructed.  */
199
  PyObject *pretty_printer;
200
 
201
  /* The iterator returned by the printer's 'children' method, or NULL
202
     if not available.  */
203
  PyObject *child_iter;
204
 
205
  /* We request one extra item from the iterator, so that we can
206
     report to the caller whether there are more items than we have
207
     already reported.  However, we don't want to install this value
208
     when we read it, because that will mess up future updates.  So,
209
     we stash it here instead.  */
210
  PyObject *saved_item;
211
};
212
 
213
struct cpstack
214
{
215
  char *name;
216
  struct cpstack *next;
217
};
218
 
219
/* A list of varobjs */
220
 
221
struct vlist
222
{
223
  struct varobj *var;
224
  struct vlist *next;
225
};
226
 
227
/* Private function prototypes */
228
 
229
/* Helper functions for the above subcommands. */
230
 
231
static int delete_variable (struct cpstack **, struct varobj *, int);
232
 
233
static void delete_variable_1 (struct cpstack **, int *,
234
                               struct varobj *, int, int);
235
 
236
static int install_variable (struct varobj *);
237
 
238
static void uninstall_variable (struct varobj *);
239
 
240
static struct varobj *create_child (struct varobj *, int, char *);
241
 
242
static struct varobj *
243
create_child_with_value (struct varobj *parent, int index, const char *name,
244
                         struct value *value);
245
 
246
/* Utility routines */
247
 
248
static struct varobj *new_variable (void);
249
 
250
static struct varobj *new_root_variable (void);
251
 
252
static void free_variable (struct varobj *var);
253
 
254
static struct cleanup *make_cleanup_free_variable (struct varobj *var);
255
 
256
static struct type *get_type (struct varobj *var);
257
 
258
static struct type *get_value_type (struct varobj *var);
259
 
260
static struct type *get_target_type (struct type *);
261
 
262
static enum varobj_display_formats variable_default_display (struct varobj *);
263
 
264
static void cppush (struct cpstack **pstack, char *name);
265
 
266
static char *cppop (struct cpstack **pstack);
267
 
268
static int install_new_value (struct varobj *var, struct value *value,
269
                              int initial);
270
 
271
/* Language-specific routines. */
272
 
273
static enum varobj_languages variable_language (struct varobj *var);
274
 
275
static int number_of_children (struct varobj *);
276
 
277
static char *name_of_variable (struct varobj *);
278
 
279
static char *name_of_child (struct varobj *, int);
280
 
281
static struct value *value_of_root (struct varobj **var_handle, int *);
282
 
283
static struct value *value_of_child (struct varobj *parent, int index);
284
 
285
static char *my_value_of_variable (struct varobj *var,
286
                                   enum varobj_display_formats format);
287
 
288
static char *value_get_print_value (struct value *value,
289
                                    enum varobj_display_formats format,
290
                                    struct varobj *var);
291
 
292
static int varobj_value_is_changeable_p (struct varobj *var);
293
 
294
static int is_root_p (struct varobj *var);
295
 
296
#if HAVE_PYTHON
297
 
298
static struct varobj *
299
varobj_add_child (struct varobj *var, const char *name, struct value *value);
300
 
301
#endif /* HAVE_PYTHON */
302
 
303
/* C implementation */
304
 
305
static int c_number_of_children (struct varobj *var);
306
 
307
static char *c_name_of_variable (struct varobj *parent);
308
 
309
static char *c_name_of_child (struct varobj *parent, int index);
310
 
311
static char *c_path_expr_of_child (struct varobj *child);
312
 
313
static struct value *c_value_of_root (struct varobj **var_handle);
314
 
315
static struct value *c_value_of_child (struct varobj *parent, int index);
316
 
317
static struct type *c_type_of_child (struct varobj *parent, int index);
318
 
319
static char *c_value_of_variable (struct varobj *var,
320
                                  enum varobj_display_formats format);
321
 
322
/* C++ implementation */
323
 
324
static int cplus_number_of_children (struct varobj *var);
325
 
326
static void cplus_class_num_children (struct type *type, int children[3]);
327
 
328
static char *cplus_name_of_variable (struct varobj *parent);
329
 
330
static char *cplus_name_of_child (struct varobj *parent, int index);
331
 
332
static char *cplus_path_expr_of_child (struct varobj *child);
333
 
334
static struct value *cplus_value_of_root (struct varobj **var_handle);
335
 
336
static struct value *cplus_value_of_child (struct varobj *parent, int index);
337
 
338
static struct type *cplus_type_of_child (struct varobj *parent, int index);
339
 
340
static char *cplus_value_of_variable (struct varobj *var,
341
                                      enum varobj_display_formats format);
342
 
343
/* Java implementation */
344
 
345
static int java_number_of_children (struct varobj *var);
346
 
347
static char *java_name_of_variable (struct varobj *parent);
348
 
349
static char *java_name_of_child (struct varobj *parent, int index);
350
 
351
static char *java_path_expr_of_child (struct varobj *child);
352
 
353
static struct value *java_value_of_root (struct varobj **var_handle);
354
 
355
static struct value *java_value_of_child (struct varobj *parent, int index);
356
 
357
static struct type *java_type_of_child (struct varobj *parent, int index);
358
 
359
static char *java_value_of_variable (struct varobj *var,
360
                                     enum varobj_display_formats format);
361
 
362
/* The language specific vector */
363
 
364
struct language_specific
365
{
366
 
367
  /* The language of this variable */
368
  enum varobj_languages language;
369
 
370
  /* The number of children of PARENT. */
371
  int (*number_of_children) (struct varobj * parent);
372
 
373
  /* The name (expression) of a root varobj. */
374
  char *(*name_of_variable) (struct varobj * parent);
375
 
376
  /* The name of the INDEX'th child of PARENT. */
377
  char *(*name_of_child) (struct varobj * parent, int index);
378
 
379
  /* Returns the rooted expression of CHILD, which is a variable
380
     obtain that has some parent.  */
381
  char *(*path_expr_of_child) (struct varobj * child);
382
 
383
  /* The ``struct value *'' of the root variable ROOT. */
384
  struct value *(*value_of_root) (struct varobj ** root_handle);
385
 
386
  /* The ``struct value *'' of the INDEX'th child of PARENT. */
387
  struct value *(*value_of_child) (struct varobj * parent, int index);
388
 
389
  /* The type of the INDEX'th child of PARENT. */
390
  struct type *(*type_of_child) (struct varobj * parent, int index);
391
 
392
  /* The current value of VAR. */
393
  char *(*value_of_variable) (struct varobj * var,
394
                              enum varobj_display_formats format);
395
};
396
 
397
/* Array of known source language routines. */
398
static struct language_specific languages[vlang_end] = {
399
  /* Unknown (try treating as C */
400
  {
401
   vlang_unknown,
402
   c_number_of_children,
403
   c_name_of_variable,
404
   c_name_of_child,
405
   c_path_expr_of_child,
406
   c_value_of_root,
407
   c_value_of_child,
408
   c_type_of_child,
409
   c_value_of_variable}
410
  ,
411
  /* C */
412
  {
413
   vlang_c,
414
   c_number_of_children,
415
   c_name_of_variable,
416
   c_name_of_child,
417
   c_path_expr_of_child,
418
   c_value_of_root,
419
   c_value_of_child,
420
   c_type_of_child,
421
   c_value_of_variable}
422
  ,
423
  /* C++ */
424
  {
425
   vlang_cplus,
426
   cplus_number_of_children,
427
   cplus_name_of_variable,
428
   cplus_name_of_child,
429
   cplus_path_expr_of_child,
430
   cplus_value_of_root,
431
   cplus_value_of_child,
432
   cplus_type_of_child,
433
   cplus_value_of_variable}
434
  ,
435
  /* Java */
436
  {
437
   vlang_java,
438
   java_number_of_children,
439
   java_name_of_variable,
440
   java_name_of_child,
441
   java_path_expr_of_child,
442
   java_value_of_root,
443
   java_value_of_child,
444
   java_type_of_child,
445
   java_value_of_variable}
446
};
447
 
448
/* A little convenience enum for dealing with C++/Java */
449
enum vsections
450
{
451
  v_public = 0, v_private, v_protected
452
};
453
 
454
/* Private data */
455
 
456
/* Mappings of varobj_display_formats enums to gdb's format codes */
457
static int format_code[] = { 0, 't', 'd', 'x', 'o' };
458
 
459
/* Header of the list of root variable objects */
460
static struct varobj_root *rootlist;
461
 
462
/* Prime number indicating the number of buckets in the hash table */
463
/* A prime large enough to avoid too many colisions */
464
#define VAROBJ_TABLE_SIZE 227
465
 
466
/* Pointer to the varobj hash table (built at run time) */
467
static struct vlist **varobj_table;
468
 
469
/* Is the variable X one of our "fake" children? */
470
#define CPLUS_FAKE_CHILD(x) \
471
((x) != NULL && (x)->type == NULL && (x)->value == NULL)
472
 
473
 
474
/* API Implementation */
475
static int
476
is_root_p (struct varobj *var)
477
{
478
  return (var->root->rootvar == var);
479
}
480
 
481
#ifdef HAVE_PYTHON
482
/* Helper function to install a Python environment suitable for
483
   use during operations on VAR.  */
484
struct cleanup *
485
varobj_ensure_python_env (struct varobj *var)
486
{
487
  return ensure_python_env (var->root->exp->gdbarch,
488
                            var->root->exp->language_defn);
489
}
490
#endif
491
 
492
/* Creates a varobj (not its children) */
493
 
494
/* Return the full FRAME which corresponds to the given CORE_ADDR
495
   or NULL if no FRAME on the chain corresponds to CORE_ADDR.  */
496
 
497
static struct frame_info *
498
find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
499
{
500
  struct frame_info *frame = NULL;
501
 
502
  if (frame_addr == (CORE_ADDR) 0)
503
    return NULL;
504
 
505
  for (frame = get_current_frame ();
506
       frame != NULL;
507
       frame = get_prev_frame (frame))
508
    {
509
      /* The CORE_ADDR we get as argument was parsed from a string GDB
510
         output as $fp.  This output got truncated to gdbarch_addr_bit.
511
         Truncate the frame base address in the same manner before
512
         comparing it against our argument.  */
513
      CORE_ADDR frame_base = get_frame_base_address (frame);
514
      int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
515
      if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
516
        frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
517
 
518
      if (frame_base == frame_addr)
519
        return frame;
520
    }
521
 
522
  return NULL;
523
}
524
 
525
struct varobj *
526
varobj_create (char *objname,
527
               char *expression, CORE_ADDR frame, enum varobj_type type)
528
{
529
  struct varobj *var;
530
  struct frame_info *fi;
531
  struct frame_info *old_fi = NULL;
532
  struct block *block;
533
  struct cleanup *old_chain;
534
 
535
  /* Fill out a varobj structure for the (root) variable being constructed. */
536
  var = new_root_variable ();
537
  old_chain = make_cleanup_free_variable (var);
538
 
539
  if (expression != NULL)
540
    {
541
      char *p;
542
      enum varobj_languages lang;
543
      struct value *value = NULL;
544
 
545
      /* Parse and evaluate the expression, filling in as much of the
546
         variable's data as possible.  */
547
 
548
      if (has_stack_frames ())
549
        {
550
          /* Allow creator to specify context of variable */
551
          if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
552
            fi = get_selected_frame (NULL);
553
          else
554
            /* FIXME: cagney/2002-11-23: This code should be doing a
555
               lookup using the frame ID and not just the frame's
556
               ``address''.  This, of course, means an interface
557
               change.  However, with out that interface change ISAs,
558
               such as the ia64 with its two stacks, won't work.
559
               Similar goes for the case where there is a frameless
560
               function.  */
561
            fi = find_frame_addr_in_frame_chain (frame);
562
        }
563
      else
564
        fi = NULL;
565
 
566
      /* frame = -2 means always use selected frame */
567
      if (type == USE_SELECTED_FRAME)
568
        var->root->floating = 1;
569
 
570
      block = NULL;
571
      if (fi != NULL)
572
        block = get_frame_block (fi, 0);
573
 
574
      p = expression;
575
      innermost_block = NULL;
576
      /* Wrap the call to parse expression, so we can
577
         return a sensible error. */
578
      if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
579
        {
580
          return NULL;
581
        }
582
 
583
      /* Don't allow variables to be created for types. */
584
      if (var->root->exp->elts[0].opcode == OP_TYPE)
585
        {
586
          do_cleanups (old_chain);
587
          fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
588
                              " as an expression.\n");
589
          return NULL;
590
        }
591
 
592
      var->format = variable_default_display (var);
593
      var->root->valid_block = innermost_block;
594
      var->name = xstrdup (expression);
595
      /* For a root var, the name and the expr are the same.  */
596
      var->path_expr = xstrdup (expression);
597
 
598
      /* When the frame is different from the current frame,
599
         we must select the appropriate frame before parsing
600
         the expression, otherwise the value will not be current.
601
         Since select_frame is so benign, just call it for all cases. */
602
      if (innermost_block)
603
        {
604
          /* User could specify explicit FRAME-ADDR which was not found but
605
             EXPRESSION is frame specific and we would not be able to evaluate
606
             it correctly next time.  With VALID_BLOCK set we must also set
607
             FRAME and THREAD_ID.  */
608
          if (fi == NULL)
609
            error (_("Failed to find the specified frame"));
610
 
611
          var->root->frame = get_frame_id (fi);
612
          var->root->thread_id = pid_to_thread_id (inferior_ptid);
613
          old_fi = get_selected_frame (NULL);
614
          select_frame (fi);
615
        }
616
 
617
      /* We definitely need to catch errors here.
618
         If evaluate_expression succeeds we got the value we wanted.
619
         But if it fails, we still go on with a call to evaluate_type()  */
620
      if (!gdb_evaluate_expression (var->root->exp, &value))
621
        {
622
          /* Error getting the value.  Try to at least get the
623
             right type.  */
624
          struct value *type_only_value = evaluate_type (var->root->exp);
625
          var->type = value_type (type_only_value);
626
        }
627
      else
628
        var->type = value_type (value);
629
 
630
      install_new_value (var, value, 1 /* Initial assignment */);
631
 
632
      /* Set language info */
633
      lang = variable_language (var);
634
      var->root->lang = &languages[lang];
635
 
636
      /* Set ourselves as our root */
637
      var->root->rootvar = var;
638
 
639
      /* Reset the selected frame */
640
      if (old_fi != NULL)
641
        select_frame (old_fi);
642
    }
643
 
644
  /* If the variable object name is null, that means this
645
     is a temporary variable, so don't install it. */
646
 
647
  if ((var != NULL) && (objname != NULL))
648
    {
649
      var->obj_name = xstrdup (objname);
650
 
651
      /* If a varobj name is duplicated, the install will fail so
652
         we must clenup */
653
      if (!install_variable (var))
654
        {
655
          do_cleanups (old_chain);
656
          return NULL;
657
        }
658
    }
659
 
660
  discard_cleanups (old_chain);
661
  return var;
662
}
663
 
664
/* Generates an unique name that can be used for a varobj */
665
 
666
char *
667
varobj_gen_name (void)
668
{
669
  static int id = 0;
670
  char *obj_name;
671
 
672
  /* generate a name for this object */
673
  id++;
674
  obj_name = xstrprintf ("var%d", id);
675
 
676
  return obj_name;
677
}
678
 
679
/* Given an OBJNAME, returns the pointer to the corresponding varobj.  Call
680
   error if OBJNAME cannot be found.  */
681
 
682
struct varobj *
683
varobj_get_handle (char *objname)
684
{
685
  struct vlist *cv;
686
  const char *chp;
687
  unsigned int index = 0;
688
  unsigned int i = 1;
689
 
690
  for (chp = objname; *chp; chp++)
691
    {
692
      index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
693
    }
694
 
695
  cv = *(varobj_table + index);
696
  while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
697
    cv = cv->next;
698
 
699
  if (cv == NULL)
700
    error (_("Variable object not found"));
701
 
702
  return cv->var;
703
}
704
 
705
/* Given the handle, return the name of the object */
706
 
707
char *
708
varobj_get_objname (struct varobj *var)
709
{
710
  return var->obj_name;
711
}
712
 
713
/* Given the handle, return the expression represented by the object */
714
 
715
char *
716
varobj_get_expression (struct varobj *var)
717
{
718
  return name_of_variable (var);
719
}
720
 
721
/* Deletes a varobj and all its children if only_children == 0,
722
   otherwise deletes only the children; returns a malloc'ed list of all the
723
   (malloc'ed) names of the variables that have been deleted (NULL terminated) */
724
 
725
int
726
varobj_delete (struct varobj *var, char ***dellist, int only_children)
727
{
728
  int delcount;
729
  int mycount;
730
  struct cpstack *result = NULL;
731
  char **cp;
732
 
733
  /* Initialize a stack for temporary results */
734
  cppush (&result, NULL);
735
 
736
  if (only_children)
737
    /* Delete only the variable children */
738
    delcount = delete_variable (&result, var, 1 /* only the children */ );
739
  else
740
    /* Delete the variable and all its children */
741
    delcount = delete_variable (&result, var, 0 /* parent+children */ );
742
 
743
  /* We may have been asked to return a list of what has been deleted */
744
  if (dellist != NULL)
745
    {
746
      *dellist = xmalloc ((delcount + 1) * sizeof (char *));
747
 
748
      cp = *dellist;
749
      mycount = delcount;
750
      *cp = cppop (&result);
751
      while ((*cp != NULL) && (mycount > 0))
752
        {
753
          mycount--;
754
          cp++;
755
          *cp = cppop (&result);
756
        }
757
 
758
      if (mycount || (*cp != NULL))
759
        warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
760
                 mycount);
761
    }
762
 
763
  return delcount;
764
}
765
 
766
#if HAVE_PYTHON
767
 
768
/* Convenience function for varobj_set_visualizer.  Instantiate a
769
   pretty-printer for a given value.  */
770
static PyObject *
771
instantiate_pretty_printer (PyObject *constructor, struct value *value)
772
{
773
  PyObject *val_obj = NULL;
774
  PyObject *printer;
775
 
776
  val_obj = value_to_value_object (value);
777
  if (! val_obj)
778
    return NULL;
779
 
780
  printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
781
  Py_DECREF (val_obj);
782
  return printer;
783
  return NULL;
784
}
785
 
786
#endif
787
 
788
/* Set/Get variable object display format */
789
 
790
enum varobj_display_formats
791
varobj_set_display_format (struct varobj *var,
792
                           enum varobj_display_formats format)
793
{
794
  switch (format)
795
    {
796
    case FORMAT_NATURAL:
797
    case FORMAT_BINARY:
798
    case FORMAT_DECIMAL:
799
    case FORMAT_HEXADECIMAL:
800
    case FORMAT_OCTAL:
801
      var->format = format;
802
      break;
803
 
804
    default:
805
      var->format = variable_default_display (var);
806
    }
807
 
808
  if (varobj_value_is_changeable_p (var)
809
      && var->value && !value_lazy (var->value))
810
    {
811
      xfree (var->print_value);
812
      var->print_value = value_get_print_value (var->value, var->format, var);
813
    }
814
 
815
  return var->format;
816
}
817
 
818
enum varobj_display_formats
819
varobj_get_display_format (struct varobj *var)
820
{
821
  return var->format;
822
}
823
 
824
char *
825
varobj_get_display_hint (struct varobj *var)
826
{
827
  char *result = NULL;
828
 
829
#if HAVE_PYTHON
830
  struct cleanup *back_to = varobj_ensure_python_env (var);
831
 
832
  if (var->pretty_printer)
833
    result = gdbpy_get_display_hint (var->pretty_printer);
834
 
835
  do_cleanups (back_to);
836
#endif
837
 
838
  return result;
839
}
840
 
841
/* Return true if the varobj has items after TO, false otherwise.  */
842
 
843
int
844
varobj_has_more (struct varobj *var, int to)
845
{
846
  if (VEC_length (varobj_p, var->children) > to)
847
    return 1;
848
  return ((to == -1 || VEC_length (varobj_p, var->children) == to)
849
          && var->saved_item != NULL);
850
}
851
 
852
/* If the variable object is bound to a specific thread, that
853
   is its evaluation can always be done in context of a frame
854
   inside that thread, returns GDB id of the thread -- which
855
   is always positive.  Otherwise, returns -1. */
856
int
857
varobj_get_thread_id (struct varobj *var)
858
{
859
  if (var->root->valid_block && var->root->thread_id > 0)
860
    return var->root->thread_id;
861
  else
862
    return -1;
863
}
864
 
865
void
866
varobj_set_frozen (struct varobj *var, int frozen)
867
{
868
  /* When a variable is unfrozen, we don't fetch its value.
869
     The 'not_fetched' flag remains set, so next -var-update
870
     won't complain.
871
 
872
     We don't fetch the value, because for structures the client
873
     should do -var-update anyway.  It would be bad to have different
874
     client-size logic for structure and other types.  */
875
  var->frozen = frozen;
876
}
877
 
878
int
879
varobj_get_frozen (struct varobj *var)
880
{
881
  return var->frozen;
882
}
883
 
884
/* A helper function that restricts a range to what is actually
885
   available in a VEC.  This follows the usual rules for the meaning
886
   of FROM and TO -- if either is negative, the entire range is
887
   used.  */
888
 
889
static void
890
restrict_range (VEC (varobj_p) *children, int *from, int *to)
891
{
892
  if (*from < 0 || *to < 0)
893
    {
894
      *from = 0;
895
      *to = VEC_length (varobj_p, children);
896
    }
897
  else
898
    {
899
      if (*from > VEC_length (varobj_p, children))
900
        *from = VEC_length (varobj_p, children);
901
      if (*to > VEC_length (varobj_p, children))
902
        *to = VEC_length (varobj_p, children);
903
      if (*from > *to)
904
        *from = *to;
905
    }
906
}
907
 
908
#if HAVE_PYTHON
909
 
910
/* A helper for update_dynamic_varobj_children that installs a new
911
   child when needed.  */
912
 
913
static void
914
install_dynamic_child (struct varobj *var,
915
                       VEC (varobj_p) **changed,
916
                       VEC (varobj_p) **new,
917
                       VEC (varobj_p) **unchanged,
918
                       int *cchanged,
919
                       int index,
920
                       const char *name,
921
                       struct value *value)
922
{
923
  if (VEC_length (varobj_p, var->children) < index + 1)
924
    {
925
      /* There's no child yet.  */
926
      struct varobj *child = varobj_add_child (var, name, value);
927
      if (new)
928
        {
929
          VEC_safe_push (varobj_p, *new, child);
930
          *cchanged = 1;
931
        }
932
    }
933
  else
934
    {
935
      varobj_p existing = VEC_index (varobj_p, var->children, index);
936
      if (install_new_value (existing, value, 0))
937
        {
938
          if (changed)
939
            VEC_safe_push (varobj_p, *changed, existing);
940
        }
941
      else if (unchanged)
942
        VEC_safe_push (varobj_p, *unchanged, existing);
943
    }
944
}
945
 
946
static int
947
dynamic_varobj_has_child_method (struct varobj *var)
948
{
949
  struct cleanup *back_to;
950
  PyObject *printer = var->pretty_printer;
951
  int result;
952
 
953
  back_to = varobj_ensure_python_env (var);
954
  result = PyObject_HasAttr (printer, gdbpy_children_cst);
955
  do_cleanups (back_to);
956
  return result;
957
}
958
 
959
#endif
960
 
961
static int
962
update_dynamic_varobj_children (struct varobj *var,
963
                                VEC (varobj_p) **changed,
964
                                VEC (varobj_p) **new,
965
                                VEC (varobj_p) **unchanged,
966
                                int *cchanged,
967
                                int update_children,
968
                                int from,
969
                                int to)
970
{
971
#if HAVE_PYTHON
972
  struct cleanup *back_to;
973
  PyObject *children;
974
  int i;
975
  PyObject *printer = var->pretty_printer;
976
 
977
  back_to = varobj_ensure_python_env (var);
978
 
979
  *cchanged = 0;
980
  if (!PyObject_HasAttr (printer, gdbpy_children_cst))
981
    {
982
      do_cleanups (back_to);
983
      return 0;
984
    }
985
 
986
  if (update_children || !var->child_iter)
987
    {
988
      children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
989
                                             NULL);
990
 
991
      if (!children)
992
        {
993
          gdbpy_print_stack ();
994
          error (_("Null value returned for children"));
995
        }
996
 
997
      make_cleanup_py_decref (children);
998
 
999
      if (!PyIter_Check (children))
1000
        error (_("Returned value is not iterable"));
1001
 
1002
      Py_XDECREF (var->child_iter);
1003
      var->child_iter = PyObject_GetIter (children);
1004
      if (!var->child_iter)
1005
        {
1006
          gdbpy_print_stack ();
1007
          error (_("Could not get children iterator"));
1008
        }
1009
 
1010
      Py_XDECREF (var->saved_item);
1011
      var->saved_item = NULL;
1012
 
1013
      i = 0;
1014
    }
1015
  else
1016
    i = VEC_length (varobj_p, var->children);
1017
 
1018
  /* We ask for one extra child, so that MI can report whether there
1019
     are more children.  */
1020
  for (; to < 0 || i < to + 1; ++i)
1021
    {
1022
      PyObject *item;
1023
 
1024
      /* See if there was a leftover from last time.  */
1025
      if (var->saved_item)
1026
        {
1027
          item = var->saved_item;
1028
          var->saved_item = NULL;
1029
        }
1030
      else
1031
        item = PyIter_Next (var->child_iter);
1032
 
1033
      if (!item)
1034
        break;
1035
 
1036
      /* We don't want to push the extra child on any report list.  */
1037
      if (to < 0 || i < to)
1038
        {
1039
          PyObject *py_v;
1040
          char *name;
1041
          struct value *v;
1042
          struct cleanup *inner;
1043
          int can_mention = from < 0 || i >= from;
1044
 
1045
          inner = make_cleanup_py_decref (item);
1046
 
1047
          if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
1048
            error (_("Invalid item from the child list"));
1049
 
1050
          v = convert_value_from_python (py_v);
1051
          install_dynamic_child (var, can_mention ? changed : NULL,
1052
                                 can_mention ? new : NULL,
1053
                                 can_mention ? unchanged : NULL,
1054
                                 can_mention ? cchanged : NULL, i, name, v);
1055
          do_cleanups (inner);
1056
        }
1057
      else
1058
        {
1059
          Py_XDECREF (var->saved_item);
1060
          var->saved_item = item;
1061
 
1062
          /* We want to truncate the child list just before this
1063
             element.  */
1064
          break;
1065
        }
1066
    }
1067
 
1068
  if (i < VEC_length (varobj_p, var->children))
1069
    {
1070
      int j;
1071
      *cchanged = 1;
1072
      for (j = i; j < VEC_length (varobj_p, var->children); ++j)
1073
        varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
1074
      VEC_truncate (varobj_p, var->children, i);
1075
    }
1076
 
1077
  /* If there are fewer children than requested, note that the list of
1078
     children changed.  */
1079
  if (to >= 0 && VEC_length (varobj_p, var->children) < to)
1080
    *cchanged = 1;
1081
 
1082
  var->num_children = VEC_length (varobj_p, var->children);
1083
 
1084
  do_cleanups (back_to);
1085
 
1086
  return 1;
1087
#else
1088
  gdb_assert (0 && "should never be called if Python is not enabled");
1089
#endif
1090
}
1091
 
1092
int
1093
varobj_get_num_children (struct varobj *var)
1094
{
1095
  if (var->num_children == -1)
1096
    {
1097
      if (var->pretty_printer)
1098
        {
1099
          int dummy;
1100
 
1101
          /* If we have a dynamic varobj, don't report -1 children.
1102
             So, try to fetch some children first.  */
1103
          update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy,
1104
                                          0, 0, 0);
1105
        }
1106
      else
1107
        var->num_children = number_of_children (var);
1108
    }
1109
 
1110
  return var->num_children >= 0 ? var->num_children : 0;
1111
}
1112
 
1113
/* Creates a list of the immediate children of a variable object;
1114
   the return code is the number of such children or -1 on error */
1115
 
1116
VEC (varobj_p)*
1117
varobj_list_children (struct varobj *var, int *from, int *to)
1118
{
1119
  struct varobj *child;
1120
  char *name;
1121
  int i, children_changed;
1122
 
1123
  var->children_requested = 1;
1124
 
1125
  if (var->pretty_printer)
1126
    {
1127
      /* This, in theory, can result in the number of children changing without
1128
         frontend noticing.  But well, calling -var-list-children on the same
1129
         varobj twice is not something a sane frontend would do.  */
1130
      update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed,
1131
                                      0, 0, *to);
1132
      restrict_range (var->children, from, to);
1133
      return var->children;
1134
    }
1135
 
1136
  if (var->num_children == -1)
1137
    var->num_children = number_of_children (var);
1138
 
1139
  /* If that failed, give up.  */
1140
  if (var->num_children == -1)
1141
    return var->children;
1142
 
1143
  /* If we're called when the list of children is not yet initialized,
1144
     allocate enough elements in it.  */
1145
  while (VEC_length (varobj_p, var->children) < var->num_children)
1146
    VEC_safe_push (varobj_p, var->children, NULL);
1147
 
1148
  for (i = 0; i < var->num_children; i++)
1149
    {
1150
      varobj_p existing = VEC_index (varobj_p, var->children, i);
1151
 
1152
      if (existing == NULL)
1153
        {
1154
          /* Either it's the first call to varobj_list_children for
1155
             this variable object, and the child was never created,
1156
             or it was explicitly deleted by the client.  */
1157
          name = name_of_child (var, i);
1158
          existing = create_child (var, i, name);
1159
          VEC_replace (varobj_p, var->children, i, existing);
1160
        }
1161
    }
1162
 
1163
  restrict_range (var->children, from, to);
1164
  return var->children;
1165
}
1166
 
1167
#if HAVE_PYTHON
1168
 
1169
static struct varobj *
1170
varobj_add_child (struct varobj *var, const char *name, struct value *value)
1171
{
1172
  varobj_p v = create_child_with_value (var,
1173
                                        VEC_length (varobj_p, var->children),
1174
                                        name, value);
1175
  VEC_safe_push (varobj_p, var->children, v);
1176
  return v;
1177
}
1178
 
1179
#endif /* HAVE_PYTHON */
1180
 
1181
/* Obtain the type of an object Variable as a string similar to the one gdb
1182
   prints on the console */
1183
 
1184
char *
1185
varobj_get_type (struct varobj *var)
1186
{
1187
  /* For the "fake" variables, do not return a type. (It's type is
1188
     NULL, too.)
1189
     Do not return a type for invalid variables as well.  */
1190
  if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1191
    return NULL;
1192
 
1193
  return type_to_string (var->type);
1194
}
1195
 
1196
/* Obtain the type of an object variable.  */
1197
 
1198
struct type *
1199
varobj_get_gdb_type (struct varobj *var)
1200
{
1201
  return var->type;
1202
}
1203
 
1204
/* Return a pointer to the full rooted expression of varobj VAR.
1205
   If it has not been computed yet, compute it.  */
1206
char *
1207
varobj_get_path_expr (struct varobj *var)
1208
{
1209
  if (var->path_expr != NULL)
1210
    return var->path_expr;
1211
  else
1212
    {
1213
      /* For root varobjs, we initialize path_expr
1214
         when creating varobj, so here it should be
1215
         child varobj.  */
1216
      gdb_assert (!is_root_p (var));
1217
      return (*var->root->lang->path_expr_of_child) (var);
1218
    }
1219
}
1220
 
1221
enum varobj_languages
1222
varobj_get_language (struct varobj *var)
1223
{
1224
  return variable_language (var);
1225
}
1226
 
1227
int
1228
varobj_get_attributes (struct varobj *var)
1229
{
1230
  int attributes = 0;
1231
 
1232
  if (varobj_editable_p (var))
1233
    /* FIXME: define masks for attributes */
1234
    attributes |= 0x00000001;   /* Editable */
1235
 
1236
  return attributes;
1237
}
1238
 
1239
int
1240
varobj_pretty_printed_p (struct varobj *var)
1241
{
1242
  return var->pretty_printer != NULL;
1243
}
1244
 
1245
char *
1246
varobj_get_formatted_value (struct varobj *var,
1247
                            enum varobj_display_formats format)
1248
{
1249
  return my_value_of_variable (var, format);
1250
}
1251
 
1252
char *
1253
varobj_get_value (struct varobj *var)
1254
{
1255
  return my_value_of_variable (var, var->format);
1256
}
1257
 
1258
/* Set the value of an object variable (if it is editable) to the
1259
   value of the given expression */
1260
/* Note: Invokes functions that can call error() */
1261
 
1262
int
1263
varobj_set_value (struct varobj *var, char *expression)
1264
{
1265
  struct value *val;
1266
  int offset = 0;
1267
  int error = 0;
1268
 
1269
  /* The argument "expression" contains the variable's new value.
1270
     We need to first construct a legal expression for this -- ugh! */
1271
  /* Does this cover all the bases? */
1272
  struct expression *exp;
1273
  struct value *value;
1274
  int saved_input_radix = input_radix;
1275
  char *s = expression;
1276
  int i;
1277
 
1278
  gdb_assert (varobj_editable_p (var));
1279
 
1280
  input_radix = 10;             /* ALWAYS reset to decimal temporarily */
1281
  exp = parse_exp_1 (&s, 0, 0);
1282
  if (!gdb_evaluate_expression (exp, &value))
1283
    {
1284
      /* We cannot proceed without a valid expression. */
1285
      xfree (exp);
1286
      return 0;
1287
    }
1288
 
1289
  /* All types that are editable must also be changeable.  */
1290
  gdb_assert (varobj_value_is_changeable_p (var));
1291
 
1292
  /* The value of a changeable variable object must not be lazy.  */
1293
  gdb_assert (!value_lazy (var->value));
1294
 
1295
  /* Need to coerce the input.  We want to check if the
1296
     value of the variable object will be different
1297
     after assignment, and the first thing value_assign
1298
     does is coerce the input.
1299
     For example, if we are assigning an array to a pointer variable we
1300
     should compare the pointer with the the array's address, not with the
1301
     array's content.  */
1302
  value = coerce_array (value);
1303
 
1304
  /* The new value may be lazy.  gdb_value_assign, or
1305
     rather value_contents, will take care of this.
1306
     If fetching of the new value will fail, gdb_value_assign
1307
     with catch the exception.  */
1308
  if (!gdb_value_assign (var->value, value, &val))
1309
    return 0;
1310
 
1311
  /* If the value has changed, record it, so that next -var-update can
1312
     report this change.  If a variable had a value of '1', we've set it
1313
     to '333' and then set again to '1', when -var-update will report this
1314
     variable as changed -- because the first assignment has set the
1315
     'updated' flag.  There's no need to optimize that, because return value
1316
     of -var-update should be considered an approximation.  */
1317
  var->updated = install_new_value (var, val, 0 /* Compare values. */);
1318
  input_radix = saved_input_radix;
1319
  return 1;
1320
}
1321
 
1322
#if HAVE_PYTHON
1323
 
1324
/* A helper function to install a constructor function and visualizer
1325
   in a varobj.  */
1326
 
1327
static void
1328
install_visualizer (struct varobj *var, PyObject *constructor,
1329
                    PyObject *visualizer)
1330
{
1331
  Py_XDECREF (var->constructor);
1332
  var->constructor = constructor;
1333
 
1334
  Py_XDECREF (var->pretty_printer);
1335
  var->pretty_printer = visualizer;
1336
 
1337
  Py_XDECREF (var->child_iter);
1338
  var->child_iter = NULL;
1339
}
1340
 
1341
/* Install the default visualizer for VAR.  */
1342
 
1343
static void
1344
install_default_visualizer (struct varobj *var)
1345
{
1346
  if (pretty_printing)
1347
    {
1348
      PyObject *pretty_printer = NULL;
1349
 
1350
      if (var->value)
1351
        {
1352
          pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1353
          if (! pretty_printer)
1354
            {
1355
              gdbpy_print_stack ();
1356
              error (_("Cannot instantiate printer for default visualizer"));
1357
            }
1358
        }
1359
 
1360
      if (pretty_printer == Py_None)
1361
        {
1362
          Py_DECREF (pretty_printer);
1363
          pretty_printer = NULL;
1364
        }
1365
 
1366
      install_visualizer (var, NULL, pretty_printer);
1367
    }
1368
}
1369
 
1370
/* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1371
   make a new object.  */
1372
 
1373
static void
1374
construct_visualizer (struct varobj *var, PyObject *constructor)
1375
{
1376
  PyObject *pretty_printer;
1377
 
1378
  Py_INCREF (constructor);
1379
  if (constructor == Py_None)
1380
    pretty_printer = NULL;
1381
  else
1382
    {
1383
      pretty_printer = instantiate_pretty_printer (constructor, var->value);
1384
      if (! pretty_printer)
1385
        {
1386
          gdbpy_print_stack ();
1387
          Py_DECREF (constructor);
1388
          constructor = Py_None;
1389
          Py_INCREF (constructor);
1390
        }
1391
 
1392
      if (pretty_printer == Py_None)
1393
        {
1394
          Py_DECREF (pretty_printer);
1395
          pretty_printer = NULL;
1396
        }
1397
    }
1398
 
1399
  install_visualizer (var, constructor, pretty_printer);
1400
}
1401
 
1402
#endif /* HAVE_PYTHON */
1403
 
1404
/* A helper function for install_new_value.  This creates and installs
1405
   a visualizer for VAR, if appropriate.  */
1406
 
1407
static void
1408
install_new_value_visualizer (struct varobj *var)
1409
{
1410
#if HAVE_PYTHON
1411
  /* If the constructor is None, then we want the raw value.  If VAR
1412
     does not have a value, just skip this.  */
1413
  if (var->constructor != Py_None && var->value)
1414
    {
1415
      struct cleanup *cleanup;
1416
      PyObject *pretty_printer = NULL;
1417
 
1418
      cleanup = varobj_ensure_python_env (var);
1419
 
1420
      if (!var->constructor)
1421
        install_default_visualizer (var);
1422
      else
1423
        construct_visualizer (var, var->constructor);
1424
 
1425
      do_cleanups (cleanup);
1426
    }
1427
#else
1428
  /* Do nothing.  */
1429
#endif
1430
}
1431
 
1432
/* Assign a new value to a variable object.  If INITIAL is non-zero,
1433
   this is the first assignement after the variable object was just
1434
   created, or changed type.  In that case, just assign the value
1435
   and return 0.
1436
   Otherwise, assign the new value, and return 1 if the value is different
1437
   from the current one, 0 otherwise. The comparison is done on textual
1438
   representation of value. Therefore, some types need not be compared. E.g.
1439
   for structures the reported value is always "{...}", so no comparison is
1440
   necessary here. If the old value was NULL and new one is not, or vice versa,
1441
   we always return 1.
1442
 
1443
   The VALUE parameter should not be released -- the function will
1444
   take care of releasing it when needed.  */
1445
static int
1446
install_new_value (struct varobj *var, struct value *value, int initial)
1447
{
1448
  int changeable;
1449
  int need_to_fetch;
1450
  int changed = 0;
1451
  int intentionally_not_fetched = 0;
1452
  char *print_value = NULL;
1453
 
1454
  /* We need to know the varobj's type to decide if the value should
1455
     be fetched or not.  C++ fake children (public/protected/private) don't have
1456
     a type. */
1457
  gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1458
  changeable = varobj_value_is_changeable_p (var);
1459
 
1460
  /* If the type has custom visualizer, we consider it to be always
1461
     changeable. FIXME: need to make sure this behaviour will not
1462
     mess up read-sensitive values.  */
1463
  if (var->pretty_printer)
1464
    changeable = 1;
1465
 
1466
  need_to_fetch = changeable;
1467
 
1468
  /* We are not interested in the address of references, and given
1469
     that in C++ a reference is not rebindable, it cannot
1470
     meaningfully change.  So, get hold of the real value.  */
1471
  if (value)
1472
    value = coerce_ref (value);
1473
 
1474
  if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1475
    /* For unions, we need to fetch the value implicitly because
1476
       of implementation of union member fetch.  When gdb
1477
       creates a value for a field and the value of the enclosing
1478
       structure is not lazy,  it immediately copies the necessary
1479
       bytes from the enclosing values.  If the enclosing value is
1480
       lazy, the call to value_fetch_lazy on the field will read
1481
       the data from memory.  For unions, that means we'll read the
1482
       same memory more than once, which is not desirable.  So
1483
       fetch now.  */
1484
    need_to_fetch = 1;
1485
 
1486
  /* The new value might be lazy.  If the type is changeable,
1487
     that is we'll be comparing values of this type, fetch the
1488
     value now.  Otherwise, on the next update the old value
1489
     will be lazy, which means we've lost that old value.  */
1490
  if (need_to_fetch && value && value_lazy (value))
1491
    {
1492
      struct varobj *parent = var->parent;
1493
      int frozen = var->frozen;
1494
      for (; !frozen && parent; parent = parent->parent)
1495
        frozen |= parent->frozen;
1496
 
1497
      if (frozen && initial)
1498
        {
1499
          /* For variables that are frozen, or are children of frozen
1500
             variables, we don't do fetch on initial assignment.
1501
             For non-initial assignemnt we do the fetch, since it means we're
1502
             explicitly asked to compare the new value with the old one.  */
1503
          intentionally_not_fetched = 1;
1504
        }
1505
      else if (!gdb_value_fetch_lazy (value))
1506
        {
1507
          /* Set the value to NULL, so that for the next -var-update,
1508
             we don't try to compare the new value with this value,
1509
             that we couldn't even read.  */
1510
          value = NULL;
1511
        }
1512
    }
1513
 
1514
 
1515
  /* Below, we'll be comparing string rendering of old and new
1516
     values.  Don't get string rendering if the value is
1517
     lazy -- if it is, the code above has decided that the value
1518
     should not be fetched.  */
1519
  if (value && !value_lazy (value) && !var->pretty_printer)
1520
    print_value = value_get_print_value (value, var->format, var);
1521
 
1522
  /* If the type is changeable, compare the old and the new values.
1523
     If this is the initial assignment, we don't have any old value
1524
     to compare with.  */
1525
  if (!initial && changeable)
1526
    {
1527
      /* If the value of the varobj was changed by -var-set-value, then the
1528
         value in the varobj and in the target is the same.  However, that value
1529
         is different from the value that the varobj had after the previous
1530
         -var-update. So need to the varobj as changed.  */
1531
      if (var->updated)
1532
        {
1533
          changed = 1;
1534
        }
1535
      else if (! var->pretty_printer)
1536
        {
1537
          /* Try to compare the values.  That requires that both
1538
             values are non-lazy.  */
1539
          if (var->not_fetched && value_lazy (var->value))
1540
            {
1541
              /* This is a frozen varobj and the value was never read.
1542
                 Presumably, UI shows some "never read" indicator.
1543
                 Now that we've fetched the real value, we need to report
1544
                 this varobj as changed so that UI can show the real
1545
                 value.  */
1546
              changed = 1;
1547
            }
1548
          else  if (var->value == NULL && value == NULL)
1549
            /* Equal. */
1550
            ;
1551
          else if (var->value == NULL || value == NULL)
1552
            {
1553
              changed = 1;
1554
            }
1555
          else
1556
            {
1557
              gdb_assert (!value_lazy (var->value));
1558
              gdb_assert (!value_lazy (value));
1559
 
1560
              gdb_assert (var->print_value != NULL && print_value != NULL);
1561
              if (strcmp (var->print_value, print_value) != 0)
1562
                changed = 1;
1563
            }
1564
        }
1565
    }
1566
 
1567
  if (!initial && !changeable)
1568
    {
1569
      /* For values that are not changeable, we don't compare the values.
1570
         However, we want to notice if a value was not NULL and now is NULL,
1571
         or vise versa, so that we report when top-level varobjs come in scope
1572
         and leave the scope.  */
1573
      changed = (var->value != NULL) != (value != NULL);
1574
    }
1575
 
1576
  /* We must always keep the new value, since children depend on it.  */
1577
  if (var->value != NULL && var->value != value)
1578
    value_free (var->value);
1579
  var->value = value;
1580
  if (value != NULL)
1581
    value_incref (value);
1582
  if (value && value_lazy (value) && intentionally_not_fetched)
1583
    var->not_fetched = 1;
1584
  else
1585
    var->not_fetched = 0;
1586
  var->updated = 0;
1587
 
1588
  install_new_value_visualizer (var);
1589
 
1590
  /* If we installed a pretty-printer, re-compare the printed version
1591
     to see if the variable changed.  */
1592
  if (var->pretty_printer)
1593
    {
1594
      xfree (print_value);
1595
      print_value = value_get_print_value (var->value, var->format, var);
1596
      if ((var->print_value == NULL && print_value != NULL)
1597
          || (var->print_value != NULL && print_value == NULL)
1598
          || (var->print_value != NULL && print_value != NULL
1599
              && strcmp (var->print_value, print_value) != 0))
1600
        changed = 1;
1601
    }
1602
  if (var->print_value)
1603
    xfree (var->print_value);
1604
  var->print_value = print_value;
1605
 
1606
  gdb_assert (!var->value || value_type (var->value));
1607
 
1608
  return changed;
1609
}
1610
 
1611
/* Return the requested range for a varobj.  VAR is the varobj.  FROM
1612
   and TO are out parameters; *FROM and *TO will be set to the
1613
   selected sub-range of VAR.  If no range was selected using
1614
   -var-set-update-range, then both will be -1.  */
1615
void
1616
varobj_get_child_range (struct varobj *var, int *from, int *to)
1617
{
1618
  *from = var->from;
1619
  *to = var->to;
1620
}
1621
 
1622
/* Set the selected sub-range of children of VAR to start at index
1623
   FROM and end at index TO.  If either FROM or TO is less than zero,
1624
   this is interpreted as a request for all children.  */
1625
void
1626
varobj_set_child_range (struct varobj *var, int from, int to)
1627
{
1628
  var->from = from;
1629
  var->to = to;
1630
}
1631
 
1632
void
1633
varobj_set_visualizer (struct varobj *var, const char *visualizer)
1634
{
1635
#if HAVE_PYTHON
1636
  PyObject *mainmod, *globals, *pretty_printer, *constructor;
1637
  struct cleanup *back_to, *value;
1638
 
1639
  back_to = varobj_ensure_python_env (var);
1640
 
1641
  mainmod = PyImport_AddModule ("__main__");
1642
  globals = PyModule_GetDict (mainmod);
1643
  Py_INCREF (globals);
1644
  make_cleanup_py_decref (globals);
1645
 
1646
  constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1647
 
1648
  if (! constructor)
1649
    {
1650
      gdbpy_print_stack ();
1651
      error (_("Could not evaluate visualizer expression: %s"), visualizer);
1652
    }
1653
 
1654
  construct_visualizer (var, constructor);
1655
  Py_XDECREF (constructor);
1656
 
1657
  /* If there are any children now, wipe them.  */
1658
  varobj_delete (var, NULL, 1 /* children only */);
1659
  var->num_children = -1;
1660
 
1661
  do_cleanups (back_to);
1662
#else
1663
  error (_("Python support required"));
1664
#endif
1665
}
1666
 
1667
/* Update the values for a variable and its children.  This is a
1668
   two-pronged attack.  First, re-parse the value for the root's
1669
   expression to see if it's changed.  Then go all the way
1670
   through its children, reconstructing them and noting if they've
1671
   changed.
1672
 
1673
   The EXPLICIT parameter specifies if this call is result
1674
   of MI request to update this specific variable, or
1675
   result of implicit -var-update *. For implicit request, we don't
1676
   update frozen variables.
1677
 
1678
   NOTE: This function may delete the caller's varobj. If it
1679
   returns TYPE_CHANGED, then it has done this and VARP will be modified
1680
   to point to the new varobj.  */
1681
 
1682
VEC(varobj_update_result) *varobj_update (struct varobj **varp, int explicit)
1683
{
1684
  int changed = 0;
1685
  int type_changed = 0;
1686
  int i;
1687
  int vleft;
1688
  struct varobj *v;
1689
  struct varobj **cv;
1690
  struct varobj **templist = NULL;
1691
  struct value *new;
1692
  VEC (varobj_update_result) *stack = NULL;
1693
  VEC (varobj_update_result) *result = NULL;
1694
  struct frame_info *fi;
1695
 
1696
  /* Frozen means frozen -- we don't check for any change in
1697
     this varobj, including its going out of scope, or
1698
     changing type.  One use case for frozen varobjs is
1699
     retaining previously evaluated expressions, and we don't
1700
     want them to be reevaluated at all.  */
1701
  if (!explicit && (*varp)->frozen)
1702
    return result;
1703
 
1704
  if (!(*varp)->root->is_valid)
1705
    {
1706
      varobj_update_result r = {0};
1707
      r.varobj = *varp;
1708
      r.status = VAROBJ_INVALID;
1709
      VEC_safe_push (varobj_update_result, result, &r);
1710
      return result;
1711
    }
1712
 
1713
  if ((*varp)->root->rootvar == *varp)
1714
    {
1715
      varobj_update_result r = {0};
1716
      r.varobj = *varp;
1717
      r.status = VAROBJ_IN_SCOPE;
1718
 
1719
      /* Update the root variable. value_of_root can return NULL
1720
         if the variable is no longer around, i.e. we stepped out of
1721
         the frame in which a local existed. We are letting the
1722
         value_of_root variable dispose of the varobj if the type
1723
         has changed.  */
1724
      new = value_of_root (varp, &type_changed);
1725
      r.varobj = *varp;
1726
 
1727
      r.type_changed = type_changed;
1728
      if (install_new_value ((*varp), new, type_changed))
1729
        r.changed = 1;
1730
 
1731
      if (new == NULL)
1732
        r.status = VAROBJ_NOT_IN_SCOPE;
1733
      r.value_installed = 1;
1734
 
1735
      if (r.status == VAROBJ_NOT_IN_SCOPE)
1736
        {
1737
          if (r.type_changed || r.changed)
1738
            VEC_safe_push (varobj_update_result, result, &r);
1739
          return result;
1740
        }
1741
 
1742
      VEC_safe_push (varobj_update_result, stack, &r);
1743
    }
1744
  else
1745
    {
1746
      varobj_update_result r = {0};
1747
      r.varobj = *varp;
1748
      VEC_safe_push (varobj_update_result, stack, &r);
1749
    }
1750
 
1751
  /* Walk through the children, reconstructing them all.  */
1752
  while (!VEC_empty (varobj_update_result, stack))
1753
    {
1754
      varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1755
      struct varobj *v = r.varobj;
1756
 
1757
      VEC_pop (varobj_update_result, stack);
1758
 
1759
      /* Update this variable, unless it's a root, which is already
1760
         updated.  */
1761
      if (!r.value_installed)
1762
        {
1763
          new = value_of_child (v->parent, v->index);
1764
          if (install_new_value (v, new, 0 /* type not changed */))
1765
            {
1766
              r.changed = 1;
1767
              v->updated = 0;
1768
            }
1769
        }
1770
 
1771
      /* We probably should not get children of a varobj that has a
1772
         pretty-printer, but for which -var-list-children was never
1773
         invoked.    */
1774
      if (v->pretty_printer)
1775
        {
1776
          VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0;
1777
          int i, children_changed = 0;
1778
 
1779
          if (v->frozen)
1780
            continue;
1781
 
1782
          if (!v->children_requested)
1783
            {
1784
              int dummy;
1785
 
1786
              /* If we initially did not have potential children, but
1787
                 now we do, consider the varobj as changed.
1788
                 Otherwise, if children were never requested, consider
1789
                 it as unchanged -- presumably, such varobj is not yet
1790
                 expanded in the UI, so we need not bother getting
1791
                 it.  */
1792
              if (!varobj_has_more (v, 0))
1793
                {
1794
                  update_dynamic_varobj_children (v, NULL, NULL, NULL,
1795
                                                  &dummy, 0, 0, 0);
1796
                  if (varobj_has_more (v, 0))
1797
                    r.changed = 1;
1798
                }
1799
 
1800
              if (r.changed)
1801
                VEC_safe_push (varobj_update_result, result, &r);
1802
 
1803
              continue;
1804
            }
1805
 
1806
          /* If update_dynamic_varobj_children returns 0, then we have
1807
             a non-conforming pretty-printer, so we skip it.  */
1808
          if (update_dynamic_varobj_children (v, &changed, &new, &unchanged,
1809
                                              &children_changed, 1,
1810
                                              v->from, v->to))
1811
            {
1812
              if (children_changed || new)
1813
                {
1814
                  r.children_changed = 1;
1815
                  r.new = new;
1816
                }
1817
              /* Push in reverse order so that the first child is
1818
                 popped from the work stack first, and so will be
1819
                 added to result first.  This does not affect
1820
                 correctness, just "nicer".  */
1821
              for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1822
                {
1823
                  varobj_p tmp = VEC_index (varobj_p, changed, i);
1824
                  varobj_update_result r = {0};
1825
                  r.varobj = tmp;
1826
                  r.changed = 1;
1827
                  r.value_installed = 1;
1828
                  VEC_safe_push (varobj_update_result, stack, &r);
1829
                }
1830
              for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1831
                {
1832
                  varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1833
                  if (!tmp->frozen)
1834
                    {
1835
                      varobj_update_result r = {0};
1836
                      r.varobj = tmp;
1837
                      r.value_installed = 1;
1838
                      VEC_safe_push (varobj_update_result, stack, &r);
1839
                    }
1840
                }
1841
              if (r.changed || r.children_changed)
1842
                VEC_safe_push (varobj_update_result, result, &r);
1843
 
1844
              /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1845
                 has been put into the result vector.  */
1846
              VEC_free (varobj_p, changed);
1847
              VEC_free (varobj_p, unchanged);
1848
 
1849
              continue;
1850
            }
1851
        }
1852
 
1853
      /* Push any children.  Use reverse order so that the first
1854
         child is popped from the work stack first, and so
1855
         will be added to result first.  This does not
1856
         affect correctness, just "nicer".  */
1857
      for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1858
        {
1859
          varobj_p c = VEC_index (varobj_p, v->children, i);
1860
          /* Child may be NULL if explicitly deleted by -var-delete.  */
1861
          if (c != NULL && !c->frozen)
1862
            {
1863
              varobj_update_result r = {0};
1864
              r.varobj = c;
1865
              VEC_safe_push (varobj_update_result, stack, &r);
1866
            }
1867
        }
1868
 
1869
      if (r.changed || r.type_changed)
1870
        VEC_safe_push (varobj_update_result, result, &r);
1871
    }
1872
 
1873
  VEC_free (varobj_update_result, stack);
1874
 
1875
  return result;
1876
}
1877
 
1878
 
1879
/* Helper functions */
1880
 
1881
/*
1882
 * Variable object construction/destruction
1883
 */
1884
 
1885
static int
1886
delete_variable (struct cpstack **resultp, struct varobj *var,
1887
                 int only_children_p)
1888
{
1889
  int delcount = 0;
1890
 
1891
  delete_variable_1 (resultp, &delcount, var,
1892
                     only_children_p, 1 /* remove_from_parent_p */ );
1893
 
1894
  return delcount;
1895
}
1896
 
1897
/* Delete the variable object VAR and its children */
1898
/* IMPORTANT NOTE: If we delete a variable which is a child
1899
   and the parent is not removed we dump core.  It must be always
1900
   initially called with remove_from_parent_p set */
1901
static void
1902
delete_variable_1 (struct cpstack **resultp, int *delcountp,
1903
                   struct varobj *var, int only_children_p,
1904
                   int remove_from_parent_p)
1905
{
1906
  int i;
1907
 
1908
  /* Delete any children of this variable, too. */
1909
  for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1910
    {
1911
      varobj_p child = VEC_index (varobj_p, var->children, i);
1912
      if (!child)
1913
        continue;
1914
      if (!remove_from_parent_p)
1915
        child->parent = NULL;
1916
      delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1917
    }
1918
  VEC_free (varobj_p, var->children);
1919
 
1920
  /* if we were called to delete only the children we are done here */
1921
  if (only_children_p)
1922
    return;
1923
 
1924
  /* Otherwise, add it to the list of deleted ones and proceed to do so */
1925
  /* If the name is null, this is a temporary variable, that has not
1926
     yet been installed, don't report it, it belongs to the caller... */
1927
  if (var->obj_name != NULL)
1928
    {
1929
      cppush (resultp, xstrdup (var->obj_name));
1930
      *delcountp = *delcountp + 1;
1931
    }
1932
 
1933
  /* If this variable has a parent, remove it from its parent's list */
1934
  /* OPTIMIZATION: if the parent of this variable is also being deleted,
1935
     (as indicated by remove_from_parent_p) we don't bother doing an
1936
     expensive list search to find the element to remove when we are
1937
     discarding the list afterwards */
1938
  if ((remove_from_parent_p) && (var->parent != NULL))
1939
    {
1940
      VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1941
    }
1942
 
1943
  if (var->obj_name != NULL)
1944
    uninstall_variable (var);
1945
 
1946
  /* Free memory associated with this variable */
1947
  free_variable (var);
1948
}
1949
 
1950
/* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1951
static int
1952
install_variable (struct varobj *var)
1953
{
1954
  struct vlist *cv;
1955
  struct vlist *newvl;
1956
  const char *chp;
1957
  unsigned int index = 0;
1958
  unsigned int i = 1;
1959
 
1960
  for (chp = var->obj_name; *chp; chp++)
1961
    {
1962
      index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1963
    }
1964
 
1965
  cv = *(varobj_table + index);
1966
  while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1967
    cv = cv->next;
1968
 
1969
  if (cv != NULL)
1970
    error (_("Duplicate variable object name"));
1971
 
1972
  /* Add varobj to hash table */
1973
  newvl = xmalloc (sizeof (struct vlist));
1974
  newvl->next = *(varobj_table + index);
1975
  newvl->var = var;
1976
  *(varobj_table + index) = newvl;
1977
 
1978
  /* If root, add varobj to root list */
1979
  if (is_root_p (var))
1980
    {
1981
      /* Add to list of root variables */
1982
      if (rootlist == NULL)
1983
        var->root->next = NULL;
1984
      else
1985
        var->root->next = rootlist;
1986
      rootlist = var->root;
1987
    }
1988
 
1989
  return 1;                     /* OK */
1990
}
1991
 
1992
/* Unistall the object VAR. */
1993
static void
1994
uninstall_variable (struct varobj *var)
1995
{
1996
  struct vlist *cv;
1997
  struct vlist *prev;
1998
  struct varobj_root *cr;
1999
  struct varobj_root *prer;
2000
  const char *chp;
2001
  unsigned int index = 0;
2002
  unsigned int i = 1;
2003
 
2004
  /* Remove varobj from hash table */
2005
  for (chp = var->obj_name; *chp; chp++)
2006
    {
2007
      index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2008
    }
2009
 
2010
  cv = *(varobj_table + index);
2011
  prev = NULL;
2012
  while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2013
    {
2014
      prev = cv;
2015
      cv = cv->next;
2016
    }
2017
 
2018
  if (varobjdebug)
2019
    fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2020
 
2021
  if (cv == NULL)
2022
    {
2023
      warning
2024
        ("Assertion failed: Could not find variable object \"%s\" to delete",
2025
         var->obj_name);
2026
      return;
2027
    }
2028
 
2029
  if (prev == NULL)
2030
    *(varobj_table + index) = cv->next;
2031
  else
2032
    prev->next = cv->next;
2033
 
2034
  xfree (cv);
2035
 
2036
  /* If root, remove varobj from root list */
2037
  if (is_root_p (var))
2038
    {
2039
      /* Remove from list of root variables */
2040
      if (rootlist == var->root)
2041
        rootlist = var->root->next;
2042
      else
2043
        {
2044
          prer = NULL;
2045
          cr = rootlist;
2046
          while ((cr != NULL) && (cr->rootvar != var))
2047
            {
2048
              prer = cr;
2049
              cr = cr->next;
2050
            }
2051
          if (cr == NULL)
2052
            {
2053
              warning
2054
                ("Assertion failed: Could not find varobj \"%s\" in root list",
2055
                 var->obj_name);
2056
              return;
2057
            }
2058
          if (prer == NULL)
2059
            rootlist = NULL;
2060
          else
2061
            prer->next = cr->next;
2062
        }
2063
    }
2064
 
2065
}
2066
 
2067
/* Create and install a child of the parent of the given name */
2068
static struct varobj *
2069
create_child (struct varobj *parent, int index, char *name)
2070
{
2071
  return create_child_with_value (parent, index, name,
2072
                                  value_of_child (parent, index));
2073
}
2074
 
2075
static struct varobj *
2076
create_child_with_value (struct varobj *parent, int index, const char *name,
2077
                         struct value *value)
2078
{
2079
  struct varobj *child;
2080
  char *childs_name;
2081
 
2082
  child = new_variable ();
2083
 
2084
  /* name is allocated by name_of_child */
2085
  /* FIXME: xstrdup should not be here.  */
2086
  child->name = xstrdup (name);
2087
  child->index = index;
2088
  child->parent = parent;
2089
  child->root = parent->root;
2090
  childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2091
  child->obj_name = childs_name;
2092
  install_variable (child);
2093
 
2094
  /* Compute the type of the child.  Must do this before
2095
     calling install_new_value.  */
2096
  if (value != NULL)
2097
    /* If the child had no evaluation errors, var->value
2098
       will be non-NULL and contain a valid type. */
2099
    child->type = value_type (value);
2100
  else
2101
    /* Otherwise, we must compute the type. */
2102
    child->type = (*child->root->lang->type_of_child) (child->parent,
2103
                                                       child->index);
2104
  install_new_value (child, value, 1);
2105
 
2106
  return child;
2107
}
2108
 
2109
 
2110
/*
2111
 * Miscellaneous utility functions.
2112
 */
2113
 
2114
/* Allocate memory and initialize a new variable */
2115
static struct varobj *
2116
new_variable (void)
2117
{
2118
  struct varobj *var;
2119
 
2120
  var = (struct varobj *) xmalloc (sizeof (struct varobj));
2121
  var->name = NULL;
2122
  var->path_expr = NULL;
2123
  var->obj_name = NULL;
2124
  var->index = -1;
2125
  var->type = NULL;
2126
  var->value = NULL;
2127
  var->num_children = -1;
2128
  var->parent = NULL;
2129
  var->children = NULL;
2130
  var->format = 0;
2131
  var->root = NULL;
2132
  var->updated = 0;
2133
  var->print_value = NULL;
2134
  var->frozen = 0;
2135
  var->not_fetched = 0;
2136
  var->children_requested = 0;
2137
  var->from = -1;
2138
  var->to = -1;
2139
  var->constructor = 0;
2140
  var->pretty_printer = 0;
2141
  var->child_iter = 0;
2142
  var->saved_item = 0;
2143
 
2144
  return var;
2145
}
2146
 
2147
/* Allocate memory and initialize a new root variable */
2148
static struct varobj *
2149
new_root_variable (void)
2150
{
2151
  struct varobj *var = new_variable ();
2152
  var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));;
2153
  var->root->lang = NULL;
2154
  var->root->exp = NULL;
2155
  var->root->valid_block = NULL;
2156
  var->root->frame = null_frame_id;
2157
  var->root->floating = 0;
2158
  var->root->rootvar = NULL;
2159
  var->root->is_valid = 1;
2160
 
2161
  return var;
2162
}
2163
 
2164
/* Free any allocated memory associated with VAR. */
2165
static void
2166
free_variable (struct varobj *var)
2167
{
2168
#if HAVE_PYTHON
2169
  if (var->pretty_printer)
2170
    {
2171
      struct cleanup *cleanup = varobj_ensure_python_env (var);
2172
      Py_XDECREF (var->constructor);
2173
      Py_XDECREF (var->pretty_printer);
2174
      Py_XDECREF (var->child_iter);
2175
      Py_XDECREF (var->saved_item);
2176
      do_cleanups (cleanup);
2177
    }
2178
#endif
2179
 
2180
  value_free (var->value);
2181
 
2182
  /* Free the expression if this is a root variable. */
2183
  if (is_root_p (var))
2184
    {
2185
      xfree (var->root->exp);
2186
      xfree (var->root);
2187
    }
2188
 
2189
  xfree (var->name);
2190
  xfree (var->obj_name);
2191
  xfree (var->print_value);
2192
  xfree (var->path_expr);
2193
  xfree (var);
2194
}
2195
 
2196
static void
2197
do_free_variable_cleanup (void *var)
2198
{
2199
  free_variable (var);
2200
}
2201
 
2202
static struct cleanup *
2203
make_cleanup_free_variable (struct varobj *var)
2204
{
2205
  return make_cleanup (do_free_variable_cleanup, var);
2206
}
2207
 
2208
/* This returns the type of the variable. It also skips past typedefs
2209
   to return the real type of the variable.
2210
 
2211
   NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2212
   except within get_target_type and get_type. */
2213
static struct type *
2214
get_type (struct varobj *var)
2215
{
2216
  struct type *type;
2217
  type = var->type;
2218
 
2219
  if (type != NULL)
2220
    type = check_typedef (type);
2221
 
2222
  return type;
2223
}
2224
 
2225
/* Return the type of the value that's stored in VAR,
2226
   or that would have being stored there if the
2227
   value were accessible.
2228
 
2229
   This differs from VAR->type in that VAR->type is always
2230
   the true type of the expession in the source language.
2231
   The return value of this function is the type we're
2232
   actually storing in varobj, and using for displaying
2233
   the values and for comparing previous and new values.
2234
 
2235
   For example, top-level references are always stripped.  */
2236
static struct type *
2237
get_value_type (struct varobj *var)
2238
{
2239
  struct type *type;
2240
 
2241
  if (var->value)
2242
    type = value_type (var->value);
2243
  else
2244
    type = var->type;
2245
 
2246
  type = check_typedef (type);
2247
 
2248
  if (TYPE_CODE (type) == TYPE_CODE_REF)
2249
    type = get_target_type (type);
2250
 
2251
  type = check_typedef (type);
2252
 
2253
  return type;
2254
}
2255
 
2256
/* This returns the target type (or NULL) of TYPE, also skipping
2257
   past typedefs, just like get_type ().
2258
 
2259
   NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2260
   except within get_target_type and get_type. */
2261
static struct type *
2262
get_target_type (struct type *type)
2263
{
2264
  if (type != NULL)
2265
    {
2266
      type = TYPE_TARGET_TYPE (type);
2267
      if (type != NULL)
2268
        type = check_typedef (type);
2269
    }
2270
 
2271
  return type;
2272
}
2273
 
2274
/* What is the default display for this variable? We assume that
2275
   everything is "natural". Any exceptions? */
2276
static enum varobj_display_formats
2277
variable_default_display (struct varobj *var)
2278
{
2279
  return FORMAT_NATURAL;
2280
}
2281
 
2282
/* FIXME: The following should be generic for any pointer */
2283
static void
2284
cppush (struct cpstack **pstack, char *name)
2285
{
2286
  struct cpstack *s;
2287
 
2288
  s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2289
  s->name = name;
2290
  s->next = *pstack;
2291
  *pstack = s;
2292
}
2293
 
2294
/* FIXME: The following should be generic for any pointer */
2295
static char *
2296
cppop (struct cpstack **pstack)
2297
{
2298
  struct cpstack *s;
2299
  char *v;
2300
 
2301
  if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2302
    return NULL;
2303
 
2304
  s = *pstack;
2305
  v = s->name;
2306
  *pstack = (*pstack)->next;
2307
  xfree (s);
2308
 
2309
  return v;
2310
}
2311
 
2312
/*
2313
 * Language-dependencies
2314
 */
2315
 
2316
/* Common entry points */
2317
 
2318
/* Get the language of variable VAR. */
2319
static enum varobj_languages
2320
variable_language (struct varobj *var)
2321
{
2322
  enum varobj_languages lang;
2323
 
2324
  switch (var->root->exp->language_defn->la_language)
2325
    {
2326
    default:
2327
    case language_c:
2328
      lang = vlang_c;
2329
      break;
2330
    case language_cplus:
2331
      lang = vlang_cplus;
2332
      break;
2333
    case language_java:
2334
      lang = vlang_java;
2335
      break;
2336
    }
2337
 
2338
  return lang;
2339
}
2340
 
2341
/* Return the number of children for a given variable.
2342
   The result of this function is defined by the language
2343
   implementation. The number of children returned by this function
2344
   is the number of children that the user will see in the variable
2345
   display. */
2346
static int
2347
number_of_children (struct varobj *var)
2348
{
2349
  return (*var->root->lang->number_of_children) (var);;
2350
}
2351
 
2352
/* What is the expression for the root varobj VAR? Returns a malloc'd string. */
2353
static char *
2354
name_of_variable (struct varobj *var)
2355
{
2356
  return (*var->root->lang->name_of_variable) (var);
2357
}
2358
 
2359
/* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
2360
static char *
2361
name_of_child (struct varobj *var, int index)
2362
{
2363
  return (*var->root->lang->name_of_child) (var, index);
2364
}
2365
 
2366
/* What is the ``struct value *'' of the root variable VAR?
2367
   For floating variable object, evaluation can get us a value
2368
   of different type from what is stored in varobj already.  In
2369
   that case:
2370
   - *type_changed will be set to 1
2371
   - old varobj will be freed, and new one will be
2372
   created, with the same name.
2373
   - *var_handle will be set to the new varobj
2374
   Otherwise, *type_changed will be set to 0.  */
2375
static struct value *
2376
value_of_root (struct varobj **var_handle, int *type_changed)
2377
{
2378
  struct varobj *var;
2379
 
2380
  if (var_handle == NULL)
2381
    return NULL;
2382
 
2383
  var = *var_handle;
2384
 
2385
  /* This should really be an exception, since this should
2386
     only get called with a root variable. */
2387
 
2388
  if (!is_root_p (var))
2389
    return NULL;
2390
 
2391
  if (var->root->floating)
2392
    {
2393
      struct varobj *tmp_var;
2394
      char *old_type, *new_type;
2395
 
2396
      tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2397
                               USE_SELECTED_FRAME);
2398
      if (tmp_var == NULL)
2399
        {
2400
          return NULL;
2401
        }
2402
      old_type = varobj_get_type (var);
2403
      new_type = varobj_get_type (tmp_var);
2404
      if (strcmp (old_type, new_type) == 0)
2405
        {
2406
          /* The expression presently stored inside var->root->exp
2407
             remembers the locations of local variables relatively to
2408
             the frame where the expression was created (in DWARF location
2409
             button, for example).  Naturally, those locations are not
2410
             correct in other frames, so update the expression.  */
2411
 
2412
         struct expression *tmp_exp = var->root->exp;
2413
         var->root->exp = tmp_var->root->exp;
2414
         tmp_var->root->exp = tmp_exp;
2415
 
2416
          varobj_delete (tmp_var, NULL, 0);
2417
          *type_changed = 0;
2418
        }
2419
      else
2420
        {
2421
          tmp_var->obj_name = xstrdup (var->obj_name);
2422
          tmp_var->from = var->from;
2423
          tmp_var->to = var->to;
2424
          varobj_delete (var, NULL, 0);
2425
 
2426
          install_variable (tmp_var);
2427
          *var_handle = tmp_var;
2428
          var = *var_handle;
2429
          *type_changed = 1;
2430
        }
2431
      xfree (old_type);
2432
      xfree (new_type);
2433
    }
2434
  else
2435
    {
2436
      *type_changed = 0;
2437
    }
2438
 
2439
  return (*var->root->lang->value_of_root) (var_handle);
2440
}
2441
 
2442
/* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2443
static struct value *
2444
value_of_child (struct varobj *parent, int index)
2445
{
2446
  struct value *value;
2447
 
2448
  value = (*parent->root->lang->value_of_child) (parent, index);
2449
 
2450
  return value;
2451
}
2452
 
2453
/* GDB already has a command called "value_of_variable". Sigh. */
2454
static char *
2455
my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2456
{
2457
  if (var->root->is_valid)
2458
    {
2459
      if (var->pretty_printer)
2460
        return value_get_print_value (var->value, var->format, var);
2461
      return (*var->root->lang->value_of_variable) (var, format);
2462
    }
2463
  else
2464
    return NULL;
2465
}
2466
 
2467
static char *
2468
value_get_print_value (struct value *value, enum varobj_display_formats format,
2469
                       struct varobj *var)
2470
{
2471
  struct ui_file *stb;
2472
  struct cleanup *old_chain;
2473
  gdb_byte *thevalue = NULL;
2474
  struct value_print_options opts;
2475
  struct type *type = NULL;
2476
  long len = 0;
2477
  char *encoding = NULL;
2478
  struct gdbarch *gdbarch = NULL;
2479
 
2480
  if (value == NULL)
2481
    return NULL;
2482
 
2483
  gdbarch = get_type_arch (value_type (value));
2484
#if HAVE_PYTHON
2485
  {
2486
    struct cleanup *back_to = varobj_ensure_python_env (var);
2487
    PyObject *value_formatter = var->pretty_printer;
2488
 
2489
    if (value_formatter)
2490
      {
2491
        /* First check to see if we have any children at all.  If so,
2492
           we simply return {...}.  */
2493
        if (dynamic_varobj_has_child_method (var))
2494
          return xstrdup ("{...}");
2495
 
2496
        if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2497
          {
2498
            char *hint;
2499
            struct value *replacement;
2500
            int string_print = 0;
2501
            PyObject *output = NULL;
2502
 
2503
            hint = gdbpy_get_display_hint (value_formatter);
2504
            if (hint)
2505
              {
2506
                if (!strcmp (hint, "string"))
2507
                  string_print = 1;
2508
                xfree (hint);
2509
              }
2510
 
2511
            output = apply_varobj_pretty_printer (value_formatter,
2512
                                                  &replacement);
2513
            if (output)
2514
              {
2515
                if (gdbpy_is_lazy_string (output))
2516
                  {
2517
                    thevalue = gdbpy_extract_lazy_string (output, &type,
2518
                                                          &len, &encoding);
2519
                    string_print = 1;
2520
                  }
2521
                else
2522
                  {
2523
                    PyObject *py_str
2524
                      = python_string_to_target_python_string (output);
2525
                    if (py_str)
2526
                      {
2527
                        char *s = PyString_AsString (py_str);
2528
                        len = PyString_Size (py_str);
2529
                        thevalue = xmemdup (s, len + 1, len + 1);
2530
                        type = builtin_type (gdbarch)->builtin_char;
2531
                        Py_DECREF (py_str);
2532
                      }
2533
                  }
2534
                Py_DECREF (output);
2535
              }
2536
            if (thevalue && !string_print)
2537
              {
2538
                do_cleanups (back_to);
2539
                xfree (encoding);
2540
                return thevalue;
2541
              }
2542
            if (replacement)
2543
              value = replacement;
2544
          }
2545
      }
2546
    do_cleanups (back_to);
2547
  }
2548
#endif
2549
 
2550
  stb = mem_fileopen ();
2551
  old_chain = make_cleanup_ui_file_delete (stb);
2552
 
2553
  get_formatted_print_options (&opts, format_code[(int) format]);
2554
  opts.deref_ref = 0;
2555
  opts.raw = 1;
2556
  if (thevalue)
2557
    {
2558
      make_cleanup (xfree, thevalue);
2559
      make_cleanup (xfree, encoding);
2560
      LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts);
2561
    }
2562
  else
2563
    common_val_print (value, stb, 0, &opts, current_language);
2564
  thevalue = ui_file_xstrdup (stb, NULL);
2565
 
2566
  do_cleanups (old_chain);
2567
  return thevalue;
2568
}
2569
 
2570
int
2571
varobj_editable_p (struct varobj *var)
2572
{
2573
  struct type *type;
2574
  struct value *value;
2575
 
2576
  if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2577
    return 0;
2578
 
2579
  type = get_value_type (var);
2580
 
2581
  switch (TYPE_CODE (type))
2582
    {
2583
    case TYPE_CODE_STRUCT:
2584
    case TYPE_CODE_UNION:
2585
    case TYPE_CODE_ARRAY:
2586
    case TYPE_CODE_FUNC:
2587
    case TYPE_CODE_METHOD:
2588
      return 0;
2589
      break;
2590
 
2591
    default:
2592
      return 1;
2593
      break;
2594
    }
2595
}
2596
 
2597
/* Return non-zero if changes in value of VAR
2598
   must be detected and reported by -var-update.
2599
   Return zero is -var-update should never report
2600
   changes of such values.  This makes sense for structures
2601
   (since the changes in children values will be reported separately),
2602
   or for artifical objects (like 'public' pseudo-field in C++).
2603
 
2604
   Return value of 0 means that gdb need not call value_fetch_lazy
2605
   for the value of this variable object.  */
2606
static int
2607
varobj_value_is_changeable_p (struct varobj *var)
2608
{
2609
  int r;
2610
  struct type *type;
2611
 
2612
  if (CPLUS_FAKE_CHILD (var))
2613
    return 0;
2614
 
2615
  type = get_value_type (var);
2616
 
2617
  switch (TYPE_CODE (type))
2618
    {
2619
    case TYPE_CODE_STRUCT:
2620
    case TYPE_CODE_UNION:
2621
    case TYPE_CODE_ARRAY:
2622
      r = 0;
2623
      break;
2624
 
2625
    default:
2626
      r = 1;
2627
    }
2628
 
2629
  return r;
2630
}
2631
 
2632
/* Return 1 if that varobj is floating, that is is always evaluated in the
2633
   selected frame, and not bound to thread/frame.  Such variable objects
2634
   are created using '@' as frame specifier to -var-create.  */
2635
int
2636
varobj_floating_p (struct varobj *var)
2637
{
2638
  return var->root->floating;
2639
}
2640
 
2641
/* Given the value and the type of a variable object,
2642
   adjust the value and type to those necessary
2643
   for getting children of the variable object.
2644
   This includes dereferencing top-level references
2645
   to all types and dereferencing pointers to
2646
   structures.
2647
 
2648
   Both TYPE and *TYPE should be non-null. VALUE
2649
   can be null if we want to only translate type.
2650
   *VALUE can be null as well -- if the parent
2651
   value is not known.
2652
 
2653
   If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2654
   depending on whether pointer was dereferenced
2655
   in this function.  */
2656
static void
2657
adjust_value_for_child_access (struct value **value,
2658
                                  struct type **type,
2659
                                  int *was_ptr)
2660
{
2661
  gdb_assert (type && *type);
2662
 
2663
  if (was_ptr)
2664
    *was_ptr = 0;
2665
 
2666
  *type = check_typedef (*type);
2667
 
2668
  /* The type of value stored in varobj, that is passed
2669
     to us, is already supposed to be
2670
     reference-stripped.  */
2671
 
2672
  gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
2673
 
2674
  /* Pointers to structures are treated just like
2675
     structures when accessing children.  Don't
2676
     dererences pointers to other types.  */
2677
  if (TYPE_CODE (*type) == TYPE_CODE_PTR)
2678
    {
2679
      struct type *target_type = get_target_type (*type);
2680
      if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
2681
          || TYPE_CODE (target_type) == TYPE_CODE_UNION)
2682
        {
2683
          if (value && *value)
2684
            {
2685
              int success = gdb_value_ind (*value, value);
2686
              if (!success)
2687
                *value = NULL;
2688
            }
2689
          *type = target_type;
2690
          if (was_ptr)
2691
            *was_ptr = 1;
2692
        }
2693
    }
2694
 
2695
  /* The 'get_target_type' function calls check_typedef on
2696
     result, so we can immediately check type code.  No
2697
     need to call check_typedef here.  */
2698
}
2699
 
2700
/* C */
2701
static int
2702
c_number_of_children (struct varobj *var)
2703
{
2704
  struct type *type = get_value_type (var);
2705
  int children = 0;
2706
  struct type *target;
2707
 
2708
  adjust_value_for_child_access (NULL, &type, NULL);
2709
  target = get_target_type (type);
2710
 
2711
  switch (TYPE_CODE (type))
2712
    {
2713
    case TYPE_CODE_ARRAY:
2714
      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
2715
          && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
2716
        children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
2717
      else
2718
        /* If we don't know how many elements there are, don't display
2719
           any.  */
2720
        children = 0;
2721
      break;
2722
 
2723
    case TYPE_CODE_STRUCT:
2724
    case TYPE_CODE_UNION:
2725
      children = TYPE_NFIELDS (type);
2726
      break;
2727
 
2728
    case TYPE_CODE_PTR:
2729
      /* The type here is a pointer to non-struct. Typically, pointers
2730
         have one child, except for function ptrs, which have no children,
2731
         and except for void*, as we don't know what to show.
2732
 
2733
         We can show char* so we allow it to be dereferenced.  If you decide
2734
         to test for it, please mind that a little magic is necessary to
2735
         properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2736
         TYPE_NAME == "char" */
2737
      if (TYPE_CODE (target) == TYPE_CODE_FUNC
2738
          || TYPE_CODE (target) == TYPE_CODE_VOID)
2739
        children = 0;
2740
      else
2741
        children = 1;
2742
      break;
2743
 
2744
    default:
2745
      /* Other types have no children */
2746
      break;
2747
    }
2748
 
2749
  return children;
2750
}
2751
 
2752
static char *
2753
c_name_of_variable (struct varobj *parent)
2754
{
2755
  return xstrdup (parent->name);
2756
}
2757
 
2758
/* Return the value of element TYPE_INDEX of a structure
2759
   value VALUE.  VALUE's type should be a structure,
2760
   or union, or a typedef to struct/union.
2761
 
2762
   Returns NULL if getting the value fails.  Never throws.  */
2763
static struct value *
2764
value_struct_element_index (struct value *value, int type_index)
2765
{
2766
  struct value *result = NULL;
2767
  volatile struct gdb_exception e;
2768
 
2769
  struct type *type = value_type (value);
2770
  type = check_typedef (type);
2771
 
2772
  gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2773
              || TYPE_CODE (type) == TYPE_CODE_UNION);
2774
 
2775
  TRY_CATCH (e, RETURN_MASK_ERROR)
2776
    {
2777
      if (field_is_static (&TYPE_FIELD (type, type_index)))
2778
        result = value_static_field (type, type_index);
2779
      else
2780
        result = value_primitive_field (value, 0, type_index, type);
2781
    }
2782
  if (e.reason < 0)
2783
    {
2784
      return NULL;
2785
    }
2786
  else
2787
    {
2788
      return result;
2789
    }
2790
}
2791
 
2792
/* Obtain the information about child INDEX of the variable
2793
   object PARENT.
2794
   If CNAME is not null, sets *CNAME to the name of the child relative
2795
   to the parent.
2796
   If CVALUE is not null, sets *CVALUE to the value of the child.
2797
   If CTYPE is not null, sets *CTYPE to the type of the child.
2798
 
2799
   If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2800
   information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2801
   to NULL.  */
2802
static void
2803
c_describe_child (struct varobj *parent, int index,
2804
                  char **cname, struct value **cvalue, struct type **ctype,
2805
                  char **cfull_expression)
2806
{
2807
  struct value *value = parent->value;
2808
  struct type *type = get_value_type (parent);
2809
  char *parent_expression = NULL;
2810
  int was_ptr;
2811
 
2812
  if (cname)
2813
    *cname = NULL;
2814
  if (cvalue)
2815
    *cvalue = NULL;
2816
  if (ctype)
2817
    *ctype = NULL;
2818
  if (cfull_expression)
2819
    {
2820
      *cfull_expression = NULL;
2821
      parent_expression = varobj_get_path_expr (parent);
2822
    }
2823
  adjust_value_for_child_access (&value, &type, &was_ptr);
2824
 
2825
  switch (TYPE_CODE (type))
2826
    {
2827
    case TYPE_CODE_ARRAY:
2828
      if (cname)
2829
        *cname = xstrdup (int_string (index
2830
                                      + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2831
                                      10, 1, 0, 0));
2832
 
2833
      if (cvalue && value)
2834
        {
2835
          int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
2836
          gdb_value_subscript (value, real_index, cvalue);
2837
        }
2838
 
2839
      if (ctype)
2840
        *ctype = get_target_type (type);
2841
 
2842
      if (cfull_expression)
2843
        *cfull_expression =
2844
          xstrprintf ("(%s)[%s]", parent_expression,
2845
                      int_string (index
2846
                                  + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2847
                                  10, 1, 0, 0));
2848
 
2849
 
2850
      break;
2851
 
2852
    case TYPE_CODE_STRUCT:
2853
    case TYPE_CODE_UNION:
2854
      if (cname)
2855
        *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2856
 
2857
      if (cvalue && value)
2858
        {
2859
          /* For C, varobj index is the same as type index.  */
2860
          *cvalue = value_struct_element_index (value, index);
2861
        }
2862
 
2863
      if (ctype)
2864
        *ctype = TYPE_FIELD_TYPE (type, index);
2865
 
2866
      if (cfull_expression)
2867
        {
2868
          char *join = was_ptr ? "->" : ".";
2869
          *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
2870
                                          TYPE_FIELD_NAME (type, index));
2871
        }
2872
 
2873
      break;
2874
 
2875
    case TYPE_CODE_PTR:
2876
      if (cname)
2877
        *cname = xstrprintf ("*%s", parent->name);
2878
 
2879
      if (cvalue && value)
2880
        {
2881
          int success = gdb_value_ind (value, cvalue);
2882
          if (!success)
2883
            *cvalue = NULL;
2884
        }
2885
 
2886
      /* Don't use get_target_type because it calls
2887
         check_typedef and here, we want to show the true
2888
         declared type of the variable.  */
2889
      if (ctype)
2890
        *ctype = TYPE_TARGET_TYPE (type);
2891
 
2892
      if (cfull_expression)
2893
        *cfull_expression = xstrprintf ("*(%s)", parent_expression);
2894
 
2895
      break;
2896
 
2897
    default:
2898
      /* This should not happen */
2899
      if (cname)
2900
        *cname = xstrdup ("???");
2901
      if (cfull_expression)
2902
        *cfull_expression = xstrdup ("???");
2903
      /* Don't set value and type, we don't know then. */
2904
    }
2905
}
2906
 
2907
static char *
2908
c_name_of_child (struct varobj *parent, int index)
2909
{
2910
  char *name;
2911
  c_describe_child (parent, index, &name, NULL, NULL, NULL);
2912
  return name;
2913
}
2914
 
2915
static char *
2916
c_path_expr_of_child (struct varobj *child)
2917
{
2918
  c_describe_child (child->parent, child->index, NULL, NULL, NULL,
2919
                    &child->path_expr);
2920
  return child->path_expr;
2921
}
2922
 
2923
/* If frame associated with VAR can be found, switch
2924
   to it and return 1.  Otherwise, return 0.  */
2925
static int
2926
check_scope (struct varobj *var)
2927
{
2928
  struct frame_info *fi;
2929
  int scope;
2930
 
2931
  fi = frame_find_by_id (var->root->frame);
2932
  scope = fi != NULL;
2933
 
2934
  if (fi)
2935
    {
2936
      CORE_ADDR pc = get_frame_pc (fi);
2937
      if (pc <  BLOCK_START (var->root->valid_block) ||
2938
          pc >= BLOCK_END (var->root->valid_block))
2939
        scope = 0;
2940
      else
2941
        select_frame (fi);
2942
    }
2943
  return scope;
2944
}
2945
 
2946
static struct value *
2947
c_value_of_root (struct varobj **var_handle)
2948
{
2949
  struct value *new_val = NULL;
2950
  struct varobj *var = *var_handle;
2951
  struct frame_info *fi;
2952
  int within_scope = 0;
2953
  struct cleanup *back_to;
2954
 
2955
  /*  Only root variables can be updated... */
2956
  if (!is_root_p (var))
2957
    /* Not a root var */
2958
    return NULL;
2959
 
2960
  back_to = make_cleanup_restore_current_thread ();
2961
 
2962
  /* Determine whether the variable is still around. */
2963
  if (var->root->valid_block == NULL || var->root->floating)
2964
    within_scope = 1;
2965
  else if (var->root->thread_id == 0)
2966
    {
2967
      /* The program was single-threaded when the variable object was
2968
         created.  Technically, it's possible that the program became
2969
         multi-threaded since then, but we don't support such
2970
         scenario yet.  */
2971
      within_scope = check_scope (var);
2972
    }
2973
  else
2974
    {
2975
      ptid_t ptid = thread_id_to_pid (var->root->thread_id);
2976
      if (in_thread_list (ptid))
2977
        {
2978
          switch_to_thread (ptid);
2979
          within_scope = check_scope (var);
2980
        }
2981
    }
2982
 
2983
  if (within_scope)
2984
    {
2985
      /* We need to catch errors here, because if evaluate
2986
         expression fails we want to just return NULL.  */
2987
      gdb_evaluate_expression (var->root->exp, &new_val);
2988
      return new_val;
2989
    }
2990
 
2991
  do_cleanups (back_to);
2992
 
2993
  return NULL;
2994
}
2995
 
2996
static struct value *
2997
c_value_of_child (struct varobj *parent, int index)
2998
{
2999
  struct value *value = NULL;
3000
  c_describe_child (parent, index, NULL, &value, NULL, NULL);
3001
 
3002
  return value;
3003
}
3004
 
3005
static struct type *
3006
c_type_of_child (struct varobj *parent, int index)
3007
{
3008
  struct type *type = NULL;
3009
  c_describe_child (parent, index, NULL, NULL, &type, NULL);
3010
  return type;
3011
}
3012
 
3013
static char *
3014
c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3015
{
3016
  /* BOGUS: if val_print sees a struct/class, or a reference to one,
3017
     it will print out its children instead of "{...}".  So we need to
3018
     catch that case explicitly.  */
3019
  struct type *type = get_type (var);
3020
 
3021
  /* If we have a custom formatter, return whatever string it has
3022
     produced.  */
3023
  if (var->pretty_printer && var->print_value)
3024
    return xstrdup (var->print_value);
3025
 
3026
  /* Strip top-level references. */
3027
  while (TYPE_CODE (type) == TYPE_CODE_REF)
3028
    type = check_typedef (TYPE_TARGET_TYPE (type));
3029
 
3030
  switch (TYPE_CODE (type))
3031
    {
3032
    case TYPE_CODE_STRUCT:
3033
    case TYPE_CODE_UNION:
3034
      return xstrdup ("{...}");
3035
      /* break; */
3036
 
3037
    case TYPE_CODE_ARRAY:
3038
      {
3039
        char *number;
3040
        number = xstrprintf ("[%d]", var->num_children);
3041
        return (number);
3042
      }
3043
      /* break; */
3044
 
3045
    default:
3046
      {
3047
        if (var->value == NULL)
3048
          {
3049
            /* This can happen if we attempt to get the value of a struct
3050
               member when the parent is an invalid pointer. This is an
3051
               error condition, so we should tell the caller. */
3052
            return NULL;
3053
          }
3054
        else
3055
          {
3056
            if (var->not_fetched && value_lazy (var->value))
3057
              /* Frozen variable and no value yet.  We don't
3058
                 implicitly fetch the value.  MI response will
3059
                 use empty string for the value, which is OK.  */
3060
              return NULL;
3061
 
3062
            gdb_assert (varobj_value_is_changeable_p (var));
3063
            gdb_assert (!value_lazy (var->value));
3064
 
3065
            /* If the specified format is the current one,
3066
               we can reuse print_value */
3067
            if (format == var->format)
3068
              return xstrdup (var->print_value);
3069
            else
3070
              return value_get_print_value (var->value, format, var);
3071
          }
3072
      }
3073
    }
3074
}
3075
 
3076
 
3077
/* C++ */
3078
 
3079
static int
3080
cplus_number_of_children (struct varobj *var)
3081
{
3082
  struct type *type;
3083
  int children, dont_know;
3084
 
3085
  dont_know = 1;
3086
  children = 0;
3087
 
3088
  if (!CPLUS_FAKE_CHILD (var))
3089
    {
3090
      type = get_value_type (var);
3091
      adjust_value_for_child_access (NULL, &type, NULL);
3092
 
3093
      if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
3094
          ((TYPE_CODE (type)) == TYPE_CODE_UNION))
3095
        {
3096
          int kids[3];
3097
 
3098
          cplus_class_num_children (type, kids);
3099
          if (kids[v_public] != 0)
3100
            children++;
3101
          if (kids[v_private] != 0)
3102
            children++;
3103
          if (kids[v_protected] != 0)
3104
            children++;
3105
 
3106
          /* Add any baseclasses */
3107
          children += TYPE_N_BASECLASSES (type);
3108
          dont_know = 0;
3109
 
3110
          /* FIXME: save children in var */
3111
        }
3112
    }
3113
  else
3114
    {
3115
      int kids[3];
3116
 
3117
      type = get_value_type (var->parent);
3118
      adjust_value_for_child_access (NULL, &type, NULL);
3119
 
3120
      cplus_class_num_children (type, kids);
3121
      if (strcmp (var->name, "public") == 0)
3122
        children = kids[v_public];
3123
      else if (strcmp (var->name, "private") == 0)
3124
        children = kids[v_private];
3125
      else
3126
        children = kids[v_protected];
3127
      dont_know = 0;
3128
    }
3129
 
3130
  if (dont_know)
3131
    children = c_number_of_children (var);
3132
 
3133
  return children;
3134
}
3135
 
3136
/* Compute # of public, private, and protected variables in this class.
3137
   That means we need to descend into all baseclasses and find out
3138
   how many are there, too. */
3139
static void
3140
cplus_class_num_children (struct type *type, int children[3])
3141
{
3142
  int i, vptr_fieldno;
3143
  struct type *basetype = NULL;
3144
 
3145
  children[v_public] = 0;
3146
  children[v_private] = 0;
3147
  children[v_protected] = 0;
3148
 
3149
  vptr_fieldno = get_vptr_fieldno (type, &basetype);
3150
  for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
3151
    {
3152
      /* If we have a virtual table pointer, omit it.  Even if virtual
3153
         table pointers are not specifically marked in the debug info,
3154
         they should be artificial.  */
3155
      if ((type == basetype && i == vptr_fieldno)
3156
          || TYPE_FIELD_ARTIFICIAL (type, i))
3157
        continue;
3158
 
3159
      if (TYPE_FIELD_PROTECTED (type, i))
3160
        children[v_protected]++;
3161
      else if (TYPE_FIELD_PRIVATE (type, i))
3162
        children[v_private]++;
3163
      else
3164
        children[v_public]++;
3165
    }
3166
}
3167
 
3168
static char *
3169
cplus_name_of_variable (struct varobj *parent)
3170
{
3171
  return c_name_of_variable (parent);
3172
}
3173
 
3174
enum accessibility { private_field, protected_field, public_field };
3175
 
3176
/* Check if field INDEX of TYPE has the specified accessibility.
3177
   Return 0 if so and 1 otherwise.  */
3178
static int
3179
match_accessibility (struct type *type, int index, enum accessibility acc)
3180
{
3181
  if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
3182
    return 1;
3183
  else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
3184
    return 1;
3185
  else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
3186
           && !TYPE_FIELD_PROTECTED (type, index))
3187
    return 1;
3188
  else
3189
    return 0;
3190
}
3191
 
3192
static void
3193
cplus_describe_child (struct varobj *parent, int index,
3194
                      char **cname, struct value **cvalue, struct type **ctype,
3195
                      char **cfull_expression)
3196
{
3197
  char *name = NULL;
3198
  struct value *value;
3199
  struct type *type;
3200
  int was_ptr;
3201
  char *parent_expression = NULL;
3202
 
3203
  if (cname)
3204
    *cname = NULL;
3205
  if (cvalue)
3206
    *cvalue = NULL;
3207
  if (ctype)
3208
    *ctype = NULL;
3209
  if (cfull_expression)
3210
    *cfull_expression = NULL;
3211
 
3212
  if (CPLUS_FAKE_CHILD (parent))
3213
    {
3214
      value = parent->parent->value;
3215
      type = get_value_type (parent->parent);
3216
      if (cfull_expression)
3217
        parent_expression = varobj_get_path_expr (parent->parent);
3218
    }
3219
  else
3220
    {
3221
      value = parent->value;
3222
      type = get_value_type (parent);
3223
      if (cfull_expression)
3224
        parent_expression = varobj_get_path_expr (parent);
3225
    }
3226
 
3227
  adjust_value_for_child_access (&value, &type, &was_ptr);
3228
 
3229
  if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3230
      || TYPE_CODE (type) == TYPE_CODE_UNION)
3231
    {
3232
      char *join = was_ptr ? "->" : ".";
3233
      if (CPLUS_FAKE_CHILD (parent))
3234
        {
3235
          /* The fields of the class type are ordered as they
3236
             appear in the class.  We are given an index for a
3237
             particular access control type ("public","protected",
3238
             or "private").  We must skip over fields that don't
3239
             have the access control we are looking for to properly
3240
             find the indexed field. */
3241
          int type_index = TYPE_N_BASECLASSES (type);
3242
          enum accessibility acc = public_field;
3243
          int vptr_fieldno;
3244
          struct type *basetype = NULL;
3245
 
3246
          vptr_fieldno = get_vptr_fieldno (type, &basetype);
3247
          if (strcmp (parent->name, "private") == 0)
3248
            acc = private_field;
3249
          else if (strcmp (parent->name, "protected") == 0)
3250
            acc = protected_field;
3251
 
3252
          while (index >= 0)
3253
            {
3254
              if ((type == basetype && type_index == vptr_fieldno)
3255
                  || TYPE_FIELD_ARTIFICIAL (type, type_index))
3256
                ; /* ignore vptr */
3257
              else if (match_accessibility (type, type_index, acc))
3258
                    --index;
3259
                  ++type_index;
3260
            }
3261
          --type_index;
3262
 
3263
          if (cname)
3264
            *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
3265
 
3266
          if (cvalue && value)
3267
            *cvalue = value_struct_element_index (value, type_index);
3268
 
3269
          if (ctype)
3270
            *ctype = TYPE_FIELD_TYPE (type, type_index);
3271
 
3272
          if (cfull_expression)
3273
            *cfull_expression = xstrprintf ("((%s)%s%s)", parent_expression,
3274
                                            join,
3275
                                            TYPE_FIELD_NAME (type, type_index));
3276
        }
3277
      else if (index < TYPE_N_BASECLASSES (type))
3278
        {
3279
          /* This is a baseclass.  */
3280
          if (cname)
3281
            *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3282
 
3283
          if (cvalue && value)
3284
            *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
3285
 
3286
          if (ctype)
3287
            {
3288
              *ctype = TYPE_FIELD_TYPE (type, index);
3289
            }
3290
 
3291
          if (cfull_expression)
3292
            {
3293
              char *ptr = was_ptr ? "*" : "";
3294
              /* Cast the parent to the base' type. Note that in gdb,
3295
                 expression like
3296
                         (Base1)d
3297
                 will create an lvalue, for all appearences, so we don't
3298
                 need to use more fancy:
3299
                         *(Base1*)(&d)
3300
                 construct.  */
3301
              *cfull_expression = xstrprintf ("(%s(%s%s) %s)",
3302
                                              ptr,
3303
                                              TYPE_FIELD_NAME (type, index),
3304
                                              ptr,
3305
                                              parent_expression);
3306
            }
3307
        }
3308
      else
3309
        {
3310
          char *access = NULL;
3311
          int children[3];
3312
          cplus_class_num_children (type, children);
3313
 
3314
          /* Everything beyond the baseclasses can
3315
             only be "public", "private", or "protected"
3316
 
3317
             The special "fake" children are always output by varobj in
3318
             this order. So if INDEX == 2, it MUST be "protected". */
3319
          index -= TYPE_N_BASECLASSES (type);
3320
          switch (index)
3321
            {
3322
            case 0:
3323
              if (children[v_public] > 0)
3324
                access = "public";
3325
              else if (children[v_private] > 0)
3326
                access = "private";
3327
              else
3328
                access = "protected";
3329
              break;
3330
            case 1:
3331
              if (children[v_public] > 0)
3332
                {
3333
                  if (children[v_private] > 0)
3334
                    access = "private";
3335
                  else
3336
                    access = "protected";
3337
                }
3338
              else if (children[v_private] > 0)
3339
                access = "protected";
3340
              break;
3341
            case 2:
3342
              /* Must be protected */
3343
              access = "protected";
3344
              break;
3345
            default:
3346
              /* error! */
3347
              break;
3348
            }
3349
 
3350
          gdb_assert (access);
3351
          if (cname)
3352
            *cname = xstrdup (access);
3353
 
3354
          /* Value and type and full expression are null here.  */
3355
        }
3356
    }
3357
  else
3358
    {
3359
      c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3360
    }
3361
}
3362
 
3363
static char *
3364
cplus_name_of_child (struct varobj *parent, int index)
3365
{
3366
  char *name = NULL;
3367
  cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3368
  return name;
3369
}
3370
 
3371
static char *
3372
cplus_path_expr_of_child (struct varobj *child)
3373
{
3374
  cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3375
                        &child->path_expr);
3376
  return child->path_expr;
3377
}
3378
 
3379
static struct value *
3380
cplus_value_of_root (struct varobj **var_handle)
3381
{
3382
  return c_value_of_root (var_handle);
3383
}
3384
 
3385
static struct value *
3386
cplus_value_of_child (struct varobj *parent, int index)
3387
{
3388
  struct value *value = NULL;
3389
  cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3390
  return value;
3391
}
3392
 
3393
static struct type *
3394
cplus_type_of_child (struct varobj *parent, int index)
3395
{
3396
  struct type *type = NULL;
3397
  cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3398
  return type;
3399
}
3400
 
3401
static char *
3402
cplus_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3403
{
3404
 
3405
  /* If we have one of our special types, don't print out
3406
     any value. */
3407
  if (CPLUS_FAKE_CHILD (var))
3408
    return xstrdup ("");
3409
 
3410
  return c_value_of_variable (var, format);
3411
}
3412
 
3413
/* Java */
3414
 
3415
static int
3416
java_number_of_children (struct varobj *var)
3417
{
3418
  return cplus_number_of_children (var);
3419
}
3420
 
3421
static char *
3422
java_name_of_variable (struct varobj *parent)
3423
{
3424
  char *p, *name;
3425
 
3426
  name = cplus_name_of_variable (parent);
3427
  /* If  the name has "-" in it, it is because we
3428
     needed to escape periods in the name... */
3429
  p = name;
3430
 
3431
  while (*p != '\000')
3432
    {
3433
      if (*p == '-')
3434
        *p = '.';
3435
      p++;
3436
    }
3437
 
3438
  return name;
3439
}
3440
 
3441
static char *
3442
java_name_of_child (struct varobj *parent, int index)
3443
{
3444
  char *name, *p;
3445
 
3446
  name = cplus_name_of_child (parent, index);
3447
  /* Escape any periods in the name... */
3448
  p = name;
3449
 
3450
  while (*p != '\000')
3451
    {
3452
      if (*p == '.')
3453
        *p = '-';
3454
      p++;
3455
    }
3456
 
3457
  return name;
3458
}
3459
 
3460
static char *
3461
java_path_expr_of_child (struct varobj *child)
3462
{
3463
  return NULL;
3464
}
3465
 
3466
static struct value *
3467
java_value_of_root (struct varobj **var_handle)
3468
{
3469
  return cplus_value_of_root (var_handle);
3470
}
3471
 
3472
static struct value *
3473
java_value_of_child (struct varobj *parent, int index)
3474
{
3475
  return cplus_value_of_child (parent, index);
3476
}
3477
 
3478
static struct type *
3479
java_type_of_child (struct varobj *parent, int index)
3480
{
3481
  return cplus_type_of_child (parent, index);
3482
}
3483
 
3484
static char *
3485
java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3486
{
3487
  return cplus_value_of_variable (var, format);
3488
}
3489
 
3490
/* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3491
   with an arbitrary caller supplied DATA pointer.  */
3492
 
3493
void
3494
all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
3495
{
3496
  struct varobj_root *var_root, *var_root_next;
3497
 
3498
  /* Iterate "safely" - handle if the callee deletes its passed VAROBJ.  */
3499
 
3500
  for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
3501
    {
3502
      var_root_next = var_root->next;
3503
 
3504
      (*func) (var_root->rootvar, data);
3505
    }
3506
}
3507
 
3508
extern void _initialize_varobj (void);
3509
void
3510
_initialize_varobj (void)
3511
{
3512
  int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
3513
 
3514
  varobj_table = xmalloc (sizeof_table);
3515
  memset (varobj_table, 0, sizeof_table);
3516
 
3517
  add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
3518
                            &varobjdebug, _("\
3519
Set varobj debugging."), _("\
3520
Show varobj debugging."), _("\
3521
When non-zero, varobj debugging is enabled."),
3522
                            NULL,
3523
                            show_varobjdebug,
3524
                            &setlist, &showlist);
3525
}
3526
 
3527
/* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3528
   defined on globals.  It is a helper for varobj_invalidate.  */
3529
 
3530
static void
3531
varobj_invalidate_iter (struct varobj *var, void *unused)
3532
{
3533
  /* Floating varobjs are reparsed on each stop, so we don't care if the
3534
     presently parsed expression refers to something that's gone.  */
3535
  if (var->root->floating)
3536
    return;
3537
 
3538
  /* global var must be re-evaluated.  */
3539
  if (var->root->valid_block == NULL)
3540
    {
3541
      struct varobj *tmp_var;
3542
 
3543
      /* Try to create a varobj with same expression.  If we succeed
3544
         replace the old varobj, otherwise invalidate it.  */
3545
      tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
3546
                               USE_CURRENT_FRAME);
3547
      if (tmp_var != NULL)
3548
        {
3549
          tmp_var->obj_name = xstrdup (var->obj_name);
3550
          varobj_delete (var, NULL, 0);
3551
          install_variable (tmp_var);
3552
        }
3553
      else
3554
        var->root->is_valid = 0;
3555
    }
3556
  else /* locals must be invalidated.  */
3557
    var->root->is_valid = 0;
3558
}
3559
 
3560
/* Invalidate the varobjs that are tied to locals and re-create the ones that
3561
   are defined on globals.
3562
   Invalidated varobjs will be always printed in_scope="invalid".  */
3563
 
3564
void
3565
varobj_invalidate (void)
3566
{
3567
  all_root_varobjs (varobj_invalidate_iter, NULL);
3568
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.