gdb/ch-lang.c

   1 /* Chill language support routines for GDB, the GNU debugger.
   2    Copyright 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "expression.h"
  24 #include "parser-defs.h"
  25 #include "language.h"
  26 #include "ch-lang.h"
  27
  28
  29 /* For now, Chill uses a simple mangling algorithm whereby you simply
  30    discard everything after the occurance of two successive CPLUS_MARKER
  31    characters to derive the demangled form. */
  32
  33 char *
  34 chill_demangle (mangled)
  35      const char *mangled;
  36 {
  37   char *joiner;
  38   char *demangled;
  39
  40   joiner = strchr (mangled, CPLUS_MARKER);
  41   if (joiner != NULL && *(joiner + 1) == CPLUS_MARKER)
  42     {
  43       demangled = savestring (mangled, joiner - mangled);
  44     }
  45   else
  46     {
  47       demangled = NULL;
  48     }
  49   return (demangled);
  50 }
  51
  52 static void
  53 chill_printchar (c, stream)
  54      register int c;
  55      GDB_FILE *stream;
  56 {
  57   c &= 0xFF;                    /* Avoid sign bit follies */
  58
  59   if (PRINT_LITERAL_FORM (c))
  60     {
  61       fprintf_filtered (stream, "'%c'", c);
  62     }
  63   else
  64     {
  65       fprintf_filtered (stream, "C'%.2x'", (unsigned int) c);
  66     }
  67 }
  68
  69 /* Print the character string STRING, printing at most LENGTH characters.
  70    Printing stops early if the number hits print_max; repeat counts
  71    are printed as appropriate.  Print ellipses at the end if we
  72    had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
  73    Note that gdb maintains the length of strings without counting the
  74    terminating null byte, while chill strings are typically written with
  75    an explicit null byte.  So we always assume an implied null byte
  76    until gdb is able to maintain non-null terminated strings as well
  77    as null terminated strings (FIXME).
  78   */
  79
  80 static void
  81 chill_printstr (stream, string, length, force_ellipses)
  82      GDB_FILE *stream;
  83      char *string;
  84      unsigned int length;
  85      int force_ellipses;
  86 {
  87   register unsigned int i;
  88   unsigned int things_printed = 0;
  89   int in_literal_form = 0;
  90   int in_control_form = 0;
  91   int need_slashslash = 0;
  92   unsigned int c;
  93   extern int repeat_count_threshold;
  94   extern int print_max;
  95
  96   if (length == 0)
  97     {
  98       chill_printchar ('\0', stream);
  99       return;
 100     }
 101
 102   for (i = 0; i < length && things_printed < print_max; ++i)
 103     {
 104       /* Position of the character we are examining
 105          to see whether it is repeated.  */
 106       unsigned int rep1;
 107       /* Number of repetitions we have detected so far.  */
 108       unsigned int reps;
 109
 110       QUIT;
 111
 112       if (need_slashslash)
 113         {
 114           fputs_filtered ("//", stream);
 115           need_slashslash = 0;
 116         }
 117
 118       rep1 = i + 1;
 119       reps = 1;
 120       while (rep1 < length && string[rep1] == string[i])
 121         {
 122           ++rep1;
 123           ++reps;
 124         }
 125
 126       c = string[i];
 127       if (reps > repeat_count_threshold)
 128         {
 129           if (in_control_form || in_literal_form)
 130             {
 131               fputs_filtered ("\"//", stream);
 132               in_control_form = in_literal_form = 0;
 133             }
 134           chill_printchar (c, stream);
 135           fprintf_filtered (stream, "<repeats %u times>", reps);
 136           i = rep1 - 1;
 137           things_printed += repeat_count_threshold;
 138           need_slashslash = 1;
 139         }
 140       else
 141         {
 142           if (PRINT_LITERAL_FORM (c))
 143             {
 144               if (!in_literal_form)
 145                 {
 146                   if (in_control_form)
 147                     {
 148                       fputs_filtered ("\"//", stream);
 149                       in_control_form = 0;
 150                     }
 151                   fputs_filtered ("\"", stream);
 152                   in_literal_form = 1;
 153                 }
 154               fprintf_filtered (stream, "%c", c);
 155             }
 156           else
 157             {
 158               if (!in_control_form)
 159                 {
 160                   if (in_literal_form)
 161                     {
 162                       fputs_filtered ("\"//", stream);
 163                       in_literal_form = 0;
 164                     }
 165                   fputs_filtered ("c\"", stream);
 166                   in_control_form = 1;
 167                 }
 168               fprintf_filtered (stream, "%.2x", c);
 169             }
 170           ++things_printed;
 171         }
 172     }
 173
 174   /* Terminate the quotes if necessary.  */
 175   if (in_literal_form || in_control_form)
 176     {
 177       fputs_filtered ("\"", stream);
 178     }
 179   if (force_ellipses || (i < length))
 180     {
 181       fputs_filtered ("...", stream);
 182     }
 183 }
 184
 185 /* Return 1 if TYPE is a varying string or array. */
 186
 187 int
 188 chill_is_varying_struct (type)
 189      struct type *type;
 190 {
 191   if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
 192     return 0;
 193   if (TYPE_NFIELDS (type) != 2)
 194     return 0;
 195   if (strcmp (TYPE_FIELD_NAME (type, 0), "<var_length>") != 0)
 196     return 0;
 197   return 1;
 198 }
 199
 200 static struct type *
 201 chill_create_fundamental_type (objfile, typeid)
 202      struct objfile *objfile;
 203      int typeid;
 204 {
 205   register struct type *type = NULL;
 206
 207   switch (typeid)
 208     {
 209       default:
 210         /* FIXME:  For now, if we are asked to produce a type not in this
 211            language, create the equivalent of a C integer type with the
 212            name "<?type?>".  When all the dust settles from the type
 213            reconstruction work, this should probably become an error. */
 214         type = init_type (TYPE_CODE_INT, 2, 0, "<?type?>", objfile);
 215         warning ("internal error: no chill fundamental type %d", typeid);
 216         break;
 217       case FT_VOID:
 218         /* FIXME:  Currently the GNU Chill compiler emits some DWARF entries for
 219            typedefs, unrelated to anything directly in the code being compiled,
 220            that have some FT_VOID types.  Just fake it for now. */
 221         type = init_type (TYPE_CODE_VOID, 0, 0, "<?VOID?>", objfile);
 222         break;
 223       case FT_BOOLEAN:
 224         type = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED, "BOOL", objfile);
 225         break;
 226       case FT_CHAR:
 227         type = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED, "CHAR", objfile);
 228         break;
 229       case FT_SIGNED_CHAR:
 230         type = init_type (TYPE_CODE_INT, 1, 0, "BYTE", objfile);
 231         break;
 232       case FT_UNSIGNED_CHAR:
 233         type = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, "UBYTE", objfile);
 234         break;
 235       case FT_SHORT:                    /* Chill ints are 2 bytes */
 236         type = init_type (TYPE_CODE_INT, 2, 0, "INT", objfile);
 237         break;
 238       case FT_UNSIGNED_SHORT:           /* Chill ints are 2 bytes */
 239         type = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, "UINT", objfile);
 240         break;
 241       case FT_INTEGER:                  /* FIXME? */
 242       case FT_SIGNED_INTEGER:           /* FIXME? */
 243       case FT_LONG:                     /* Chill longs are 4 bytes */
 244       case FT_SIGNED_LONG:              /* Chill longs are 4 bytes */
 245         type = init_type (TYPE_CODE_INT, 4, 0, "LONG", objfile);
 246         break;
 247       case FT_UNSIGNED_INTEGER:         /* FIXME? */
 248       case FT_UNSIGNED_LONG:            /* Chill longs are 4 bytes */
 249         type = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, "ULONG", objfile);
 250         break;
 251       case FT_FLOAT:
 252         type = init_type (TYPE_CODE_FLT, 4, 0, "REAL", objfile);
 253         break;
 254       case FT_DBL_PREC_FLOAT:
 255         type = init_type (TYPE_CODE_FLT, 8, 0, "LONG_REAL", objfile);
 256         break;
 257       }
 258   return (type);
 259 }
 260
 261 \f
 262 /* Table of operators and their precedences for printing expressions.  */
 263
 264 static const struct op_print chill_op_print_tab[] = {
 265     {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 266     {"OR",  BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 267     {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 268     {"MOD", BINOP_MOD, PREC_MUL, 0},
 269     {"REM", BINOP_REM, PREC_MUL, 0},
 270     {":=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
 271     {"=",   BINOP_EQUAL, PREC_EQUAL, 0},
 272     {"/=",  BINOP_NOTEQUAL, PREC_EQUAL, 0},
 273     {"<=",  BINOP_LEQ, PREC_ORDER, 0},
 274     {">=",  BINOP_GEQ, PREC_ORDER, 0},
 275     {">",   BINOP_GTR, PREC_ORDER, 0},
 276     {"<",   BINOP_LESS, PREC_ORDER, 0},
 277     {"+",   BINOP_ADD, PREC_ADD, 0},
 278     {"-",   BINOP_SUB, PREC_ADD, 0},
 279     {"*",   BINOP_MUL, PREC_MUL, 0},
 280     {"/",   BINOP_DIV, PREC_MUL, 0},
 281     {"//",  BINOP_CONCAT, PREC_PREFIX, 0},      /* FIXME: precedence? */
 282     {"-",   UNOP_NEG, PREC_PREFIX, 0},
 283     {NULL,  0, 0, 0}
 284 };
 285
 286 \f
 287 /* The built-in types of Chill.  */
 288
 289 struct type *builtin_type_chill_bool;
 290 struct type *builtin_type_chill_char;
 291 struct type *builtin_type_chill_long;
 292 struct type *builtin_type_chill_ulong;
 293 struct type *builtin_type_chill_real;
 294
 295 struct type ** const (chill_builtin_types[]) =
 296 {
 297   &builtin_type_chill_bool,
 298   &builtin_type_chill_char,
 299   &builtin_type_chill_long,
 300   &builtin_type_chill_ulong,
 301   &builtin_type_chill_real,
 302   0
 303 };
 304
 305 const struct language_defn chill_language_defn = {
 306   "chill",
 307   language_chill,
 308   chill_builtin_types,
 309   range_check_on,
 310   type_check_on,
 311   chill_parse,                  /* parser */
 312   chill_error,                  /* parser error function */
 313   chill_printchar,              /* print a character constant */
 314   chill_printstr,               /* function to print a string constant */
 315   chill_create_fundamental_type,/* Create fundamental type in this language */
 316   chill_print_type,             /* Print a type using appropriate syntax */
 317   chill_val_print,              /* Print a value using appropriate syntax */
 318   &BUILTIN_TYPE_LONGEST,        /* longest signed   integral type */
 319   &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
 320   &builtin_type_chill_real,     /* longest floating point type */
 321   {"",      "B'",  "",   ""},   /* Binary format info */
 322   {"O'%lo",  "O'",  "o",  ""},  /* Octal format info */
 323   {"D'%ld",  "D'",  "d",  ""},  /* Decimal format info */
 324   {"H'%lx",  "H'",  "x",  ""},  /* Hex format info */
 325   chill_op_print_tab,           /* expression operators for printing */
 326   LANG_MAGIC
 327 };
 328
 329 /* Initialization for Chill */
 330
 331 void
 332 _initialize_chill_language ()
 333 {
 334   builtin_type_chill_bool =
 335     init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 336                TYPE_FLAG_UNSIGNED,
 337                "BOOL", (struct objfile *) NULL);
 338   builtin_type_chill_char =
 339     init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 340                TYPE_FLAG_UNSIGNED,
 341                "CHAR", (struct objfile *) NULL);
 342   builtin_type_chill_long =
 343     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
 344                0,
 345                "LONG", (struct objfile *) NULL);
 346   builtin_type_chill_ulong =
 347     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
 348                TYPE_FLAG_UNSIGNED,
 349                "ULONG", (struct objfile *) NULL);
 350   builtin_type_chill_real =
 351     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 352                0,
 353                "LONG_REAL", (struct objfile *) NULL);
 354
 355   add_language (&chill_language_defn);
 356 }