]> git.saurik.com Git - cycript.git/blob - sig/parse.cpp
Started working on CYApplicationMain replacement, added bridging for some Foundation...
[cycript.git] / sig / parse.cpp
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
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
54 void Parse_(apr_pool_t *pool, struct Signature *signature, const char **name, char eos, Callback callback);
55 struct Type *Parse_(apr_pool_t *pool, const char **name, char eos, bool named, Callback callback);
56
57
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
65 void Parse_(apr_pool_t *pool, struct Signature *signature, const char **name, char eos, Callback callback) {
66 _assert(*name != NULL);
67
68 // XXX: this is just a stupid check :(
69 bool named(**name == '"');
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
93 element->type = Parse_(pool, name, eos, named, callback);
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
107 struct Type *Parse_(apr_pool_t *pool, const char **name, char eos, bool named, Callback callback) {
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 '(':
121 type->primitive = union_P;
122 next = ')';
123 goto aggregate;
124
125 case '*': type->primitive = string_P; break;
126 case ':': type->primitive = selector_P; break;
127
128 case '@':
129 if (**name == '"') {
130 char *quote = strchr(*name + 1, '"');
131 if (!named || quote[1] == eos || quote[1] == '"') {
132 type->name = apr_pstrmemdup(pool, *name + 1, quote - *name - 1);
133 *name = quote + 1;
134 }
135 }
136
137 type->primitive = object_P;
138 break;
139
140 case 'B': type->primitive = boolean_P; break;
141 case 'C': type->primitive = uchar_P; break;
142 case 'I': type->primitive = uint_P; break;
143 case 'L': type->primitive = ulong_P; break;
144 case 'Q': type->primitive = ulonglong_P; break;
145 case 'S': type->primitive = ushort_P; break;
146
147 case '[':
148 type->primitive = array_P;
149 type->data.data.size = strtoul(*name, (char **) name, 10);
150 type->data.data.type = Parse_(pool, name, eos, false, callback);
151 if (**name != ']') {
152 printf("']' != \"%s\"\n", *name);
153 _assert(false);
154 }
155 ++*name;
156 break;
157
158 case '^':
159 type->primitive = pointer_P;
160 if (**name == 'v') {
161 type->data.data.type = NULL;
162 ++*name;
163 } else if (**name == '"') {
164 type->data.data.type = NULL;
165 } else {
166 type->data.data.type = Parse_(pool, name, eos, named, callback);
167 }
168 break;
169
170 case 'b':
171 type->primitive = bit_P;
172 type->data.data.size = strtoul(*name, (char **) name, 10);
173 break;
174
175 case 'c': type->primitive = char_P; break;
176 case 'd': type->primitive = double_P; break;
177 case 'f': type->primitive = float_P; break;
178 case 'i': type->primitive = int_P; break;
179 case 'l': type->primitive = long_P; break;
180 case 'q': type->primitive = longlong_P; break;
181 case 's': type->primitive = short_P; break;
182 case 'v': type->primitive = void_P; break;
183
184 case '{':
185 type->primitive = struct_P;
186 next = '}';
187 goto aggregate;
188
189 aggregate: {
190 char end = next;
191 const char *begin = *name;
192 do next = *(*name)++;
193 while (
194 next != '=' &&
195 next != '}'
196 );
197 size_t length = *name - begin - 1;
198 if (strncmp(begin, "?", length) != 0)
199 type->name = (char *) apr_pstrmemdup(pool, begin, length);
200 else
201 type->name = NULL;
202
203 // XXX: this types thing is a throwback to JocStrap
204
205 char *types;
206 if (next != '=') {
207 types = NULL;
208 } else {
209 const char *temp(*name);
210 Parse_(pool, &type->data.signature, name, end, callback);
211 types = (char *) apr_pstrmemdup(pool, temp, *name - temp - 1);
212 }
213
214 if (callback != NULL)
215 (*callback)(pool, type->name, types, type);
216 } break;
217
218 case 'N': type->flags |= JOC_TYPE_INOUT; goto next;
219 case 'n': type->flags |= JOC_TYPE_IN; goto next;
220 case 'O': type->flags |= JOC_TYPE_BYCOPY; goto next;
221 case 'o': type->flags |= JOC_TYPE_OUT; goto next;
222 case 'R': type->flags |= JOC_TYPE_BYREF; goto next;
223 case 'r': type->flags |= JOC_TYPE_CONST; goto next;
224 case 'V': type->flags |= JOC_TYPE_ONEWAY; goto next;
225
226 next:
227 next = *(*name)++;
228 goto parse;
229 break;
230
231 default:
232 printf("invalid type character: '%c' {%s}\n", next, *name - 10);
233 _assert(false);
234 }
235
236 return type;
237 }
238
239 void Parse(apr_pool_t *pool, struct Signature *signature, const char *name, Callback callback) {
240 const char *temp = name;
241 Parse_(pool, signature, &temp, '\0', callback);
242 _assert(temp[-1] == '\0');
243 }
244
245 const char *Unparse(apr_pool_t *pool, struct Signature *signature) {
246 const char *value = "";
247 size_t offset;
248
249 for (offset = 0; offset != signature->count; ++offset) {
250 const char *type = Unparse(pool, signature->elements[offset].type);
251 value = apr_pstrcat(pool, value, type, NULL);
252 }
253
254 return value;
255 }
256
257 const char *Unparse(apr_pool_t *pool, struct Type *type) {
258 if (type == NULL)
259 return "?";
260 else switch (type->primitive) {
261 case typename_P: return "#";
262 case union_P: return apr_psprintf(pool, "(%s)", Unparse(pool, &type->data.signature));
263 case string_P: return "*";
264 case selector_P: return ":";
265 case object_P: return type->name == NULL ? "@" : apr_psprintf(pool, "@\"%s\"", type->name);
266 case boolean_P: return "B";
267 case uchar_P: return "C";
268 case uint_P: return "I";
269 case ulong_P: return "L";
270 case ulonglong_P: return "Q";
271 case ushort_P: return "S";
272
273 case array_P: {
274 const char *value = Unparse(pool, type->data.data.type);
275 return apr_psprintf(pool, "[%lu%s]", type->data.data.size, value);
276 } break;
277
278 case pointer_P: return apr_psprintf(pool, "^%s", type->data.data.type == NULL ? "" : Unparse(pool, type->data.data.type));
279 case bit_P: return apr_psprintf(pool, "b%zu", type->data.data.size);
280 case char_P: return "c";
281 case double_P: return "d";
282 case float_P: return "f";
283 case int_P: return "i";
284 case long_P: return "l";
285 case longlong_P: return "q";
286 case short_P: return "s";
287 case void_P: return "v";
288 case struct_P: return apr_psprintf(pool, "{%s=%s}", type->name == NULL ? "?" : type->name, Unparse(pool, &type->data.signature));
289 }
290
291 _assert(false);
292 return NULL;
293 }
294
295 }