gdb/d-lang.c

   1 /* D language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2005, 2006, 2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "language.h"
  23 #include "d-lang.h"
  24 #include "c-lang.h"
  25 #include "gdb_string.h"
  26 #include "parser-defs.h"
  27 #include "gdb_obstack.h"
  28
  29 #include <ctype.h>
  30
  31 /* Extract identifiers from MANGLED_STR and append it to TEMPBUF.
  32    Return 1 on success or 0 on failure.  */
  33 static int
  34 extract_identifiers (const char *mangled_str, struct obstack *tempbuf)
  35 {
  36   long i = 0;
  37
  38   while (isdigit (*mangled_str))
  39     {
  40       i = strtol (mangled_str, NULL, 10);
  41       mangled_str++;
  42       if (i <= 0  && strlen (mangled_str) < i)
  43         return 0;
  44       obstack_grow (tempbuf, mangled_str, i);
  45       mangled_str += i;
  46       obstack_grow_str (tempbuf, ".");
  47     }
  48   if (*mangled_str == '\0' || i == 0)
  49     return 0;
  50   obstack_blank (tempbuf, -1);
  51   return 1;
  52 }
  53
  54 /* Extract and demangle type from MANGLED_STR and append it to TEMPBUF.
  55    Return 1 on success or 0 on failure.  */
  56 static int
  57 extract_type_info (const char *mangled_str, struct obstack *tempbuf)
  58 {
  59   if (*mangled_str == '\0')
  60     return 0;
  61   switch (*mangled_str++)
  62     {
  63       case 'A': /* dynamic array */
  64       case 'G': /* static array */
  65       case 'H': /* associative array */
  66         if (!extract_type_info (mangled_str, tempbuf))
  67           return 0;
  68         obstack_grow_str (tempbuf, "[]");
  69         return 1;
  70       case 'P': /* pointer */
  71         if (!extract_type_info (mangled_str, tempbuf))
  72           return 0;
  73         obstack_grow_str (tempbuf, "*");
  74         return 1;
  75       case 'R': /* reference */
  76         if (!extract_type_info (mangled_str, tempbuf))
  77           return 0;
  78         obstack_grow_str (tempbuf, "&");
  79         return 1;
  80       case 'Z': /* return value */
  81         return extract_type_info (mangled_str, tempbuf);
  82       case 'J': /* out */
  83         obstack_grow_str (tempbuf, "out ");
  84         return extract_type_info (mangled_str, tempbuf);
  85       case 'K': /* inout */
  86         obstack_grow_str (tempbuf, "inout ");
  87         return extract_type_info (mangled_str, tempbuf);
  88       case 'E': /* enum */
  89       case 'T': /* typedef */
  90       case 'D': /* delegate */
  91       case 'C': /* class */
  92       case 'S': /* struct */
  93         return extract_identifiers (mangled_str, tempbuf);
  94
  95       /* basic types: */
  96       case 'n': obstack_grow_str (tempbuf, "none"); return 1;
  97       case 'v': obstack_grow_str (tempbuf, "void"); return 1;
  98       case 'g': obstack_grow_str (tempbuf, "byte"); return 1;
  99       case 'h': obstack_grow_str (tempbuf, "ubyte"); return 1;
 100       case 's': obstack_grow_str (tempbuf, "short"); return 1;
 101       case 't': obstack_grow_str (tempbuf, "ushort"); return 1;
 102       case 'i': obstack_grow_str (tempbuf, "int"); return 1;
 103       case 'k': obstack_grow_str (tempbuf, "uint"); return 1;
 104       case 'l': obstack_grow_str (tempbuf, "long"); return 1;
 105       case 'm': obstack_grow_str (tempbuf, "ulong"); return 1;
 106       case 'f': obstack_grow_str (tempbuf, "float"); return 1;
 107       case 'd': obstack_grow_str (tempbuf, "double"); return 1;
 108       case 'e': obstack_grow_str (tempbuf, "real"); return 1;
 109
 110       /* imaginary and complex: */
 111       case 'o': obstack_grow_str (tempbuf, "ifloat"); return 1;
 112       case 'p': obstack_grow_str (tempbuf, "idouble"); return 1;
 113       case 'j': obstack_grow_str (tempbuf, "ireal"); return 1;
 114       case 'q': obstack_grow_str (tempbuf, "cfloat"); return 1;
 115       case 'r': obstack_grow_str (tempbuf, "cdouble"); return 1;
 116       case 'c': obstack_grow_str (tempbuf, "creal"); return 1;
 117
 118       /* other types: */
 119       case 'b': obstack_grow_str (tempbuf, "bit"); return 1;
 120       case 'a': obstack_grow_str (tempbuf, "char"); return 1;
 121       case 'u': obstack_grow_str (tempbuf, "wchar"); return 1;
 122       case 'w': obstack_grow_str (tempbuf, "dchar"); return 1;
 123
 124       default:
 125         obstack_grow_str (tempbuf, "unknown");
 126         return 1;
 127     }
 128 }
 129
 130 /* Implements the la_demangle language_defn routine for language D.  */
 131 char *
 132 d_demangle (const char *symbol, int options)
 133 {
 134   struct obstack tempbuf;
 135   char *out_str;
 136   unsigned char is_func = 0;
 137
 138   if (symbol == NULL)
 139     return NULL;
 140   else if (strcmp (symbol, "_Dmain") == 0)
 141     return xstrdup ("D main");
 142
 143   obstack_init (&tempbuf);
 144
 145   if (symbol[0] == '_' && symbol[1] == 'D')
 146     {
 147       symbol += 2;
 148       is_func = 1;
 149     }
 150   else if (strncmp (symbol, "__Class_", 8) == 0)
 151     symbol += 8;
 152   else if (strncmp (symbol, "__init_", 7) == 0)
 153     symbol += 7;
 154   else if (strncmp (symbol, "__vtbl_", 7) == 0)
 155     symbol += 7;
 156   else if (strncmp (symbol, "__modctor_", 10) == 0)
 157     symbol += 10;
 158   else if (strncmp (symbol, "__moddtor_", 10) == 0)
 159     symbol += 10;
 160   else if (strncmp (symbol, "__ModuleInfo_", 13) == 0)
 161     symbol += 13;
 162   else
 163     {
 164       obstack_free (&tempbuf, NULL);
 165       return NULL;
 166     }
 167
 168   if (!extract_identifiers (symbol, &tempbuf))
 169     {
 170       obstack_free (&tempbuf, NULL);
 171       return NULL;
 172     }
 173
 174   obstack_grow_str (&tempbuf, "(");
 175   if (is_func == 1 && *symbol == 'F')
 176     {
 177       symbol++;
 178       while (*symbol != '\0' && *symbol != 'Z')
 179         {
 180           if (is_func == 1)
 181             is_func++;
 182           else
 183             obstack_grow_str (&tempbuf, ", ");
 184           if (!extract_type_info (symbol, &tempbuf))
 185             {
 186               obstack_free (&tempbuf, NULL);
 187               return NULL;
 188            }
 189         }
 190      }
 191   obstack_grow_str0 (&tempbuf, ")");
 192
 193   /* Doesn't display the return type, but wouldn't be too hard to do.  */
 194
 195   out_str = xstrdup (obstack_finish (&tempbuf));
 196   obstack_free (&tempbuf, NULL);
 197   return out_str;
 198 }
 199
 200 /* Table mapping opcodes into strings for printing operators
 201    and precedences of the operators.  */
 202 static const struct op_print d_op_print_tab[] =
 203 {
 204   {",", BINOP_COMMA, PREC_COMMA, 0},
 205   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 206   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 207   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 208   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 209   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 210   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 211   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 212   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 213   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 214   {">=", BINOP_GEQ, PREC_ORDER, 0},
 215   {">", BINOP_GTR, PREC_ORDER, 0},
 216   {"<", BINOP_LESS, PREC_ORDER, 0},
 217   {">>", BINOP_RSH, PREC_SHIFT, 0},
 218   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 219   {"+", BINOP_ADD, PREC_ADD, 0},
 220   {"-", BINOP_SUB, PREC_ADD, 0},
 221   {"*", BINOP_MUL, PREC_MUL, 0},
 222   {"/", BINOP_DIV, PREC_MUL, 0},
 223   {"%", BINOP_REM, PREC_MUL, 0},
 224   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 225   {"-", UNOP_NEG, PREC_PREFIX, 0},
 226   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 227   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 228   {"*", UNOP_IND, PREC_PREFIX, 0},
 229   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 230   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 231   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 232   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 233   {NULL, 0, 0, 0}
 234 };
 235
 236 static const struct language_defn d_language_defn =
 237 {
 238   "d",
 239   language_d,
 240   range_check_off,
 241   type_check_off,
 242   case_sensitive_on,
 243   array_row_major,
 244   macro_expansion_c,
 245   &exp_descriptor_c,
 246   c_parse,
 247   c_error,
 248   null_post_parser,
 249   c_printchar,                  /* Print a character constant.  */
 250   c_printstr,                   /* Function to print string constant.  */
 251   c_emit_char,                  /* Print a single char.  */
 252   c_print_type,                 /* Print a type using appropriate syntax.  */
 253   c_print_typedef,              /* Print a typedef using appropriate syntax.  */
 254   d_val_print,                  /* Print a value using appropriate syntax.  */
 255   c_value_print,                /* Print a top-level value.  */
 256   NULL,                         /* Language specific skip_trampoline.  */
 257   "this",
 258   basic_lookup_symbol_nonlocal,
 259   basic_lookup_transparent_type,
 260   d_demangle,                   /* Language specific symbol demangler.  */
 261   NULL,                         /* Language specific class_name_from_physname.  */
 262   d_op_print_tab,               /* Expression operators for printing.  */
 263   1,                            /* C-style arrays.  */
 264   0,                            /* String lower bound.  */
 265   default_word_break_characters,
 266   default_make_symbol_completion_list,
 267   c_language_arch_info,
 268   default_print_array_index,
 269   default_pass_by_reference,
 270   c_get_string,
 271   LANG_MAGIC
 272 };
 273
 274 void
 275 _initialize_d_language (void)
 276 {
 277   add_language (&d_language_defn);
 278 }