sig/parse.cpp

   1 /* Cycript - Inlining/Optimizing JavaScript Compiler
   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 #include <apr_strings.h>
  41 #include "sig/parse.hpp"
  42 #include "Error.hpp"
  43
  44 #include <cstdio>
  45 #include <cstdlib>
  46 #include <cstring>
  47
  48 namespace sig {
  49
  50 void Parse_(apr_pool_t *pool, struct Signature *signature, const char **name, char eos, Callback callback);
  51 struct Type *Parse_(apr_pool_t *pool, const char **name, char eos, bool named, Callback callback);
  52
  53
  54 /* XXX: I really screwed up this time */
  55 void *prealloc_(apr_pool_t *pool, void *odata, size_t osize, size_t nsize) {
  56     void *ndata = apr_palloc(pool, nsize);
  57     memcpy(ndata, odata, osize);
  58     return ndata;
  59 }
  60
  61 void Parse_(apr_pool_t *pool, struct Signature *signature, const char **name, char eos, Callback callback) {
  62     _assert(*name != NULL);
  63
  64     // XXX: this is just a stupid check :(
  65     bool named(**name == '"');
  66
  67     signature->elements = NULL;
  68     signature->count = 0;
  69
  70     for (;;) {
  71         if (**name == eos) {
  72             ++*name;
  73             return;
  74         }
  75
  76         signature->elements = (struct Element *) prealloc_(pool, signature->elements, signature->count * sizeof(struct Element), (signature->count + 1) * sizeof(struct Element));
  77         _assert(signature->elements != NULL);
  78
  79         struct Element *element = &signature->elements[signature->count++];
  80
  81         if (**name != '"')
  82             element->name = NULL;
  83         else {
  84             const char *quote = strchr(++*name, '"');
  85             element->name = apr_pstrmemdup(pool, *name, quote - *name);
  86             *name = quote + 1;
  87         }
  88
  89         element->type = Parse_(pool, name, eos, named, callback);
  90
  91         if (**name < '0' || **name > '9')
  92             element->offset = _not(size_t);
  93         else {
  94             element->offset = 0;
  95
  96             do
  97                 element->offset = element->offset * 10 + (*(*name)++ - '0');
  98             while (**name >= '0' && **name <= '9');
  99         }
 100     }
 101 }
 102
 103 struct Type *Parse_(apr_pool_t *pool, const char **name, char eos, bool named, Callback callback) {
 104     char next = *(*name)++;
 105     if (next == '?')
 106         return NULL;
 107
 108     struct Type *type = (struct Type *) apr_palloc(pool, sizeof(struct Type));
 109     _assert(type != NULL);
 110     memset(type, 0, sizeof(struct Type));
 111
 112   parse:
 113     switch (next) {
 114         case '#': type->primitive = typename_P; break;
 115
 116         case '(':
 117             if (type->data.signature.count < 2)
 118                 type->primitive = struct_P;
 119             else
 120                 type->primitive = union_P;
 121             next = ')';
 122         goto aggregate;
 123
 124         case '*': type->primitive = string_P; break;
 125         case ':': type->primitive = selector_P; break;
 126
 127         case '@': {
 128             char next(**name);
 129
 130             if (next == '?') {
 131                 type->primitive = block_P;
 132                 ++*name;
 133             } else {
 134                 type->primitive = object_P;
 135
 136                 if (next == '"') {
 137                     const char *quote = strchr(*name + 1, '"');
 138                     if (!named || quote[1] == eos || quote[1] == '"') {
 139                         type->name = apr_pstrmemdup(pool, *name + 1, quote - *name - 1);
 140                         *name = quote + 1;
 141                     }
 142                 }
 143             }
 144
 145         } break;
 146
 147         case 'B': type->primitive = boolean_P; break;
 148         case 'C': type->primitive = uchar_P; break;
 149         case 'I': type->primitive = uint_P; break;
 150         case 'L': type->primitive = ulong_P; break;
 151         case 'Q': type->primitive = ulonglong_P; break;
 152         case 'S': type->primitive = ushort_P; break;
 153
 154         case '[':
 155             type->primitive = array_P;
 156             type->data.data.size = strtoul(*name, (char **) name, 10);
 157             type->data.data.type = Parse_(pool, name, eos, false, callback);
 158             if (**name != ']') {
 159                 printf("']' != \"%s\"\n", *name);
 160                 _assert(false);
 161             }
 162             ++*name;
 163         break;
 164
 165         case '^':
 166             type->primitive = pointer_P;
 167             if (**name == '"') {
 168                 type->data.data.type = NULL;
 169             } else {
 170                 type->data.data.type = Parse_(pool, name, eos, named, callback);
 171                 sig::Type *&target(type->data.data.type);
 172                 if (target != NULL && target->primitive == void_P)
 173                     target = NULL;
 174             }
 175         break;
 176
 177         case 'b':
 178             type->primitive = bit_P;
 179             type->data.data.size = strtoul(*name, (char **) name, 10);
 180         break;
 181
 182         case 'c': type->primitive = char_P; break;
 183         case 'd': type->primitive = double_P; break;
 184         case 'f': type->primitive = float_P; break;
 185         case 'i': type->primitive = int_P; break;
 186         case 'l': type->primitive = long_P; break;
 187         case 'q': type->primitive = longlong_P; break;
 188         case 's': type->primitive = short_P; break;
 189         case 'v': type->primitive = void_P; break;
 190
 191         case '{':
 192             type->primitive = struct_P;
 193             next = '}';
 194         goto aggregate;
 195
 196         aggregate: {
 197             char end = next;
 198             const char *begin = *name;
 199             do next = *(*name)++;
 200             while (
 201                 next != '=' &&
 202                 next != '}'
 203             );
 204             size_t length = *name - begin - 1;
 205             if (strncmp(begin, "?", length) != 0)
 206                 type->name = (char *) apr_pstrmemdup(pool, begin, length);
 207             else
 208                 type->name = NULL;
 209
 210             // XXX: this types thing is a throwback to JocStrap
 211
 212             if (next == '=')
 213                 Parse_(pool, &type->data.signature, name, end, callback);
 214         } break;
 215
 216         case 'N': type->flags |= JOC_TYPE_INOUT; goto next;
 217         case 'n': type->flags |= JOC_TYPE_IN; goto next;
 218         case 'O': type->flags |= JOC_TYPE_BYCOPY; goto next;
 219         case 'o': type->flags |= JOC_TYPE_OUT; goto next;
 220         case 'R': type->flags |= JOC_TYPE_BYREF; goto next;
 221         case 'r': type->flags |= JOC_TYPE_CONST; goto next;
 222         case 'V': type->flags |= JOC_TYPE_ONEWAY; goto next;
 223
 224         next:
 225             next = *(*name)++;
 226             goto parse;
 227         break;
 228
 229         default:
 230             printf("invalid type character: '%c' {%s}\n", next, *name - 10);
 231             _assert(false);
 232     }
 233
 234     if (callback != NULL)
 235         (*callback)(pool, type);
 236
 237     return type;
 238 }
 239
 240 void Parse(apr_pool_t *pool, struct Signature *signature, const char *name, Callback callback) {
 241     const char *temp = name;
 242     Parse_(pool, signature, &temp, '\0', callback);
 243     _assert(temp[-1] == '\0');
 244 }
 245
 246 const char *Unparse(apr_pool_t *pool, struct Signature *signature) {
 247     const char *value = "";
 248     size_t offset;
 249
 250     for (offset = 0; offset != signature->count; ++offset) {
 251         const char *type = Unparse(pool, signature->elements[offset].type);
 252         value = apr_pstrcat(pool, value, type, NULL);
 253     }
 254
 255     return value;
 256 }
 257
 258 const char *Unparse(apr_pool_t *pool, struct Type *type) {
 259     if (type == NULL)
 260         return "?";
 261     else switch (type->primitive) {
 262         case typename_P: return "#";
 263         case union_P: return apr_psprintf(pool, "(%s)", Unparse(pool, &type->data.signature));
 264         case string_P: return "*";
 265         case selector_P: return ":";
 266         case block_P: return "@?";
 267         case object_P: return type->name == NULL ? "@" : apr_psprintf(pool, "@\"%s\"", type->name);
 268         case boolean_P: return "B";
 269         case uchar_P: return "C";
 270         case uint_P: return "I";
 271         case ulong_P: return "L";
 272         case ulonglong_P: return "Q";
 273         case ushort_P: return "S";
 274
 275         case array_P: {
 276             const char *value = Unparse(pool, type->data.data.type);
 277             return apr_psprintf(pool, "[%"APR_SIZE_T_FMT"%s]", type->data.data.size, value);
 278         } break;
 279
 280         case pointer_P: return apr_psprintf(pool, "^%s", type->data.data.type == NULL ? "v" : Unparse(pool, type->data.data.type));
 281         case bit_P: return apr_psprintf(pool, "b%"APR_SIZE_T_FMT"", type->data.data.size);
 282         case char_P: return "c";
 283         case double_P: return "d";
 284         case float_P: return "f";
 285         case int_P: return "i";
 286         case long_P: return "l";
 287         case longlong_P: return "q";
 288         case short_P: return "s";
 289         case void_P: return "v";
 290         case struct_P: return apr_psprintf(pool, "{%s=%s}", type->name == NULL ? "?" : type->name, Unparse(pool, &type->data.signature));
 291     }
 292
 293     _assert(false);
 294     return NULL;
 295 }
 296
 297 }