Library.cpp

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2015  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #include "cycript.hpp"
  23
  24 #include <iostream>
  25 #include <set>
  26 #include <map>
  27 #include <iomanip>
  28 #include <sstream>
  29 #include <cmath>
  30
  31 #include <dlfcn.h>
  32
  33 #include <sys/mman.h>
  34
  35 #include "ConvertUTF.h"
  36 #include "Driver.hpp"
  37 #include "Error.hpp"
  38 #include "Execute.hpp"
  39 #include "Pooling.hpp"
  40 #include "String.hpp"
  41 #include "Syntax.hpp"
  42
  43 template <>
  44 ::pthread_key_t CYLocal<CYPool>::key_ = Key_();
  45
  46 /* C Strings {{{ */
  47 CYUTF8String CYPoolUTF8String(CYPool &pool, CYUTF16String utf16) {
  48     // XXX: this is wrong
  49     size_t size(utf16.size * 5);
  50     char *temp(new(pool) char[size]);
  51
  52     const uint16_t *lhs(utf16.data);
  53     uint8_t *rhs(reinterpret_cast<uint8_t *>(temp));
  54     _assert(ConvertUTF16toUTF8(&lhs, lhs + utf16.size, &rhs, rhs + size, lenientConversion) == conversionOK);
  55
  56     *rhs = 0;
  57     return CYUTF8String(temp, reinterpret_cast<char *>(rhs) - temp);
  58 }
  59
  60 CYUTF16String CYPoolUTF16String(CYPool &pool, CYUTF8String utf8) {
  61     // XXX: this is wrong
  62     size_t size(utf8.size * 5);
  63     uint16_t *temp(new (pool) uint16_t[size]);
  64
  65     const uint8_t *lhs(reinterpret_cast<const uint8_t *>(utf8.data));
  66     uint16_t *rhs(temp);
  67     _assert(ConvertUTF8toUTF16(&lhs, lhs + utf8.size, &rhs, rhs + size, lenientConversion) == conversionOK);
  68
  69     *rhs = 0;
  70     return CYUTF16String(temp, rhs - temp);
  71 }
  72 /* }}} */
  73 /* Index Offsets {{{ */
  74 size_t CYGetIndex(const CYUTF8String &value) {
  75     if (value.data[0] != '0') {
  76         size_t index(0);
  77         for (size_t i(0); i != value.size; ++i) {
  78             if (!DigitRange_[value.data[i]])
  79                 return _not(size_t);
  80             index *= 10;
  81             index += value.data[i] - '0';
  82         }
  83         return index;
  84     } else if (value.size == 1)
  85         return 0;
  86     else
  87         return _not(size_t);
  88 }
  89
  90 // XXX: this isn't actually right
  91 bool CYGetOffset(const char *value, ssize_t &index) {
  92     if (value[0] != '0') {
  93         char *end;
  94         index = strtol(value, &end, 10);
  95         if (value + strlen(value) == end)
  96             return true;
  97     } else if (value[1] == '\0') {
  98         index = 0;
  99         return true;
 100     }
 101
 102     return false;
 103 }
 104 /* }}} */
 105 /* JavaScript *ify {{{ */
 106 void CYStringify(std::ostringstream &str, const char *data, size_t size, bool c) {
 107     bool single;
 108     if (c)
 109         single = false;
 110     else {
 111         unsigned quot(0), apos(0);
 112         for (const char *value(data), *end(data + size); value != end; ++value)
 113             if (*value == '"')
 114                 ++quot;
 115             else if (*value == '\'')
 116                 ++apos;
 117
 118         single = quot > apos;
 119     }
 120
 121     str << (single ? '\'' : '"');
 122
 123     for (const char *value(data), *end(data + size); value != end; ++value)
 124         switch (uint8_t next = *value) {
 125             case '\\': str << "\\\\"; break;
 126             case '\b': str << "\\b"; break;
 127             case '\f': str << "\\f"; break;
 128             case '\n': str << "\\n"; break;
 129             case '\r': str << "\\r"; break;
 130             case '\t': str << "\\t"; break;
 131             case '\v': str << "\\v"; break;
 132
 133             case '"':
 134                 if (!single)
 135                     str << "\\\"";
 136                 else goto simple;
 137             break;
 138
 139             case '\'':
 140                 if (single)
 141                     str << "\\'";
 142                 else goto simple;
 143             break;
 144
 145             case '\0':
 146                 if (value[1] >= '0' && value[1] <= '9')
 147                     str << "\\x00";
 148                 else
 149                     str << "\\0";
 150             break;
 151
 152             default:
 153                 if (next >= 0x20 && next < 0x7f) simple:
 154                     str << *value;
 155                 else {
 156                     unsigned levels(1);
 157                     if ((next & 0x80) != 0)
 158                         while ((next & 0x80 >> ++levels) != 0);
 159
 160                     unsigned point(next & 0xff >> levels);
 161                     while (--levels != 0)
 162                         point = point << 6 | uint8_t(*++value) & 0x3f;
 163
 164                     if (point < 0x100)
 165                         str << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << point;
 166                     else if (point < 0x10000)
 167                         str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << point;
 168                     else {
 169                         point -= 0x10000;
 170                         str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << (0xd800 | point >> 0x0a);
 171                         str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << (0xdc00 | point & 0x3ff);
 172                     }
 173                 }
 174         }
 175
 176     str << (single ? '\'' : '"');
 177 }
 178
 179 void CYNumerify(std::ostringstream &str, double value) {
 180     if (std::isinf(value)) {
 181         if (value < 0)
 182             str << '-';
 183         str << "Infinity";
 184         return;
 185     }
 186
 187     char string[32];
 188     // XXX: I want this to print 1e3 rather than 1000
 189     sprintf(string, "%.17g", value);
 190     str << string;
 191 }
 192
 193 bool CYIsKey(CYUTF8String value) {
 194     const char *data(value.data);
 195     size_t size(value.size);
 196
 197     if (size == 0)
 198         return false;
 199
 200     if (DigitRange_[data[0]]) {
 201         size_t index(CYGetIndex(value));
 202         if (index == _not(size_t))
 203             return false;
 204     } else {
 205         if (!WordStartRange_[data[0]])
 206             return false;
 207         for (size_t i(1); i != size; ++i)
 208             if (!WordEndRange_[data[i]])
 209                 return false;
 210     }
 211
 212     return true;
 213 }
 214 /* }}} */
 215
 216 double CYCastDouble(const char *value, size_t size) {
 217     char *end;
 218     double number(strtod(value, &end));
 219     if (end != value + size)
 220         return NAN;
 221     return number;
 222 }
 223
 224 double CYCastDouble(const char *value) {
 225     return CYCastDouble(value, strlen(value));
 226 }
 227
 228 _visible bool CYStartsWith(const CYUTF8String &haystack, const CYUTF8String &needle) {
 229     return haystack.size >= needle.size && strncmp(haystack.data, needle.data, needle.size) == 0;
 230 }
 231
 232 CYUTF8String CYPoolCode(CYPool &pool, std::streambuf &stream) {
 233     CYLocalPool local;
 234     CYDriver driver(local, stream);
 235     _assert(!driver.Parse());
 236     _assert(driver.errors_.empty());
 237
 238     CYOptions options;
 239     CYContext context(options);
 240     driver.script_->Replace(context);
 241
 242     std::stringbuf str;
 243     CYOutput out(str, options);
 244     out << *driver.script_;
 245     return $pool.strdup(str.str().c_str());
 246 }
 247
 248 CYPool &CYGetGlobalPool() {
 249     static CYPool pool;
 250     return pool;
 251 }
 252
 253 _visible void CYThrow(const char *format, ...) {
 254     va_list args;
 255     va_start(args, format);
 256     throw CYPoolError(format, args);
 257     // XXX: does this matter? :(
 258     va_end(args);
 259 }
 260
 261 const char *CYPoolError::PoolCString(CYPool &pool) const {
 262     return pool.strdup(message_);
 263 }
 264
 265 CYPoolError::CYPoolError(const CYPoolError &rhs) :
 266     message_(pool_.strdup(rhs.message_))
 267 {
 268 }
 269
 270 CYPoolError::CYPoolError(const char *format, ...) {
 271     va_list args;
 272     va_start(args, format);
 273     // XXX: there might be a beter way to think about this
 274     message_ = pool_.vsprintf(64, format, args);
 275     va_end(args);
 276 }
 277
 278 CYPoolError::CYPoolError(const char *format, va_list args) {
 279     // XXX: there might be a beter way to think about this
 280     message_ = pool_.vsprintf(64, format, args);
 281 }