gdb/cplus-dem.c

   1 /* Demangler for GNU C++
   2    Copyright 1989, 1991 Free Software Foundation, Inc.
   3    written by James Clark (jjc@jclark.uucp)
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 /* This is for g++ 1.95.03 (November 13 verison).  */
  20
  21 /* This file exports one function
  22
  23    char *cplus_demangle (const char *name, int mode)
  24
  25    If NAME is a mangled function name produced by GNU C++, then
  26    a pointer to a malloced string giving a C++ representation
  27    of the name will be returned; otherwise NULL will be returned.
  28    It is the caller's responsibility to free the string which
  29    is returned.
  30
  31    If MODE > 0, then ANSI qualifiers such as `const' and `void' are output.
  32    Otherwise they are not.
  33    If MODE >= 0, parameters are emitted; otherwise not.
  34
  35    For example,
  36
  37    cplus_demangle ("foo__1Ai",  0)      => "A::foo(int)"
  38    cplus_demangle ("foo__1Ai",  1)      => "A::foo(int)"
  39    cplus_demangle ("foo__1Ai", -1)      => "A::foo"
  40
  41    cplus_demangle ("foo__1Afe",  0)     => "A::foo(float,...)"
  42    cplus_demangle ("foo__1Afe",  1)     => "A::foo(float,...)"
  43    cplus_demangle ("foo__1Afe", -1)     => "A::foo"
  44
  45    This file imports xmalloc and xrealloc, which are like malloc and
  46    realloc except that they generate a fatal error if there is no
  47    available memory. */
  48
  49 /* define this if names don't start with _ */
  50 /* #define nounderscore 1 */
  51
  52 /* GDB-specific, FIXME.  */
  53 #include "defs.h"
  54
  55 #include <ctype.h>
  56
  57 #ifdef USG
  58 #include <memory.h>
  59 #include <string.h>
  60 #else
  61 #include <strings.h>
  62 #endif
  63
  64 /* This is '$' on systems where the assembler can deal with that.
  65    Where the assembler can't, it's '.' (but on many systems '.' is
  66    used for other things).  */
  67 #if !defined (CPLUS_MARKER)
  68 #define CPLUS_MARKER '$'
  69 #endif
  70
  71 #ifndef __STDC__
  72 #define const
  73 #endif
  74
  75 #ifdef __STDC__
  76 extern char *cplus_demangle (const char *type, int mode);
  77 #else
  78 extern char *cplus_demangle ();
  79 #endif
  80
  81 static char **typevec = 0;
  82 static int ntypes = 0;
  83 static int typevec_size = 0;
  84
  85 const static struct optable {
  86   const char *in;
  87   const char *out;
  88   int ansi;
  89 } optable[] = {
  90   "nw", " new", 1,              /* new (1.92, ansi) */
  91   "dl", " delete", 1,           /* new (1.92, ansi) */
  92   "new", " new", 0,             /* old (1.91, and 1.x) */
  93   "delete", " delete", 0,       /* old (1.91, and 1.x) */
  94   "as", "=", 1,                 /* ansi */
  95   "ne", "!=", 1,                /* old, ansi */
  96   "eq", "==", 1,                /* old, ansi */
  97   "ge", ">=", 1,                /* old, ansi */
  98   "gt", ">", 1,                 /* old, ansi */
  99   "le", "<=", 1,                /* old, ansi */
 100   "lt", "<", 1,                 /* old, ansi */
 101   "plus", "+", 0,               /* old */
 102   "pl", "+", 1,                 /* ansi */
 103   "apl", "+=", 1,               /* ansi */
 104   "minus", "-", 0,              /* old */
 105   "mi", "-", 1,                 /* ansi */
 106   "ami", "-=", 1,               /* ansi */
 107   "mult", "*", 0,               /* old */
 108   "ml", "*", 1,                 /* ansi */
 109   "aml", "*=", 1,               /* ansi */
 110   "convert", "+", 0,            /* old (unary +) */
 111   "negate", "-", 0,             /* old (unary -) */
 112   "trunc_mod", "%", 0,          /* old */
 113   "md", "%", 1,                 /* ansi */
 114   "amd", "%=", 1,               /* ansi */
 115   "trunc_div", "/", 0,          /* old */
 116   "dv", "/", 1,                 /* ansi */
 117   "adv", "/=", 1,               /* ansi */
 118   "truth_andif", "&&", 0,       /* old */
 119   "aa", "&&", 1,                /* ansi */
 120   "truth_orif", "||", 0,        /* old */
 121   "oo", "||", 1,                /* ansi */
 122   "truth_not", "!", 0,          /* old */
 123   "nt", "!", 1,                 /* ansi */
 124   "postincrement", "++", 0,     /* old */
 125   "pp", "++", 1,                /* ansi */
 126   "postdecrement", "--", 0,     /* old */
 127   "mm", "--", 1,                /* ansi */
 128   "bit_ior", "|", 0,            /* old */
 129   "or", "|", 1,                 /* ansi */
 130   "aor", "|=", 1,               /* ansi */
 131   "bit_xor", "^", 0,            /* old */
 132   "er", "^", 1,                 /* ansi */
 133   "aer", "^=", 1,               /* ansi */
 134   "bit_and", "&", 0,            /* old */
 135   "ad", "&", 1,                 /* ansi */
 136   "aad", "&=", 1,               /* ansi */
 137   "bit_not", "~", 0,            /* old */
 138   "co", "~", 1,                 /* ansi */
 139   "call", "()", 0,              /* old */
 140   "cl", "()", 1,                /* ansi */
 141   "alshift", "<<", 0,           /* old */
 142   "ls", "<<", 1,                /* ansi */
 143   "als", "<<=", 1,              /* ansi */
 144   "arshift", ">>", 0,           /* old */
 145   "rs", ">>", 1,                /* ansi */
 146   "ars", ">>=", 1,              /* ansi */
 147   "component", "->", 0,         /* old */
 148   "rf", "->", 1,                /* ansi */
 149   "indirect", "*", 0,           /* old */
 150   "method_call", "->()", 0,     /* old */
 151   "addr", "&", 0,               /* old (unary &) */
 152   "array", "[]", 0,             /* old */
 153   "vc", "[]", 1,                /* ansi */
 154   "compound", ",", 0,           /* old */
 155   "cm", ",", 1,                 /* ansi */
 156   "cond", "?:", 0,              /* old */
 157   "cn", "?:", 1,                /* psuedo-ansi */
 158   "max", ">?", 0,               /* old */
 159   "mx", ">?", 1,                /* psuedo-ansi */
 160   "min", "<?", 0,               /* old */
 161   "mn", "<?", 1,                /* psuedo-ansi */
 162   "nop", "", 0,                 /* old (for operator=) */
 163 };
 164
 165 /* Beware: these aren't '\0' terminated. */
 166
 167 typedef struct string {
 168   char *b;                      /* pointer to start of string */
 169   char *p;                      /* pointer after last character */
 170   char *e;                      /* pointer after end of allocated space */
 171 } string;
 172
 173 static void
 174 string_need PARAMS ((string *, int));
 175
 176 static void
 177 string_delete PARAMS ((string *));
 178
 179 static void
 180 string_init PARAMS ((string *));
 181
 182 static void
 183 string_clear PARAMS ((string *));
 184
 185 static int
 186 string_empty PARAMS ((string *));
 187
 188 static void
 189 string_append PARAMS ((string *, const char *));
 190
 191 static void
 192 string_appends PARAMS ((string *, string *));
 193
 194 static void
 195 string_appendn PARAMS ((string *, const char *, int));
 196
 197 static void
 198 string_prepend PARAMS ((string *, const char *));
 199
 200 static void
 201 string_prependn PARAMS ((string *, const char *, int));
 202
 203 static int
 204 get_count PARAMS ((const char **, int *));
 205
 206 static int
 207 do_args PARAMS ((const char **, string *, int));
 208
 209 static int
 210 do_type PARAMS ((const char **, string *, int));
 211
 212 static int
 213 do_arg PARAMS ((const char **, string *, int));
 214
 215 static void
 216 munge_function_name PARAMS ((string *, int));
 217
 218 static void
 219 remember_type PARAMS ((const char *, int));
 220
 221 #if 0
 222 static void
 223 string_prepends PARAMS ((string *, string *));
 224 #endif
 225
 226
 227 /* Takes operator name as e.g. "++" and returns mangled
 228    operator name (e.g. "postincrement_expr"), or NULL if not found.
 229
 230    If ARG_MODE == 1, return the ANSI name;
 231    if ARG_MODE == 0 return the old GNU name.  */
 232 char *
 233 cplus_mangle_opname (opname, arg_mode)
 234      char *opname;
 235      int arg_mode;
 236 {
 237   int i, len = strlen (opname);
 238
 239   if (arg_mode != 0 && arg_mode != 1)
 240     error ("invalid arg_mode");
 241
 242   for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
 243     {
 244       if (strlen (optable[i].out) == len
 245           && arg_mode == optable[i].ansi
 246           && memcmp (optable[i].out, opname, len) == 0)
 247         return (char *)optable[i].in;
 248     }
 249   return 0;
 250 }
 251
 252 char *
 253 cplus_demangle (type, arg_mode)
 254      const char *type;
 255      int arg_mode;
 256 {
 257   string decl;
 258   int n;
 259   int success = 0;
 260   int constructor = 0;
 261   int destructor = 0;
 262   int static_type = 0;
 263   int const_flag = 0;
 264   int i;
 265   const char *p;
 266 #ifndef LONGERNAMES
 267   const char *premangle;
 268 #endif
 269
 270 # define print_ansi_qualifiers (arg_mode >  0)
 271 # define print_arg_types       (arg_mode >= 0)
 272
 273   if (type == NULL || *type == '\0')
 274     return NULL;
 275 #ifndef nounderscore
 276   if (*type++ != '_')
 277     return NULL;
 278 #endif
 279   p = type;
 280   while (*p != '\0' && !(*p == '_' && p[1] == '_'))
 281     p++;
 282   if (*p == '\0')
 283     {
 284       /* destructor */
 285       if (type[0] == '_' && type[1] == CPLUS_MARKER && type[2] == '_')
 286         {
 287           int n;
 288           char *tem;
 289
 290           type += 3;            /* Get past _$_ at front.  */
 291           while (isdigit (*type))
 292             /* If there are digits at the front, it's because
 293                of new 2.0 name mangling.  Just skip them.  */
 294             type++;
 295
 296           n = strlen (type)*2 + 3 + 2 + 1;
 297           tem = (char *) xmalloc (n);
 298           strcpy (tem, type);
 299           strcat (tem, "::~");
 300           strcat (tem, type);
 301           if (print_arg_types)
 302             strcat (tem, "()");
 303           return tem;
 304         }
 305       /* static data member */
 306       if (*type != '_' && (p = strchr (type, CPLUS_MARKER)) != NULL)
 307         {
 308           int n = strlen (type) + 2;
 309           char *tem = (char *) xmalloc (n);
 310           memcpy (tem, type, p - type);
 311           strcpy (tem + (p - type), "::");
 312           strcpy (tem + (p - type) + 2, p + 1);
 313           return tem;
 314         }
 315       /* virtual table "_vt$"  */
 316       if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
 317         {
 318           int n = strlen (type + 4) + 14 + 1;
 319           char *tem = (char *) xmalloc (n);
 320           strcpy (tem, type + 4);
 321           strcat (tem, " virtual table");
 322           return tem;
 323         }
 324       return NULL;
 325     }
 326
 327   string_init (&decl);
 328
 329   if (static_type)
 330     {
 331       if (!isdigit (p[0]) && ('t' != p[0]))
 332         {
 333           string_delete (&decl);
 334           return NULL;
 335         }
 336     }
 337   else if (p == type)
 338     {
 339       if (!isdigit (p[2]) && ('t' != p[2]))
 340         {
 341           p += 1;
 342           while (*p != '\0' && !(*p == '_' && p[1] == '_'))
 343             p++;
 344           string_appendn (&decl, type, p - type);
 345           string_need (&decl, 1);
 346           *(decl.p) = '\0';
 347           munge_function_name (&decl, 1);
 348           if (decl.b[0] == '_')
 349             {
 350               string_delete (&decl);
 351               return NULL;
 352             }
 353           else
 354             p += 2;
 355         }
 356       else
 357         {
 358           constructor = 1;
 359           p += 2;
 360         }
 361     }
 362   else
 363     {
 364       string_appendn (&decl, type, p - type);
 365       string_need (&decl, 1);
 366       *(decl.p) = '\0';
 367       munge_function_name (&decl, arg_mode);
 368       p += 2;
 369     }
 370
 371 #ifndef LONGERNAMES
 372   premangle = p;
 373 #endif
 374   switch (*p)
 375     {
 376     case 'C':
 377       /* a const member function */
 378       if (!isdigit (p[1]))
 379         {
 380           string_delete (&decl);
 381           return NULL;
 382         }
 383       p += 1;
 384       const_flag = 1;
 385       /* fall through */
 386     case '0':
 387     case '1':
 388     case '2':
 389     case '3':
 390     case '4':
 391     case '5':
 392     case '6':
 393     case '7':
 394     case '8':
 395     case '9':
 396       n = 0;
 397       do
 398         {
 399           n *= 10;
 400           n += *p - '0';
 401           p += 1;
 402         }
 403       while (isdigit (*p));
 404       if (strlen (p) < n)
 405         {
 406           string_delete (&decl);
 407           return NULL;
 408         }
 409       if (constructor || destructor)
 410         {
 411           string_appendn (&decl, p, n);
 412           string_append (&decl, "::");
 413           if (destructor)
 414             string_append(&decl, "~");
 415           string_appendn (&decl, p, n);
 416         }
 417       else
 418         {
 419           string_prepend (&decl, "::");
 420           string_prependn (&decl, p, n);
 421         }
 422       p += n;
 423 #ifndef LONGERNAMES
 424       remember_type (premangle, p - premangle);
 425 #endif
 426       if (static_type)
 427         {
 428           string_append(&decl, p+1);
 429           p += strlen(p);
 430           success = 1;
 431         }
 432       else
 433         success = do_args (&p, &decl, arg_mode);
 434       if (const_flag && print_arg_types)
 435         string_append (&decl, " const");
 436       break;
 437     case 'F':
 438       p += 1;
 439       success = do_args (&p, &decl, arg_mode);
 440       break;
 441     /* template additions */
 442     case 't':
 443       p += 1;
 444       {
 445         int r, i;
 446         string tname;
 447         string trawname;
 448
 449         string temp;
 450         int need_comma = 0;
 451
 452         string_init(&tname);
 453         string_init(&trawname);
 454
 455         /* get template name */
 456         if (!get_count (&p, &r))
 457           return 0;
 458         string_appendn (&tname, p, r);
 459         string_appendn (&trawname, p, r);
 460         string_appendn (&trawname, "", 1);
 461         p += r;
 462         string_append (&tname, "<");
 463         /* get size of template parameter list */
 464         if (!get_count (&p, &r))
 465           return 0;
 466         for (i = 0; i < r; i++)
 467           {
 468             if (need_comma)
 469               string_append (&tname, ", ");
 470             /* Z for type parameters */
 471             if (*p == 'Z')
 472               {
 473                 p += 1;
 474
 475                 success = do_type (&p, &temp, arg_mode);
 476                 string_appendn (&temp, "", 1);
 477                 if (success)
 478                   string_append (&tname, temp.b);
 479                 string_delete(&temp);
 480                 if (!success)
 481                   break;
 482               }
 483             /* otherwise, value parameter */
 484             else
 485               {
 486                 const char *old_p  = p;
 487                 int is_pointer = 0;
 488                 int is_real = 0;
 489                 int is_integral = 0;
 490                 int done = 0;
 491
 492                 success = do_type (&p, &temp, arg_mode);
 493                 string_appendn (&temp, "", 1);
 494                 if (success)
 495                   string_append (&tname, temp.b);
 496                 string_delete(&temp);
 497                 if (!success)
 498                   break;
 499                 string_append (&tname, "=");
 500                 while (*old_p && !done)
 501                   {
 502                     switch (*old_p)
 503                       {
 504                       case 'P':
 505                       case 'R':
 506                         done = is_pointer = 1;
 507                         break;
 508                       case 'C': /* const */
 509                       case 'S': /* explicitly signed [char] */
 510                       case 'U': /* unsigned */
 511                       case 'V': /* volatile */
 512                       case 'F': /* function */
 513                       case 'M': /* member function */
 514                       case 'O': /* ??? */
 515                         old_p++;
 516                         continue;
 517                       case 'Q': /* repetition of following */
 518                       case 'T': /* remembered type */
 519                         abort();
 520                         break;
 521                       case 'v': /* void */
 522                         abort();
 523                         break;
 524                       case 'x': /* long long */
 525                       case 'l': /* long */
 526                       case 'i': /* int */
 527                       case 's': /* short */
 528                       case 'c': /* char */
 529                         done = is_integral = 1;
 530                         break;
 531                       case 'r': /* long double */
 532                       case 'd': /* double */
 533                       case 'f': /* float */
 534                         done = is_real = 1;
 535                         break;
 536                       default:
 537                         abort();
 538                       }
 539                   }
 540                 if (is_integral)
 541                   {
 542                     if (*p == 'm')
 543                       {
 544                         string_appendn (&tname, "-", 1);
 545                         p++;
 546                       }
 547                     while (isdigit (*p))
 548                       {
 549                         string_appendn (&tname, p, 1);
 550                         p++;
 551                       }
 552                   }
 553                 else if (is_real)
 554                   {
 555                     if (*p == 'm')
 556                       {
 557                         string_appendn (&tname, "-", 1);
 558                         p++;
 559                       }
 560                     while (isdigit (*p))
 561                       {
 562                         string_appendn (&tname, p, 1);
 563                         p++;
 564                       }
 565                     if (*p == '.') /* fraction */
 566                       {
 567                         string_appendn (&tname, ".", 1);
 568                         p++;
 569                         while (isdigit (*p))
 570                           {
 571                             string_appendn (&tname, p, 1);
 572                             p++;
 573                           }
 574                       }
 575                     if (*p == 'e') /* exponent */
 576                       {
 577                         string_appendn (&tname, "e", 1);
 578                         p++;
 579                         while (isdigit (*p))
 580                           {
 581                             string_appendn (&tname, p, 1);
 582                             p++;
 583                           }
 584                       }
 585                   }
 586                 else if (is_pointer)
 587                   {
 588                     int symbol_len;
 589
 590                     if (!get_count (&p, &symbol_len))
 591                       {
 592                         success = 0;
 593                         break;
 594                       }
 595                     string_appendn (&tname, p, symbol_len);
 596                     p += symbol_len;
 597                   }
 598               }
 599             need_comma = 1;
 600           }
 601         string_append (&tname, ">::");
 602         if (destructor)
 603           string_append(&tname, "~");
 604         if (constructor || destructor) {
 605           string_append (&tname, trawname.b);
 606         }
 607         string_delete(&trawname);
 608
 609         if (!success) {
 610           string_delete(&tname);
 611           return 0;
 612         }
 613         string_prepend (&decl, tname.b);
 614         string_delete(&tname);
 615
 616         if (static_type)
 617           {
 618             string_append(&decl, p+1);
 619             p += strlen(p);
 620             success = 1;
 621           }
 622         else
 623           success = do_args (&p, &decl, arg_mode);
 624         break;
 625       }
 626     }
 627
 628   for (i = 0; i < ntypes; i++)
 629     if (typevec[i] != NULL)
 630       free (typevec[i]);
 631   ntypes = 0;
 632   if (typevec != NULL)
 633     {
 634       free ((char *)typevec);
 635       typevec = NULL;
 636       typevec_size = 0;
 637     }
 638
 639   if (success)
 640     {
 641       string_appendn (&decl, "", 1);
 642       return decl.b;
 643     }
 644   else
 645     {
 646       string_delete (&decl);
 647       return NULL;
 648     }
 649 }
 650
 651 static int
 652 get_count (type, count)
 653      const char **type;
 654      int *count;
 655 {
 656   if (!isdigit (**type))
 657     return 0;
 658   *count = **type - '0';
 659   *type += 1;
 660   /* see flush_repeats in cplus-method.c */
 661   if (isdigit (**type))
 662     {
 663       const char *p = *type;
 664       int n = *count;
 665       do
 666         {
 667           n *= 10;
 668           n += *p - '0';
 669           p += 1;
 670         }
 671       while (isdigit (*p));
 672       if (*p == '_')
 673         {
 674           *type = p + 1;
 675           *count = n;
 676         }
 677     }
 678   return 1;
 679 }
 680
 681 /* result will be initialised here; it will be freed on failure */
 682
 683 static int
 684 do_type (type, result, arg_mode)
 685      const char **type;
 686      string *result;
 687      int arg_mode;
 688 {
 689   int n;
 690   int done;
 691   int non_empty = 0;
 692   int success;
 693   string decl;
 694   const char *remembered_type;
 695
 696   string_init (&decl);
 697   string_init (result);
 698
 699   done = 0;
 700   success = 1;
 701   while (success && !done)
 702     {
 703       int member;
 704       switch (**type)
 705         {
 706         case 'Q':
 707           n = (*type)[1] - '0';
 708           if (n < 0 || n > 9)
 709             success = 0;
 710           *type += 2;
 711           while (n-- > 0)
 712             do_type (type, result, arg_mode);
 713           break;
 714
 715         case 'P':
 716           *type += 1;
 717           string_prepend (&decl, "*");
 718           break;
 719
 720         case 'R':
 721           *type += 1;
 722           string_prepend (&decl, "&");
 723           break;
 724
 725         case 'T':
 726           *type += 1;
 727           if (!get_count (type, &n) || n >= ntypes)
 728             success = 0;
 729           else
 730             {
 731               remembered_type = typevec[n];
 732               type = &remembered_type;
 733             }
 734           break;
 735
 736         case 'F':
 737           *type += 1;
 738           if (!string_empty (&decl) && decl.b[0] == '*')
 739             {
 740               string_prepend (&decl, "(");
 741               string_append (&decl, ")");
 742             }
 743           if (!do_args (type, &decl, arg_mode) || **type != '_')
 744             success = 0;
 745           else
 746             *type += 1;
 747           break;
 748
 749         case 'M':
 750         case 'O':
 751           {
 752             int constp = 0;
 753             int volatilep = 0;
 754
 755             member = **type == 'M';
 756             *type += 1;
 757             if (!isdigit (**type))
 758               {
 759                 success = 0;
 760                 break;
 761               }
 762             n = 0;
 763             do
 764               {
 765                 n *= 10;
 766                 n += **type - '0';
 767                 *type += 1;
 768               }
 769             while (isdigit (**type));
 770             if (strlen (*type) < n)
 771               {
 772                 success = 0;
 773                 break;
 774               }
 775             string_append (&decl, ")");
 776             string_prepend (&decl, "::");
 777             string_prependn (&decl, *type, n);
 778             string_prepend (&decl, "(");
 779             *type += n;
 780             if (member)
 781               {
 782                 if (**type == 'C')
 783                   {
 784                     *type += 1;
 785                     constp = 1;
 786                   }
 787                 if (**type == 'V')
 788                   {
 789                     *type += 1;
 790                     volatilep = 1;
 791                   }
 792                 if (*(*type)++ != 'F')
 793                   {
 794                     success = 0;
 795                     break;
 796                   }
 797               }
 798             if ((member && !do_args (type, &decl, arg_mode)) || **type != '_')
 799               {
 800                 success = 0;
 801                 break;
 802               }
 803             *type += 1;
 804             if (! print_ansi_qualifiers)
 805               break;
 806             if (constp)
 807               {
 808                 if (non_empty)
 809                   string_append (&decl, " ");
 810                 else
 811                   non_empty = 1;
 812                 string_append (&decl, "const");
 813               }
 814             if (volatilep)
 815               {
 816                 if (non_empty)
 817                   string_append (&decl, " ");
 818                 else
 819                   non_empty = 1;
 820                 string_append (&decl, "volatile");
 821               }
 822             break;
 823           }
 824
 825         case 'C':
 826           if ((*type)[1] == 'P')
 827             {
 828               *type += 1;
 829               if (print_ansi_qualifiers)
 830                 {
 831                   if (!string_empty (&decl))
 832                     string_prepend (&decl, " ");
 833                   string_prepend (&decl, "const");
 834                 }
 835               break;
 836             }
 837
 838           /* fall through */
 839         default:
 840           done = 1;
 841           break;
 842         }
 843     }
 844
 845   done = 0;
 846   non_empty = 0;
 847   while (success && !done)
 848     {
 849       switch (**type)
 850         {
 851         case 'C':
 852           *type += 1;
 853           if (print_ansi_qualifiers)
 854             {
 855               if (non_empty)
 856                 string_append (result, " ");
 857               else
 858                 non_empty = 1;
 859               string_append (result, "const");
 860             }
 861           break;
 862         case 'U':
 863           *type += 1;
 864           if (non_empty)
 865             string_append (result, " ");
 866           else
 867             non_empty = 1;
 868           string_append (result, "unsigned");
 869           break;
 870         case 'S': /* signed char only */
 871           *type += 1;
 872           if (non_empty)
 873             string_append (result, " ");
 874           else
 875             non_empty = 1;
 876           string_append (result, "signed");
 877           break;
 878         case 'V':
 879           *type += 1;
 880           if (print_ansi_qualifiers)
 881             {
 882               if (non_empty)
 883                 string_append (result, " ");
 884               else
 885                 non_empty = 1;
 886               string_append (result, "volatile");
 887             }
 888           break;
 889         default:
 890           done = 1;
 891           break;
 892         }
 893     }
 894
 895   if (success)
 896     switch (**type)
 897       {
 898       case '\0':
 899       case '_':
 900         break;
 901       case 'v':
 902         *type += 1;
 903         if (non_empty)
 904           string_append (result, " ");
 905         string_append (result, "void");
 906         break;
 907       case 'x':
 908         *type += 1;
 909         if (non_empty)
 910           string_append (result, " ");
 911         string_append (result, "long long");
 912         break;
 913       case 'l':
 914         *type += 1;
 915         if (non_empty)
 916           string_append (result, " ");
 917         string_append (result, "long");
 918         break;
 919       case 'i':
 920         *type += 1;
 921         if (non_empty)
 922           string_append (result, " ");
 923         string_append (result, "int");
 924         break;
 925       case 's':
 926         *type += 1;
 927         if (non_empty)
 928           string_append (result, " ");
 929         string_append (result, "short");
 930         break;
 931       case 'c':
 932         *type += 1;
 933         if (non_empty)
 934           string_append (result, " ");
 935         string_append (result, "char");
 936         break;
 937       case 'r':
 938         *type += 1;
 939         if (non_empty)
 940           string_append (result, " ");
 941         string_append (result, "long double");
 942         break;
 943       case 'd':
 944         *type += 1;
 945         if (non_empty)
 946           string_append (result, " ");
 947         string_append (result, "double");
 948         break;
 949       case 'f':
 950         *type += 1;
 951         if (non_empty)
 952           string_append (result, " ");
 953         string_append (result, "float");
 954         break;
 955       case 'G':
 956         *type += 1;
 957         if (!isdigit (**type))
 958           {
 959             success = 0;
 960             break;
 961           }
 962         /* fall through */
 963       case '0':
 964       case '1':
 965       case '2':
 966       case '3':
 967       case '4':
 968       case '5':
 969       case '6':
 970       case '7':
 971       case '8':
 972       case '9':
 973         n = 0;
 974         do
 975           {
 976             n *= 10;
 977             n += **type - '0';
 978             *type += 1;
 979           }
 980         while (isdigit (**type));
 981         if (strlen (*type) < n)
 982           {
 983             success = 0;
 984             break;
 985           }
 986         if (non_empty)
 987           string_append (result, " ");
 988         string_appendn (result, *type, n);
 989         *type += n;
 990         break;
 991       default:
 992         success = 0;
 993         break;
 994       }
 995
 996   if (success)
 997     {
 998       if (!string_empty (&decl))
 999         {
1000           string_append (result, " ");
1001           string_appends (result, &decl);
1002         }
1003       string_delete (&decl);
1004       return 1;
1005     }
1006   else
1007     {
1008       string_delete (&decl);
1009       string_delete (result);
1010       return 0;
1011     }
1012 }
1013
1014 /* `result' will be initialised in do_type; it will be freed on failure */
1015
1016 static int
1017 do_arg (type, result, arg_mode)
1018      const char **type;
1019      string *result;
1020      int arg_mode;
1021 {
1022   const char *start = *type;
1023
1024   if (!do_type (type, result, arg_mode))
1025     return 0;
1026   remember_type (start, *type - start);
1027   return 1;
1028 }
1029
1030 static void
1031 remember_type (start, len)
1032      const char *start;
1033      int len;
1034 {
1035   char *tem;
1036
1037   if (ntypes >= typevec_size)
1038     {
1039       if (typevec_size == 0)
1040         {
1041           typevec_size = 3;
1042           typevec = (char **) xmalloc (sizeof (char*)*typevec_size);
1043         }
1044       else
1045         {
1046           typevec_size *= 2;
1047           typevec = (char **) xrealloc ((char *)typevec, sizeof (char*)*typevec_size);
1048         }
1049     }
1050   tem = (char *) xmalloc (len + 1);
1051   memcpy (tem, start, len);
1052   tem[len] = '\0';
1053   typevec[ntypes++] = tem;
1054 }
1055
1056 /* `decl' must be already initialised, usually non-empty;
1057    it won't be freed on failure */
1058
1059 static int
1060 do_args (type, decl, arg_mode)
1061      const char **type;
1062      string *decl;
1063      int arg_mode;
1064 {
1065   string arg;
1066   int need_comma = 0;
1067
1068   if (print_arg_types)
1069     string_append (decl, "(");
1070
1071   while (**type != '_' && **type != '\0' && **type != 'e' && **type != 'v')
1072     {
1073       if (**type == 'N')
1074         {
1075           int r;
1076           int t;
1077           *type += 1;
1078           if (!get_count (type, &r) || !get_count (type, &t) || t >= ntypes)
1079             return 0;
1080           while (--r >= 0)
1081             {
1082               const char *tem = typevec[t];
1083               if (need_comma && print_arg_types)
1084                 string_append (decl, ", ");
1085               if (!do_arg (&tem, &arg, arg_mode))
1086                 return 0;
1087               if (print_arg_types)
1088                 string_appends (decl, &arg);
1089               string_delete (&arg);
1090               need_comma = 1;
1091             }
1092         }
1093       else
1094         {
1095           if (need_comma & print_arg_types)
1096             string_append (decl, ", ");
1097           if (!do_arg (type, &arg, arg_mode))
1098             return 0;
1099           if (print_arg_types)
1100             string_appends (decl, &arg);
1101           string_delete (&arg);
1102           need_comma = 1;
1103         }
1104     }
1105
1106   if (**type == 'v')
1107     *type += 1;
1108   else if (**type == 'e')
1109     {
1110       *type += 1;
1111       if (print_arg_types)
1112         {
1113           if (need_comma)
1114             string_append (decl, ",");
1115           string_append (decl, "...");
1116         }
1117     }
1118
1119   if (print_arg_types)
1120     string_append (decl, ")");
1121   return 1;
1122 }
1123
1124 static void
1125 munge_function_name (name, arg_mode)
1126      string *name;
1127      int arg_mode;
1128 {
1129   if (string_empty (name))
1130     return;
1131
1132   if (name->p - name->b >= 3
1133       && name->b[0] == 'o' && name->b[1] == 'p' && name->b[2] == CPLUS_MARKER)
1134     {
1135       int i;
1136       /* see if it's an assignment expression */
1137       if (name->p - name->b >= 10 /* op$assign_ */
1138           && memcmp (name->b + 3, "assign_", 7) == 0)
1139         {
1140           for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
1141             {
1142               int len = name->p - name->b - 10;
1143               if (strlen (optable[i].in) == len
1144                   && memcmp (optable[i].in, name->b + 10, len) == 0)
1145                 {
1146                   string_clear (name);
1147                   string_append (name, "operator");
1148                   string_append (name, optable[i].out);
1149                   string_append (name, "=");
1150                   return;
1151                 }
1152             }
1153         }
1154       else
1155         {
1156           for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
1157             {
1158               int len = name->p - name->b - 3;
1159               if (strlen (optable[i].in) == len
1160                   && memcmp (optable[i].in, name->b + 3, len) == 0)
1161                 {
1162                   string_clear (name);
1163                   string_append (name, "operator");
1164                   string_append (name, optable[i].out);
1165                   return;
1166                 }
1167             }
1168         }
1169       return;
1170     }
1171   else if (name->p - name->b >= 5 && memcmp (name->b, "type$", 5) == 0)
1172     {
1173       /* type conversion operator */
1174       string type;
1175       const char *tem = name->b + 5;
1176       if (do_type (&tem, &type, arg_mode))
1177         {
1178           string_clear (name);
1179           string_append (name, "operator ");
1180           string_appends (name, &type);
1181           string_delete (&type);
1182           return;
1183         }
1184     }
1185   /* ANSI.  */
1186   else if (name->b[2] == 'o' && name->b[3] == 'p')
1187     {
1188       /* type conversion operator.  */
1189       string type;
1190       const char *tem = name->b + 4;
1191       if (do_type (&tem, &type, arg_mode))
1192         {
1193           string_clear (name);
1194           string_append (name, "operator ");
1195           string_appends (name, &type);
1196           string_delete (&type);
1197           return;
1198         }
1199     }
1200   else if (name->b[0] == '_' && name->b[1] == '_'
1201            && name->b[2] >= 'a' && name->b[2] <= 'z'
1202            && name->b[3] >= 'a' && name->b[3] <= 'z')
1203     {
1204       int i;
1205
1206       if (name->b[4] == '\0')
1207         {
1208           /* Operator.  */
1209           for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
1210             {
1211               if (strlen (optable[i].in) == 2
1212                   && memcmp (optable[i].in, name->b + 2, 2) == 0)
1213                 {
1214                   string_clear (name);
1215                   string_append (name, "operator");
1216                   string_append (name, optable[i].out);
1217                   return;
1218                 }
1219             }
1220         }
1221       else
1222         {
1223           if (name->b[2] != 'a' || name->b[5] != '\0')
1224             return;
1225           /* Assignment.  */
1226           for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
1227             {
1228               if (strlen (optable[i].in) == 3
1229                   && memcmp (optable[i].in, name->b + 2, 3) == 0)
1230                 {
1231                   string_clear (name);
1232                   string_append (name, "operator");
1233                   string_append (name, optable[i].out);
1234                   return;
1235                 }
1236             }
1237         }
1238     }
1239 }
1240
1241 /* a mini string-handling package */
1242
1243 static void
1244 string_need (s, n)
1245      string *s;
1246      int n;
1247 {
1248   if (s->b == NULL)
1249     {
1250       if (n < 32)
1251         n = 32;
1252       s->p = s->b = (char *) xmalloc (n);
1253       s->e = s->b + n;
1254     }
1255   else if (s->e - s->p < n)
1256     {
1257       int tem = s->p - s->b;
1258       n += tem;
1259       n *= 2;
1260       s->b = (char *) xrealloc (s->b, n);
1261       s->p = s->b + tem;
1262       s->e = s->b + n;
1263     }
1264 }
1265
1266 static void
1267 string_delete (s)
1268      string *s;
1269 {
1270   if (s->b != NULL)
1271     {
1272       free (s->b);
1273       s->b = s->e = s->p = NULL;
1274     }
1275 }
1276
1277 static void
1278 string_init (s)
1279      string *s;
1280 {
1281   s->b = s->p = s->e = NULL;
1282 }
1283
1284 static void
1285 string_clear (s)
1286      string *s;
1287 {
1288   s->p = s->b;
1289 }
1290
1291 static int
1292 string_empty (s)
1293      string *s;
1294 {
1295   return s->b == s->p;
1296 }
1297
1298 static void
1299 string_append (p, s)
1300      string *p;
1301      const char *s;
1302 {
1303   int n;
1304   if (s == NULL || *s == '\0')
1305     return;
1306   n = strlen (s);
1307   string_need (p, n);
1308   memcpy (p->p, s, n);
1309   p->p += n;
1310 }
1311
1312 static void
1313 string_appends (p, s)
1314      string *p, *s;
1315 {
1316   int n;
1317   if (s->b == s->p)
1318     return;
1319   n = s->p - s->b;
1320   string_need (p, n);
1321   memcpy (p->p, s->b, n);
1322   p->p += n;
1323 }
1324
1325 static void
1326 string_appendn (p, s, n)
1327      string *p;
1328      const char *s;
1329      int n;
1330 {
1331   if (n == 0)
1332     return;
1333   string_need (p, n);
1334   memcpy (p->p, s, n);
1335   p->p += n;
1336 }
1337
1338 static void
1339 string_prepend (p, s)
1340      string *p;
1341      const char *s;
1342 {
1343   if (s == NULL || *s == '\0')
1344     return;
1345   string_prependn (p, s, strlen (s));
1346 }
1347
1348 #if 0
1349 static void
1350 string_prepends (p, s)
1351      string *p, *s;
1352 {
1353   if (s->b == s->p)
1354     return;
1355   string_prependn (p, s->b, s->p - s->b);
1356 }
1357 #endif
1358
1359 static void
1360 string_prependn (p, s, n)
1361      string *p;
1362      const char *s;
1363      int n;
1364 {
1365   char *q;
1366
1367   if (n == 0)
1368     return;
1369   string_need (p, n);
1370   for (q = p->p - 1; q >= p->b; q--)
1371     q[n] = q[0];
1372   memcpy (p->b, s, n);
1373   p->p += n;
1374 }