decodetype.cc

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *
 * (C) Copyright Koninklijke Philips Electronics NV 2006. 
 * All rights reserved. This software is licensed under the terms of
 * version 2.1 of the GNU Lesser General Public License as published 
 * by the Free Software Foundation. For licensing and warranty
 * information, see the file COPYING in the main directory.
 *
 *------------------------------------------------------------------*/

#include "decodetype.h"

/*
 * For gcc decoding see
 * http://www.delorie.com/gnu/docs/gcc/gxxint_15.html
*/

#ifdef __GNUC__

#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <string>
#include <iostream>

using std::string;
using std::cout;
using std::cerr;
using std::endl;

static char *in;
static char out[256];

string scanType();

char scanChar()
{
  return *in++;
}

void unScanChar()
{
  in--;
}

unsigned int scanInt()
{
  char c;
  unsigned int l = 0;
  while (isdigit(c = scanChar()))
    l = l*10 + c - '0';
  unScanChar();
  return l;
}

string scanName()
{ 
  string r;
  unsigned int l = scanInt();
  for (unsigned int i=0; i<l; i++)
    r += scanChar();

  // new template format (g++ 3.0.*)
  char c = scanChar();
  if (c == 'I') {
    // new
    r += "< ";
    unsigned int n = 0;
    while ((c = scanChar()) != 'E')
    {
      unScanChar();
      if (n != 0)
        r += ", ";
      r += scanType();
      n++;
    }
    r += " >";
  } else {
    unScanChar();
  }
  return r;
}

string itoa(unsigned int i)
{
  char buf[32];
  sprintf(buf, "%d", i);
  return buf;
}

string scanArray()
{
  unsigned int l = scanInt();
  char c = scanChar(); 
  assert(c = '_');
  string t = scanType();
  return t + '[' + itoa(l) + ']';
}

string scanTemplate()
{
  // old template format (g++ 2.95.*)
  string r = scanName();
  unsigned int n = scanInt();
  r += "< ";
  for (unsigned int i=0; i<n; i++)
  {
    assert(scanChar() == 'Z');
    r += scanType();
    if (i == n-1)
      r += " >";
    else
      r += ", ";
  }
  return r;
}

string scanType()
{
  switch(scanChar())
  {
  case 'b': return "bool";
  case 'c': return "char";
  case 's': return "short";
  case 'i': return "int";
  case 'l': return "long";
  case 'f': return "float";
  case 'd': return "double";
  case 'v': return "void";
  case 'h': return "unsigned char";
  case 'j': return "unsigned int";
  case 'x': return "long long";
  case 'w': return "wchar_t";
  case 'J': return "complex";
  case 'C': 
  case 'K': 
    return "const " + scanType();
  case 'U': 
    return "unsigned " + scanType();
  case 'S':
    return "signed " + scanType();
  case 'P':
    return scanType() + "*";
  case 'R':
    return scanType() + "&";
  case 't':
#if (__GNUC__ >= 3)
    return "unsigned short";
#else
    return scanTemplate();
#endif
  case 'A':
    return scanArray();

  case '0':
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
  case '6':
  case '7':
  case '8':
  case '9':
    unScanChar();
    return scanName();

  default:
    unScanChar();
    cerr << "Cannot decode type " << in << endl;
    return "?";
  }
}

char* decodeType(const char* n)
{
  in = (char*)n;
  // cout << in << endl;
  string r = scanType();
  strncpy(out, r.c_str(), r.size());
  out[r.size()] = '\0';
  return out;
}

#else

char* decodeType(const char* n)
{
  return (char*)n;
}

#endif

---