[cycript.git] / sig / parse.cpp

/* Cycript - Remove Execution Server and Disassembler
 * Copyright (C) 2009  Jay Freeman (saurik)
*/

/* Modified BSD License {{{ */
/*
 *        Redistribution and use in source and binary
 * forms, with or without modification, are permitted
 * provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the
 *    above copyright notice, this list of conditions
 *    and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the
 *    above copyright notice, this list of conditions
 *    and the following disclaimer in the documentation
 *    and/or other materials provided with the
 *    distribution.
 * 3. The name of the author may not be used to endorse
 *    or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* }}} */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include "minimal/stdlib.h"

#include <apr-1/apr_strings.h>

#include <string.h>

#include "sig/parse.hpp"

namespace sig {

void Parse_(apr_pool_t *pool, struct Signature *signature, const char **name, char eos, Callback callback);
struct Type *Parse_(apr_pool_t *pool, const char **name, char eos, bool named, Callback callback);


/* XXX: I really screwed up this time */
void *prealloc_(apr_pool_t *pool, void *odata, size_t osize, size_t nsize) {
    void *ndata = apr_palloc(pool, nsize);
    memcpy(ndata, odata, osize);
    return ndata;
}

void Parse_(apr_pool_t *pool, struct Signature *signature, const char **name, char eos, Callback callback) {
    _assert(*name != NULL);

    // XXX: this is just a stupid check :(
    bool named(**name == '"');

    signature->elements = NULL;
    signature->count = 0;

    for (;;) {
        if (**name == eos) {
            ++*name;
            return;
        }

        signature->elements = (struct Element *) prealloc_(pool, signature->elements, signature->count * sizeof(struct Element), (signature->count + 1) * sizeof(struct Element));
        _assert(signature->elements != NULL);

        struct Element *element = &signature->elements[signature->count++];

        if (**name != '"')
            element->name = NULL;
        else {
            char *quote = strchr(++*name, '"');
            element->name = apr_pstrmemdup(pool, *name, quote - *name);
            *name = quote + 1;
        }

        element->type = Parse_(pool, name, eos, named, callback);

        if (**name < '0' || **name > '9')
            element->offset = _not(size_t);
        else {
            element->offset = 0;

            do
                element->offset = element->offset * 10 + (*(*name)++ - '0');
            while (**name >= '0' && **name <= '9');
        }
    }
}

struct Type *Parse_(apr_pool_t *pool, const char **name, char eos, bool named, Callback callback) {
    char next = *(*name)++;
    if (next == '?')
        return NULL;

    struct Type *type = (struct Type *) apr_palloc(pool, sizeof(struct Type));
    _assert(type != NULL);
    memset(type, 0, sizeof(struct Type));

  parse:
    switch (next) {
        case '#': type->primitive = typename_P; break;

        case '(':
            if (type->data.signature.count < 2)
                type->primitive = struct_P;
            else
                type->primitive = union_P;
            next = ')';
        goto aggregate;

        case '*': type->primitive = string_P; break;
        case ':': type->primitive = selector_P; break;

        case '@':
            if (**name == '"') {
                char *quote = strchr(*name + 1, '"');
                if (!named || quote[1] == eos || quote[1] == '"') {
                    type->name = apr_pstrmemdup(pool, *name + 1, quote - *name - 1);
                    *name = quote + 1;
                }
            }

            type->primitive = object_P;
        break;

        case 'B': type->primitive = boolean_P; break;
        case 'C': type->primitive = uchar_P; break;
        case 'I': type->primitive = uint_P; break;
        case 'L': type->primitive = ulong_P; break;
        case 'Q': type->primitive = ulonglong_P; break;
        case 'S': type->primitive = ushort_P; break;

        case '[':
            type->primitive = array_P;
            type->data.data.size = strtoul(*name, (char **) name, 10);
            type->data.data.type = Parse_(pool, name, eos, false, callback);
            if (**name != ']') {
                printf("']' != \"%s\"\n", *name);
                _assert(false);
            }
            ++*name;
        break;

        case '^':
            type->primitive = pointer_P;
            if (**name == 'v') {
                type->data.data.type = NULL;
                ++*name;
            } else if (**name == '"') {
                type->data.data.type = NULL;
            } else {
                type->data.data.type = Parse_(pool, name, eos, named, callback);
            }
        break;

        case 'b':
            type->primitive = bit_P;
            type->data.data.size = strtoul(*name, (char **) name, 10);
        break;

        case 'c': type->primitive = char_P; break;
        case 'd': type->primitive = double_P; break;
        case 'f': type->primitive = float_P; break;
        case 'i': type->primitive = int_P; break;
        case 'l': type->primitive = long_P; break;
        case 'q': type->primitive = longlong_P; break;
        case 's': type->primitive = short_P; break;
        case 'v': type->primitive = void_P; break;

        case '{':
            type->primitive = struct_P;
            next = '}';
        goto aggregate;

        aggregate: {
            char end = next;
            const char *begin = *name;
            do next = *(*name)++;
            while (
                next != '=' &&
                next != '}'
            );
            size_t length = *name - begin - 1;
            if (strncmp(begin, "?", length) != 0)
                type->name = (char *) apr_pstrmemdup(pool, begin, length);
            else
                type->name = NULL;

            // XXX: this types thing is a throwback to JocStrap

            char *types;
            if (next != '=') {
                types = NULL;
            } else {
                const char *temp(*name);
                Parse_(pool, &type->data.signature, name, end, callback);
                types = (char *) apr_pstrmemdup(pool, temp, *name - temp - 1);
            }

            if (callback != NULL)
                (*callback)(pool, type->name, types, type);
        } break;

        case 'N': type->flags |= JOC_TYPE_INOUT; goto next;
        case 'n': type->flags |= JOC_TYPE_IN; goto next;
        case 'O': type->flags |= JOC_TYPE_BYCOPY; goto next;
        case 'o': type->flags |= JOC_TYPE_OUT; goto next;
        case 'R': type->flags |= JOC_TYPE_BYREF; goto next;
        case 'r': type->flags |= JOC_TYPE_CONST; goto next;
        case 'V': type->flags |= JOC_TYPE_ONEWAY; goto next;

        next:
            next = *(*name)++;
            goto parse;
        break;

        default:
            printf("invalid type character: '%c' {%s}\n", next, *name - 10);
            _assert(false);
    }

    return type;
}

void Parse(apr_pool_t *pool, struct Signature *signature, const char *name, Callback callback) {
    const char *temp = name;
    Parse_(pool, signature, &temp, '\0', callback);
    _assert(temp[-1] == '\0');
}

const char *Unparse(apr_pool_t *pool, struct Signature *signature) {
    const char *value = "";
    size_t offset;

    for (offset = 0; offset != signature->count; ++offset) {
        const char *type = Unparse(pool, signature->elements[offset].type);
        value = apr_pstrcat(pool, value, type, NULL);
    }

    return value;
}

const char *Unparse(apr_pool_t *pool, struct Type *type) {
    if (type == NULL)
        return "?";
    else switch (type->primitive) {
        case typename_P: return "#";
        case union_P: return apr_psprintf(pool, "(%s)", Unparse(pool, &type->data.signature));
        case string_P: return "*";
        case selector_P: return ":";
        case object_P: return type->name == NULL ? "@" : apr_psprintf(pool, "@\"%s\"", type->name);
        case boolean_P: return "B";
        case uchar_P: return "C";
        case uint_P: return "I";
        case ulong_P: return "L";
        case ulonglong_P: return "Q";
        case ushort_P: return "S";

        case array_P: {
            const char *value = Unparse(pool, type->data.data.type);
            return apr_psprintf(pool, "[%lu%s]", type->data.data.size, value);
        } break;

        case pointer_P: return apr_psprintf(pool, "^%s", type->data.data.type == NULL ? "" : Unparse(pool, type->data.data.type));
        case bit_P: return apr_psprintf(pool, "b%zu", type->data.data.size);
        case char_P: return "c";
        case double_P: return "d";
        case float_P: return "f";
        case int_P: return "i";
        case long_P: return "l";
        case longlong_P: return "q";
        case short_P: return "s";
        case void_P: return "v";
        case struct_P: return apr_psprintf(pool, "{%s=%s}", type->name == NULL ? "?" : type->name, Unparse(pool, &type->data.signature));
    }

    _assert(false);
    return NULL;
}

}
Commit	Line	Data
b4aa79af JF	1	/* Cycript - Remove Execution Server and Disassembler
	2	* Copyright (C) 2009 Jay Freeman (saurik)
	3	*/
	4
	5	/* Modified BSD License {{{ */
	6	/*
	7	* Redistribution and use in source and binary
	8	* forms, with or without modification, are permitted
	9	* provided that the following conditions are met:
	10	*
	11	* 1. Redistributions of source code must retain the
	12	* above copyright notice, this list of conditions
	13	* and the following disclaimer.
	14	* 2. Redistributions in binary form must reproduce the
	15	* above copyright notice, this list of conditions
	16	* and the following disclaimer in the documentation
	17	* and/or other materials provided with the
	18	* distribution.
	19	* 3. The name of the author may not be used to endorse
	20	* or promote products derived from this software
	21	* without specific prior written permission.
	22	*
	23	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
	24	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
	25	* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	26	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
	28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	29	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	30	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	31	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	32	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	33	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
	34	* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
	35	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	36	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	37	*/
	38	/* }}} */
	39
ea2d184c JF	40	#ifndef _GNU_SOURCE
	41	#define _GNU_SOURCE
	42	#endif
	43
	44	#include "minimal/stdlib.h"
	45
	46	#include <apr-1/apr_strings.h>
	47
	48	#include <string.h>
	49
	50	#include "sig/parse.hpp"
	51
	52	namespace sig {
	53
f33b048a JF	54	void Parse_(apr_pool_t pool, struct Signature signature, const char **name, char eos, Callback callback);
f33b048a JF	55	struct Type Parse_(apr_pool_t pool, const char **name, char eos, bool named, Callback callback);
b21525c7 JF	56
b21525c7 JF	57
ea2d184c JF	58	/* XXX: I really screwed up this time */
	59	void prealloc_(apr_pool_t pool, void *odata, size_t osize, size_t nsize) {
	60	void *ndata = apr_palloc(pool, nsize);
	61	memcpy(ndata, odata, osize);
	62	return ndata;
	63	}
	64
f33b048a	65	void Parse_(apr_pool_t pool, struct Signature signature, const char **name, char eos, Callback callback) {
ea2d184c JF	66	_assert(*name != NULL);
ea2d184c JF	67
f33b048a JF	68	// XXX: this is just a stupid check :(
f33b048a JF	69	bool named(**name == '"');
ea2d184c JF	70
	71	signature->elements = NULL;
	72	signature->count = 0;
	73
	74	for (;;) {
	75	if (**name == eos) {
	76	++*name;
	77	return;
	78	}
	79
	80	signature->elements = (struct Element ) prealloc_(pool, signature->elements, signature->count sizeof(struct Element), (signature->count + 1) * sizeof(struct Element));
	81	_assert(signature->elements != NULL);
	82
	83	struct Element *element = &signature->elements[signature->count++];
	84
	85	if (**name != '"')
	86	element->name = NULL;
	87	else {
	88	char quote = strchr(++name, '"');
	89	element->name = apr_pstrmemdup(pool, name, quote - name);
	90	*name = quote + 1;
	91	}
	92
f33b048a	93	element->type = Parse_(pool, name, eos, named, callback);
ea2d184c JF	94
	95	if (name < '0' \|\| name > '9')
	96	element->offset = _not(size_t);
	97	else {
	98	element->offset = 0;
	99
	100	do
	101	element->offset = element->offset * 10 + ((name)++ - '0');
	102	while (name >= '0' && name <= '9');
	103	}
	104	}
	105	}
	106
f33b048a	107	struct Type Parse_(apr_pool_t pool, const char **name, char eos, bool named, Callback callback) {
ea2d184c JF	108	char next = (name)++;
	109	if (next == '?')
	110	return NULL;
	111
	112	struct Type type = (struct Type ) apr_palloc(pool, sizeof(struct Type));
	113	_assert(type != NULL);
	114	memset(type, 0, sizeof(struct Type));
	115
	116	parse:
	117	switch (next) {
	118	case '#': type->primitive = typename_P; break;
	119
	120	case '(':
d63c39cc JF	121	if (type->data.signature.count < 2)
	122	type->primitive = struct_P;
	123	else
	124	type->primitive = union_P;
ea2d184c JF	125	next = ')';
	126	goto aggregate;
	127
	128	case '*': type->primitive = string_P; break;
	129	case ':': type->primitive = selector_P; break;
	130
	131	case '@':
	132	if (**name == '"') {
	133	char quote = strchr(name + 1, '"');
	134	if (!named \|\| quote[1] == eos \|\| quote[1] == '"') {
	135	type->name = apr_pstrmemdup(pool, name + 1, quote - name - 1);
	136	*name = quote + 1;
	137	}
	138	}
	139
	140	type->primitive = object_P;
	141	break;
	142
	143	case 'B': type->primitive = boolean_P; break;
	144	case 'C': type->primitive = uchar_P; break;
	145	case 'I': type->primitive = uint_P; break;
	146	case 'L': type->primitive = ulong_P; break;
	147	case 'Q': type->primitive = ulonglong_P; break;
	148	case 'S': type->primitive = ushort_P; break;
	149
	150	case '[':
	151	type->primitive = array_P;
	152	type->data.data.size = strtoul(name, (char *) name, 10);
f33b048a	153	type->data.data.type = Parse_(pool, name, eos, false, callback);
ea2d184c JF	154	if (**name != ']') {
	155	printf("']' != \"%s\"\n", *name);
	156	_assert(false);
	157	}
	158	++*name;
	159	break;
	160
	161	case '^':
	162	type->primitive = pointer_P;
	163	if (**name == 'v') {
	164	type->data.data.type = NULL;
	165	++*name;
	166	} else if (**name == '"') {
	167	type->data.data.type = NULL;
	168	} else {
f33b048a	169	type->data.data.type = Parse_(pool, name, eos, named, callback);
ea2d184c JF	170	}
	171	break;
	172
	173	case 'b':
	174	type->primitive = bit_P;
	175	type->data.data.size = strtoul(name, (char *) name, 10);
	176	break;
	177
	178	case 'c': type->primitive = char_P; break;
	179	case 'd': type->primitive = double_P; break;
	180	case 'f': type->primitive = float_P; break;
	181	case 'i': type->primitive = int_P; break;
	182	case 'l': type->primitive = long_P; break;
	183	case 'q': type->primitive = longlong_P; break;
	184	case 's': type->primitive = short_P; break;
	185	case 'v': type->primitive = void_P; break;
	186
	187	case '{':
	188	type->primitive = struct_P;
	189	next = '}';
	190	goto aggregate;
	191
	192	aggregate: {
	193	char end = next;
	194	const char begin = name;
	195	do next = (name)++;
	196	while (
	197	next != '=' &&
	198	next != '}'
	199	);
	200	size_t length = *name - begin - 1;
	201	if (strncmp(begin, "?", length) != 0)
	202	type->name = (char *) apr_pstrmemdup(pool, begin, length);
	203	else
	204	type->name = NULL;
	205
f33b048a JF	206	// XXX: this types thing is a throwback to JocStrap
f33b048a JF	207
ea2d184c	208	char *types;
f33b048a	209	if (next != '=') {
ea2d184c	210	types = NULL;
f33b048a JF	211	} else {
	212	const char temp(name);
	213	Parse_(pool, &type->data.signature, name, end, callback);
ea2d184c JF	214	types = (char ) apr_pstrmemdup(pool, temp, name - temp - 1);
	215	}
	216
f33b048a JF	217	if (callback != NULL)
f33b048a JF	218	(*callback)(pool, type->name, types, type);
ea2d184c JF	219	} break;
	220
	221	case 'N': type->flags \|= JOC_TYPE_INOUT; goto next;
	222	case 'n': type->flags \|= JOC_TYPE_IN; goto next;
	223	case 'O': type->flags \|= JOC_TYPE_BYCOPY; goto next;
	224	case 'o': type->flags \|= JOC_TYPE_OUT; goto next;
	225	case 'R': type->flags \|= JOC_TYPE_BYREF; goto next;
	226	case 'r': type->flags \|= JOC_TYPE_CONST; goto next;
	227	case 'V': type->flags \|= JOC_TYPE_ONEWAY; goto next;
	228
	229	next:
	230	next = (name)++;
	231	goto parse;
	232	break;
	233
	234	default:
	235	printf("invalid type character: '%c' {%s}\n", next, *name - 10);
	236	_assert(false);
	237	}
	238
	239	return type;
	240	}
	241
f33b048a	242	void Parse(apr_pool_t pool, struct Signature signature, const char *name, Callback callback) {
ea2d184c	243	const char *temp = name;
f33b048a	244	Parse_(pool, signature, &temp, '\0', callback);
ea2d184c JF	245	_assert(temp[-1] == '\0');
	246	}
	247
b21525c7	248	const char Unparse(apr_pool_t pool, struct Signature *signature) {
ea2d184c JF	249	const char *value = "";
	250	size_t offset;
	251
	252	for (offset = 0; offset != signature->count; ++offset) {
b21525c7	253	const char *type = Unparse(pool, signature->elements[offset].type);
ea2d184c JF	254	value = apr_pstrcat(pool, value, type, NULL);
	255	}
	256
	257	return value;
	258	}
	259
b21525c7	260	const char Unparse(apr_pool_t pool, struct Type *type) {
ea2d184c JF	261	if (type == NULL)
	262	return "?";
	263	else switch (type->primitive) {
	264	case typename_P: return "#";
b21525c7	265	case union_P: return apr_psprintf(pool, "(%s)", Unparse(pool, &type->data.signature));
ea2d184c JF	266	case string_P: return "*";
	267	case selector_P: return ":";
	268	case object_P: return type->name == NULL ? "@" : apr_psprintf(pool, "@\"%s\"", type->name);
	269	case boolean_P: return "B";
	270	case uchar_P: return "C";
	271	case uint_P: return "I";
	272	case ulong_P: return "L";
	273	case ulonglong_P: return "Q";
	274	case ushort_P: return "S";
	275
	276	case array_P: {
b21525c7	277	const char *value = Unparse(pool, type->data.data.type);
ea2d184c JF	278	return apr_psprintf(pool, "[%lu%s]", type->data.data.size, value);
	279	} break;
	280
b21525c7	281	case pointer_P: return apr_psprintf(pool, "^%s", type->data.data.type == NULL ? "" : Unparse(pool, type->data.data.type));
ea2d184c JF	282	case bit_P: return apr_psprintf(pool, "b%zu", type->data.data.size);
	283	case char_P: return "c";
	284	case double_P: return "d";
	285	case float_P: return "f";
	286	case int_P: return "i";
	287	case long_P: return "l";
	288	case longlong_P: return "q";
	289	case short_P: return "s";
	290	case void_P: return "v";
b21525c7	291	case struct_P: return apr_psprintf(pool, "{%s=%s}", type->name == NULL ? "?" : type->name, Unparse(pool, &type->data.signature));
ea2d184c JF	292	}
	293
	294	_assert(false);
	295	return NULL;
	296	}
	297
	298	}