[cycript.git] / sig / parse.cpp

/* Cycript - Optimizing JavaScript Compiler/Runtime
 * Copyright (C) 2009-2013  Jay Freeman (saurik)
*/

/* GNU General Public License, Version 3 {{{ */
/*
 * Cycript is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 *
 * Cycript is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Cycript.  If not, see <http://www.gnu.org/licenses/>.
**/
/* }}} */

#include "sig/parse.hpp"
#include "Error.hpp"

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sstream>

namespace sig {

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


/* XXX: I really screwed up this time */
void *prealloc_(CYPool &pool, void *odata, size_t osize, size_t nsize) {
    void *ndata(pool.malloc<void>(nsize));
    memcpy(ndata, odata, osize);
    return ndata;
}

void Parse_(CYPool &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 {
            const char *quote = strchr(++*name, '"');
            element->name = pool.strmemdup(*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');
        }
    }
}

Type *Parse_(CYPool &pool, const char **name, char eos, bool named, Callback callback) {
    char next = *(*name)++;

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

  parse:
    switch (next) {
        case '?': type->primitive = unknown_P; break;
        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 '@': {
            char next(**name);

            if (next == '?') {
                type->primitive = block_P;
                ++*name;
            } else {
                type->primitive = object_P;

                if (next == '"') {
                    const char *quote = strchr(*name + 1, '"');
                    if (quote == NULL) {
                        printf("unterminated specific id type {%s}\n", *name - 10);
                        _assert(false);
                    } else if (!named || quote[1] == eos || quote[1] == '"') {
                        type->name = pool.strmemdup(*name + 1, quote - *name - 1);
                        *name = quote + 1;
                    }
                }
            }

        } 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 == '"')
                // XXX: why is this here?
                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;

#ifdef __LP64__
        case 'F': type->primitive = double_P; break;
#else
        case 'F': type->primitive = float_P; break;
#endif

        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 *) pool.strmemdup(begin, length);
            else
                type->name = NULL;

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

            if (next == '=')
                Parse_(pool, &type->data.signature, name, end, callback);
        } 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);
    }

    if (callback != NULL)
        (*callback)(pool, type);

    return type;
}

void Parse(CYPool &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(CYPool &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 = pool.strcat(value, type, NULL);
    }

    return value;
}

const char *Unparse_(CYPool &pool, struct Type *type) {
    switch (type->primitive) {
        case function_P: {
            if (type->data.signature.count == 0)
                return "?";
            std::ostringstream out;
            for (size_t i(0); i != type->data.signature.count; ++i) {
                Element &element(type->data.signature.elements[i]);
                out << Unparse(pool, element.type);
                if (element.offset != _not(size_t))
                    out << pool.itoa(element.offset);
            }
            return pool.strdup(out.str().c_str());
        } break;

        case unknown_P: return "?";
        case typename_P: return "#";
        case union_P: return pool.strcat("(", Unparse(pool, &type->data.signature), ")", NULL);
        case string_P: return "*";
        case selector_P: return ":";
        case block_P: return "@?";
        case object_P: return type->name == NULL ? "@" : pool.strcat("@\"", type->name, "\"", NULL);
        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 pool.strcat("[", pool.itoa(type->data.data.size), value, "]", NULL);
        } break;

        case pointer_P: {
            // XXX: protect against the weird '"' check in Parse_
            _assert(type->data.data.type != NULL);
            if (type->data.data.type->primitive == function_P)
                return "^?";
            else
                return pool.strcat("^", Unparse(pool, type->data.data.type), NULL);
        } break;

        case bit_P: return pool.strcat("b", pool.itoa(type->data.data.size), NULL);
        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 pool.strcat("{", type->name == NULL ? "?" : type->name, "=", Unparse(pool, &type->data.signature), "}", NULL);
    }

    _assert(false);
    return NULL;
}

const char *Unparse(CYPool &pool, struct Type *type) {
    if (type == NULL)
        return "?";

    const char *base(Unparse_(pool, type));
    if (type->flags == 0)
        return base;

    #define iovec_(base, size) \
        (struct iovec) {const_cast<char *>(base), size}

    size_t size(strlen(base));
    char buffer[7 + size];
    size_t offset(0);

    if ((type->flags & JOC_TYPE_INOUT) != 0)
        buffer[offset++] = 'N';
    if ((type->flags & JOC_TYPE_IN) != 0)
        buffer[offset++] = 'n';
    if ((type->flags & JOC_TYPE_BYCOPY) != 0)
        buffer[offset++] = 'O';
    if ((type->flags & JOC_TYPE_OUT) != 0)
        buffer[offset++] = 'o';
    if ((type->flags & JOC_TYPE_BYREF) != 0)
        buffer[offset++] = 'R';
    if ((type->flags & JOC_TYPE_CONST) != 0)
        buffer[offset++] = 'r';
    if ((type->flags & JOC_TYPE_ONEWAY) != 0)
        buffer[offset++] = 'V';

    memcpy(buffer + offset, base, size);
    return pool.strmemdup(buffer, offset + size);
}

}
Commit	Line	Data
b3378a02	1	/* Cycript - Optimizing JavaScript Compiler/Runtime
c15969fd	2	* Copyright (C) 2009-2013 Jay Freeman (saurik)
b4aa79af JF	3	*/
b4aa79af JF	4
c15969fd	5	/* GNU General Public License, Version 3 {{{ */
b4aa79af	6	/*
c15969fd JF	7	* Cycript is free software: you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published
	9	* by the Free Software Foundation, either version 3 of the License,
	10	* or (at your option) any later version.
b4aa79af	11	*
c15969fd JF	12	* Cycript is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
b4aa79af	16	*
c15969fd	17	* You should have received a copy of the GNU General Public License
b3378a02 JF	18	* along with Cycript. If not, see <http://www.gnu.org/licenses/>.
b3378a02 JF	19	**/
b4aa79af JF	20	/* }}} */
b4aa79af JF	21
ea2d184c	22	#include "sig/parse.hpp"
37954781 JF	23	#include "Error.hpp"
	24
	25	#include <cstdio>
	26	#include <cstdlib>
	27	#include <cstring>
9a39f705	28	#include <sstream>
ea2d184c JF	29
	30	namespace sig {
	31
b799113b JF	32	void Parse_(CYPool &pool, struct Signature signature, const char *name, char eos, Callback callback);
b799113b JF	33	struct Type Parse_(CYPool &pool, const char *name, char eos, bool named, Callback callback);
b21525c7 JF	34
b21525c7 JF	35
ea2d184c	36	/* XXX: I really screwed up this time */
b799113b	37	void prealloc_(CYPool &pool, void odata, size_t osize, size_t nsize) {
0cbeddf8	38	void *ndata(pool.malloc<void>(nsize));
ea2d184c JF	39	memcpy(ndata, odata, osize);
	40	return ndata;
	41	}
	42
b799113b	43	void Parse_(CYPool &pool, struct Signature signature, const char *name, char eos, Callback callback) {
ea2d184c JF	44	_assert(*name != NULL);
ea2d184c JF	45
f33b048a JF	46	// XXX: this is just a stupid check :(
f33b048a JF	47	bool named(**name == '"');
ea2d184c JF	48
	49	signature->elements = NULL;
	50	signature->count = 0;
	51
	52	for (;;) {
	53	if (**name == eos) {
	54	++*name;
	55	return;
	56	}
	57
	58	signature->elements = (struct Element ) prealloc_(pool, signature->elements, signature->count sizeof(struct Element), (signature->count + 1) * sizeof(struct Element));
	59	_assert(signature->elements != NULL);
	60
	61	struct Element *element = &signature->elements[signature->count++];
	62
	63	if (**name != '"')
	64	element->name = NULL;
	65	else {
a815a4d6	66	const char quote = strchr(++name, '"');
b799113b	67	element->name = pool.strmemdup(name, quote - name);
ea2d184c JF	68	*name = quote + 1;
	69	}
	70
f33b048a	71	element->type = Parse_(pool, name, eos, named, callback);
ea2d184c JF	72
	73	if (name < '0' \|\| name > '9')
	74	element->offset = _not(size_t);
	75	else {
	76	element->offset = 0;
	77
	78	do
	79	element->offset = element->offset * 10 + ((name)++ - '0');
	80	while (name >= '0' && name <= '9');
	81	}
	82	}
	83	}
	84
b799113b	85	Type Parse_(CYPool &pool, const char *name, char eos, bool named, Callback callback) {
ea2d184c	86	char next = (name)++;
ea2d184c	87
b799113b	88	Type *type(new(pool) Type());
ea2d184c	89	_assert(type != NULL);
b799113b	90	memset(type, 0, sizeof(Type));
ea2d184c JF	91
	92	parse:
	93	switch (next) {
03db6a67	94	case '?': type->primitive = unknown_P; break;
ea2d184c JF	95	case '#': type->primitive = typename_P; break;
	96
	97	case '(':
d63c39cc JF	98	if (type->data.signature.count < 2)
	99	type->primitive = struct_P;
	100	else
	101	type->primitive = union_P;
ea2d184c JF	102	next = ')';
	103	goto aggregate;
	104
	105	case '*': type->primitive = string_P; break;
	106	case ':': type->primitive = selector_P; break;
	107
ecf94af8 JF	108	case '@': {
	109	char next(**name);
	110
	111	if (next == '?') {
	112	type->primitive = block_P;
	113	++*name;
	114	} else {
	115	type->primitive = object_P;
	116
	117	if (next == '"') {
	118	const char quote = strchr(name + 1, '"');
506aad76 JF	119	if (quote == NULL) {
	120	printf("unterminated specific id type {%s}\n", *name - 10);
	121	_assert(false);
	122	} else if (!named \|\| quote[1] == eos \|\| quote[1] == '"') {
b799113b	123	type->name = pool.strmemdup(name + 1, quote - name - 1);
ecf94af8 JF	124	*name = quote + 1;
ecf94af8 JF	125	}
ea2d184c JF	126	}
	127	}
	128
ecf94af8	129	} break;
ea2d184c JF	130
	131	case 'B': type->primitive = boolean_P; break;
	132	case 'C': type->primitive = uchar_P; break;
	133	case 'I': type->primitive = uint_P; break;
	134	case 'L': type->primitive = ulong_P; break;
	135	case 'Q': type->primitive = ulonglong_P; break;
	136	case 'S': type->primitive = ushort_P; break;
	137
	138	case '[':
	139	type->primitive = array_P;
	140	type->data.data.size = strtoul(name, (char *) name, 10);
f33b048a	141	type->data.data.type = Parse_(pool, name, eos, false, callback);
ea2d184c JF	142	if (**name != ']') {
	143	printf("']' != \"%s\"\n", *name);
	144	_assert(false);
	145	}
	146	++*name;
	147	break;
	148
	149	case '^':
	150	type->primitive = pointer_P;
a2f3ecab JF	151	if (**name == '"')
a2f3ecab JF	152	// XXX: why is this here?
ea2d184c	153	type->data.data.type = NULL;
a2f3ecab	154	else
f33b048a	155	type->data.data.type = Parse_(pool, name, eos, named, callback);
ea2d184c JF	156	break;
	157
	158	case 'b':
	159	type->primitive = bit_P;
	160	type->data.data.size = strtoul(name, (char *) name, 10);
	161	break;
	162
	163	case 'c': type->primitive = char_P; break;
	164	case 'd': type->primitive = double_P; break;
	165	case 'f': type->primitive = float_P; break;
	166	case 'i': type->primitive = int_P; break;
	167	case 'l': type->primitive = long_P; break;
	168	case 'q': type->primitive = longlong_P; break;
	169	case 's': type->primitive = short_P; break;
	170	case 'v': type->primitive = void_P; break;
	171
f61f9da6 JF	172	#ifdef __LP64__
	173	case 'F': type->primitive = double_P; break;
	174	#else
	175	case 'F': type->primitive = float_P; break;
	176	#endif
	177
ea2d184c JF	178	case '{':
	179	type->primitive = struct_P;
	180	next = '}';
	181	goto aggregate;
	182
	183	aggregate: {
	184	char end = next;
	185	const char begin = name;
	186	do next = (name)++;
	187	while (
	188	next != '=' &&
	189	next != '}'
	190	);
	191	size_t length = *name - begin - 1;
	192	if (strncmp(begin, "?", length) != 0)
b799113b	193	type->name = (char *) pool.strmemdup(begin, length);
ea2d184c JF	194	else
	195	type->name = NULL;
	196
f33b048a JF	197	// XXX: this types thing is a throwback to JocStrap
f33b048a JF	198
9814ec39	199	if (next == '=')
f33b048a	200	Parse_(pool, &type->data.signature, name, end, callback);
ea2d184c JF	201	} break;
	202
	203	case 'N': type->flags \|= JOC_TYPE_INOUT; goto next;
	204	case 'n': type->flags \|= JOC_TYPE_IN; goto next;
	205	case 'O': type->flags \|= JOC_TYPE_BYCOPY; goto next;
	206	case 'o': type->flags \|= JOC_TYPE_OUT; goto next;
	207	case 'R': type->flags \|= JOC_TYPE_BYREF; goto next;
	208	case 'r': type->flags \|= JOC_TYPE_CONST; goto next;
	209	case 'V': type->flags \|= JOC_TYPE_ONEWAY; goto next;
	210
	211	next:
	212	next = (name)++;
	213	goto parse;
	214	break;
	215
	216	default:
	217	printf("invalid type character: '%c' {%s}\n", next, *name - 10);
	218	_assert(false);
	219	}
	220
9814ec39 JF	221	if (callback != NULL)
	222	(*callback)(pool, type);
	223
ea2d184c JF	224	return type;
	225	}
	226
b799113b	227	void Parse(CYPool &pool, struct Signature signature, const char name, Callback callback) {
ea2d184c	228	const char *temp = name;
f33b048a	229	Parse_(pool, signature, &temp, '\0', callback);
ea2d184c JF	230	_assert(temp[-1] == '\0');
	231	}
	232
b799113b	233	const char Unparse(CYPool &pool, struct Signature signature) {
ea2d184c JF	234	const char *value = "";
	235	size_t offset;
	236
	237	for (offset = 0; offset != signature->count; ++offset) {
b21525c7	238	const char *type = Unparse(pool, signature->elements[offset].type);
0cbeddf8	239	value = pool.strcat(value, type, NULL);
ea2d184c JF	240	}
	241
	242	return value;
	243	}
	244
b799113b	245	const char Unparse_(CYPool &pool, struct Type type) {
51714815	246	switch (type->primitive) {
9a39f705 JF	247	case function_P: {
	248	if (type->data.signature.count == 0)
	249	return "?";
	250	std::ostringstream out;
	251	for (size_t i(0); i != type->data.signature.count; ++i) {
	252	Element &element(type->data.signature.elements[i]);
	253	out << Unparse(pool, element.type);
	254	if (element.offset != _not(size_t))
	255	out << pool.itoa(element.offset);
	256	}
	257	return pool.strdup(out.str().c_str());
	258	} break;
	259
03db6a67	260	case unknown_P: return "?";
ea2d184c	261	case typename_P: return "#";
0cbeddf8	262	case union_P: return pool.strcat("(", Unparse(pool, &type->data.signature), ")", NULL);
ea2d184c JF	263	case string_P: return "*";
ea2d184c JF	264	case selector_P: return ":";
ecf94af8	265	case block_P: return "@?";
0cbeddf8	266	case object_P: return type->name == NULL ? "@" : pool.strcat("@\"", type->name, "\"", NULL);
ea2d184c JF	267	case boolean_P: return "B";
	268	case uchar_P: return "C";
	269	case uint_P: return "I";
	270	case ulong_P: return "L";
	271	case ulonglong_P: return "Q";
	272	case ushort_P: return "S";
	273
	274	case array_P: {
b21525c7	275	const char *value = Unparse(pool, type->data.data.type);
0cbeddf8	276	return pool.strcat("[", pool.itoa(type->data.data.size), value, "]", NULL);
ea2d184c JF	277	} break;
ea2d184c JF	278
9a39f705	279	case pointer_P: {
a2f3ecab JF	280	// XXX: protect against the weird '"' check in Parse_
	281	_assert(type->data.data.type != NULL);
	282	if (type->data.data.type->primitive == function_P)
9a39f705 JF	283	return "^?";
	284	else
	285	return pool.strcat("^", Unparse(pool, type->data.data.type), NULL);
	286	} break;
	287
0cbeddf8	288	case bit_P: return pool.strcat("b", pool.itoa(type->data.data.size), NULL);
ea2d184c JF	289	case char_P: return "c";
	290	case double_P: return "d";
	291	case float_P: return "f";
	292	case int_P: return "i";
	293	case long_P: return "l";
	294	case longlong_P: return "q";
	295	case short_P: return "s";
	296	case void_P: return "v";
0cbeddf8	297	case struct_P: return pool.strcat("{", type->name == NULL ? "?" : type->name, "=", Unparse(pool, &type->data.signature), "}", NULL);
ea2d184c JF	298	}
	299
	300	_assert(false);
	301	return NULL;
	302	}
	303
b799113b	304	const char Unparse(CYPool &pool, struct Type type) {
51714815 JF	305	if (type == NULL)
	306	return "?";
	307
	308	const char *base(Unparse_(pool, type));
	309	if (type->flags == 0)
	310	return base;
	311
	312	#define iovec_(base, size) \
	313	(struct iovec) {const_cast<char *>(base), size}
	314
0cbeddf8 JF	315	size_t size(strlen(base));
	316	char buffer[7 + size];
	317	size_t offset(0);
51714815 JF	318
51714815 JF	319	if ((type->flags & JOC_TYPE_INOUT) != 0)
0cbeddf8	320	buffer[offset++] = 'N';
51714815	321	if ((type->flags & JOC_TYPE_IN) != 0)
0cbeddf8	322	buffer[offset++] = 'n';
51714815	323	if ((type->flags & JOC_TYPE_BYCOPY) != 0)
0cbeddf8	324	buffer[offset++] = 'O';
51714815	325	if ((type->flags & JOC_TYPE_OUT) != 0)
0cbeddf8	326	buffer[offset++] = 'o';
51714815	327	if ((type->flags & JOC_TYPE_BYREF) != 0)
0cbeddf8	328	buffer[offset++] = 'R';
51714815	329	if ((type->flags & JOC_TYPE_CONST) != 0)
0cbeddf8	330	buffer[offset++] = 'r';
51714815	331	if ((type->flags & JOC_TYPE_ONEWAY) != 0)
0cbeddf8	332	buffer[offset++] = 'V';
51714815	333
0cbeddf8 JF	334	memcpy(buffer + offset, base, size);
0cbeddf8 JF	335	return pool.strmemdup(buffer, offset + size);
51714815 JF	336	}
51714815 JF	337
ea2d184c	338	}