Quelle  demangle-java.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "symbol.h"

#include "demangle-java.h"

#include <linux/ctype.h>
#include <linux/kernel.h>

enum {
 MODE_PREFIX = 0,
 MODE_CLASS  = 1,
 MODE_FUNC   = 2,
 MODE_TYPE   = 3,
 MODE_CTYPE  = 4, /* class arg */
};

#define BASE_ENT(c, n) [c - 'A']=n
static const char *base_types['Z' - 'A' + 1] = {
 BASE_ENT('B', "byte" ),
 BASE_ENT('C', "char" ),
 BASE_ENT('D', "double" ),
 BASE_ENT('F', "float" ),
 BASE_ENT('I', "int" ),
 BASE_ENT('J', "long" ),
 BASE_ENT('S', "short" ),
 BASE_ENT('Z', "boolean" ),
};

/*
 * demangle Java symbol between str and end positions and stores
 * up to maxlen characters into buf. The parser starts in mode.
 *
 * Use MODE_PREFIX to process entire prototype till end position
 * Use MODE_TYPE to process return type if str starts on return type char
 *
 *  Return:
 * success: buf
 * error  : NULL
 */
static char *
__demangle_java_sym(const char *str, const char *end, char *buf, int maxlen, int mode)
{
 int rlen = 0;
 int array = 0;
 int narg = 0;
 const char *q;

 if (!end)
  end = str + strlen(str);

 for (q = str; q != end; q++) {

  if (rlen == (maxlen - 1))
   break;

  switch (*q) {
  case 'L':
   if (mode == MODE_PREFIX || mode == MODE_TYPE) {
    if (mode == MODE_TYPE) {
     if (narg)
      rlen += scnprintf(buf + rlen, maxlen - rlen, ", ");
     narg++;
    }
    if (mode == MODE_PREFIX)
     mode = MODE_CLASS;
    else
     mode = MODE_CTYPE;
   } else
    buf[rlen++] = *q;
   break;
  case 'B':
  case 'C':
  case 'D':
  case 'F':
  case 'I':
  case 'J':
  case 'S':
  case 'Z':
   if (mode == MODE_TYPE) {
    if (narg)
     rlen += scnprintf(buf + rlen, maxlen - rlen, ", ");
    rlen += scnprintf(buf + rlen, maxlen - rlen, "%s", base_types[*q - 'A']);
    while (array--)
     rlen += scnprintf(buf + rlen, maxlen - rlen, "[]");
    array = 0;
    narg++;
   } else
    buf[rlen++] = *q;
   break;
  case 'V':
   if (mode == MODE_TYPE) {
    rlen += scnprintf(buf + rlen, maxlen - rlen, "void");
    while (array--)
     rlen += scnprintf(buf + rlen, maxlen - rlen, "[]");
    array = 0;
   } else
    buf[rlen++] = *q;
   break;
  case '[':
   if (mode != MODE_TYPE)
    goto error;
   array++;
   break;
  case '(':
   if (mode != MODE_FUNC)
    goto error;
   buf[rlen++] = *q;
   mode = MODE_TYPE;
   break;
  case ')':
   if (mode != MODE_TYPE)
    goto error;
   buf[rlen++] = *q;
   narg = 0;
   break;
  case ';':
   if (mode != MODE_CLASS && mode != MODE_CTYPE)
    goto error;
   /* safe because at least one other char to process */
   if (isalpha(*(q + 1)) && mode == MODE_CLASS)
    rlen += scnprintf(buf + rlen, maxlen - rlen, ".");
   if (mode == MODE_CLASS)
    mode = MODE_FUNC;
   else if (mode == MODE_CTYPE)
    mode = MODE_TYPE;
   break;
  case '/':
   if (mode != MODE_CLASS && mode != MODE_CTYPE)
    goto error;
   rlen += scnprintf(buf + rlen, maxlen - rlen, ".");
   break;
  default :
   buf[rlen++] = *q;
  }
 }
 buf[rlen] = '\0';
 return buf;
error:
 return NULL;
}

/*
 * Demangle Java function signature (openJDK, not GCJ)
 * input:
 *  str: string to parse. String is not modified
 *    flags: combination of JAVA_DEMANGLE_* flags to modify demangling
 * return:
 * if input can be demangled, then a newly allocated string is returned.
 * if input cannot be demangled, then NULL is returned
 *
 * Note: caller is responsible for freeing demangled string
 */
char *
java_demangle_sym(const char *str, int flags)
{
 char *buf, *ptr;
 char *p;
 size_t len, l1 = 0;

 if (!str)
  return NULL;

 /* find start of return type */
 p = strrchr(str, ')');
 if (!p)
  return NULL;

 /*
  * expansion factor estimated to 3x
 */
 len = strlen(str) * 3 + 1;
 buf = malloc(len);
 if (!buf)
  return NULL;

 buf[0] = '\0';
 if (!(flags & JAVA_DEMANGLE_NORET)) {
  /*
   * get return type first
 */
  ptr = __demangle_java_sym(p + 1, NULL, buf, len, MODE_TYPE);
  if (!ptr)
   goto error;

  /* add space between return type and function prototype */
  l1 = strlen(buf);
  buf[l1++] = ' ';
 }

 /* process function up to return type */
 ptr = __demangle_java_sym(str, p + 1, buf + l1, len - l1, MODE_PREFIX);
 if (!ptr)
  goto error;

 return buf;
error:
 free(buf);
 return NULL;
}