OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Print values for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4
   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
5
   2009, 2010 Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "gdb_string.h"
24
#include "symtab.h"
25
#include "gdbtypes.h"
26
#include "value.h"
27
#include "gdbcore.h"
28
#include "gdbcmd.h"
29
#include "target.h"
30
#include "language.h"
31
#include "annotate.h"
32
#include "valprint.h"
33
#include "floatformat.h"
34
#include "doublest.h"
35
#include "exceptions.h"
36
#include "dfp.h"
37
#include "python/python.h"
38
 
39
#include <errno.h>
40
 
41
/* Prototypes for local functions */
42
 
43
static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
44
                                int len, int *errnoptr);
45
 
46
static void show_print (char *, int);
47
 
48
static void set_print (char *, int);
49
 
50
static void set_radix (char *, int);
51
 
52
static void show_radix (char *, int);
53
 
54
static void set_input_radix (char *, int, struct cmd_list_element *);
55
 
56
static void set_input_radix_1 (int, unsigned);
57
 
58
static void set_output_radix (char *, int, struct cmd_list_element *);
59
 
60
static void set_output_radix_1 (int, unsigned);
61
 
62
void _initialize_valprint (void);
63
 
64
#define PRINT_MAX_DEFAULT 200   /* Start print_max off at this value. */
65
 
66
struct value_print_options user_print_options =
67
{
68
  Val_pretty_default,           /* pretty */
69
  0,                             /* prettyprint_arrays */
70
  0,                             /* prettyprint_structs */
71
  0,                             /* vtblprint */
72
  1,                            /* unionprint */
73
  1,                            /* addressprint */
74
  0,                             /* objectprint */
75
  PRINT_MAX_DEFAULT,            /* print_max */
76
  10,                           /* repeat_count_threshold */
77
  0,                             /* output_format */
78
  0,                             /* format */
79
  0,                             /* stop_print_at_null */
80
  0,                             /* inspect_it */
81
  0,                             /* print_array_indexes */
82
  0,                             /* deref_ref */
83
  1,                            /* static_field_print */
84
  1,                            /* pascal_static_field_print */
85
  0,                             /* raw */
86
 
87
};
88
 
89
/* Initialize *OPTS to be a copy of the user print options.  */
90
void
91
get_user_print_options (struct value_print_options *opts)
92
{
93
  *opts = user_print_options;
94
}
95
 
96
/* Initialize *OPTS to be a copy of the user print options, but with
97
   pretty-printing disabled.  */
98
void
99
get_raw_print_options (struct value_print_options *opts)
100
{
101
  *opts = user_print_options;
102
  opts->pretty = Val_no_prettyprint;
103
}
104
 
105
/* Initialize *OPTS to be a copy of the user print options, but using
106
   FORMAT as the formatting option.  */
107
void
108
get_formatted_print_options (struct value_print_options *opts,
109
                             char format)
110
{
111
  *opts = user_print_options;
112
  opts->format = format;
113
}
114
 
115
static void
116
show_print_max (struct ui_file *file, int from_tty,
117
                struct cmd_list_element *c, const char *value)
118
{
119
  fprintf_filtered (file, _("\
120
Limit on string chars or array elements to print is %s.\n"),
121
                    value);
122
}
123
 
124
 
125
/* Default input and output radixes, and output format letter.  */
126
 
127
unsigned input_radix = 10;
128
static void
129
show_input_radix (struct ui_file *file, int from_tty,
130
                  struct cmd_list_element *c, const char *value)
131
{
132
  fprintf_filtered (file, _("\
133
Default input radix for entering numbers is %s.\n"),
134
                    value);
135
}
136
 
137
unsigned output_radix = 10;
138
static void
139
show_output_radix (struct ui_file *file, int from_tty,
140
                   struct cmd_list_element *c, const char *value)
141
{
142
  fprintf_filtered (file, _("\
143
Default output radix for printing of values is %s.\n"),
144
                    value);
145
}
146
 
147
/* By default we print arrays without printing the index of each element in
148
   the array.  This behavior can be changed by setting PRINT_ARRAY_INDEXES.  */
149
 
150
static void
151
show_print_array_indexes (struct ui_file *file, int from_tty,
152
                          struct cmd_list_element *c, const char *value)
153
{
154
  fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
155
}
156
 
157
/* Print repeat counts if there are more than this many repetitions of an
158
   element in an array.  Referenced by the low level language dependent
159
   print routines. */
160
 
161
static void
162
show_repeat_count_threshold (struct ui_file *file, int from_tty,
163
                             struct cmd_list_element *c, const char *value)
164
{
165
  fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
166
                    value);
167
}
168
 
169
/* If nonzero, stops printing of char arrays at first null. */
170
 
171
static void
172
show_stop_print_at_null (struct ui_file *file, int from_tty,
173
                         struct cmd_list_element *c, const char *value)
174
{
175
  fprintf_filtered (file, _("\
176
Printing of char arrays to stop at first null char is %s.\n"),
177
                    value);
178
}
179
 
180
/* Controls pretty printing of structures. */
181
 
182
static void
183
show_prettyprint_structs (struct ui_file *file, int from_tty,
184
                          struct cmd_list_element *c, const char *value)
185
{
186
  fprintf_filtered (file, _("Prettyprinting of structures is %s.\n"), value);
187
}
188
 
189
/* Controls pretty printing of arrays.  */
190
 
191
static void
192
show_prettyprint_arrays (struct ui_file *file, int from_tty,
193
                         struct cmd_list_element *c, const char *value)
194
{
195
  fprintf_filtered (file, _("Prettyprinting of arrays is %s.\n"), value);
196
}
197
 
198
/* If nonzero, causes unions inside structures or other unions to be
199
   printed. */
200
 
201
static void
202
show_unionprint (struct ui_file *file, int from_tty,
203
                 struct cmd_list_element *c, const char *value)
204
{
205
  fprintf_filtered (file, _("\
206
Printing of unions interior to structures is %s.\n"),
207
                    value);
208
}
209
 
210
/* If nonzero, causes machine addresses to be printed in certain contexts. */
211
 
212
static void
213
show_addressprint (struct ui_file *file, int from_tty,
214
                   struct cmd_list_element *c, const char *value)
215
{
216
  fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
217
}
218
 
219
 
220
/* A helper function for val_print.  When printing in "summary" mode,
221
   we want to print scalar arguments, but not aggregate arguments.
222
   This function distinguishes between the two.  */
223
 
224
static int
225
scalar_type_p (struct type *type)
226
{
227
  CHECK_TYPEDEF (type);
228
  while (TYPE_CODE (type) == TYPE_CODE_REF)
229
    {
230
      type = TYPE_TARGET_TYPE (type);
231
      CHECK_TYPEDEF (type);
232
    }
233
  switch (TYPE_CODE (type))
234
    {
235
    case TYPE_CODE_ARRAY:
236
    case TYPE_CODE_STRUCT:
237
    case TYPE_CODE_UNION:
238
    case TYPE_CODE_SET:
239
    case TYPE_CODE_STRING:
240
    case TYPE_CODE_BITSTRING:
241
      return 0;
242
    default:
243
      return 1;
244
    }
245
}
246
 
247
/* Print using the given LANGUAGE the data of type TYPE located at VALADDR
248
   (within GDB), which came from the inferior at address ADDRESS, onto
249
   stdio stream STREAM according to OPTIONS.
250
 
251
   If the data are a string pointer, returns the number of string characters
252
   printed.
253
 
254
   FIXME:  The data at VALADDR is in target byte order.  If gdb is ever
255
   enhanced to be able to debug more than the single target it was compiled
256
   for (specific CPU type and thus specific target byte ordering), then
257
   either the print routines are going to have to take this into account,
258
   or the data is going to have to be passed into here already converted
259
   to the host byte ordering, whichever is more convenient. */
260
 
261
 
262
int
263
val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
264
           CORE_ADDR address, struct ui_file *stream, int recurse,
265
           const struct value_print_options *options,
266
           const struct language_defn *language)
267
{
268
  volatile struct gdb_exception except;
269
  int ret = 0;
270
  struct value_print_options local_opts = *options;
271
  struct type *real_type = check_typedef (type);
272
 
273
  if (local_opts.pretty == Val_pretty_default)
274
    local_opts.pretty = (local_opts.prettyprint_structs
275
                         ? Val_prettyprint : Val_no_prettyprint);
276
 
277
  QUIT;
278
 
279
  /* Ensure that the type is complete and not just a stub.  If the type is
280
     only a stub and we can't find and substitute its complete type, then
281
     print appropriate string and return.  */
282
 
283
  if (TYPE_STUB (real_type))
284
    {
285
      fprintf_filtered (stream, "<incomplete type>");
286
      gdb_flush (stream);
287
      return (0);
288
    }
289
 
290
  if (!options->raw)
291
    {
292
      ret = apply_val_pretty_printer (type, valaddr, embedded_offset,
293
                                      address, stream, recurse, options,
294
                                      language);
295
      if (ret)
296
        return ret;
297
    }
298
 
299
  /* Handle summary mode.  If the value is a scalar, print it;
300
     otherwise, print an ellipsis.  */
301
  if (options->summary && !scalar_type_p (type))
302
    {
303
      fprintf_filtered (stream, "...");
304
      return 0;
305
    }
306
 
307
  TRY_CATCH (except, RETURN_MASK_ERROR)
308
    {
309
      ret = language->la_val_print (type, valaddr, embedded_offset, address,
310
                                    stream, recurse, &local_opts);
311
    }
312
  if (except.reason < 0)
313
    fprintf_filtered (stream, _("<error reading variable>"));
314
 
315
  return ret;
316
}
317
 
318
/* Check whether the value VAL is printable.  Return 1 if it is;
319
   return 0 and print an appropriate error message to STREAM if it
320
   is not.  */
321
 
322
static int
323
value_check_printable (struct value *val, struct ui_file *stream)
324
{
325
  if (val == 0)
326
    {
327
      fprintf_filtered (stream, _("<address of value unknown>"));
328
      return 0;
329
    }
330
 
331
  if (value_optimized_out (val))
332
    {
333
      fprintf_filtered (stream, _("<value optimized out>"));
334
      return 0;
335
    }
336
 
337
  if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
338
    {
339
      fprintf_filtered (stream, _("<internal function %s>"),
340
                        value_internal_function_name (val));
341
      return 0;
342
    }
343
 
344
  return 1;
345
}
346
 
347
/* Print using the given LANGUAGE the value VAL onto stream STREAM according
348
   to OPTIONS.
349
 
350
   If the data are a string pointer, returns the number of string characters
351
   printed.
352
 
353
   This is a preferable interface to val_print, above, because it uses
354
   GDB's value mechanism.  */
355
 
356
int
357
common_val_print (struct value *val, struct ui_file *stream, int recurse,
358
                  const struct value_print_options *options,
359
                  const struct language_defn *language)
360
{
361
  if (!value_check_printable (val, stream))
362
    return 0;
363
 
364
  return val_print (value_type (val), value_contents_all (val),
365
                    value_embedded_offset (val), value_address (val),
366
                    stream, recurse, options, language);
367
}
368
 
369
/* Print on stream STREAM the value VAL according to OPTIONS.  The value
370
   is printed using the current_language syntax.
371
 
372
   If the object printed is a string pointer, return the number of string
373
   bytes printed.  */
374
 
375
int
376
value_print (struct value *val, struct ui_file *stream,
377
             const struct value_print_options *options)
378
{
379
  if (!value_check_printable (val, stream))
380
    return 0;
381
 
382
  if (!options->raw)
383
    {
384
      int r = apply_val_pretty_printer (value_type (val),
385
                                        value_contents_all (val),
386
                                        value_embedded_offset (val),
387
                                        value_address (val),
388
                                        stream, 0, options,
389
                                        current_language);
390
      if (r)
391
        return r;
392
    }
393
 
394
  return LA_VALUE_PRINT (val, stream, options);
395
}
396
 
397
/* Called by various <lang>_val_print routines to print
398
   TYPE_CODE_INT's.  TYPE is the type.  VALADDR is the address of the
399
   value.  STREAM is where to print the value.  */
400
 
401
void
402
val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
403
                         struct ui_file *stream)
404
{
405
  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
406
 
407
  if (TYPE_LENGTH (type) > sizeof (LONGEST))
408
    {
409
      LONGEST val;
410
 
411
      if (TYPE_UNSIGNED (type)
412
          && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
413
                                            byte_order, &val))
414
        {
415
          print_longest (stream, 'u', 0, val);
416
        }
417
      else
418
        {
419
          /* Signed, or we couldn't turn an unsigned value into a
420
             LONGEST.  For signed values, one could assume two's
421
             complement (a reasonable assumption, I think) and do
422
             better than this.  */
423
          print_hex_chars (stream, (unsigned char *) valaddr,
424
                           TYPE_LENGTH (type), byte_order);
425
        }
426
    }
427
  else
428
    {
429
      print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
430
                     unpack_long (type, valaddr));
431
    }
432
}
433
 
434
void
435
val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
436
                           struct ui_file *stream)
437
{
438
  ULONGEST val = unpack_long (type, valaddr);
439
  int bitpos, nfields = TYPE_NFIELDS (type);
440
 
441
  fputs_filtered ("[ ", stream);
442
  for (bitpos = 0; bitpos < nfields; bitpos++)
443
    {
444
      if (TYPE_FIELD_BITPOS (type, bitpos) != -1
445
          && (val & ((ULONGEST)1 << bitpos)))
446
        {
447
          if (TYPE_FIELD_NAME (type, bitpos))
448
            fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
449
          else
450
            fprintf_filtered (stream, "#%d ", bitpos);
451
        }
452
    }
453
  fputs_filtered ("]", stream);
454
}
455
 
456
/* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
457
   The raison d'etre of this function is to consolidate printing of
458
   LONG_LONG's into this one function. The format chars b,h,w,g are
459
   from print_scalar_formatted().  Numbers are printed using C
460
   format.
461
 
462
   USE_C_FORMAT means to use C format in all cases.  Without it,
463
   'o' and 'x' format do not include the standard C radix prefix
464
   (leading 0 or 0x).
465
 
466
   Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
467
   and was intended to request formating according to the current
468
   language and would be used for most integers that GDB prints.  The
469
   exceptional cases were things like protocols where the format of
470
   the integer is a protocol thing, not a user-visible thing).  The
471
   parameter remains to preserve the information of what things might
472
   be printed with language-specific format, should we ever resurrect
473
   that capability. */
474
 
475
void
476
print_longest (struct ui_file *stream, int format, int use_c_format,
477
               LONGEST val_long)
478
{
479
  const char *val;
480
 
481
  switch (format)
482
    {
483
    case 'd':
484
      val = int_string (val_long, 10, 1, 0, 1); break;
485
    case 'u':
486
      val = int_string (val_long, 10, 0, 0, 1); break;
487
    case 'x':
488
      val = int_string (val_long, 16, 0, 0, use_c_format); break;
489
    case 'b':
490
      val = int_string (val_long, 16, 0, 2, 1); break;
491
    case 'h':
492
      val = int_string (val_long, 16, 0, 4, 1); break;
493
    case 'w':
494
      val = int_string (val_long, 16, 0, 8, 1); break;
495
    case 'g':
496
      val = int_string (val_long, 16, 0, 16, 1); break;
497
      break;
498
    case 'o':
499
      val = int_string (val_long, 8, 0, 0, use_c_format); break;
500
    default:
501
      internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
502
    }
503
  fputs_filtered (val, stream);
504
}
505
 
506
/* This used to be a macro, but I don't think it is called often enough
507
   to merit such treatment.  */
508
/* Convert a LONGEST to an int.  This is used in contexts (e.g. number of
509
   arguments to a function, number in a value history, register number, etc.)
510
   where the value must not be larger than can fit in an int.  */
511
 
512
int
513
longest_to_int (LONGEST arg)
514
{
515
  /* Let the compiler do the work */
516
  int rtnval = (int) arg;
517
 
518
  /* Check for overflows or underflows */
519
  if (sizeof (LONGEST) > sizeof (int))
520
    {
521
      if (rtnval != arg)
522
        {
523
          error (_("Value out of range."));
524
        }
525
    }
526
  return (rtnval);
527
}
528
 
529
/* Print a floating point value of type TYPE (not always a
530
   TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM.  */
531
 
532
void
533
print_floating (const gdb_byte *valaddr, struct type *type,
534
                struct ui_file *stream)
535
{
536
  DOUBLEST doub;
537
  int inv;
538
  const struct floatformat *fmt = NULL;
539
  unsigned len = TYPE_LENGTH (type);
540
  enum float_kind kind;
541
 
542
  /* If it is a floating-point, check for obvious problems.  */
543
  if (TYPE_CODE (type) == TYPE_CODE_FLT)
544
    fmt = floatformat_from_type (type);
545
  if (fmt != NULL)
546
    {
547
      kind = floatformat_classify (fmt, valaddr);
548
      if (kind == float_nan)
549
        {
550
          if (floatformat_is_negative (fmt, valaddr))
551
            fprintf_filtered (stream, "-");
552
          fprintf_filtered (stream, "nan(");
553
          fputs_filtered ("0x", stream);
554
          fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
555
          fprintf_filtered (stream, ")");
556
          return;
557
        }
558
      else if (kind == float_infinite)
559
        {
560
          if (floatformat_is_negative (fmt, valaddr))
561
            fputs_filtered ("-", stream);
562
          fputs_filtered ("inf", stream);
563
          return;
564
        }
565
    }
566
 
567
  /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
568
     isn't necessarily a TYPE_CODE_FLT.  Consequently, unpack_double
569
     needs to be used as that takes care of any necessary type
570
     conversions.  Such conversions are of course direct to DOUBLEST
571
     and disregard any possible target floating point limitations.
572
     For instance, a u64 would be converted and displayed exactly on a
573
     host with 80 bit DOUBLEST but with loss of information on a host
574
     with 64 bit DOUBLEST.  */
575
 
576
  doub = unpack_double (type, valaddr, &inv);
577
  if (inv)
578
    {
579
      fprintf_filtered (stream, "<invalid float value>");
580
      return;
581
    }
582
 
583
  /* FIXME: kettenis/2001-01-20: The following code makes too much
584
     assumptions about the host and target floating point format.  */
585
 
586
  /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
587
     not necessarily be a TYPE_CODE_FLT, the below ignores that and
588
     instead uses the type's length to determine the precision of the
589
     floating-point value being printed.  */
590
 
591
  if (len < sizeof (double))
592
      fprintf_filtered (stream, "%.9g", (double) doub);
593
  else if (len == sizeof (double))
594
      fprintf_filtered (stream, "%.17g", (double) doub);
595
  else
596
#ifdef PRINTF_HAS_LONG_DOUBLE
597
    fprintf_filtered (stream, "%.35Lg", doub);
598
#else
599
    /* This at least wins with values that are representable as
600
       doubles.  */
601
    fprintf_filtered (stream, "%.17g", (double) doub);
602
#endif
603
}
604
 
605
void
606
print_decimal_floating (const gdb_byte *valaddr, struct type *type,
607
                        struct ui_file *stream)
608
{
609
  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
610
  char decstr[MAX_DECIMAL_STRING];
611
  unsigned len = TYPE_LENGTH (type);
612
 
613
  decimal_to_string (valaddr, len, byte_order, decstr);
614
  fputs_filtered (decstr, stream);
615
  return;
616
}
617
 
618
void
619
print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
620
                    unsigned len, enum bfd_endian byte_order)
621
{
622
 
623
#define BITS_IN_BYTES 8
624
 
625
  const gdb_byte *p;
626
  unsigned int i;
627
  int b;
628
 
629
  /* Declared "int" so it will be signed.
630
   * This ensures that right shift will shift in zeros.
631
   */
632
  const int mask = 0x080;
633
 
634
  /* FIXME: We should be not printing leading zeroes in most cases.  */
635
 
636
  if (byte_order == BFD_ENDIAN_BIG)
637
    {
638
      for (p = valaddr;
639
           p < valaddr + len;
640
           p++)
641
        {
642
          /* Every byte has 8 binary characters; peel off
643
           * and print from the MSB end.
644
           */
645
          for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
646
            {
647
              if (*p & (mask >> i))
648
                b = 1;
649
              else
650
                b = 0;
651
 
652
              fprintf_filtered (stream, "%1d", b);
653
            }
654
        }
655
    }
656
  else
657
    {
658
      for (p = valaddr + len - 1;
659
           p >= valaddr;
660
           p--)
661
        {
662
          for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
663
            {
664
              if (*p & (mask >> i))
665
                b = 1;
666
              else
667
                b = 0;
668
 
669
              fprintf_filtered (stream, "%1d", b);
670
            }
671
        }
672
    }
673
}
674
 
675
/* VALADDR points to an integer of LEN bytes.
676
 * Print it in octal on stream or format it in buf.
677
 */
678
void
679
print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
680
                   unsigned len, enum bfd_endian byte_order)
681
{
682
  const gdb_byte *p;
683
  unsigned char octa1, octa2, octa3, carry;
684
  int cycle;
685
 
686
  /* FIXME: We should be not printing leading zeroes in most cases.  */
687
 
688
 
689
  /* Octal is 3 bits, which doesn't fit.  Yuk.  So we have to track
690
   * the extra bits, which cycle every three bytes:
691
   *
692
   * Byte side:       0            1             2          3
693
   *                         |             |            |            |
694
   * bit number   123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
695
   *
696
   * Octal side:   0   1   carry  3   4  carry ...
697
   *
698
   * Cycle number:    0             1            2
699
   *
700
   * But of course we are printing from the high side, so we have to
701
   * figure out where in the cycle we are so that we end up with no
702
   * left over bits at the end.
703
   */
704
#define BITS_IN_OCTAL 3
705
#define HIGH_ZERO     0340
706
#define LOW_ZERO      0016
707
#define CARRY_ZERO    0003
708
#define HIGH_ONE      0200
709
#define MID_ONE       0160
710
#define LOW_ONE       0016
711
#define CARRY_ONE     0001
712
#define HIGH_TWO      0300
713
#define MID_TWO       0070
714
#define LOW_TWO       0007
715
 
716
  /* For 32 we start in cycle 2, with two bits and one bit carry;
717
   * for 64 in cycle in cycle 1, with one bit and a two bit carry.
718
   */
719
  cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
720
  carry = 0;
721
 
722
  fputs_filtered ("0", stream);
723
  if (byte_order == BFD_ENDIAN_BIG)
724
    {
725
      for (p = valaddr;
726
           p < valaddr + len;
727
           p++)
728
        {
729
          switch (cycle)
730
            {
731
            case 0:
732
              /* No carry in, carry out two bits.
733
               */
734
              octa1 = (HIGH_ZERO & *p) >> 5;
735
              octa2 = (LOW_ZERO & *p) >> 2;
736
              carry = (CARRY_ZERO & *p);
737
              fprintf_filtered (stream, "%o", octa1);
738
              fprintf_filtered (stream, "%o", octa2);
739
              break;
740
 
741
            case 1:
742
              /* Carry in two bits, carry out one bit.
743
               */
744
              octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
745
              octa2 = (MID_ONE & *p) >> 4;
746
              octa3 = (LOW_ONE & *p) >> 1;
747
              carry = (CARRY_ONE & *p);
748
              fprintf_filtered (stream, "%o", octa1);
749
              fprintf_filtered (stream, "%o", octa2);
750
              fprintf_filtered (stream, "%o", octa3);
751
              break;
752
 
753
            case 2:
754
              /* Carry in one bit, no carry out.
755
               */
756
              octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
757
              octa2 = (MID_TWO & *p) >> 3;
758
              octa3 = (LOW_TWO & *p);
759
              carry = 0;
760
              fprintf_filtered (stream, "%o", octa1);
761
              fprintf_filtered (stream, "%o", octa2);
762
              fprintf_filtered (stream, "%o", octa3);
763
              break;
764
 
765
            default:
766
              error (_("Internal error in octal conversion;"));
767
            }
768
 
769
          cycle++;
770
          cycle = cycle % BITS_IN_OCTAL;
771
        }
772
    }
773
  else
774
    {
775
      for (p = valaddr + len - 1;
776
           p >= valaddr;
777
           p--)
778
        {
779
          switch (cycle)
780
            {
781
            case 0:
782
              /* Carry out, no carry in */
783
              octa1 = (HIGH_ZERO & *p) >> 5;
784
              octa2 = (LOW_ZERO & *p) >> 2;
785
              carry = (CARRY_ZERO & *p);
786
              fprintf_filtered (stream, "%o", octa1);
787
              fprintf_filtered (stream, "%o", octa2);
788
              break;
789
 
790
            case 1:
791
              /* Carry in, carry out */
792
              octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
793
              octa2 = (MID_ONE & *p) >> 4;
794
              octa3 = (LOW_ONE & *p) >> 1;
795
              carry = (CARRY_ONE & *p);
796
              fprintf_filtered (stream, "%o", octa1);
797
              fprintf_filtered (stream, "%o", octa2);
798
              fprintf_filtered (stream, "%o", octa3);
799
              break;
800
 
801
            case 2:
802
              /* Carry in, no carry out */
803
              octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
804
              octa2 = (MID_TWO & *p) >> 3;
805
              octa3 = (LOW_TWO & *p);
806
              carry = 0;
807
              fprintf_filtered (stream, "%o", octa1);
808
              fprintf_filtered (stream, "%o", octa2);
809
              fprintf_filtered (stream, "%o", octa3);
810
              break;
811
 
812
            default:
813
              error (_("Internal error in octal conversion;"));
814
            }
815
 
816
          cycle++;
817
          cycle = cycle % BITS_IN_OCTAL;
818
        }
819
    }
820
 
821
}
822
 
823
/* VALADDR points to an integer of LEN bytes.
824
 * Print it in decimal on stream or format it in buf.
825
 */
826
void
827
print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
828
                     unsigned len, enum bfd_endian byte_order)
829
{
830
#define TEN             10
831
#define CARRY_OUT(  x ) ((x) / TEN)     /* extend char to int */
832
#define CARRY_LEFT( x ) ((x) % TEN)
833
#define SHIFT( x )      ((x) << 4)
834
#define LOW_NIBBLE(  x ) ( (x) & 0x00F)
835
#define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
836
 
837
  const gdb_byte *p;
838
  unsigned char *digits;
839
  int carry;
840
  int decimal_len;
841
  int i, j, decimal_digits;
842
  int dummy;
843
  int flip;
844
 
845
  /* Base-ten number is less than twice as many digits
846
   * as the base 16 number, which is 2 digits per byte.
847
   */
848
  decimal_len = len * 2 * 2;
849
  digits = xmalloc (decimal_len);
850
 
851
  for (i = 0; i < decimal_len; i++)
852
    {
853
      digits[i] = 0;
854
    }
855
 
856
  /* Ok, we have an unknown number of bytes of data to be printed in
857
   * decimal.
858
   *
859
   * Given a hex number (in nibbles) as XYZ, we start by taking X and
860
   * decemalizing it as "x1 x2" in two decimal nibbles.  Then we multiply
861
   * the nibbles by 16, add Y and re-decimalize.  Repeat with Z.
862
   *
863
   * The trick is that "digits" holds a base-10 number, but sometimes
864
   * the individual digits are > 10.
865
   *
866
   * Outer loop is per nibble (hex digit) of input, from MSD end to
867
   * LSD end.
868
   */
869
  decimal_digits = 0;            /* Number of decimal digits so far */
870
  p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
871
  flip = 0;
872
  while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
873
    {
874
      /*
875
       * Multiply current base-ten number by 16 in place.
876
       * Each digit was between 0 and 9, now is between
877
       * 0 and 144.
878
       */
879
      for (j = 0; j < decimal_digits; j++)
880
        {
881
          digits[j] = SHIFT (digits[j]);
882
        }
883
 
884
      /* Take the next nibble off the input and add it to what
885
       * we've got in the LSB position.  Bottom 'digit' is now
886
       * between 0 and 159.
887
       *
888
       * "flip" is used to run this loop twice for each byte.
889
       */
890
      if (flip == 0)
891
        {
892
          /* Take top nibble.
893
           */
894
          digits[0] += HIGH_NIBBLE (*p);
895
          flip = 1;
896
        }
897
      else
898
        {
899
          /* Take low nibble and bump our pointer "p".
900
           */
901
          digits[0] += LOW_NIBBLE (*p);
902
          if (byte_order == BFD_ENDIAN_BIG)
903
            p++;
904
          else
905
            p--;
906
          flip = 0;
907
        }
908
 
909
      /* Re-decimalize.  We have to do this often enough
910
       * that we don't overflow, but once per nibble is
911
       * overkill.  Easier this way, though.  Note that the
912
       * carry is often larger than 10 (e.g. max initial
913
       * carry out of lowest nibble is 15, could bubble all
914
       * the way up greater than 10).  So we have to do
915
       * the carrying beyond the last current digit.
916
       */
917
      carry = 0;
918
      for (j = 0; j < decimal_len - 1; j++)
919
        {
920
          digits[j] += carry;
921
 
922
          /* "/" won't handle an unsigned char with
923
           * a value that if signed would be negative.
924
           * So extend to longword int via "dummy".
925
           */
926
          dummy = digits[j];
927
          carry = CARRY_OUT (dummy);
928
          digits[j] = CARRY_LEFT (dummy);
929
 
930
          if (j >= decimal_digits && carry == 0)
931
            {
932
              /*
933
               * All higher digits are 0 and we
934
               * no longer have a carry.
935
               *
936
               * Note: "j" is 0-based, "decimal_digits" is
937
               *       1-based.
938
               */
939
              decimal_digits = j + 1;
940
              break;
941
            }
942
        }
943
    }
944
 
945
  /* Ok, now "digits" is the decimal representation, with
946
   * the "decimal_digits" actual digits.  Print!
947
   */
948
  for (i = decimal_digits - 1; i >= 0; i--)
949
    {
950
      fprintf_filtered (stream, "%1d", digits[i]);
951
    }
952
  xfree (digits);
953
}
954
 
955
/* VALADDR points to an integer of LEN bytes.  Print it in hex on stream.  */
956
 
957
void
958
print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
959
                 unsigned len, enum bfd_endian byte_order)
960
{
961
  const gdb_byte *p;
962
 
963
  /* FIXME: We should be not printing leading zeroes in most cases.  */
964
 
965
  fputs_filtered ("0x", stream);
966
  if (byte_order == BFD_ENDIAN_BIG)
967
    {
968
      for (p = valaddr;
969
           p < valaddr + len;
970
           p++)
971
        {
972
          fprintf_filtered (stream, "%02x", *p);
973
        }
974
    }
975
  else
976
    {
977
      for (p = valaddr + len - 1;
978
           p >= valaddr;
979
           p--)
980
        {
981
          fprintf_filtered (stream, "%02x", *p);
982
        }
983
    }
984
}
985
 
986
/* VALADDR points to a char integer of LEN bytes.  Print it out in appropriate language form on stream.
987
   Omit any leading zero chars.  */
988
 
989
void
990
print_char_chars (struct ui_file *stream, struct type *type,
991
                  const gdb_byte *valaddr,
992
                  unsigned len, enum bfd_endian byte_order)
993
{
994
  const gdb_byte *p;
995
 
996
  if (byte_order == BFD_ENDIAN_BIG)
997
    {
998
      p = valaddr;
999
      while (p < valaddr + len - 1 && *p == 0)
1000
        ++p;
1001
 
1002
      while (p < valaddr + len)
1003
        {
1004
          LA_EMIT_CHAR (*p, type, stream, '\'');
1005
          ++p;
1006
        }
1007
    }
1008
  else
1009
    {
1010
      p = valaddr + len - 1;
1011
      while (p > valaddr && *p == 0)
1012
        --p;
1013
 
1014
      while (p >= valaddr)
1015
        {
1016
          LA_EMIT_CHAR (*p, type, stream, '\'');
1017
          --p;
1018
        }
1019
    }
1020
}
1021
 
1022
/* Assuming TYPE is a simple, non-empty array type, compute its upper
1023
   and lower bound.  Save the low bound into LOW_BOUND if not NULL.
1024
   Save the high bound into HIGH_BOUND if not NULL.
1025
 
1026
   Return 1 if the operation was successful. Return zero otherwise,
1027
   in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
1028
 
1029
   Computing the array upper and lower bounds is pretty easy, but this
1030
   function does some additional verifications before returning them.
1031
   If something incorrect is detected, it is better to return a status
1032
   rather than throwing an error, making it easier for the caller to
1033
   implement an error-recovery plan.  For instance, it may decide to
1034
   warn the user that the bounds were not found and then use some
1035
   default values instead.  */
1036
 
1037
int
1038
get_array_bounds (struct type *type, long *low_bound, long *high_bound)
1039
{
1040
  struct type *index = TYPE_INDEX_TYPE (type);
1041
  long low = 0;
1042
  long high = 0;
1043
 
1044
  if (index == NULL)
1045
    return 0;
1046
 
1047
  if (TYPE_CODE (index) == TYPE_CODE_RANGE)
1048
    {
1049
      low = TYPE_LOW_BOUND (index);
1050
      high = TYPE_HIGH_BOUND (index);
1051
    }
1052
  else if (TYPE_CODE (index) == TYPE_CODE_ENUM)
1053
    {
1054
      const int n_enums = TYPE_NFIELDS (index);
1055
 
1056
      low = TYPE_FIELD_BITPOS (index, 0);
1057
      high = TYPE_FIELD_BITPOS (index, n_enums - 1);
1058
    }
1059
  else
1060
    return 0;
1061
 
1062
  /* Abort if the lower bound is greater than the higher bound, except
1063
     when low = high + 1.  This is a very common idiom used in Ada when
1064
     defining empty ranges (for instance "range 1 .. 0").  */
1065
  if (low > high + 1)
1066
    return 0;
1067
 
1068
  if (low_bound)
1069
    *low_bound = low;
1070
 
1071
  if (high_bound)
1072
    *high_bound = high;
1073
 
1074
  return 1;
1075
}
1076
 
1077
/* Print on STREAM using the given OPTIONS the index for the element
1078
   at INDEX of an array whose index type is INDEX_TYPE.  */
1079
 
1080
void
1081
maybe_print_array_index (struct type *index_type, LONGEST index,
1082
                         struct ui_file *stream,
1083
                         const struct value_print_options *options)
1084
{
1085
  struct value *index_value;
1086
 
1087
  if (!options->print_array_indexes)
1088
    return;
1089
 
1090
  index_value = value_from_longest (index_type, index);
1091
 
1092
  LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1093
}
1094
 
1095
/*  Called by various <lang>_val_print routines to print elements of an
1096
   array in the form "<elem1>, <elem2>, <elem3>, ...".
1097
 
1098
   (FIXME?)  Assumes array element separator is a comma, which is correct
1099
   for all languages currently handled.
1100
   (FIXME?)  Some languages have a notation for repeated array elements,
1101
   perhaps we should try to use that notation when appropriate.
1102
 */
1103
 
1104
void
1105
val_print_array_elements (struct type *type, const gdb_byte *valaddr,
1106
                          CORE_ADDR address, struct ui_file *stream,
1107
                          int recurse,
1108
                          const struct value_print_options *options,
1109
                          unsigned int i)
1110
{
1111
  unsigned int things_printed = 0;
1112
  unsigned len;
1113
  struct type *elttype, *index_type;
1114
  unsigned eltlen;
1115
  /* Position of the array element we are examining to see
1116
     whether it is repeated.  */
1117
  unsigned int rep1;
1118
  /* Number of repetitions we have detected so far.  */
1119
  unsigned int reps;
1120
  long low_bound_index = 0;
1121
 
1122
  elttype = TYPE_TARGET_TYPE (type);
1123
  eltlen = TYPE_LENGTH (check_typedef (elttype));
1124
  index_type = TYPE_INDEX_TYPE (type);
1125
 
1126
  /* Compute the number of elements in the array.  On most arrays,
1127
     the size of its elements is not zero, and so the number of elements
1128
     is simply the size of the array divided by the size of the elements.
1129
     But for arrays of elements whose size is zero, we need to look at
1130
     the bounds.  */
1131
  if (eltlen != 0)
1132
    len = TYPE_LENGTH (type) / eltlen;
1133
  else
1134
    {
1135
      long low, hi;
1136
      if (get_array_bounds (type, &low, &hi))
1137
        len = hi - low + 1;
1138
      else
1139
        {
1140
          warning (_("unable to get bounds of array, assuming null array"));
1141
          len = 0;
1142
        }
1143
    }
1144
 
1145
  /* Get the array low bound.  This only makes sense if the array
1146
     has one or more element in it.  */
1147
  if (len > 0 && !get_array_bounds (type, &low_bound_index, NULL))
1148
    {
1149
      warning (_("unable to get low bound of array, using zero as default"));
1150
      low_bound_index = 0;
1151
    }
1152
 
1153
  annotate_array_section_begin (i, elttype);
1154
 
1155
  for (; i < len && things_printed < options->print_max; i++)
1156
    {
1157
      if (i != 0)
1158
        {
1159
          if (options->prettyprint_arrays)
1160
            {
1161
              fprintf_filtered (stream, ",\n");
1162
              print_spaces_filtered (2 + 2 * recurse, stream);
1163
            }
1164
          else
1165
            {
1166
              fprintf_filtered (stream, ", ");
1167
            }
1168
        }
1169
      wrap_here (n_spaces (2 + 2 * recurse));
1170
      maybe_print_array_index (index_type, i + low_bound_index,
1171
                               stream, options);
1172
 
1173
      rep1 = i + 1;
1174
      reps = 1;
1175
      while ((rep1 < len) &&
1176
             !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
1177
        {
1178
          ++reps;
1179
          ++rep1;
1180
        }
1181
 
1182
      if (reps > options->repeat_count_threshold)
1183
        {
1184
          val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
1185
                     stream, recurse + 1, options, current_language);
1186
          annotate_elt_rep (reps);
1187
          fprintf_filtered (stream, " <repeats %u times>", reps);
1188
          annotate_elt_rep_end ();
1189
 
1190
          i = rep1 - 1;
1191
          things_printed += options->repeat_count_threshold;
1192
        }
1193
      else
1194
        {
1195
          val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
1196
                     stream, recurse + 1, options, current_language);
1197
          annotate_elt ();
1198
          things_printed++;
1199
        }
1200
    }
1201
  annotate_array_section_end ();
1202
  if (i < len)
1203
    {
1204
      fprintf_filtered (stream, "...");
1205
    }
1206
}
1207
 
1208
/* Read LEN bytes of target memory at address MEMADDR, placing the
1209
   results in GDB's memory at MYADDR.  Returns a count of the bytes
1210
   actually read, and optionally an errno value in the location
1211
   pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1212
 
1213
/* FIXME: cagney/1999-10-14: Only used by val_print_string.  Can this
1214
   function be eliminated.  */
1215
 
1216
static int
1217
partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errnoptr)
1218
{
1219
  int nread;                    /* Number of bytes actually read. */
1220
  int errcode;                  /* Error from last read. */
1221
 
1222
  /* First try a complete read. */
1223
  errcode = target_read_memory (memaddr, myaddr, len);
1224
  if (errcode == 0)
1225
    {
1226
      /* Got it all. */
1227
      nread = len;
1228
    }
1229
  else
1230
    {
1231
      /* Loop, reading one byte at a time until we get as much as we can. */
1232
      for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1233
        {
1234
          errcode = target_read_memory (memaddr++, myaddr++, 1);
1235
        }
1236
      /* If an error, the last read was unsuccessful, so adjust count. */
1237
      if (errcode != 0)
1238
        {
1239
          nread--;
1240
        }
1241
    }
1242
  if (errnoptr != NULL)
1243
    {
1244
      *errnoptr = errcode;
1245
    }
1246
  return (nread);
1247
}
1248
 
1249
/* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1250
   each.  Fetch at most FETCHLIMIT characters.  BUFFER will be set to a newly
1251
   allocated buffer containing the string, which the caller is responsible to
1252
   free, and BYTES_READ will be set to the number of bytes read.  Returns 0 on
1253
   success, or errno on failure.
1254
 
1255
   If LEN > 0, reads exactly LEN characters (including eventual NULs in
1256
   the middle or end of the string).  If LEN is -1, stops at the first
1257
   null character (not necessarily the first null byte) up to a maximum
1258
   of FETCHLIMIT characters.  Set FETCHLIMIT to UINT_MAX to read as many
1259
   characters as possible from the string.
1260
 
1261
   Unless an exception is thrown, BUFFER will always be allocated, even on
1262
   failure.  In this case, some characters might have been read before the
1263
   failure happened.  Check BYTES_READ to recognize this situation.
1264
 
1265
   Note: There was a FIXME asking to make this code use target_read_string,
1266
   but this function is more general (can read past null characters, up to
1267
   given LEN). Besides, it is used much more often than target_read_string
1268
   so it is more tested.  Perhaps callers of target_read_string should use
1269
   this function instead?  */
1270
 
1271
int
1272
read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
1273
             enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
1274
{
1275
  int found_nul;                /* Non-zero if we found the nul char.  */
1276
  int errcode;                  /* Errno returned from bad reads.  */
1277
  unsigned int nfetch;          /* Chars to fetch / chars fetched.  */
1278
  unsigned int chunksize;       /* Size of each fetch, in chars.  */
1279
  gdb_byte *bufptr;             /* Pointer to next available byte in buffer.  */
1280
  gdb_byte *limit;              /* First location past end of fetch buffer.  */
1281
  struct cleanup *old_chain = NULL;     /* Top of the old cleanup chain.  */
1282
 
1283
  /* Decide how large of chunks to try to read in one operation.  This
1284
     is also pretty simple.  If LEN >= zero, then we want fetchlimit chars,
1285
     so we might as well read them all in one operation.  If LEN is -1, we
1286
     are looking for a NUL terminator to end the fetching, so we might as
1287
     well read in blocks that are large enough to be efficient, but not so
1288
     large as to be slow if fetchlimit happens to be large.  So we choose the
1289
     minimum of 8 and fetchlimit.  We used to use 200 instead of 8 but
1290
     200 is way too big for remote debugging over a serial line.  */
1291
 
1292
  chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1293
 
1294
  /* Loop until we either have all the characters, or we encounter
1295
     some error, such as bumping into the end of the address space.  */
1296
 
1297
  found_nul = 0;
1298
  *buffer = NULL;
1299
 
1300
  old_chain = make_cleanup (free_current_contents, buffer);
1301
 
1302
  if (len > 0)
1303
    {
1304
      *buffer = (gdb_byte *) xmalloc (len * width);
1305
      bufptr = *buffer;
1306
 
1307
      nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
1308
        / width;
1309
      addr += nfetch * width;
1310
      bufptr += nfetch * width;
1311
    }
1312
  else if (len == -1)
1313
    {
1314
      unsigned long bufsize = 0;
1315
 
1316
      do
1317
        {
1318
          QUIT;
1319
          nfetch = min (chunksize, fetchlimit - bufsize);
1320
 
1321
          if (*buffer == NULL)
1322
            *buffer = (gdb_byte *) xmalloc (nfetch * width);
1323
          else
1324
            *buffer = (gdb_byte *) xrealloc (*buffer,
1325
                                             (nfetch + bufsize) * width);
1326
 
1327
          bufptr = *buffer + bufsize * width;
1328
          bufsize += nfetch;
1329
 
1330
          /* Read as much as we can.  */
1331
          nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1332
                    / width;
1333
 
1334
          /* Scan this chunk for the null character that terminates the string
1335
             to print.  If found, we don't need to fetch any more.  Note
1336
             that bufptr is explicitly left pointing at the next character
1337
             after the null character, or at the next character after the end
1338
             of the buffer.  */
1339
 
1340
          limit = bufptr + nfetch * width;
1341
          while (bufptr < limit)
1342
            {
1343
              unsigned long c;
1344
 
1345
              c = extract_unsigned_integer (bufptr, width, byte_order);
1346
              addr += width;
1347
              bufptr += width;
1348
              if (c == 0)
1349
                {
1350
                  /* We don't care about any error which happened after
1351
                     the NUL terminator.  */
1352
                  errcode = 0;
1353
                  found_nul = 1;
1354
                  break;
1355
                }
1356
            }
1357
        }
1358
      while (errcode == 0        /* no error */
1359
             && bufptr - *buffer < fetchlimit * width   /* no overrun */
1360
             && !found_nul);    /* haven't found NUL yet */
1361
    }
1362
  else
1363
    {                           /* Length of string is really 0!  */
1364
      /* We always allocate *buffer.  */
1365
      *buffer = bufptr = xmalloc (1);
1366
      errcode = 0;
1367
    }
1368
 
1369
  /* bufptr and addr now point immediately beyond the last byte which we
1370
     consider part of the string (including a '\0' which ends the string).  */
1371
  *bytes_read = bufptr - *buffer;
1372
 
1373
  QUIT;
1374
 
1375
  discard_cleanups (old_chain);
1376
 
1377
  return errcode;
1378
}
1379
 
1380
/* Print a string from the inferior, starting at ADDR and printing up to LEN
1381
   characters, of WIDTH bytes a piece, to STREAM.  If LEN is -1, printing
1382
   stops at the first null byte, otherwise printing proceeds (including null
1383
   bytes) until either print_max or LEN characters have been printed,
1384
   whichever is smaller.  */
1385
 
1386
int
1387
val_print_string (struct type *elttype, CORE_ADDR addr, int len,
1388
                  struct ui_file *stream,
1389
                  const struct value_print_options *options)
1390
{
1391
  int force_ellipsis = 0;        /* Force ellipsis to be printed if nonzero.  */
1392
  int errcode;                  /* Errno returned from bad reads.  */
1393
  int found_nul;                /* Non-zero if we found the nul char */
1394
  unsigned int fetchlimit;      /* Maximum number of chars to print.  */
1395
  int bytes_read;
1396
  gdb_byte *buffer = NULL;      /* Dynamically growable fetch buffer.  */
1397
  struct cleanup *old_chain = NULL;     /* Top of the old cleanup chain.  */
1398
  struct gdbarch *gdbarch = get_type_arch (elttype);
1399
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1400
  int width = TYPE_LENGTH (elttype);
1401
 
1402
  /* First we need to figure out the limit on the number of characters we are
1403
     going to attempt to fetch and print.  This is actually pretty simple.  If
1404
     LEN >= zero, then the limit is the minimum of LEN and print_max.  If
1405
     LEN is -1, then the limit is print_max.  This is true regardless of
1406
     whether print_max is zero, UINT_MAX (unlimited), or something in between,
1407
     because finding the null byte (or available memory) is what actually
1408
     limits the fetch.  */
1409
 
1410
  fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
1411
 
1412
  errcode = read_string (addr, len, width, fetchlimit, byte_order,
1413
                         &buffer, &bytes_read);
1414
  old_chain = make_cleanup (xfree, buffer);
1415
 
1416
  addr += bytes_read;
1417
 
1418
  /* We now have either successfully filled the buffer to fetchlimit, or
1419
     terminated early due to an error or finding a null char when LEN is -1.  */
1420
 
1421
  /* Determine found_nul by looking at the last character read.  */
1422
  found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
1423
                                        byte_order) == 0;
1424
  if (len == -1 && !found_nul)
1425
    {
1426
      gdb_byte *peekbuf;
1427
 
1428
      /* We didn't find a NUL terminator we were looking for.  Attempt
1429
         to peek at the next character.  If not successful, or it is not
1430
         a null byte, then force ellipsis to be printed.  */
1431
 
1432
      peekbuf = (gdb_byte *) alloca (width);
1433
 
1434
      if (target_read_memory (addr, peekbuf, width) == 0
1435
          && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
1436
        force_ellipsis = 1;
1437
    }
1438
  else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
1439
    {
1440
      /* Getting an error when we have a requested length, or fetching less
1441
         than the number of characters actually requested, always make us
1442
         print ellipsis.  */
1443
      force_ellipsis = 1;
1444
    }
1445
 
1446
  /* If we get an error before fetching anything, don't print a string.
1447
     But if we fetch something and then get an error, print the string
1448
     and then the error message.  */
1449
  if (errcode == 0 || bytes_read > 0)
1450
    {
1451
      if (options->addressprint)
1452
        {
1453
          fputs_filtered (" ", stream);
1454
        }
1455
      LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
1456
                       NULL, force_ellipsis, options);
1457
    }
1458
 
1459
  if (errcode != 0)
1460
    {
1461
      if (errcode == EIO)
1462
        {
1463
          fprintf_filtered (stream, " <Address ");
1464
          fputs_filtered (paddress (gdbarch, addr), stream);
1465
          fprintf_filtered (stream, " out of bounds>");
1466
        }
1467
      else
1468
        {
1469
          fprintf_filtered (stream, " <Error reading address ");
1470
          fputs_filtered (paddress (gdbarch, addr), stream);
1471
          fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
1472
        }
1473
    }
1474
 
1475
  gdb_flush (stream);
1476
  do_cleanups (old_chain);
1477
 
1478
  return (bytes_read / width);
1479
}
1480
 
1481
 
1482
/* The 'set input-radix' command writes to this auxiliary variable.
1483
   If the requested radix is valid, INPUT_RADIX is updated; otherwise,
1484
   it is left unchanged.  */
1485
 
1486
static unsigned input_radix_1 = 10;
1487
 
1488
/* Validate an input or output radix setting, and make sure the user
1489
   knows what they really did here.  Radix setting is confusing, e.g.
1490
   setting the input radix to "10" never changes it!  */
1491
 
1492
static void
1493
set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
1494
{
1495
  set_input_radix_1 (from_tty, input_radix_1);
1496
}
1497
 
1498
static void
1499
set_input_radix_1 (int from_tty, unsigned radix)
1500
{
1501
  /* We don't currently disallow any input radix except 0 or 1, which don't
1502
     make any mathematical sense.  In theory, we can deal with any input
1503
     radix greater than 1, even if we don't have unique digits for every
1504
     value from 0 to radix-1, but in practice we lose on large radix values.
1505
     We should either fix the lossage or restrict the radix range more.
1506
     (FIXME). */
1507
 
1508
  if (radix < 2)
1509
    {
1510
      input_radix_1 = input_radix;
1511
      error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
1512
             radix);
1513
    }
1514
  input_radix_1 = input_radix = radix;
1515
  if (from_tty)
1516
    {
1517
      printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
1518
                       radix, radix, radix);
1519
    }
1520
}
1521
 
1522
/* The 'set output-radix' command writes to this auxiliary variable.
1523
   If the requested radix is valid, OUTPUT_RADIX is updated,
1524
   otherwise, it is left unchanged.  */
1525
 
1526
static unsigned output_radix_1 = 10;
1527
 
1528
static void
1529
set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
1530
{
1531
  set_output_radix_1 (from_tty, output_radix_1);
1532
}
1533
 
1534
static void
1535
set_output_radix_1 (int from_tty, unsigned radix)
1536
{
1537
  /* Validate the radix and disallow ones that we aren't prepared to
1538
     handle correctly, leaving the radix unchanged. */
1539
  switch (radix)
1540
    {
1541
    case 16:
1542
      user_print_options.output_format = 'x';   /* hex */
1543
      break;
1544
    case 10:
1545
      user_print_options.output_format = 0;      /* decimal */
1546
      break;
1547
    case 8:
1548
      user_print_options.output_format = 'o';   /* octal */
1549
      break;
1550
    default:
1551
      output_radix_1 = output_radix;
1552
      error (_("Unsupported output radix ``decimal %u''; output radix unchanged."),
1553
             radix);
1554
    }
1555
  output_radix_1 = output_radix = radix;
1556
  if (from_tty)
1557
    {
1558
      printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
1559
                       radix, radix, radix);
1560
    }
1561
}
1562
 
1563
/* Set both the input and output radix at once.  Try to set the output radix
1564
   first, since it has the most restrictive range.  An radix that is valid as
1565
   an output radix is also valid as an input radix.
1566
 
1567
   It may be useful to have an unusual input radix.  If the user wishes to
1568
   set an input radix that is not valid as an output radix, he needs to use
1569
   the 'set input-radix' command. */
1570
 
1571
static void
1572
set_radix (char *arg, int from_tty)
1573
{
1574
  unsigned radix;
1575
 
1576
  radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
1577
  set_output_radix_1 (0, radix);
1578
  set_input_radix_1 (0, radix);
1579
  if (from_tty)
1580
    {
1581
      printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
1582
                       radix, radix, radix);
1583
    }
1584
}
1585
 
1586
/* Show both the input and output radices. */
1587
 
1588
static void
1589
show_radix (char *arg, int from_tty)
1590
{
1591
  if (from_tty)
1592
    {
1593
      if (input_radix == output_radix)
1594
        {
1595
          printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
1596
                           input_radix, input_radix, input_radix);
1597
        }
1598
      else
1599
        {
1600
          printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
1601
                           input_radix, input_radix, input_radix);
1602
          printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
1603
                           output_radix, output_radix, output_radix);
1604
        }
1605
    }
1606
}
1607
 
1608
 
1609
static void
1610
set_print (char *arg, int from_tty)
1611
{
1612
  printf_unfiltered (
1613
     "\"set print\" must be followed by the name of a print subcommand.\n");
1614
  help_list (setprintlist, "set print ", -1, gdb_stdout);
1615
}
1616
 
1617
static void
1618
show_print (char *args, int from_tty)
1619
{
1620
  cmd_show_list (showprintlist, from_tty, "");
1621
}
1622
 
1623
void
1624
_initialize_valprint (void)
1625
{
1626
  struct cmd_list_element *c;
1627
 
1628
  add_prefix_cmd ("print", no_class, set_print,
1629
                  _("Generic command for setting how things print."),
1630
                  &setprintlist, "set print ", 0, &setlist);
1631
  add_alias_cmd ("p", "print", no_class, 1, &setlist);
1632
  /* prefer set print to set prompt */
1633
  add_alias_cmd ("pr", "print", no_class, 1, &setlist);
1634
 
1635
  add_prefix_cmd ("print", no_class, show_print,
1636
                  _("Generic command for showing print settings."),
1637
                  &showprintlist, "show print ", 0, &showlist);
1638
  add_alias_cmd ("p", "print", no_class, 1, &showlist);
1639
  add_alias_cmd ("pr", "print", no_class, 1, &showlist);
1640
 
1641
  add_setshow_uinteger_cmd ("elements", no_class,
1642
                            &user_print_options.print_max, _("\
1643
Set limit on string chars or array elements to print."), _("\
1644
Show limit on string chars or array elements to print."), _("\
1645
\"set print elements 0\" causes there to be no limit."),
1646
                            NULL,
1647
                            show_print_max,
1648
                            &setprintlist, &showprintlist);
1649
 
1650
  add_setshow_boolean_cmd ("null-stop", no_class,
1651
                           &user_print_options.stop_print_at_null, _("\
1652
Set printing of char arrays to stop at first null char."), _("\
1653
Show printing of char arrays to stop at first null char."), NULL,
1654
                           NULL,
1655
                           show_stop_print_at_null,
1656
                           &setprintlist, &showprintlist);
1657
 
1658
  add_setshow_uinteger_cmd ("repeats", no_class,
1659
                            &user_print_options.repeat_count_threshold, _("\
1660
Set threshold for repeated print elements."), _("\
1661
Show threshold for repeated print elements."), _("\
1662
\"set print repeats 0\" causes all elements to be individually printed."),
1663
                            NULL,
1664
                            show_repeat_count_threshold,
1665
                            &setprintlist, &showprintlist);
1666
 
1667
  add_setshow_boolean_cmd ("pretty", class_support,
1668
                           &user_print_options.prettyprint_structs, _("\
1669
Set prettyprinting of structures."), _("\
1670
Show prettyprinting of structures."), NULL,
1671
                           NULL,
1672
                           show_prettyprint_structs,
1673
                           &setprintlist, &showprintlist);
1674
 
1675
  add_setshow_boolean_cmd ("union", class_support,
1676
                           &user_print_options.unionprint, _("\
1677
Set printing of unions interior to structures."), _("\
1678
Show printing of unions interior to structures."), NULL,
1679
                           NULL,
1680
                           show_unionprint,
1681
                           &setprintlist, &showprintlist);
1682
 
1683
  add_setshow_boolean_cmd ("array", class_support,
1684
                           &user_print_options.prettyprint_arrays, _("\
1685
Set prettyprinting of arrays."), _("\
1686
Show prettyprinting of arrays."), NULL,
1687
                           NULL,
1688
                           show_prettyprint_arrays,
1689
                           &setprintlist, &showprintlist);
1690
 
1691
  add_setshow_boolean_cmd ("address", class_support,
1692
                           &user_print_options.addressprint, _("\
1693
Set printing of addresses."), _("\
1694
Show printing of addresses."), NULL,
1695
                           NULL,
1696
                           show_addressprint,
1697
                           &setprintlist, &showprintlist);
1698
 
1699
  add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
1700
                             _("\
1701
Set default input radix for entering numbers."), _("\
1702
Show default input radix for entering numbers."), NULL,
1703
                             set_input_radix,
1704
                             show_input_radix,
1705
                             &setlist, &showlist);
1706
 
1707
  add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
1708
                             _("\
1709
Set default output radix for printing of values."), _("\
1710
Show default output radix for printing of values."), NULL,
1711
                             set_output_radix,
1712
                             show_output_radix,
1713
                             &setlist, &showlist);
1714
 
1715
  /* The "set radix" and "show radix" commands are special in that
1716
     they are like normal set and show commands but allow two normally
1717
     independent variables to be either set or shown with a single
1718
     command.  So the usual deprecated_add_set_cmd() and [deleted]
1719
     add_show_from_set() commands aren't really appropriate. */
1720
  /* FIXME: i18n: With the new add_setshow_integer command, that is no
1721
     longer true - show can display anything.  */
1722
  add_cmd ("radix", class_support, set_radix, _("\
1723
Set default input and output number radices.\n\
1724
Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1725
Without an argument, sets both radices back to the default value of 10."),
1726
           &setlist);
1727
  add_cmd ("radix", class_support, show_radix, _("\
1728
Show the default input and output number radices.\n\
1729
Use 'show input-radix' or 'show output-radix' to independently show each."),
1730
           &showlist);
1731
 
1732
  add_setshow_boolean_cmd ("array-indexes", class_support,
1733
                           &user_print_options.print_array_indexes, _("\
1734
Set printing of array indexes."), _("\
1735
Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
1736
                           &setprintlist, &showprintlist);
1737
}

powered by: WebSVN 2.1.0

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