Return to valprint.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb

Annotation of 43BSDReno/contrib/emacs-18.55/gdb/valprint.c, revision 1.1

1.1     ! root        1: /* Print values for GNU debugger gdb.
        !             2:    Copyright (C) 1986, 1988 Free Software Foundation, Inc.
        !             3: 
        !             4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
        !             5: WARRANTY.  No author or distributor accepts responsibility to anyone
        !             6: for the consequences of using it or for whether it serves any
        !             7: particular purpose or works at all, unless he says so in writing.
        !             8: Refer to the GDB General Public License for full details.
        !             9: 
        !            10: Everyone is granted permission to copy, modify and redistribute GDB,
        !            11: but only under the conditions described in the GDB General Public
        !            12: License.  A copy of this license is supposed to have been given to you
        !            13: along with GDB so you can know your rights and responsibilities.  It
        !            14: should be in a file named COPYING.  Among other things, the copyright
        !            15: notice and this notice must be preserved on all copies.
        !            16: 
        !            17: In other words, go ahead and share GDB, but don't try to stop
        !            18: anyone else from sharing it farther.  Help stamp out software hoarding!
        !            19: */
        !            20: 
        !            21: #include <stdio.h>
        !            22: #include "defs.h"
        !            23: #include "initialize.h"
        !            24: #include "param.h"
        !            25: #include "symtab.h"
        !            26: #include "value.h"
        !            27: 
        !            28: /* Maximum number of chars to print for a string pointer value
        !            29:    or vector contents.  */
        !            30: 
        !            31: static int print_max;
        !            32: 
        !            33: static void type_print_varspec_suffix ();
        !            34: static void type_print_varspec_prefix ();
        !            35: static void type_print_base ();
        !            36: 
        !            37: START_FILE
        !            38: 
        !            39: char **unsigned_type_table;
        !            40: char **signed_type_table;
        !            41: char **float_type_table;
        !            42: 
        !            43: /* Print the value VAL in C-ish syntax on stream STREAM.
        !            44:    FORMAT is a format-letter, or 0 for print in natural format of data type.
        !            45:    If the object printed is a string pointer, returns
        !            46:    the number of string bytes printed.  */
        !            47: 
        !            48: value_print (val, stream, format)
        !            49:      value val;
        !            50:      FILE *stream;
        !            51:      char format;
        !            52: {
        !            53:   register int i, n, typelen;
        !            54: 
        !            55:   /* A "repeated" value really contains several values in a row.
        !            56:      They are made by the @ operator.
        !            57:      Print such values as if they were arrays.  */
        !            58: 
        !            59:   if (VALUE_REPEATED (val))
        !            60:     {
        !            61:       n = VALUE_REPETITIONS (val);
        !            62:       typelen = TYPE_LENGTH (VALUE_TYPE (val));
        !            63:       fputc ('{', stream);
        !            64:       /* Print arrays of characters using string syntax.  */
        !            65:       if (typelen == 1 && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT
        !            66:          && format == 0)
        !            67:        {
        !            68:          fputc ('"', stream);
        !            69:          for (i = 0; i < n && i < print_max; i++)
        !            70:            {
        !            71:              QUIT;
        !            72:              printchar (VALUE_CONTENTS (val)[i], stream, '"');
        !            73:            }
        !            74:          if (i < n)
        !            75:            fprintf (stream, "...");
        !            76:          fputc ('"', stream);
        !            77:        }
        !            78:       else
        !            79:        {
        !            80:          for (i = 0; i < n && i < print_max; i++)
        !            81:            {
        !            82:              if (i)
        !            83:                fprintf (stream, ", ");
        !            84:              val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
        !            85:                         VALUE_ADDRESS (val) + typelen * i, stream, format);
        !            86:            }
        !            87:          if (i < n)
        !            88:            fprintf (stream, "...");
        !            89:        }
        !            90:       fputc ('}', stream);
        !            91:     }
        !            92:   else
        !            93:     {
        !            94:       /* A simple (nonrepeated) value */
        !            95:       /* If it is a pointer, indicate what it points to.  */
        !            96:       if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR)
        !            97:        {
        !            98:          fprintf (stream, "(");
        !            99:          type_print (VALUE_TYPE (val), "", stream, -1);
        !           100:          fprintf (stream, ") ");
        !           101:        }
        !           102:       return val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
        !           103:                        VALUE_ADDRESS (val), stream, format);
        !           104:     }
        !           105: }
        !           106: 
        !           107: /* Print data of type TYPE located at VALADDR (within GDB),
        !           108:    which came from the inferior at address ADDRESS,
        !           109:    onto stdio stream STREAM according to FORMAT
        !           110:    (a letter or 0 for natural format).
        !           111: 
        !           112:    If the data are a string pointer, returns the number of
        !           113:    sting characters printed.  */
        !           114: 
        !           115: int
        !           116: val_print (type, valaddr, address, stream, format)
        !           117:      struct type *type;
        !           118:      char *valaddr;
        !           119:      CORE_ADDR address;
        !           120:      FILE *stream;
        !           121:      char format;
        !           122: {
        !           123:   register int i;
        !           124:   int len;
        !           125:   struct type *elttype;
        !           126:   int eltlen;
        !           127:   int val;
        !           128:   unsigned char c;
        !           129: 
        !           130:   QUIT;
        !           131: 
        !           132:   switch (TYPE_CODE (type))
        !           133:     {
        !           134:     case TYPE_CODE_ARRAY:
        !           135:       if (TYPE_LENGTH (type) >= 0)
        !           136:        {
        !           137:          elttype = TYPE_TARGET_TYPE (type);
        !           138:          eltlen = TYPE_LENGTH (elttype);
        !           139:          len = TYPE_LENGTH (type) / eltlen;
        !           140:          fprintf (stream, "{");
        !           141:          /* For an array of chars, print with string syntax.  */
        !           142:          if (eltlen == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT
        !           143:              && format == 0)
        !           144:            {
        !           145:              fputc ('"', stream);
        !           146:              for (i = 0; i < len && i < print_max; i++)
        !           147:                {
        !           148:                  QUIT;
        !           149:                  printchar (valaddr[i], stream, '"');
        !           150:                }
        !           151:              if (i < len)
        !           152:                fprintf (stream, "...");
        !           153:              fputc ('"', stream);
        !           154:            }
        !           155:          else
        !           156:            {
        !           157:              for (i = 0; i < len && i < print_max; i++)
        !           158:                {
        !           159:                  if (i) fprintf (stream, ", ");
        !           160:                  val_print (elttype, valaddr + i * eltlen,
        !           161:                             0, stream, format);
        !           162:                }
        !           163:              if (i < len)
        !           164:                fprintf (stream, "...");
        !           165:            }
        !           166:          fprintf (stream, "}");
        !           167:          break;
        !           168:        }
        !           169:       /* Array of unspecified length: treat like pointer.  */
        !           170: 
        !           171:     case TYPE_CODE_PTR:
        !           172:       if (format)
        !           173:        {
        !           174:          print_scalar_formatted (valaddr, type, format, 0, stream);
        !           175:          break;
        !           176:        }
        !           177:       fprintf (stream, "0x%x", * (int *) valaddr);
        !           178:       /* For a pointer to char or unsigned char,
        !           179:         also print the string pointed to, unless pointer is null.  */
        !           180: 
        !           181:       /* For an array of chars, print with string syntax.  */
        !           182:       elttype = TYPE_TARGET_TYPE (type);
        !           183:       if (TYPE_LENGTH (elttype) == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT
        !           184:          && format == 0
        !           185:          && unpack_long (type, valaddr) != 0)
        !           186:        {
        !           187:          fputc (' ', stream);
        !           188:          fputc ('"', stream);
        !           189:          for (i = 0; i < print_max; i++)
        !           190:            {
        !           191:              QUIT;
        !           192:              read_memory (unpack_long (type, valaddr) + i, &c, 1);
        !           193:              if (c == 0)
        !           194:                break;
        !           195:              printchar (c, stream, '"');
        !           196:            }
        !           197:          fputc ('"', stream);
        !           198:          if (i == print_max)
        !           199:            fprintf (stream, "...");
        !           200:          fflush (stream);
        !           201:          /* Return number of characters printed, plus one for the
        !           202:             terminating null if we have "reached the end".  */
        !           203:          return i + (i != print_max);
        !           204:        }
        !           205:       break;
        !           206: 
        !           207:     case TYPE_CODE_STRUCT:
        !           208:     case TYPE_CODE_UNION:
        !           209:       fprintf (stream, "{");
        !           210:       len = TYPE_NFIELDS (type);
        !           211:       for (i = 0; i < len; i++)
        !           212:        {
        !           213:          if (i) fprintf (stream, ", ");
        !           214:          fprintf (stream, "%s = ", TYPE_FIELD_NAME (type, i));
        !           215:          if (TYPE_FIELD_PACKED (type, i))
        !           216:            {
        !           217:              val = unpack_field_as_long (type, valaddr, i);
        !           218:              val_print (TYPE_FIELD_TYPE (type, i), &val, 0, stream, format);
        !           219:            }
        !           220:          else
        !           221:            val_print (TYPE_FIELD_TYPE (type, i), 
        !           222:                       valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
        !           223:                       0, stream, format);
        !           224:        }
        !           225:       fprintf (stream, "}");
        !           226:       break;
        !           227: 
        !           228:     case TYPE_CODE_ENUM:
        !           229:       if (format)
        !           230:        {
        !           231:          print_scalar_formatted (valaddr, type, format, 0, stream);
        !           232:          break;
        !           233:        }
        !           234:       len = TYPE_NFIELDS (type);
        !           235:       val = unpack_long (builtin_type_int, valaddr);
        !           236:       for (i = 0; i < len; i++)
        !           237:        {
        !           238:          QUIT;
        !           239:          if (val == TYPE_FIELD_VALUE (type, i))
        !           240:            break;
        !           241:        }
        !           242:       if (i < len)
        !           243:        fprintf (stream, "%s", TYPE_FIELD_NAME (type, i));
        !           244:       else
        !           245:        fprintf (stream, "%d", val);
        !           246:       break;
        !           247: 
        !           248:     case TYPE_CODE_FUNC:
        !           249:       if (format)
        !           250:        {
        !           251:          print_scalar_formatted (valaddr, type, format, 0, stream);
        !           252:          break;
        !           253:        }
        !           254:       fprintf (stream, "{");
        !           255:       type_print (type, "", stream, -1);
        !           256:       fprintf (stream, "} ");
        !           257:       fprintf (stream, "0x%x", address);
        !           258:       break;
        !           259: 
        !           260:     case TYPE_CODE_INT:
        !           261:       if (format)
        !           262:        {
        !           263:          print_scalar_formatted (valaddr, type, format, 0, stream);
        !           264:          break;
        !           265:        }
        !           266:       fprintf (stream,
        !           267:               TYPE_UNSIGNED (type) ? "%u" : "%d",
        !           268:               unpack_long (type, valaddr));
        !           269:       if (TYPE_LENGTH (type) == 1)
        !           270:        {
        !           271:          fprintf (stream, " '");
        !           272:          printchar (unpack_long (type, valaddr), stream, '\'');
        !           273:          fputc ('\'', stream);
        !           274:        }
        !           275:       break;
        !           276: 
        !           277:     case TYPE_CODE_FLT:
        !           278:       if (format)
        !           279:        {
        !           280:          print_scalar_formatted (valaddr, type, format, 0, stream);
        !           281:          break;
        !           282:        }
        !           283: #ifdef IEEE_FLOAT
        !           284:       if (is_nan (unpack_double (type, valaddr)))
        !           285:        {
        !           286:          fprintf (stream, "Nan");
        !           287:          break;
        !           288:        }
        !           289: #endif
        !           290:       fprintf (stream, "%g", unpack_double (type, valaddr));
        !           291:       break;
        !           292: 
        !           293:     case TYPE_CODE_VOID:
        !           294:       fprintf (stream, "void");
        !           295:       break;
        !           296: 
        !           297:     default:
        !           298:       error ("Invalid type code in symbol table.");
        !           299:     }
        !           300:   fflush (stream);
        !           301: }
        !           302: 
        !           303: #ifdef IEEE_FLOAT
        !           304: 
        !           305: union ieee {
        !           306:   int i[2];
        !           307:   double d;
        !           308: };
        !           309: 
        !           310: /* Nonzero if ARG (a double) is a NAN.  */
        !           311: 
        !           312: int
        !           313: is_nan (arg)
        !           314:      union ieee arg;
        !           315: {
        !           316:   int lowhalf, highhalf;
        !           317:   union { int i; char c; } test;
        !           318: 
        !           319:   /* Separate the high and low words of the double.
        !           320:      Distinguish big and little-endian machines.  */
        !           321:   test.i = 1;
        !           322:   if (test.c != 1)
        !           323:     /* Big-endian machine */
        !           324:     lowhalf = arg.i[1], highhalf = arg.i[0];
        !           325:   else
        !           326:     lowhalf = arg.i[0], highhalf = arg.i[1];
        !           327: 
        !           328:   /* Nan: exponent is the maximum possible, and fraction is nonzero.  */
        !           329:   return (((highhalf>>20) & 0x7ff) == 0x7ff
        !           330:          &&
        !           331:          ! ((highhalf & 0xfffff == 0) && (lowhalf == 0)));
        !           332: }
        !           333: #endif
        !           334: 
        !           335: /* Print a description of a type TYPE
        !           336:    in the form of a declaration of a variable named VARSTRING.
        !           337:    Output goes to STREAM (via stdio).
        !           338:    If SHOW is positive, we show the contents of the outermost level
        !           339:    of structure even if there is a type name that could be used instead.
        !           340:    If SHOW is negative, we never show the details of elements' types.  */
        !           341: 
        !           342: type_print (type, varstring, stream, show)
        !           343:      struct type *type;
        !           344:      char *varstring;
        !           345:      FILE *stream;
        !           346:      int show;
        !           347: {
        !           348:   type_print_1 (type, varstring, stream, show, 0);
        !           349: }
        !           350: 
        !           351: /* LEVEL is the depth to indent lines by.  */
        !           352: 
        !           353: type_print_1 (type, varstring, stream, show, level)
        !           354:      struct type *type;
        !           355:      char *varstring;
        !           356:      FILE *stream;
        !           357:      int show;
        !           358:      int level;
        !           359: {
        !           360:   register enum type_code code;
        !           361:   type_print_base (type, stream, show, level);
        !           362:   code = TYPE_CODE (type);
        !           363:   if ((varstring && *varstring)
        !           364:       ||
        !           365:       /* Need a space if going to print stars or brackets;
        !           366:         but not if we will print just a type name.  */
        !           367:       ((show > 0 || TYPE_NAME (type) == 0)
        !           368:        &&
        !           369:        (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
        !           370:        || code == TYPE_CODE_ARRAY)))
        !           371:     fprintf (stream, " ");
        !           372:   type_print_varspec_prefix (type, stream, show, 0);
        !           373:   fprintf (stream, "%s", varstring);
        !           374:   type_print_varspec_suffix (type, stream, show, 0);
        !           375: }
        !           376: 
        !           377: /* Print any asterisks or open-parentheses needed before the
        !           378:    variable name (to describe its type).
        !           379: 
        !           380:    On outermost call, pass 0 for PASSED_A_PTR.
        !           381:    On outermost call, SHOW > 0 means should ignore
        !           382:    any typename for TYPE and show its details.
        !           383:    SHOW is always zero on recursive calls.  */
        !           384: 
        !           385: static void
        !           386: type_print_varspec_prefix (type, stream, show, passed_a_ptr)
        !           387:      struct type *type;
        !           388:      FILE *stream;
        !           389:      int show;
        !           390:      int passed_a_ptr;
        !           391: {
        !           392:   if (type == 0)
        !           393:     return;
        !           394: 
        !           395:   if (TYPE_NAME (type) && show <= 0)
        !           396:     return;
        !           397: 
        !           398:   QUIT;
        !           399: 
        !           400:   switch (TYPE_CODE (type))
        !           401:     {
        !           402:     case TYPE_CODE_PTR:
        !           403:       type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
        !           404:       fputc ('*', stream);
        !           405:       break;
        !           406: 
        !           407:     case TYPE_CODE_FUNC:
        !           408:     case TYPE_CODE_ARRAY:
        !           409:       type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
        !           410:       if (passed_a_ptr)
        !           411:        fputc ('(', stream);
        !           412:       break;
        !           413:     }
        !           414: }
        !           415: 
        !           416: /* Print any array sizes, function arguments or close parentheses
        !           417:    needed after the variable name (to describe its type).
        !           418:    Args work like type_print_varspec_prefix.  */
        !           419: 
        !           420: static void
        !           421: type_print_varspec_suffix (type, stream, show, passed_a_ptr)
        !           422:      struct type *type;
        !           423:      FILE *stream;
        !           424:      int show;
        !           425:      int passed_a_ptr;
        !           426: {
        !           427:   if (type == 0)
        !           428:     return;
        !           429: 
        !           430:   if (TYPE_NAME (type) && show <= 0)
        !           431:     return;
        !           432: 
        !           433:   QUIT;
        !           434: 
        !           435:   switch (TYPE_CODE (type))
        !           436:     {
        !           437:     case TYPE_CODE_ARRAY:
        !           438:       type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
        !           439:       if (passed_a_ptr)
        !           440:        fprintf (stream, ")");
        !           441:       fprintf (stream, "[");
        !           442:       if (TYPE_LENGTH (type) >= 0)
        !           443:        fprintf (stream, "%d",
        !           444:                 TYPE_LENGTH (type) / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
        !           445:       fprintf (stream, "]");
        !           446:       break;
        !           447: 
        !           448:     case TYPE_CODE_PTR:
        !           449:       type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1);
        !           450:       break;
        !           451: 
        !           452:     case TYPE_CODE_FUNC:
        !           453:       type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
        !           454:       if (passed_a_ptr)
        !           455:        fprintf (stream, ")");
        !           456:       fprintf (stream, "()");
        !           457:       break;
        !           458:     }
        !           459: }
        !           460: 
        !           461: /* Print the name of the type (or the ultimate pointer target,
        !           462:    function value or array element), or the description of a
        !           463:    structure or union.
        !           464: 
        !           465:    SHOW nonzero means don't print this type as just its name;
        !           466:    show its real definition even if it has a name.
        !           467:    SHOW zero means print just typename or struct tag if there is one
        !           468:    SHOW negative means abbreviate structure elements.
        !           469:    SHOW is decremented for printing of structure elements.
        !           470: 
        !           471:    LEVEL is the depth to indent by.
        !           472:    We increase it for some recursive calls.  */
        !           473: 
        !           474: static void
        !           475: type_print_base (type, stream, show, level)
        !           476:      struct type *type;
        !           477:      FILE *stream;
        !           478:      int show;
        !           479:      int level;
        !           480: {
        !           481:   char *name;
        !           482:   register int i;
        !           483:   register int len;
        !           484:   register int lastval;
        !           485: 
        !           486:   QUIT;
        !           487: 
        !           488:   if (type == 0)
        !           489:     {
        !           490:       fprintf (stream, "type unknown");
        !           491:       return;
        !           492:     }
        !           493: 
        !           494:   if (TYPE_NAME (type) && show <= 0)
        !           495:     {
        !           496:       fprintf (stream, TYPE_NAME (type));
        !           497:       return;
        !           498:     }
        !           499: 
        !           500:   switch (TYPE_CODE (type))
        !           501:     {
        !           502:     case TYPE_CODE_ARRAY:
        !           503:     case TYPE_CODE_PTR:
        !           504:     case TYPE_CODE_FUNC:
        !           505:       type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
        !           506:       break;
        !           507: 
        !           508:     case TYPE_CODE_STRUCT:
        !           509:       fprintf (stream, "struct ");
        !           510:       goto struct_union;
        !           511: 
        !           512:     case TYPE_CODE_UNION:
        !           513:       fprintf (stream, "union ");
        !           514:     struct_union:
        !           515:       if (TYPE_NAME (type) && (name = TYPE_NAME (type)))
        !           516:        {
        !           517:          while (*name != ' ') name++;
        !           518:          fprintf (stream, "%s ", name + 1);
        !           519:        }
        !           520:       if (show < 0)
        !           521:        fprintf (stream, "{...}");
        !           522:       else
        !           523:        {
        !           524:          fprintf (stream, "{");
        !           525:          len = TYPE_NFIELDS (type);
        !           526:          fprintf (stream, "\n");
        !           527:          for (i = 0; i < len; i++)
        !           528:            {
        !           529:              QUIT;
        !           530:              print_spaces (level + 4, stream);
        !           531: 
        !           532:              /* If this is a bit-field and there is a gap before it,
        !           533:                 print a nameless field to account for the gap.  */
        !           534: 
        !           535:              if (TYPE_FIELD_PACKED (type, i))
        !           536:                {
        !           537:                  int gap = (TYPE_FIELD_BITPOS (type, i)
        !           538:                             - (i > 0
        !           539:                                ? (TYPE_FIELD_BITPOS (type, i - 1)
        !           540:                                   + (TYPE_FIELD_PACKED (type, i - 1)
        !           541:                                      ? TYPE_FIELD_BITSIZE (type, i - 1)
        !           542:                                      : TYPE_LENGTH (TYPE_FIELD_TYPE (type, i - 1)) * 8))
        !           543:                                : 0));
        !           544:                  if (gap != 0)
        !           545:                    {
        !           546:                      fprintf (stream, "int : %d;\n", gap);
        !           547:                      print_spaces (level + 4, stream);
        !           548:                    }
        !           549:                }
        !           550: 
        !           551:              /* Print the declaration of this field.  */
        !           552: 
        !           553:              type_print_1 (TYPE_FIELD_TYPE (type, i),
        !           554:                            TYPE_FIELD_NAME (type, i),
        !           555:                            stream, show - 1, level + 4);
        !           556: 
        !           557:              /* Print the field width.  */
        !           558: 
        !           559:              if (TYPE_FIELD_PACKED (type, i))
        !           560:                fprintf (stream, " : %d", TYPE_FIELD_BITSIZE (type, i));
        !           561: 
        !           562:              fprintf (stream, ";\n");
        !           563:            }
        !           564:          print_spaces (level, stream);
        !           565:          fputc ('}', stream);
        !           566:        }
        !           567:       break;
        !           568: 
        !           569:     case TYPE_CODE_ENUM:
        !           570:       fprintf (stream, "enum ");
        !           571:       if (TYPE_NAME (type))
        !           572:        {
        !           573:          name = TYPE_NAME (type);
        !           574:          while (*name != ' ') name++;
        !           575:          fprintf (stream, "%s ", name + 1);
        !           576:        }
        !           577:       if (show < 0)
        !           578:        fprintf (stream, "{...}");
        !           579:       else
        !           580:        {
        !           581:          fprintf (stream, "{");
        !           582:          len = TYPE_NFIELDS (type);
        !           583:          lastval = 0;
        !           584:          for (i = 0; i < len; i++)
        !           585:            {
        !           586:              QUIT;
        !           587:              if (i) fprintf (stream, ", ");
        !           588:              fprintf (stream, "%s", TYPE_FIELD_NAME (type, i));
        !           589:              if (lastval != TYPE_FIELD_VALUE (type, i))
        !           590:                {
        !           591:                  fprintf (stream, " : %d", TYPE_FIELD_VALUE (type, i));
        !           592:                  lastval = TYPE_FIELD_VALUE (type, i);
        !           593:                }
        !           594:              lastval++;
        !           595:            }
        !           596:          fprintf (stream, "}");
        !           597:        }
        !           598:       break;
        !           599: 
        !           600:     case TYPE_CODE_INT:
        !           601:       if (TYPE_UNSIGNED (type))
        !           602:        name = unsigned_type_table[TYPE_LENGTH (type)];
        !           603:       else
        !           604:        name = signed_type_table[TYPE_LENGTH (type)];
        !           605:       fprintf (stream, "%s", name);
        !           606:       break;
        !           607: 
        !           608:     case TYPE_CODE_FLT:
        !           609:       name = float_type_table[TYPE_LENGTH (type)];
        !           610:       fprintf (stream, "%s", name);
        !           611:       break;
        !           612: 
        !           613:     case TYPE_CODE_VOID:
        !           614:       fprintf (stream, "void");
        !           615:       break;
        !           616: 
        !           617:     case 0:
        !           618:       fprintf (stream, "struct unknown");
        !           619:       break;
        !           620: 
        !           621:     default:
        !           622:       error ("Invalid type code in symbol table.");
        !           623:     }
        !           624: }
        !           625: 
        !           626: static void
        !           627: set_maximum_command (arg)
        !           628:      char *arg;
        !           629: {
        !           630:   if (!arg) error_no_arg ("value for maximum elements to print");
        !           631:   print_max = atoi (arg);
        !           632: }
        !           633: 
        !           634: static
        !           635: initialize ()
        !           636: {
        !           637:   add_com ("set-maximum", class_vars, set_maximum_command,
        !           638:           "Set NUMBER as limit on string chars or array elements to print.");
        !           639: 
        !           640:   print_max = 200;
        !           641: 
        !           642:   unsigned_type_table
        !           643:     = (char **) xmalloc ((1 + sizeof (unsigned long)) * sizeof (char *));
        !           644:   bzero (unsigned_type_table, (1 + sizeof (unsigned long)));
        !           645:   unsigned_type_table[sizeof (unsigned char)] = "unsigned char";
        !           646:   unsigned_type_table[sizeof (unsigned short)] = "unsigned short";
        !           647:   unsigned_type_table[sizeof (unsigned long)] = "unsigned long";
        !           648:   unsigned_type_table[sizeof (unsigned int)] = "unsigned int";
        !           649: 
        !           650:   signed_type_table
        !           651:     = (char **) xmalloc ((1 + sizeof (long)) * sizeof (char *));
        !           652:   bzero (signed_type_table, (1 + sizeof (long)));
        !           653:   signed_type_table[sizeof (char)] = "char";
        !           654:   signed_type_table[sizeof (short)] = "short";
        !           655:   signed_type_table[sizeof (long)] = "long";
        !           656:   signed_type_table[sizeof (int)] = "int";
        !           657: 
        !           658:   float_type_table
        !           659:     = (char **) xmalloc ((1 + sizeof (double)) * sizeof (char *));
        !           660:   bzero (float_type_table, (1 + sizeof (double)));
        !           661:   float_type_table[sizeof (float)] = "float";
        !           662:   float_type_table[sizeof (double)] = "double";
        !           663: }
        !           664: 
        !           665: END_FILE

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.