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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [valprint.c] - Blame information for rev 105

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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