Library.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 <dlfcn.h>
  41 #include <iconv.h>
  42
  43 #include "cycript.hpp"
  44
  45 #include "Pooling.hpp"
  46
  47 #include <sys/mman.h>
  48
  49 #include <iostream>
  50 #include <ext/stdio_filebuf.h>
  51 #include <set>
  52 #include <map>
  53 #include <iomanip>
  54 #include <sstream>
  55 #include <cmath>
  56
  57 #include "Parser.hpp"
  58 #include "Cycript.tab.hh"
  59
  60 #include "Error.hpp"
  61 #include "String.hpp"
  62
  63 /* C Strings {{{ */
  64 template <typename Type_>
  65 _finline size_t iconv_(size_t (*iconv)(iconv_t, Type_, size_t *, char **, size_t *), iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft) {
  66     return iconv(cd, const_cast<Type_>(inbuf), inbytesleft, outbuf, outbytesleft);
  67 }
  68
  69 #ifdef __GLIBC__
  70 #define UCS_2_INTERNAL "UCS-2"
  71 #else
  72 #define UCS_2_INTERNAL "UCS-2-INTERNAL"
  73 #endif
  74
  75 CYUTF8String CYPoolUTF8String(apr_pool_t *pool, CYUTF16String utf16) {
  76     _assert(pool != NULL);
  77
  78     const char *in(reinterpret_cast<const char *>(utf16.data));
  79
  80     iconv_t conversion(_syscall(iconv_open("UTF-8", UCS_2_INTERNAL)));
  81
  82     // XXX: this is wrong
  83     size_t size(utf16.size * 5);
  84     char *out(new(pool) char[size]);
  85     CYUTF8String utf8(out, size);
  86
  87     size = utf16.size * 2;
  88     _syscall(iconv_(&iconv, conversion, const_cast<char **>(&in), &size, &out, &utf8.size));
  89
  90     *out = '\0';
  91     utf8.size = out - utf8.data;
  92
  93     _syscall(iconv_close(conversion));
  94
  95     return utf8;
  96 }
  97
  98 CYUTF16String CYPoolUTF16String(apr_pool_t *pool, CYUTF8String utf8) {
  99     _assert(pool != NULL);
 100
 101     const char *in(utf8.data);
 102
 103     iconv_t conversion(_syscall(iconv_open(UCS_2_INTERNAL, "UTF-8")));
 104
 105     // XXX: this is wrong
 106     size_t size(utf8.size * 5);
 107     uint16_t *temp(new (pool) uint16_t[size]);
 108     CYUTF16String utf16(temp, size * 2);
 109     char *out(reinterpret_cast<char *>(temp));
 110
 111     size = utf8.size;
 112     _syscall(iconv_(&iconv, conversion, const_cast<char **>(&in), &size, &out, &utf16.size));
 113
 114     utf16.size = reinterpret_cast<uint16_t *>(out) - utf16.data;
 115     temp[utf16.size] = 0;
 116
 117     _syscall(iconv_close(conversion));
 118
 119     return utf16;
 120 }
 121 /* }}} */
 122 /* Index Offsets {{{ */
 123 size_t CYGetIndex(const CYUTF8String &value) {
 124     if (value.data[0] != '0') {
 125         size_t index(0);
 126         for (size_t i(0); i != value.size; ++i) {
 127             if (!DigitRange_[value.data[i]])
 128                 return _not(size_t);
 129             index *= 10;
 130             index += value.data[i] - '0';
 131         }
 132         return index;
 133     } else if (value.size == 1)
 134         return 0;
 135     else
 136         return _not(size_t);
 137 }
 138
 139 // XXX: this isn't actually right
 140 bool CYGetOffset(const char *value, ssize_t &index) {
 141     if (value[0] != '0') {
 142         char *end;
 143         index = strtol(value, &end, 10);
 144         if (value + strlen(value) == end)
 145             return true;
 146     } else if (value[1] == '\0') {
 147         index = 0;
 148         return true;
 149     }
 150
 151     return false;
 152 }
 153 /* }}} */
 154 /* JavaScript *ify {{{ */
 155 void CYStringify(std::ostringstream &str, const char *data, size_t size) {
 156     unsigned quot(0), apos(0);
 157     for (const char *value(data), *end(data + size); value != end; ++value)
 158         if (*value == '"')
 159             ++quot;
 160         else if (*value == '\'')
 161             ++apos;
 162
 163     bool single(quot > apos);
 164
 165     str << (single ? '\'' : '"');
 166
 167     for (const char *value(data), *end(data + size); value != end; ++value)
 168         switch (*value) {
 169             case '\\': str << "\\\\"; break;
 170             case '\b': str << "\\b"; break;
 171             case '\f': str << "\\f"; break;
 172             case '\n': str << "\\n"; break;
 173             case '\r': str << "\\r"; break;
 174             case '\t': str << "\\t"; break;
 175             case '\v': str << "\\v"; break;
 176
 177             case '"':
 178                 if (!single)
 179                     str << "\\\"";
 180                 else goto simple;
 181             break;
 182
 183             case '\'':
 184                 if (single)
 185                     str << "\\'";
 186                 else goto simple;
 187             break;
 188
 189             default:
 190                 // this test is designed to be "awesome", generating neither warnings nor incorrect results
 191                 if (*value < 0x20 || *value >= 0x7f)
 192                     str << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(uint8_t(*value));
 193                 else simple:
 194                     str << *value;
 195         }
 196
 197     str << (single ? '\'' : '"');
 198 }
 199
 200 void CYNumerify(std::ostringstream &str, double value) {
 201     char string[32];
 202     // XXX: I want this to print 1e3 rather than 1000
 203     sprintf(string, "%.17g", value);
 204     str << string;
 205 }
 206
 207 bool CYIsKey(CYUTF8String value) {
 208     const char *data(value.data);
 209     size_t size(value.size);
 210
 211     if (size == 0)
 212         return false;
 213
 214     if (DigitRange_[data[0]]) {
 215         size_t index(CYGetIndex(value));
 216         if (index == _not(size_t))
 217             return false;
 218     } else {
 219         if (!WordStartRange_[data[0]])
 220             return false;
 221         for (size_t i(1); i != size; ++i)
 222             if (!WordEndRange_[data[i]])
 223                 return false;
 224     }
 225
 226     return true;
 227 }
 228 /* }}} */
 229
 230 double CYCastDouble(const char *value, size_t size) {
 231     char *end;
 232     double number(strtod(value, &end));
 233     if (end != value + size)
 234         return NAN;
 235     return number;
 236 }
 237
 238 double CYCastDouble(const char *value) {
 239     return CYCastDouble(value, strlen(value));
 240 }
 241
 242 extern "C" void CydgetPoolParse(apr_pool_t *pool, const uint16_t **data, size_t *size) {
 243     CYDriver driver("");
 244     cy::parser parser(driver);
 245
 246     CYUTF8String utf8(CYPoolUTF8String(pool, CYUTF16String(*data, *size)));
 247
 248     driver.data_ = utf8.data;
 249     driver.size_ = utf8.size;
 250
 251     if (parser.parse() != 0 || !driver.errors_.empty())
 252         return;
 253
 254     CYContext context(driver.pool_);
 255     driver.program_->Replace(context);
 256     std::ostringstream str;
 257     CYOutput out(str);
 258     out << *driver.program_;
 259     std::string code(str.str());
 260
 261     CYUTF16String utf16(CYPoolUTF16String(pool, CYUTF8String(code.c_str(), code.size())));
 262
 263     *data = utf16.data;
 264     *size = utf16.size;
 265 }
 266
 267 static apr_pool_t *Pool_;
 268
 269 static bool initialized_;
 270
 271 void CYInitializeStatic() {
 272     if (!initialized_)
 273         initialized_ = true;
 274     else return;
 275
 276     _aprcall(apr_initialize());
 277     _aprcall(apr_pool_create(&Pool_, NULL));
 278 }
 279
 280 apr_pool_t *CYGetGlobalPool() {
 281     CYInitializeStatic();
 282     return Pool_;
 283 }
 284
 285 void CYThrow(const char *format, ...) {
 286     va_list args;
 287     va_start(args, format);
 288     throw CYPoolError(format, args);
 289     // XXX: does this matter? :(
 290     va_end(args);
 291 }
 292
 293 const char *CYPoolError::PoolCString(apr_pool_t *pool) const {
 294     return apr_pstrdup(pool, message_);
 295 }
 296
 297 CYPoolError::CYPoolError(const char *format, ...) {
 298     va_list args;
 299     va_start(args, format);
 300     message_ = apr_pvsprintf(pool_, format, args);
 301     va_end(args);
 302 }
 303
 304 CYPoolError::CYPoolError(const char *format, va_list args) {
 305     message_ = apr_pvsprintf(pool_, format, args);
 306 }