libiberty/testsuite/test-demangle.c

   1 /* Demangler test program,
   2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Written by Zack Weinberg <zack@codesourcery.com
   4
   5    This file is part of GNU libiberty.
   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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20 */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include "ansidecl.h"
  26 #include <stdio.h>
  27 #include "libiberty.h"
  28 #include "demangle.h"
  29
  30 struct line
  31 {
  32   size_t alloced;
  33   char *data;
  34 };
  35
  36 static unsigned int lineno;
  37
  38 /* Safely read a single line of arbitrary length from standard input.  */
  39
  40 #define LINELEN 80
  41
  42 static void
  43 getline(buf)
  44      struct line *buf;
  45 {
  46   char *data = buf->data;
  47   size_t alloc = buf->alloced;
  48   size_t count = 0;
  49   int c;
  50
  51   if (data == 0)
  52     {
  53       data = xmalloc (LINELEN);
  54       alloc = LINELEN;
  55     }
  56
  57   /* Skip comment lines.  */
  58   while ((c = getchar()) == '#')
  59     {
  60       while ((c = getchar()) != EOF && c != '\n');
  61       lineno++;
  62     }
  63
  64   /* c is the first character on the line, and it's not a comment
  65      line: copy this line into the buffer and return.  */
  66   while (c != EOF && c != '\n')
  67     {
  68       if (count + 1 >= alloc)
  69         {
  70           alloc *= 2;
  71           data = xrealloc (data, alloc);
  72         }
  73       data[count++] = c;
  74       c = getchar();
  75     }
  76   lineno++;
  77   data[count] = '\0';
  78
  79   buf->data = data;
  80   buf->alloced = alloc;
  81 }
  82
  83 static void
  84 fail (lineno, opts, in, out, exp)
  85      int lineno;
  86      const char *opts;
  87      const char *in;
  88      const char *out;
  89      const char *exp;
  90 {
  91   printf ("\
  92 FAIL at line %d, options %s:\n\
  93 in:  %s\n\
  94 out: %s\n\
  95 exp: %s\n",
  96           lineno, opts, in, out != NULL ? out : "(null)", exp);
  97 }
  98
  99 /* The tester operates on a data file consisting of groups of lines:
 100    options
 101    input to be demangled
 102    expected output
 103
 104    Supported options:
 105      --format=<name>     Sets the demangling style.
 106      --no-params         There are two lines of expected output; the first
 107                          is with DMGL_PARAMS, the second is without it.
 108      --is-v3-ctor        Calls is_gnu_v3_mangled_ctor on input; expected
 109                          output is an integer representing ctor_kind.
 110      --is-v3-dtor        Likewise, but for dtors.
 111
 112    For compatibility, just in case it matters, the options line may be
 113    empty, to mean --format=auto.  If it doesn't start with --, then it
 114    may contain only a format name.
 115 */
 116
 117 int
 118 main(argc, argv)
 119      int argc;
 120      char **argv;
 121 {
 122   enum demangling_styles style;
 123   int no_params;
 124   int is_v3_ctor;
 125   int is_v3_dtor;
 126   struct line format;
 127   struct line input;
 128   struct line expect;
 129   char *result;
 130   int failures = 0;
 131   int tests = 0;
 132
 133   if (argc > 1)
 134     {
 135       fprintf (stderr, "usage: %s < test-set\n", argv[0]);
 136       return 2;
 137     }
 138
 139   format.data = 0;
 140   input.data = 0;
 141   expect.data = 0;
 142
 143   for (;;)
 144     {
 145       getline (&format);
 146       if (feof (stdin))
 147         break;
 148
 149       getline (&input);
 150       getline (&expect);
 151
 152       tests++;
 153
 154       no_params = 0;
 155       is_v3_ctor = 0;
 156       is_v3_dtor = 0;
 157       if (format.data[0] == '\0')
 158         style = auto_demangling;
 159       else if (format.data[0] != '-')
 160         {
 161           style = cplus_demangle_name_to_style (format.data);
 162           if (style == unknown_demangling)
 163             {
 164               printf ("FAIL at line %d: unknown demangling style %s\n",
 165                       lineno, format.data);
 166               failures++;
 167               continue;
 168             }
 169         }
 170       else
 171         {
 172           char *p;
 173           char *opt;
 174
 175           p = format.data;
 176           while (*p != '\0')
 177             {
 178               char c;
 179
 180               opt = p;
 181               p += strcspn (p, " \t=");
 182               c = *p;
 183               *p = '\0';
 184               if (strcmp (opt, "--format") == 0 && c == '=')
 185                 {
 186                   char *fstyle;
 187
 188                   *p = c;
 189                   ++p;
 190                   fstyle = p;
 191                   p += strcspn (p, " \t");
 192                   c = *p;
 193                   *p = '\0';
 194                   style = cplus_demangle_name_to_style (fstyle);
 195                   if (style == unknown_demangling)
 196                     {
 197                       printf ("FAIL at line %d: unknown demangling style %s\n",
 198                               lineno, fstyle);
 199                       failures++;
 200                       continue;
 201                     }
 202                 }
 203               else if (strcmp (opt, "--no-params") == 0)
 204                 no_params = 1;
 205               else if (strcmp (opt, "--is-v3-ctor") == 0)
 206                 is_v3_ctor = 1;
 207               else if (strcmp (opt, "--is-v3-dtor") == 0)
 208                 is_v3_dtor = 1;
 209               else
 210                 {
 211                   printf ("FAIL at line %d: unrecognized option %s\n",
 212                           lineno, opt);
 213                   failures++;
 214                   continue;
 215                 }
 216               *p = c;
 217               p += strspn (p, " \t");
 218             }
 219         }
 220
 221       if (is_v3_ctor || is_v3_dtor)
 222         {
 223           char buf[20];
 224
 225           if (is_v3_ctor)
 226             {
 227               enum gnu_v3_ctor_kinds kc;
 228
 229               kc = is_gnu_v3_mangled_ctor (input.data);
 230               sprintf (buf, "%d", (int) kc);
 231             }
 232           else
 233             {
 234               enum gnu_v3_dtor_kinds kd;
 235
 236               kd = is_gnu_v3_mangled_dtor (input.data);
 237               sprintf (buf, "%d", (int) kd);
 238             }
 239
 240           if (strcmp (buf, expect.data) != 0)
 241             {
 242               fail (lineno, format.data, input.data, buf, expect.data);
 243               failures++;
 244             }
 245
 246           continue;
 247         }
 248
 249       cplus_demangle_set_style (style);
 250
 251       result = cplus_demangle (input.data,
 252                                DMGL_PARAMS|DMGL_ANSI|DMGL_TYPES);
 253
 254       if (result
 255           ? strcmp (result, expect.data)
 256           : strcmp (input.data, expect.data))
 257         {
 258           fail (lineno, format.data, input.data, result, expect.data);
 259           failures++;
 260         }
 261       free (result);
 262
 263       if (no_params)
 264         {
 265           getline (&expect);
 266           result = cplus_demangle (input.data, DMGL_ANSI|DMGL_TYPES);
 267
 268           if (result
 269               ? strcmp (result, expect.data)
 270               : strcmp (input.data, expect.data))
 271             {
 272               fail (lineno, format.data, input.data, result, expect.data);
 273               failures++;
 274             }
 275           free (result);
 276         }
 277     }
 278
 279   free (format.data);
 280   free (input.data);
 281   free (expect.data);
 282
 283   printf ("%s: %d tests, %d failures\n", argv[0], tests, failures);
 284   return failures ? 1 : 0;
 285 }