X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/2eb8215d4156f442f856026f1714aef7ed185752..341d1456832396678c21074a7ec2a07181e12f49:/Library.cpp diff --git a/Library.cpp b/Library.cpp index 48ad71f..258ef61 100644 --- a/Library.cpp +++ b/Library.cpp @@ -1,44 +1,25 @@ -/* Cycript - Inlining/Optimizing JavaScript Compiler - * Copyright (C) 2009 Jay Freeman (saurik) +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) */ -/* Modified BSD License {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Redistribution and use in source and binary - * forms, with or without modification, are permitted - * provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the - * above copyright notice, this list of conditions - * and the following disclaimer. - * 2. Redistributions in binary form must reproduce the - * above copyright notice, this list of conditions - * and the following disclaimer in the documentation - * and/or other materials provided with the - * distribution. - * 3. The name of the author may not be used to endorse - * or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, - * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program 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 Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ /* }}} */ #include -#include #include "cycript.hpp" @@ -47,77 +28,50 @@ #include #include -#include #include #include #include #include #include -#include "Parser.hpp" -#include "Cycript.tab.hh" - #include "Error.hpp" -#include "String.hpp" #include "Execute.hpp" +#include "Parser.hpp" +#include "String.hpp" -/* C Strings {{{ */ -template -_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) { - return iconv(cd, const_cast(inbuf), inbytesleft, outbuf, outbytesleft); -} - -#ifdef __GLIBC__ -#define UCS_2_INTERNAL "UCS-2" -#else -#define UCS_2_INTERNAL "UCS-2-INTERNAL" -#endif - -CYUTF8String CYPoolUTF8String(apr_pool_t *pool, CYUTF16String utf16) { - _assert(pool != NULL); +#include "Cycript.tab.hh" +#include "Driver.hpp" - const char *in(reinterpret_cast(utf16.data)); +#include "ConvertUTF.h" - iconv_t conversion(_syscall(iconv_open("UTF-8", UCS_2_INTERNAL))); +template <> +::pthread_key_t CYLocal::key_ = Key_(); +/* C Strings {{{ */ +CYUTF8String CYPoolUTF8String(CYPool &pool, CYUTF16String utf16) { // XXX: this is wrong size_t size(utf16.size * 5); - char *out(new(pool) char[size]); - CYUTF8String utf8(out, size); - - size = utf16.size * 2; - _syscall(iconv_(&iconv, conversion, const_cast(&in), &size, &out, &utf8.size)); + char *temp(new(pool) char[size]); - *out = '\0'; - utf8.size = out - utf8.data; + const uint16_t *lhs(utf16.data); + uint8_t *rhs(reinterpret_cast(temp)); + _assert(ConvertUTF16toUTF8(&lhs, lhs + utf16.size, &rhs, rhs + size, lenientConversion) == conversionOK); - _syscall(iconv_close(conversion)); - - return utf8; + *rhs = 0; + return CYUTF8String(temp, reinterpret_cast(rhs) - temp); } -CYUTF16String CYPoolUTF16String(apr_pool_t *pool, CYUTF8String utf8) { - _assert(pool != NULL); - - const char *in(utf8.data); - - iconv_t conversion(_syscall(iconv_open(UCS_2_INTERNAL, "UTF-8"))); - +CYUTF16String CYPoolUTF16String(CYPool &pool, CYUTF8String utf8) { // XXX: this is wrong size_t size(utf8.size * 5); uint16_t *temp(new (pool) uint16_t[size]); - CYUTF16String utf16(temp, size * 2); - char *out(reinterpret_cast(temp)); - size = utf8.size; - _syscall(iconv_(&iconv, conversion, const_cast(&in), &size, &out, &utf16.size)); + const uint8_t *lhs(reinterpret_cast(utf8.data)); + uint16_t *rhs(temp); + _assert(ConvertUTF8toUTF16(&lhs, lhs + utf8.size, &rhs, rhs + size, lenientConversion) == conversionOK); - utf16.size = reinterpret_cast(out) - utf16.data; - temp[utf16.size] = 0; - - _syscall(iconv_close(conversion)); - - return utf16; + *rhs = 0; + return CYUTF16String(temp, rhs - temp); } /* }}} */ /* Index Offsets {{{ */ @@ -166,7 +120,7 @@ void CYStringify(std::ostringstream &str, const char *data, size_t size) { str << (single ? '\'' : '"'); for (const char *value(data), *end(data + size); value != end; ++value) - switch (*value) { + switch (uint8_t next = *value) { case '\\': str << "\\\\"; break; case '\b': str << "\\b"; break; case '\f': str << "\\f"; break; @@ -187,12 +141,35 @@ void CYStringify(std::ostringstream &str, const char *data, size_t size) { else goto simple; break; + case '\0': + if (value[1] >= '0' && value[1] <= '9') + str << "\\x00"; + else + str << "\\0"; + break; + default: - // this test is designed to be "awesome", generating neither warnings nor incorrect results - if (*value < 0x20 || *value >= 0x7f) - str << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(uint8_t(*value)); - else simple: + if (next >= 0x20 && next < 0x7f) simple: str << *value; + else { + unsigned levels(1); + if ((next & 0x80) != 0) + while ((next & 0x80 >> ++levels) != 0); + + unsigned point(next & 0xff >> levels); + while (--levels != 0) + point = point << 6 | uint8_t(*++value) & 0x3f; + + if (point < 0x100) + str << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << point; + else if (point < 0x10000) + str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << point; + else { + point -= 0x10000; + str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << (0xd800 | point >> 0x0a); + str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << (0xdc00 | point & 0x3ff); + } + } } str << (single ? '\'' : '"'); @@ -240,53 +217,30 @@ double CYCastDouble(const char *value) { return CYCastDouble(value, strlen(value)); } -extern "C" void CydgetPoolParse(apr_pool_t *remote, const uint16_t **data, size_t *size) { +CYUTF8String CYPoolCode(CYPool &pool, std::istream &stream) { CYLocalPool local; + CYDriver driver(local, stream); - CYDriver driver; cy::parser parser(driver); - - CYUTF8String utf8(CYPoolUTF8String(local, CYUTF16String(*data, *size))); - - driver.data_ = utf8.data; - driver.size_ = utf8.size; - - if (parser.parse() != 0 || !driver.errors_.empty()) - return; + _assert(parser.parse() == 0); + _assert(driver.errors_.empty()); CYOptions options; CYContext context(options); driver.program_->Replace(context); - std::ostringstream str; + + std::stringbuf str; CYOutput out(str, options); out << *driver.program_; - std::string code(str.str()); - - CYUTF16String utf16(CYPoolUTF16String(remote, CYUTF8String(code.c_str(), code.size()))); - - *data = utf16.data; - *size = utf16.size; -} - -static apr_pool_t *Pool_; - -static bool initialized_; - -void CYInitializeStatic() { - if (!initialized_) - initialized_ = true; - else return; - - _aprcall(apr_initialize()); - _aprcall(apr_pool_create(&Pool_, NULL)); + return $pool.strdup(str.str().c_str()); } -apr_pool_t *CYGetGlobalPool() { - CYInitializeStatic(); - return Pool_; +CYPool &CYGetGlobalPool() { + static CYPool pool; + return pool; } -void CYThrow(const char *format, ...) { +_visible void CYThrow(const char *format, ...) { va_list args; va_start(args, format); throw CYPoolError(format, args); @@ -294,17 +248,24 @@ void CYThrow(const char *format, ...) { va_end(args); } -const char *CYPoolError::PoolCString(apr_pool_t *pool) const { - return apr_pstrdup(pool, message_); +const char *CYPoolError::PoolCString(CYPool &pool) const { + return pool.strdup(message_); +} + +CYPoolError::CYPoolError(const CYPoolError &rhs) : + message_(pool_.strdup(rhs.message_)) +{ } CYPoolError::CYPoolError(const char *format, ...) { va_list args; va_start(args, format); - message_ = apr_pvsprintf(pool_, format, args); + // XXX: there might be a beter way to think about this + message_ = pool_.vsprintf(64, format, args); va_end(args); } CYPoolError::CYPoolError(const char *format, va_list args) { - message_ = apr_pvsprintf(pool_, format, args); + // XXX: there might be a beter way to think about this + message_ = pool_.vsprintf(64, format, args); }