OSDN Git Service

6e00d1416d789dbbfbbed531091ec359605e652e
[pf3gnuchains/gcc-fork.git] / 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 }