Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Functions | Variables
test-demangle.c File Reference
#include "ansidecl.h"
#include <stdio.h>
#include "libiberty.h"
#include "demangle.h"

Go to the source code of this file.

Classes

struct  line

Defines

#define LINELEN   80

Functions

static void getline (struct line *buf)
static const char * protect_end (const char *s)
static void fail (int lineno, const char *opts, const char *in, const char *out, const char *exp)
int main (int argc, char **argv)

Variables

static unsigned int lineno

Class Documentation

struct line

Definition at line 36 of file test-demangle.c.

Class Members
size_t alloced
char * data

Define Documentation

#define LINELEN   80

Definition at line 46 of file test-demangle.c.


Function Documentation

static void fail ( int  lineno,
const char *  opts,
const char *  in,
const char *  out,
const char *  exp 
) [static]

Definition at line 134 of file test-demangle.c.

{
  printf ("\
FAIL at line %d, options %s:\n\
in:  %s\n\
out: %s\n\
exp: %s\n",
         lineno, opts, in, out != NULL ? out : "(null)", exp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void getline ( struct line buf) [static]

Definition at line 49 of file test-demangle.c.

{
  char *data = buf->data;
  size_t alloc = buf->alloced;
  size_t count = 0;
  int c;

  if (data == 0)
    {
      data = xmalloc (LINELEN);
      alloc = LINELEN;
    }

  /* Skip comment lines.  */
  while ((c = getchar()) == '#')
    {
      while ((c = getchar()) != EOF && c != '\n');
      lineno++;
    }

  /* c is the first character on the line, and it's not a comment
     line: copy this line into the buffer and return.  */
  while (c != EOF && c != '\n')
    {
      if (count + 1 >= alloc)
       {
         alloc *= 2;
         data = xrealloc (data, alloc);
       }
      data[count++] = c;
      c = getchar();
    }
  lineno++;
  data[count] = '\0';

  buf->data = data;
  buf->alloced = alloc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main ( int  argc,
char **  argv 
)

Definition at line 169 of file test-demangle.c.

{
  enum demangling_styles style = auto_demangling;
  int no_params;
  int is_v3_ctor;
  int is_v3_dtor;
  int ret_postfix;
  struct line format;
  struct line input;
  struct line expect;
  char *result;
  int failures = 0;
  int tests = 0;

  if (argc > 1)
    {
      fprintf (stderr, "usage: %s < test-set\n", argv[0]);
      return 2;
    }

  format.data = 0;
  input.data = 0;
  expect.data = 0;

  for (;;)
    {
      const char *inp;
      
      getline (&format);
      if (feof (stdin))
       break;

      getline (&input);
      getline (&expect);

      inp = protect_end (input.data);

      tests++;

      no_params = 0;
      ret_postfix = 0;
      is_v3_ctor = 0;
      is_v3_dtor = 0;
      if (format.data[0] == '\0')
       style = auto_demangling;
      else if (format.data[0] != '-')
       {
         style = cplus_demangle_name_to_style (format.data);
         if (style == unknown_demangling)
           {
             printf ("FAIL at line %d: unknown demangling style %s\n",
                    lineno, format.data);
             failures++;
             continue;
           }
       }
      else
       {
         char *p;
         char *opt;

         p = format.data;
         while (*p != '\0')
           {
             char c;

             opt = p;
             p += strcspn (p, " \t=");
             c = *p;
             *p = '\0';
             if (strcmp (opt, "--format") == 0 && c == '=')
              {
                char *fstyle;

                *p = c;
                ++p;
                fstyle = p;
                p += strcspn (p, " \t");
                c = *p;
                *p = '\0';
                style = cplus_demangle_name_to_style (fstyle);
                if (style == unknown_demangling)
                  {
                    printf ("FAIL at line %d: unknown demangling style %s\n",
                           lineno, fstyle);
                    failures++;
                    continue;
                  }
              }
             else if (strcmp (opt, "--no-params") == 0)
              no_params = 1;
             else if (strcmp (opt, "--is-v3-ctor") == 0)
              is_v3_ctor = 1;
             else if (strcmp (opt, "--is-v3-dtor") == 0)
              is_v3_dtor = 1;
             else if (strcmp (opt, "--ret-postfix") == 0)
              ret_postfix = 1;
             else
              {
                printf ("FAIL at line %d: unrecognized option %s\n",
                       lineno, opt);
                failures++;
                continue;
              }
             *p = c;
             p += strspn (p, " \t");
           }
       }

      if (is_v3_ctor || is_v3_dtor)
       {
         char buf[20];

         if (is_v3_ctor)
           {
             enum gnu_v3_ctor_kinds kc;

             kc = is_gnu_v3_mangled_ctor (inp);
             sprintf (buf, "%d", (int) kc);
           }
         else
           {
             enum gnu_v3_dtor_kinds kd;

             kd = is_gnu_v3_mangled_dtor (inp);
             sprintf (buf, "%d", (int) kd);
           }

         if (strcmp (buf, expect.data) != 0)
           {
             fail (lineno, format.data, input.data, buf, expect.data);
             failures++;
           }

         continue;
       }

      cplus_demangle_set_style (style);

      result = cplus_demangle (inp,
                            DMGL_PARAMS|DMGL_ANSI|DMGL_TYPES
                            |(ret_postfix ? DMGL_RET_POSTFIX : 0));

      if (result
         ? strcmp (result, expect.data)
         : strcmp (input.data, expect.data))
       {
         fail (lineno, format.data, input.data, result, expect.data);
         failures++;
       }
      free (result);

      if (no_params)
       {
         getline (&expect);
         result = cplus_demangle (inp, DMGL_ANSI|DMGL_TYPES);

         if (result
             ? strcmp (result, expect.data)
             : strcmp (input.data, expect.data))
           {
             fail (lineno, format.data, input.data, result, expect.data);
             failures++;
           }
         free (result);
       }
    }

  free (format.data);
  free (input.data);
  free (expect.data);

  printf ("%s: %d tests, %d failures\n", argv[0], tests, failures);
  return failures ? 1 : 0;
}

Here is the call graph for this function:

static const char* protect_end ( const char *  s) [static]

Definition at line 102 of file test-demangle.c.

{
#if defined(HAVE_MMAP) && defined (MAP_ANONYMOUS)
  size_t pagesize = getpagesize();
  static char * buf;
  size_t s_len = strlen (s);
  char * result;
  
  /* Don't try if S is too long.  */
  if (s_len >= pagesize)
    return s;

  /* Allocate one page of allocated space followed by an unmapped
     page.  */
  if (buf == NULL)
    {
      buf = mmap (NULL, pagesize * 2, PROT_READ | PROT_WRITE,
                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
      if (! buf)
       return s;
      munmap (buf + pagesize, pagesize);
    }
  
  result = buf + (pagesize - s_len - 1);
  memcpy (result, s, s_len + 1);
  return result;
#else
  return s;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

unsigned int lineno [static]

Definition at line 42 of file test-demangle.c.