OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [libiberty/] [testsuite/] [test-demangle.c] - Blame information for rev 816

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.