yarp 0.9.0 → 0.10.0

data/lib/yarp/serialize.rb

@@ -21,7 +21,7 @@ end
 module YARP
   module Serialize
     MAJOR_VERSION = 0
-    MINOR_VERSION = 9
+    MINOR_VERSION = 10
     PATCH_VERSION = 0
 
     def self.load(input, serialized)
@@ -226,17 +226,17 @@ module YARP
         when 22 then
           ClassNode.new(Array.new(load_varint) { load_constant }, load_location, load_node, load_optional_location, load_optional_node, load_optional_node, load_location, load_string, location)
         when 23 then
-          ClassVariableAndWriteNode.new(load_location, load_location, load_node, location)
+          ClassVariableAndWriteNode.new(load_constant, load_location, load_location, load_node, location)
         when 24 then
-          ClassVariableOperatorWriteNode.new(load_location, load_location, load_node, load_constant, location)
+          ClassVariableOperatorWriteNode.new(load_constant, load_location, load_location, load_node, load_constant, location)
         when 25 then
-          ClassVariableOrWriteNode.new(load_location, load_location, load_node, location)
+          ClassVariableOrWriteNode.new(load_constant, load_location, load_location, load_node, location)
         when 26 then
-          ClassVariableReadNode.new(location)
+          ClassVariableReadNode.new(load_constant, location)
         when 27 then
-          ClassVariableTargetNode.new(location)
+          ClassVariableTargetNode.new(load_constant, location)
         when 28 then
-          ClassVariableWriteNode.new(load_location, load_optional_node, load_optional_location, location)
+          ClassVariableWriteNode.new(load_constant, load_location, load_optional_node, load_optional_location, location)
         when 29 then
           ConstantAndWriteNode.new(load_location, load_location, load_node, location)
         when 30 then
@@ -301,7 +301,7 @@ module YARP
         when 59 then
           GlobalVariableTargetNode.new(location)
         when 60 then
-          GlobalVariableWriteNode.new(load_location, load_location, load_node, location)
+          GlobalVariableWriteNode.new(load_location, load_node, load_location, location)
         when 61 then
           HashNode.new(load_location, Array.new(load_varint) { load_node }, load_location, location)
         when 62 then
@@ -313,17 +313,17 @@ module YARP
         when 65 then
           InNode.new(load_node, load_optional_node, load_location, load_optional_location, location)
         when 66 then
-          InstanceVariableAndWriteNode.new(load_location, load_location, load_node, location)
+          InstanceVariableAndWriteNode.new(load_constant, load_location, load_location, load_node, location)
         when 67 then
-          InstanceVariableOperatorWriteNode.new(load_location, load_location, load_node, load_constant, location)
+          InstanceVariableOperatorWriteNode.new(load_constant, load_location, load_location, load_node, load_constant, location)
         when 68 then
-          InstanceVariableOrWriteNode.new(load_location, load_location, load_node, location)
+          InstanceVariableOrWriteNode.new(load_constant, load_location, load_location, load_node, location)
         when 69 then
-          InstanceVariableReadNode.new(location)
+          InstanceVariableReadNode.new(load_constant, location)
         when 70 then
-          InstanceVariableTargetNode.new(location)
+          InstanceVariableTargetNode.new(load_constant, location)
         when 71 then
-          InstanceVariableWriteNode.new(load_location, load_node, load_location, location)
+          InstanceVariableWriteNode.new(load_constant, load_location, load_node, load_location, location)
         when 72 then
           IntegerNode.new(location)
         when 73 then
@@ -353,7 +353,7 @@ module YARP
         when 85 then
           LocalVariableTargetNode.new(load_constant, load_varint, location)
         when 86 then
-          LocalVariableWriteNode.new(load_constant, load_varint, load_node, load_location, load_location, location)
+          LocalVariableWriteNode.new(load_constant, load_varint, load_location, load_node, load_location, location)
         when 87 then
           MatchPredicateNode.new(load_node, load_node, load_location, location)
         when 88 then
@@ -371,7 +371,7 @@ module YARP
         when 94 then
           NoKeywordsParameterNode.new(load_location, load_location, location)
         when 95 then
-          NumberedReferenceReadNode.new(location)
+          NumberedReferenceReadNode.new(load_varint, location)
         when 96 then
           OptionalParameterNode.new(load_constant, load_location, load_location, load_node, location)
         when 97 then

data/lib/yarp.rb

@@ -462,10 +462,10 @@ module YARP
           # order here so that we can compare properly.
           if params
             sorted = [
-              *params.requireds.grep(RequiredParameterNode).map(&:constant_id),
-              *params.optionals.map(&:constant_id),
+              *params.requireds.grep(RequiredParameterNode).map(&:name),
+              *params.optionals.map(&:name),
               *((params.rest.name ? params.rest.name.to_sym : :*) if params.rest && params.rest.operator != ","),
-              *params.posts.grep(RequiredParameterNode).map(&:constant_id),
+              *params.posts.grep(RequiredParameterNode).map(&:name),
               *params.keywords.reject(&:value).map { |param| param.name.chomp(":").to_sym },
               *params.keywords.select(&:value).map { |param| param.name.chomp(":").to_sym }
             ]
@@ -485,9 +485,9 @@ module YARP
               when RequiredDestructuredParameterNode
                 param_stack.concat(param.parameters.reverse)
               when RequiredParameterNode
-                sorted << param.constant_id
+                sorted << param.name
               when SplatNode
-                sorted << param.expression.constant_id if param.expression
+                sorted << param.expression.name if param.expression
               end
             end
 

data/src/diagnostic.c

@@ -2,7 +2,7 @@
 
 // Append an error to the given list of diagnostic.
 bool
-yp_diagnostic_list_append(yp_list_t *list, const char *start, const char *end, const char *message) {
+yp_diagnostic_list_append(yp_list_t *list, const uint8_t *start, const uint8_t *end, const char *message) {
     yp_diagnostic_t *diagnostic = (yp_diagnostic_t *) malloc(sizeof(yp_diagnostic_t));
     if (diagnostic == NULL) return false;
 

data/src/enc/yp_big5.c

@@ -1,69 +1,42 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_big5_codepoint_t;
-
-static yp_big5_codepoint_t
-yp_big5_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_big5_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80) {
+        return 1;
     }
 
     // These are the double byte characters.
-    if ((n > 1) && (uc[0] >= 0xA1 && uc[0] <= 0xFE) && (uc[1] >= 0x40 && uc[1] <= 0xFE)) {
-        *width = 2;
-        return (yp_big5_codepoint_t) (uc[0] << 8 | uc[1]);
+    if ((n > 1) && (b[0] >= 0xA1 && b[0] <= 0xFE) && (b[1] >= 0x40 && b[1] <= 0xFE)) {
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_big5_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_big5_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint_t codepoint = yp_big5_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_big5_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_big5_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_big5_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint_t codepoint = yp_big5_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_big5_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_big5_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_big5_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint_t codepoint = yp_big5_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_big5_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_big5_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return false;
     }

data/src/enc/yp_euc_jp.c

@@ -1,75 +1,48 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_euc_jp_codepoint_t;
-
-static yp_euc_jp_codepoint_t
-yp_euc_jp_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_euc_jp_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80) {
+        return 1;
     }
 
     // These are the double byte characters.
     if (
         (n > 1) &&
         (
-            ((uc[0] == 0x8E) && (uc[1] >= 0xA1 && uc[1] <= 0xFE)) ||
-            ((uc[0] >= 0xA1 && uc[0] <= 0xFE) && (uc[1] >= 0xA1 && uc[1] <= 0xFE))
+            ((b[0] == 0x8E) && (b[1] >= 0xA1 && b[1] <= 0xFE)) ||
+            ((b[0] >= 0xA1 && b[0] <= 0xFE) && (b[1] >= 0xA1 && b[1] <= 0xFE))
         )
     ) {
-        *width = 2;
-        return (yp_euc_jp_codepoint_t) (uc[0] << 8 | uc[1]);
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_euc_jp_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_euc_jp_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint_t codepoint = yp_euc_jp_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_euc_jp_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_euc_jp_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint_t codepoint = yp_euc_jp_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_euc_jp_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_euc_jp_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint_t codepoint = yp_euc_jp_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_euc_jp_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return 0;
     }

data/src/enc/yp_gbk.c

@@ -1,78 +1,51 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_gbk_codepoint_t;
-
-static yp_gbk_codepoint_t
-yp_gbk_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_gbk_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80) {
+        return 1;
     }
 
     // These are the double byte characters.
     if (
         (n > 1) &&
         (
-            ((uc[0] >= 0xA1 && uc[0] <= 0xA9) && (uc[1] >= 0xA1 && uc[1] <= 0xFE)) || // GBK/1
-            ((uc[0] >= 0xB0 && uc[0] <= 0xF7) && (uc[1] >= 0xA1 && uc[1] <= 0xFE)) || // GBK/2
-            ((uc[0] >= 0x81 && uc[0] <= 0xA0) && (uc[1] >= 0x40 && uc[1] <= 0xFE) && (uc[1] != 0x7F)) || // GBK/3
-            ((uc[0] >= 0xAA && uc[0] <= 0xFE) && (uc[1] >= 0x40 && uc[1] <= 0xA0) && (uc[1] != 0x7F)) || // GBK/4
-            ((uc[0] >= 0xA8 && uc[0] <= 0xA9) && (uc[1] >= 0x40 && uc[1] <= 0xA0) && (uc[1] != 0x7F)) // GBK/5
+            ((b[0] >= 0xA1 && b[0] <= 0xA9) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // GBK/1
+            ((b[0] >= 0xB0 && b[0] <= 0xF7) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // GBK/2
+            ((b[0] >= 0x81 && b[0] <= 0xA0) && (b[1] >= 0x40 && b[1] <= 0xFE) && (b[1] != 0x7F)) || // GBK/3
+            ((b[0] >= 0xAA && b[0] <= 0xFE) && (b[1] >= 0x40 && b[1] <= 0xA0) && (b[1] != 0x7F)) || // GBK/4
+            ((b[0] >= 0xA8 && b[0] <= 0xA9) && (b[1] >= 0x40 && b[1] <= 0xA0) && (b[1] != 0x7F)) // GBK/5
         )
     ) {
-        *width = 2;
-        return (yp_gbk_codepoint_t) (uc[0] << 8 | uc[1]);
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_gbk_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_gbk_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint_t codepoint = yp_gbk_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_gbk_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_gbk_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_gbk_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint_t codepoint = yp_gbk_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_gbk_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_gbk_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_gbk_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint_t codepoint = yp_gbk_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_gbk_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_gbk_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return false;
     }

data/src/enc/yp_shift_jis.c

@@ -1,73 +1,46 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_shift_jis_codepoint_t;
-
-static yp_shift_jis_codepoint_t
-yp_shift_jis_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_shift_jis_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80 || (*uc >= 0xA1 && *uc <= 0xDF)) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80 || (*b >= 0xA1 && *b <= 0xDF)) {
+        return 1;
     }
 
     // These are the double byte characters.
     if (
         (n > 1) &&
-        ((uc[0] >= 0x81 && uc[0] <= 0x9F) || (uc[0] >= 0xE0 && uc[0] <= 0xFC)) &&
-        (uc[1] >= 0x40 && uc[1] <= 0xFC)
+        ((b[0] >= 0x81 && b[0] <= 0x9F) || (b[0] >= 0xE0 && b[0] <= 0xFC)) &&
+        (b[1] >= 0x40 && b[1] <= 0xFC)
     ) {
-        *width = 2;
-        return (yp_shift_jis_codepoint_t) (uc[0] << 8 | uc[1]);
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_shift_jis_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_shift_jis_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint_t codepoint = yp_shift_jis_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_shift_jis_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_shift_jis_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint_t codepoint = yp_shift_jis_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_shift_jis_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_shift_jis_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint_t codepoint = yp_shift_jis_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_shift_jis_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return 0;
     }