mangle.c

来自「基于LWVCL开发的库」· C语言 代码 · 共 831 行 · 第 1/2 页

			2 + /* 'cl' */
			2 + /* '0x' */
			(sizeof(void *) * 2); /* the number */
		quals++;
	}
	if( !error && (retval = (char *)KMALLOC(prepend + total_len + 1)) )
	{
		char *dest;

		/* Start after the prepended section */
		dest = retval + prepend;
		dest[0] = 0;
		if( quals )
		{
			/*
			 * Its a qualified name, print out how many qualifiers
			 * there are before continuing
			 */
			quals++;
			if( quals < 10 )
				sprintf(dest, "Q%d", quals);
			else
				sprintf(dest, "Q_%d_", quals);
			quals--;
		}
		dest += strlen(dest);
		/* Encode the class loader, if there is one */
		if( cl )
		{
			int cl_len;

			sprintf(dest + 3, "l%p", cl);
			cl_len = strlen(dest + 3) + 1;
			sprintf(dest, "%d", cl_len);
			dest[2] = 'c'; /* The previous sprintf overwrote it */
			dest += cl_len + 2;
			quals--;
		}
		curr = name;
		while( curr < end )
		{
			if( (m_len = mangleLength(curr,
						  quals ? -1 : end - curr,
						  NAME_SEPARATORS,
						  &len)) )
			{
#if MANGLE_GCJ
				*dest = 'U';
				dest++;
#endif
			}
			else
			{
				m_len = len;
			}
			/* Write the length of the name */
			sprintf(dest, "%d", m_len);
			dest += strlen(dest);
			/* Mangle the string */
			mangleString(dest, curr, len, m_len != len);
			/* Move on to the next name */
			dest += strlen(dest);
			curr += len + 1;
			quals--;
		}
		assert((dest - retval) <= (ptrdiff_t)(prepend + total_len + 1));
	}
	return( retval );
}

char *mangleType(size_t prepend, const char *type)
{
	char *retval = 0;

	switch(type[0])
	{
	case 'L':
		/* Object reference */
		if( (retval = mangleClassType((int)prepend + 1, 0, type + 1)) )
			retval[prepend] = 'P';
		break;
	case '[':
		/* Array type */
		if( (retval = mangleType(prepend + 11, type + 1)) )
			strncpy(&retval[prepend], "Pt6JArray1Z", 11);
		break;
	default:
		/* Most likely a primitive */
		{
			const char *prim;

			if( (prim = manglePrimitiveType(type[0])) )
			{
				if( (retval = (char *)KMALLOC(prepend + 2)) )
				{
					retval[prepend] = prim[0];
					retval[prepend + 1] = 0;
				}
			}
		}
		break;
	}
	return( retval );
}

size_t mangleLength(const char *string, int len, const char *term, size_t *out_len)
{
	int num_chars = 0, need_escapes = 0, num_underscores = 0;
	int retval = -1, error = 0;
	const char *curr, *end;

	curr = string;
	if( len < 0 )
		end = (char *)-1; /* ick */
	else
		end = string + len;
	while( !error && ((len < 0) || (curr < end)) )
	{
		int ch = UTF8_GET(curr, end);

		if( ch < 0 )
		{
			error = 1;
			break;
		}
		else if( term )
		{
			int found_term = 0;
			int lpc;

			for( lpc = 0; term[lpc]; lpc++ )
			{
				if( term[lpc] == ch )
					found_term = 1;
			}
			if( found_term )
			{
				/* Found the specified terminator */
				break;
			}
		}
		if( (ch >= '0') && (ch <= '9') )
		{
			/* If a number starts a name then we need an escape */
			if( (curr - 1) == string)
				need_escapes++;
		}
		else if( ch == '_' && bad_underscore(curr, end))
		{
#if MANGLE_GCJ
			num_underscores++;
#else
			need_escapes++;
#endif
		}
		else if( ((ch < 'a') || (ch > 'z')) &&
			 ((ch < 'A') || (ch > 'Z')) &&
			 (ch != '_') )
		{
			/* Special character, we'll need an escape */
			need_escapes++;
		}
		num_chars++;
	}
	if( !error )
	{
		if( need_escapes )
		{
			retval = num_chars +
				4 * (need_escapes + num_underscores);
		}
		else
			retval = 0;
		/* Write back the length */
		if( out_len )
			*out_len = num_chars;
	}
	return( retval );
}

size_t mangleString(char *dest, const char *src, size_t slen, int _unicode)
{
	int retval = 0, ch, error = 0, need_escape = 0;
	char *start;
	const char *curr, *end;

	start = dest;
	curr = src;
	end = src + slen;
	while( (curr < end) && !error )
	{
		ch = UTF8_GET(curr, end);

		if( ch < 0 )
		{
			error = 1;
		}
		else if( (ch >= '0') && (ch <= '9') )
		{
			if( (curr - 1) == src )
				need_escape = 1;
			else
				need_escape = 0;
		}
		else if( ch == '_' )
		{
			if( _unicode && bad_underscore(curr, end) )
			{
				need_escape = 1;
			}
		}
		else if( ((ch < 'a') || (ch > 'z')) &&
			 ((ch < 'A') || (ch > 'Z')) )
		{
			need_escape = 1;
		}
		else
		{
			need_escape = 0;
		}
		if( !error )
		{
			if( need_escape )
			{
				sprintf(dest, "_%04x", ch);
				dest += 5;
			}
			else
			{
				*dest = ch;
				dest++;
			}
		}
	}
	*dest = 0;
	if( error )
		retval = -1;
	else
		retval = dest - start + 1;
	return( retval );
}

static int fputss(const char *str, size_t len, FILE *stream)
{
    size_t lpc;
    int retval = 0;

    for( lpc = 0; lpc < len; lpc++ )
    {
	putc(str[lpc], stream);
    }
    return( retval );
}

int vfmanglef(FILE *file, const char *format, va_list args)
{
    unsigned int sindex, eindex;
    int retval = 0;

    for( sindex = eindex = 0; format[eindex] != '\0'; eindex++ )
    {
	switch( format[eindex] )
	{
	case '%':
	    {
		int done = 0;

		while( !done )
		{
		    eindex += 1;
		    switch( format[eindex] )
		    {
		    case 'q': /* qualified string */
			{
			    const char *quals, *str;
			    size_t offset = 0, len;
			    void *ptr;
			    
			    quals = va_arg(args, const char *);
			    str = va_arg(args, const char *);
			    ptr = va_arg(args, void *);
			    
			    len = strlen(str);

			    while( offset < len )
			    {
				char buffer[1 + 2 + sizeof(void *) * 2 + 1];
				const char *sub_end;
				size_t slen;

				buffer[0] = '\0';
				sub_end = strpbrk(&str[offset], quals);
				if( sub_end == NULL )
				{
				    sub_end = &str[len];
				    if( ptr != NULL )
				    {
					snprintf(buffer,
						 sizeof(buffer),
						 "_%p",
						 ptr);
				    }
				}
				slen = sub_end - &str[offset];
				fprintf(file, "%d", slen + strlen(buffer));
				fputss(&str[offset], slen, file);
				fprintf(file, "%s", buffer);
				offset += slen + 1;
			    }
			    done = 1;
			}
			break;
		    case 't':
			{
			    const char *in, *out, *str;
			    unsigned int lpc;

			    in = va_arg(args, const char *);
			    out = va_arg(args, const char *);
			    str = va_arg(args, const char *);
			    
			    assert(strlen(in) == strlen(out));
			    for( lpc = 0; str[lpc] != '\0'; lpc++ )
			    {
				const char *rep;

				if( (rep = strchr(in, str[lpc])) != NULL )
				{
				    putc(out[rep - in], file);
				}
				else
				{
				    putc(str[lpc], file);
				}
			    }
			    done = 1;
			}
			break;
		    case 'c':
			{
				char c;

				c = (char)va_arg(args, int);
				fprintf(file, "%c", c);
				done = 1;
			}
			break;
		    case 'd':
			{
			    int i;

			    i = va_arg(args, int);
			    fprintf(file, "%d", i);
			    done = 1;
			}
			break;
		    case 'p':
			{
			    void *ptr;

			    ptr = va_arg(args, void *);
			    fprintf(file, "%p", ptr);
			    done = 1;
			}
			break;
		    case 's':
			{
			    const char *str;
			    
			    str = va_arg(args, const char *);

			    fprintf(file, "%s", str);
			    done = 1;
			}
			break;
		    case 'S':
			{
			    const char *str;
			    size_t len;
			    
			    str = va_arg(args, const char *);
			    len = va_arg(args, size_t);

			    fputss(str, len, file);
			    done = 1;
			}
			break;
		    default:
			assert(0);
			break;
		    }
		}
	    }
	    break;
	default:
	    putc(format[eindex], file);
	    break;
	}
    }
    return( retval );
}

int fmanglef(FILE *file, const char *format, ...)
{
    va_list args;
    int retval;

    va_start(args, format);
    retval = vfmanglef(file, format, args);
    va_end(args);
    return( retval );
}

#endif /* defined(KAFFE_XDEBUGGING) || defined(KAFFE_XPROFILER) */