Verify lexer tokens are always default reductions.

[cycript.git] / Library.cpp

diff --git a/Library.cpp b/Library.cpp
index 28f9395468d00664da256054abdc77110792689b..720322564e1fb181f6ac78407f6116164ffb8c8e 100644 (file)
--- a/Library.cpp
+++ b/Library.cpp
@@ -1,32 +1,26 @@
 /* Cycript - Optimizing JavaScript Compiler/Runtime
 /* Cycript - Optimizing JavaScript Compiler/Runtime

- * Copyright (C) 2009-2013  Jay Freeman (saurik)
+ * Copyright (C) 2009-2015  Jay Freeman (saurik)

 */
 
 */
 

-/* GNU General Public License, Version 3 {{{ */
+/* GNU Affero General Public License, Version 3 {{{ */

 /*
 /*

- * Cycript is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published
- * by the Free Software Foundation, either version 3 of the License,
- * or (at your option) any later version.
- *
- * Cycript is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Cycript.  If not, see <http://www.gnu.org/licenses/>.
+ * 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 <http://www.gnu.org/licenses/>.

 **/
 /* }}} */
 
 **/
 /* }}} */
 

-#include <dlfcn.h>
-

 #include "cycript.hpp"
 
 #include "cycript.hpp"
 

-#include "Pooling.hpp"
-
-#include <sys/mman.h>
-

 #include <iostream>
 #include <set>
 #include <map>
 #include <iostream>
 #include <set>
 #include <map>


@@ -34,15 +28,20 @@
 #include <sstream>
 #include <cmath>
 
 #include <sstream>
 #include <cmath>
 

+#include <dlfcn.h>
+
+#include <sys/mman.h>
+
+#include "ConvertUTF.h"
+#include "Driver.hpp"

 #include "Error.hpp"
 #include "Execute.hpp"
 #include "Error.hpp"
 #include "Execute.hpp"

-#include "Parser.hpp"
+#include "Pooling.hpp"

 #include "String.hpp"
 #include "String.hpp"

+#include "Syntax.hpp"

 
 

-#include "Cycript.tab.hh"
-#include "Driver.hpp"
-
-#include "ConvertUTF.h"
+template <>
+::pthread_key_t CYLocal<CYPool>::key_ = Key_();

 
 /* C Strings {{{ */
 CYUTF8String CYPoolUTF8String(CYPool &pool, CYUTF16String utf16) {
 
 /* C Strings {{{ */
 CYUTF8String CYPoolUTF8String(CYPool &pool, CYUTF16String utf16) {


@@ -117,7 +116,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)
     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;
             case '\\': str << "\\\\"; break;
             case '\b': str << "\\b"; break;
             case '\f': str << "\\f"; break;


@@ -138,18 +137,48 @@ void CYStringify(std::ostringstream &str, const char *data, size_t size) {
                 else goto simple;
             break;
 
                 else goto simple;
             break;
 

+            case '\0':
+                if (value[1] >= '0' && value[1] <= '9')
+                    str << "\\x00";
+                else
+                    str << "\\0";
+            break;
+

             default:
             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;
                     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 ? '\'' : '"');
 }
 
 void CYNumerify(std::ostringstream &str, double value) {
         }
 
     str << (single ? '\'' : '"');
 }
 
 void CYNumerify(std::ostringstream &str, double value) {

+    if (std::isinf(value)) {
+        if (value < 0)
+            str << '-';
+        str << "Infinity";
+        return;
+    }
+

     char string[32];
     // XXX: I want this to print 1e3 rather than 1000
     sprintf(string, "%.17g", value);
     char string[32];
     // XXX: I want this to print 1e3 rather than 1000
     sprintf(string, "%.17g", value);


@@ -191,45 +220,24 @@ double CYCastDouble(const char *value) {
     return CYCastDouble(value, strlen(value));
 }
 
     return CYCastDouble(value, strlen(value));
 }
 

-CYUTF8String CYPoolCode(CYPool &pool, CYUTF8String code) {
-    CYLocalPool local;
-    CYStream stream(code.data, code.data + code.size);
-    CYDriver driver(stream);
+_visible bool CYStartsWith(const CYUTF8String &haystack, const CYUTF8String &needle) {
+    return haystack.size >= needle.size && strncmp(haystack.data, needle.data, needle.size) == 0;
+}

 
 

-    cy::parser parser(driver);
-    _assert(parser.parse() == 0);
+CYUTF8String CYPoolCode(CYPool &pool, std::istream &stream) {
+    CYLocalPool local;
+    CYDriver driver(local, stream);
+    _assert(!driver.Parse());

     _assert(driver.errors_.empty());
 
     CYOptions options;
     CYContext context(options);
     _assert(driver.errors_.empty());
 
     CYOptions options;
     CYContext context(options);

-    driver.program_->Replace(context);
+    driver.script_->Replace(context);

 
 

-    std::ostringstream &str(pool.object<std::ostringstream>());
+    std::stringbuf str;

     CYOutput out(str, options);
     CYOutput out(str, options);

-    out << *driver.program_;
-    return str.str().c_str();
-}
-
-extern "C" bool CydgetMemoryParse(const uint16_t **data, size_t *size) {
-    CYPool pool;
-
-    CYUTF8String utf8(CYPoolUTF8String(pool, CYUTF16String(*data, *size)));
-    try {
-        utf8 = CYPoolCode(pool, utf8);
-    } catch (const CYException &) {
-        *data = NULL;
-        *size = 0;
-        return false;
-    }
-
-    CYUTF16String utf16(CYPoolUTF16String(pool, CYUTF8String(utf8.data, utf8.size)));
-    size_t bytes(utf16.size * sizeof(uint16_t));
-    uint16_t *copy(reinterpret_cast<uint16_t *>(malloc(bytes)));
-    memcpy(copy, utf16.data, bytes);
-
-    *data = copy;
-    *size = utf16.size;
-    return true;
+    out << *driver.script_;
+    return $pool.strdup(str.str().c_str());

 }
 
 CYPool &CYGetGlobalPool() {
 }
 
 CYPool &CYGetGlobalPool() {


@@ -237,7 +245,7 @@ CYPool &CYGetGlobalPool() {
     return 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);
     va_list args;
     va_start(args, format);
     throw CYPoolError(format, args);