plugins/gdb/parser.c

   1 /*
   2  * parser.c Copyright (C) 2002
   3  *        Etay Meiri            <etay-m@bezeqint.net>
   4  *        Jean-Noel Guiheneuf   <jnoel@saudionline.com.sa>
   5  *
   6  * Adapted from kdevelop - gdbparser.cpp  Copyright (C) 1999
   7  *        by John Birch         <jb.nz@writeme.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by the Free
  11  * Software Foundation; either version 2 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17  * for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write to the Free Software Foundation, Inc., 59
  21  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include "parser.h"
  29
  30 #include <stdlib.h>
  31 #include <libgnome/gnome-i18n.h>
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <assert.h>
  35
  36 static gchar * skip_string (gchar *buf);
  37
  38 static gchar *
  39 skip_quotes (gchar *buf, gchar quotes)
  40 {
  41         if (buf && *buf == quotes)
  42         {
  43                 buf++;
  44
  45                 while (*buf)
  46                 {
  47                         if (*buf == '\\')
  48                                 buf++; // skips \" or \' problems
  49                         else if (*buf == quotes)
  50                                 return buf + 1;
  51
  52                         buf++;
  53                 }
  54         }
  55         return buf;
  56 }
  57
  58 static gchar *
  59 skip_delim (gchar * buf, gchar open, gchar close)
  60 {
  61         if (buf && *buf == open)
  62         {
  63                 buf++;
  64
  65                 while (*buf)
  66                 {
  67                         if (*buf == open)
  68                                 buf = skip_delim (buf, open, close);
  69                         else if (*buf == close)
  70                                 return buf + 1;
  71                         else if (*buf == '\"')
  72                                 buf = skip_string (buf);
  73                         else if (*buf == '\'')
  74                                 buf = skip_quotes (buf, *buf);
  75                         else if (*buf)
  76                                 buf++;
  77                 }
  78         }
  79         return buf;
  80 }
  81
  82 static gchar *
  83 skip_string (gchar *buf)
  84 {
  85         if (buf && *buf == '\"')
  86         {
  87                 buf = skip_quotes (buf, *buf);
  88                 while (*buf)
  89                 {
  90                         if ((strncmp (buf, ", \"", 3) == 0) ||
  91                                 (strncmp (buf, ", '", 3) == 0))
  92                                 buf = skip_quotes (buf + 2, *(buf + 2));
  93
  94                         else if (strncmp (buf, " <", 2) == 0)   // take care of
  95                                                                                                         // <repeats
  96                                 buf = skip_delim (buf + 1, '<', '>');
  97                         else
  98                                 break;
  99                 }
 100
 101                 // If the string is long then it's chopped and has ... after it.
 102                 while (*buf && *buf == '.')
 103                         buf++;
 104         }
 105         return buf;
 106 }
 107
 108 static gchar *
 109 skip_token_end (gchar * buf)
 110 {
 111         if (buf)
 112         {
 113                 switch (*buf)
 114                 {
 115                 case '"':
 116                         return skip_string (buf);
 117                 case '\'':
 118                         return skip_quotes (buf, *buf);
 119                 case '{':
 120                         return skip_delim (buf, '{', '}');
 121                 case '<':
 122                         return skip_delim (buf, '<', '>');
 123                 case '(':
 124                         return skip_delim (buf, '(', ')');
 125                 }
 126
 127                 while (*buf && !isspace (*buf) && *buf != ',' && *buf != '}' &&
 128                            *buf != '=')
 129                         buf++;
 130         }
 131         return buf;
 132 }
 133
 134 static gchar *
 135 skip_token_value (gchar * buf)
 136 {
 137         gchar *end;
 138
 139         if (!buf)
 140                 return NULL;
 141         while (TRUE)
 142         {
 143                 buf = skip_token_end (buf);
 144
 145                 end = buf;
 146                 while (*end && isspace (*end) && *end != '\n')
 147                         end++;
 148
 149                 if (*end == 0 || *end == ',' || *end == '\n' || *end == '=' ||
 150                         *end == '}')
 151                         break;
 152
 153                 if (buf == end)
 154                         break;
 155
 156                 buf = end;
 157         }
 158         return buf;
 159 }
 160
 161 static gchar *
 162 skip_next_token_start (gchar * buf)
 163 {
 164         if (!buf)
 165                 return NULL;
 166
 167         while (*buf &&
 168                    (isspace (*buf) || *buf == ',' || *buf == '}' || *buf == '='))
 169                 buf++;
 170
 171         return buf;
 172 }
 173
 174 static gchar *
 175 skip_next_token (gchar * buf)
 176 {
 177         if (!buf)
 178                 return NULL;
 179
 180         while (*buf &&
 181                    (isspace (*buf) || *buf == ',' || *buf == '='))
 182                 buf++;
 183
 184         return buf;
 185 }
 186
 187 static IAnjutaDebuggerDataType
 188 get_type (gchar **buf)
 189 {
 190         gchar *pos;
 191
 192         if (!*buf || !*(*buf = skip_next_token_start (*buf)))
 193                 return IANJUTA_DEBUGGER_UNKNOWN_TYPE;
 194
 195         // A reference, probably from a parameter value.
 196         if (**buf == '@')
 197                 return IANJUTA_DEBUGGER_REFERENCE_TYPE;
 198
 199         // Structures and arrays - (but which one is which?)
 200         // {void (void)} 0x804a944 <__builtin_new+41> - this is a fn pointer
 201         // (void (*)(void)) 0x804a944 <f(E *, char)> - so is this - ugly!!!
 202         if (**buf == '{')
 203         {
 204                 (*buf)++;
 205                 if (**buf ==  '{')
 206                         return IANJUTA_DEBUGGER_ARRAY_TYPE;
 207
 208                 if (strncmp (*buf, "<No data fields>}", 17) == 0)
 209                 {
 210                         (*buf) += 17;
 211                         return IANJUTA_DEBUGGER_VALUE_TYPE;
 212                 }
 213
 214                 pos = *buf;
 215                 while (*pos)
 216                 {
 217                         switch (*pos)
 218                         {
 219                         case '=':
 220                                 return IANJUTA_DEBUGGER_STRUCT_TYPE;
 221                         case '"':
 222                                 pos = skip_string (pos);
 223                                 break;
 224                         case '\'':
 225                                 pos = skip_quotes (pos, '\'');
 226                                 break;
 227                         case ',':
 228                                 if (*(pos - 1) == '}')
 229                                 {
 230                                         g_warning ("??????\n");
 231                                 }
 232                                 return IANJUTA_DEBUGGER_ARRAY_TYPE;
 233                         case '}':
 234                                 if (*(pos + 1) == ',' || *(pos + 1) == '\n' || !*(pos + 1))
 235                                         return IANJUTA_DEBUGGER_ARRAY_TYPE;                      // Hmm a single element
 236                                                                                                  // array??
 237                                 if (strncmp (pos + 1, " 0x", 3) == 0)
 238                                         return IANJUTA_DEBUGGER_POINTER_TYPE;            // What about references?
 239                                 return IANJUTA_DEBUGGER_UNKNOWN_TYPE;                    // very odd?
 240                         case '(':
 241                                 pos = skip_delim (pos, '(', ')');
 242                                 break;
 243                         case '<':
 244                                 pos = skip_delim (pos, '<', '>');
 245                                 break;
 246                         default:
 247                                 pos++;
 248                                 break;
 249                         }
 250                 }
 251                 return IANJUTA_DEBUGGER_UNKNOWN_TYPE;
 252         }
 253
 254         // some sort of address. We need to sort out if we have
 255         // a 0x888888 "this is a char*" type which we'll term a value
 256         // or whether we just have an address
 257         if (strncmp (*buf, "0x", 2) == 0)
 258         {
 259                 pos = *buf;
 260                 while (*pos)
 261                 {
 262                         if (!isspace (*pos))
 263                                 pos++;
 264                         else if (*(pos + 1) == '\"')
 265                                 return IANJUTA_DEBUGGER_VALUE_TYPE;
 266                         else
 267                                 break;
 268                 }
 269                 return IANJUTA_DEBUGGER_POINTER_TYPE;
 270         }
 271
 272         // Pointers and references - references are a bit odd
 273         // and cause GDB to fail to produce all the local data
 274         // if they haven't been initialised. but that's not our problem!!
 275         // (void (*)(void)) 0x804a944 <f(E *, char)> - this is a fn pointer
 276         if (**buf == '(')
 277         {
 278                 pos = *buf;
 279                 pos = skip_delim (pos, '(', ')');
 280                 pos -= 2;
 281                 switch (*pos)
 282                 {
 283                 case ')':
 284                 case '*':
 285                         return IANJUTA_DEBUGGER_POINTER_TYPE;
 286                 case '&':
 287                         return IANJUTA_DEBUGGER_REFERENCE_TYPE;
 288                 default:
 289                         /* fix (char * const) - case */
 290                         while(*pos && (isalpha(*pos) || *pos == ' ')) --pos;
 291                         switch(*pos)
 292                         {
 293                           case '*':     return IANJUTA_DEBUGGER_POINTER_TYPE;
 294                           case '&':     return IANJUTA_DEBUGGER_REFERENCE_TYPE;
 295                           default:      return IANJUTA_DEBUGGER_UNKNOWN_TYPE;
 296                         }
 297                 }
 298         }
 299
 300         pos = skip_token_value (*buf);
 301         if ((strncmp (pos, " = ", 3) == 0) || (*pos == '='))
 302                 return IANJUTA_DEBUGGER_NAME_TYPE;
 303
 304         return IANJUTA_DEBUGGER_VALUE_TYPE;
 305 }
 306
 307 static gchar *
 308 get_name (gchar **buf)
 309 {
 310         gchar *start;
 311
 312         start = skip_next_token_start (*buf);
 313         if (*start)
 314         {
 315                 gchar *t;
 316
 317                 *buf = skip_token_value (start);
 318                 t = *buf;
 319                 if (*t == '=')
 320                         t--;
 321                 return g_strstrip (g_strndup (start, t - start + 1));
 322         }
 323         else
 324                 *buf = start;
 325
 326         return NULL;
 327 }
 328
 329 static gchar *
 330 get_value (gchar **buf)
 331 {
 332         gchar *start;
 333         gchar *value;
 334
 335         /* g_print("get_value: %s\n",*buf); */
 336
 337         start = skip_next_token_start (*buf);
 338         *buf = skip_token_value (start);
 339
 340         if (*start == '{')
 341                 return g_strstrip (g_strndup (start + 1, *buf - start - 1));
 342         if (*buf == start)
 343                 return NULL;
 344         value = g_strstrip (g_strndup (start, *buf - start));
 345
 346         return value;
 347 }
 348
 349 static void
 350 parse_parent (IAnjutaDebuggerWatch* parent, gchar **buf)
 351 {
 352         IAnjutaDebuggerDataType type;
 353         IAnjutaDebuggerWatch* child;
 354         guint idx;
 355         gchar *pos;
 356         guint i;
 357
 358         if (*buf == NULL)
 359                 return;
 360
 361         type = get_type (buf);
 362         if (type == IANJUTA_DEBUGGER_NAME_TYPE)
 363         {
 364                 parent->name = get_name (buf);
 365                 type = get_type (buf);
 366         }
 367
 368         parent->type = type;
 369
 370         switch (parent->type)
 371         {
 372     case IANJUTA_DEBUGGER_ROOT_TYPE:
 373     case IANJUTA_DEBUGGER_UNKNOWN_TYPE:
 374     case IANJUTA_DEBUGGER_NAME_TYPE:
 375                 break;
 376     case IANJUTA_DEBUGGER_POINTER_TYPE:
 377     case IANJUTA_DEBUGGER_VALUE_TYPE:
 378     case IANJUTA_DEBUGGER_REFERENCE_TYPE:
 379                 parent->value = get_value (buf);
 380             break;
 381     case IANJUTA_DEBUGGER_ARRAY_TYPE:
 382             child = NULL;
 383             idx = 0;
 384
 385             while (**buf)
 386                 {
 387                         *buf = skip_next_token (*buf);
 388
 389                         if (**buf == '\0')
 390                                 return;
 391                         if (**buf == '}')
 392                         {
 393                                 *buf = *buf + 1;
 394                                 return;
 395                         }
 396
 397                         if (child == NULL)
 398                         {
 399                                 parent->children = g_new0 (IAnjutaDebuggerWatch, 1);
 400                                 child = parent->children;
 401                         }
 402                         else
 403                         {
 404                                 child->sibling = g_new0 (IAnjutaDebuggerWatch, 1);
 405                                 child = child->sibling;
 406                         }
 407                         child->index = idx;
 408                         parse_parent (child, buf);
 409
 410                         if (child->value)
 411                         {
 412                                 pos = strstr (child->value, " <repeats");
 413                                 if (pos)
 414                                 {
 415                                         if ((i = atoi (pos + 10)))
 416                                                 idx += (i - 1);
 417                                 }
 418                         }
 419                         idx++;
 420                 }
 421
 422            break;
 423     case IANJUTA_DEBUGGER_STRUCT_TYPE:
 424             child = NULL;
 425
 426             while (**buf)
 427                 {
 428                         *buf = skip_next_token (*buf);
 429
 430                         if (**buf == '\0')
 431                                 return;
 432                         if (**buf == '}')
 433                         {
 434                                 *buf = *buf + 1;
 435                                 return;
 436                         }
 437
 438                         if (child == NULL)
 439                         {
 440                                 parent->children = g_new0 (IAnjutaDebuggerWatch, 1);
 441                                 child = parent->children;
 442                         }
 443                         else
 444                         {
 445                                 child->sibling = g_new0 (IAnjutaDebuggerWatch, 1);
 446                                 child = child->sibling;
 447                         }
 448
 449                         parse_parent (child, buf);
 450                 }
 451                 return;
 452         }
 453
 454 }
 455
 456 IAnjutaDebuggerWatch*
 457 gdb_watch_parse (const GDBMIValue *mi_results)
 458 {
 459         IAnjutaDebuggerWatch *watch;
 460         const GDBMIValue *value = NULL;
 461
 462         if (mi_results) value = gdbmi_value_hash_lookup (mi_results, "value");
 463         if ((mi_results == NULL) || (value == NULL))
 464         {
 465                 watch = g_new0 (IAnjutaDebuggerWatch, 1);
 466                 watch->value = "?";
 467         }
 468         else
 469         {
 470                 gchar *pos;
 471                 gchar *full_output;
 472
 473                 /* Concat the answers of gdb */
 474                 full_output = (char *)gdbmi_value_literal_get (value);
 475
 476                 pos = full_output;
 477
 478                 watch = g_new0 (IAnjutaDebuggerWatch, 1);
 479
 480                 parse_parent (watch, &pos);
 481         }
 482
 483         return watch;
 484 }
 485
 486 void gdb_watch_free (IAnjutaDebuggerWatch* this)
 487 {
 488         if (this->name != NULL) g_free ((char *)this->name);
 489         if (this->value != NULL) g_free ((char *)this->value);
 490
 491         if (this->children != NULL) gdb_watch_free (this->children);
 492         if (this->sibling != NULL) gdb_watch_free (this->sibling);
 493
 494         g_free (this);
 495 }