From e90f0d51a3b2ac52aa76fa3c8b803bcc75433468 Mon Sep 17 00:00:00 2001
From: furunkel <julian@linux4you.it>
Date: Tue, 23 Jun 2015 10:35:02 +0200
Subject: Move deprecated macros and functions to dedicated header file

---
 include/mruby.h            | 15 +++++----------
 include/mruby/deprecated.h | 10 ++++++++++
 2 files changed, 15 insertions(+), 10 deletions(-)
 create mode 100644 include/mruby/deprecated.h

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 6eb3af844..69bb21704 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -192,10 +192,13 @@ typedef struct mrb_state {
 # define mrb_noreturn _Noreturn
 #elif defined __GNUC__ && !defined __STRICT_ANSI__
 # define mrb_noreturn __attribute__((noreturn))
+# define mrb_deprecated __attribute__((deprecated))
 #elif defined _MSC_VER
 # define mrb_noreturn __declspec(noreturn)
+# define mrb_deprecated __declspec(deprecated)
 #else
 # define mrb_noreturn
+# define mrb_deprecated
 #endif
 
 typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
@@ -250,16 +253,6 @@ MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *o
 /* accept no arguments */
 #define MRB_ARGS_NONE()     ((mrb_aspec)0)
 
-/* compatibility macros; will be removed */
-#define ARGS_REQ(n)         MRB_ARGS_REQ(n)
-#define ARGS_OPT(n)         MRB_ARGS_OPT(n)
-#define ARGS_REST()         MRB_ARGS_REST()
-#define ARGS_POST(n)        MRB_ARGS_POST()
-#define ARGS_KEY(n1,n2)     MRB_ARGS_KEY(n1,n2)
-#define ARGS_BLOCK()        MRB_ARGS_BLOCK()
-#define ARGS_ANY()          MRB_ARGS_ANY()
-#define ARGS_NONE()         MRB_ARGS_NONE()
-
 MRB_API mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...);
 
 /* `strlen` for character string literals (use with caution or `strlen` instead)
@@ -459,6 +452,8 @@ MRB_API void mrb_show_copyright(mrb_state *mrb);
 
 MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
 
+#include "mruby/deprecated.h"
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/deprecated.h b/include/mruby/deprecated.h
new file mode 100644
index 000000000..ac1c81b7e
--- /dev/null
+++ b/include/mruby/deprecated.h
@@ -0,0 +1,10 @@
+/* Deprecated macros and functions */
+
+#define ARGS_REQ(n)         MRB_ARGS_REQ(n)
+#define ARGS_OPT(n)         MRB_ARGS_OPT(n)
+#define ARGS_REST()         MRB_ARGS_REST()
+#define ARGS_POST(n)        MRB_ARGS_POST()
+#define ARGS_KEY(n1,n2)     MRB_ARGS_KEY(n1,n2)
+#define ARGS_BLOCK()        MRB_ARGS_BLOCK()
+#define ARGS_ANY()          MRB_ARGS_ANY()
+#define ARGS_NONE()         MRB_ARGS_NONE()
-- 
cgit v1.2.3


From e88e7dc8db4ff129de6698727fd87904b67ed0e0 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Wed, 24 Jun 2015 10:05:05 +0900
Subject: remove deprecated.h

---
 include/mruby.h            |  2 --
 include/mruby/deprecated.h | 10 ----------
 2 files changed, 12 deletions(-)
 delete mode 100644 include/mruby/deprecated.h

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 69bb21704..1b792ce90 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -452,8 +452,6 @@ MRB_API void mrb_show_copyright(mrb_state *mrb);
 
 MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
 
-#include "mruby/deprecated.h"
-
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/deprecated.h b/include/mruby/deprecated.h
deleted file mode 100644
index ac1c81b7e..000000000
--- a/include/mruby/deprecated.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/* Deprecated macros and functions */
-
-#define ARGS_REQ(n)         MRB_ARGS_REQ(n)
-#define ARGS_OPT(n)         MRB_ARGS_OPT(n)
-#define ARGS_REST()         MRB_ARGS_REST()
-#define ARGS_POST(n)        MRB_ARGS_POST()
-#define ARGS_KEY(n1,n2)     MRB_ARGS_KEY(n1,n2)
-#define ARGS_BLOCK()        MRB_ARGS_BLOCK()
-#define ARGS_ANY()          MRB_ARGS_ANY()
-#define ARGS_NONE()         MRB_ARGS_NONE()
-- 
cgit v1.2.3


From 25885072858582d3d2f985b405a8e84d58f716e8 Mon Sep 17 00:00:00 2001
From: Franck Verrot <franck@verrot.fr>
Date: Wed, 24 Jun 2015 13:07:07 +0200
Subject: Remove unnecessary backticks.

Dr Markus Kuhn published in 1999 an article [1] explaining in details
why we shouldn't use the ASCII grave accent (0x60) as a left quotation.

Backticks have been used most notably to produce nice-looking LaTeX
documents but it doesn't seem to be an issue on modern platforms and
for the oldest ones, there are workarounds as mentioned by Dr Kuhn.

[1]: https://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html
---
 include/mruby/compile.h               |  4 +-
 include/mruby/opcode.h                |  2 +-
 mrbgems/mruby-compiler/core/parse.y   | 14 +++---
 mrbgems/mruby-hash-ext/mrblib/hash.rb |  2 +-
 mrbgems/mruby-sprintf/src/sprintf.c   | 80 +++++++++++++++++------------------
 mrbgems/mruby-struct/src/struct.c     |  8 ++--
 mrblib/array.rb                       |  2 +-
 src/class.c                           |  8 ++--
 src/numeric.c                         |  4 +-
 src/object.c                          |  2 +-
 src/string.c                          |  6 +--
 src/variable.c                        |  2 +-
 12 files changed, 67 insertions(+), 67 deletions(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index e20473298..1fb81782d 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -55,8 +55,8 @@ enum mrb_lex_state_enum {
   EXPR_CMDARG,                /* newline significant, +/- is an operator. */
   EXPR_MID,                   /* newline significant, +/- is an operator. */
   EXPR_FNAME,                 /* ignore newline, no reserved words. */
-  EXPR_DOT,                   /* right after `.' or `::', no reserved words. */
-  EXPR_CLASS,                 /* immediate after `class', no here document. */
+  EXPR_DOT,                   /* right after '.' or '::', no reserved words. */
+  EXPR_CLASS,                 /* immediate after 'class', no here document. */
   EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
   EXPR_MAX_STATE
 };
diff --git a/include/mruby/opcode.h b/include/mruby/opcode.h
index 4774e78c6..9dfa7f75d 100644
--- a/include/mruby/opcode.h
+++ b/include/mruby/opcode.h
@@ -8,7 +8,7 @@
 #define MRUBY_OPCODE_H
 
 #define MAXARG_Bx        (0xffff)
-#define MAXARG_sBx       (MAXARG_Bx>>1)         /* `sBx' is signed */
+#define MAXARG_sBx       (MAXARG_Bx>>1)         /* 'sBx' is signed */
 
 /* instructions: packed 32 bit      */
 /* -------------------------------  */
diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y
index 5b17649a9..f6a43d32b 100644
--- a/mrbgems/mruby-compiler/core/parse.y
+++ b/mrbgems/mruby-compiler/core/parse.y
@@ -4204,7 +4204,7 @@ parser_yylex(parser_state *p)
       }
       pushback(p, c);
       if (IS_SPCARG(c)) {
-        yywarning(p, "`*' interpreted as argument prefix");
+        yywarning(p, "'*' interpreted as argument prefix");
         c = tSTAR;
       }
       else if (IS_BEG()) {
@@ -4455,7 +4455,7 @@ parser_yylex(parser_state *p)
     }
     pushback(p, c);
     if (IS_SPCARG(c)) {
-      yywarning(p, "`&' interpreted as argument prefix");
+      yywarning(p, "'&' interpreted as argument prefix");
       c = tAMPER;
     }
     else if (IS_BEG()) {
@@ -4761,7 +4761,7 @@ parser_yylex(parser_state *p)
         nondigit = c;
         break;
 
-      case '_':       /* `_' in number just ignored */
+      case '_':       /* '_' in number just ignored */
         if (nondigit) goto decode_num;
         nondigit = c;
         break;
@@ -4776,7 +4776,7 @@ parser_yylex(parser_state *p)
     pushback(p, c);
     if (nondigit) {
       trailing_uc:
-      yyerror_i(p, "trailing `%c' in number", nondigit);
+      yyerror_i(p, "trailing '%c' in number", nondigit);
     }
     tokfix(p);
     if (is_float) {
@@ -5157,10 +5157,10 @@ parser_yylex(parser_state *p)
       }
       else if (isdigit(c)) {
         if (p->bidx == 1) {
-          yyerror_i(p, "`@%c' is not allowed as an instance variable name", c);
+          yyerror_i(p, "'@%c' is not allowed as an instance variable name", c);
         }
         else {
-          yyerror_i(p, "`@@%c' is not allowed as a class variable name", c);
+          yyerror_i(p, "'@@%c' is not allowed as a class variable name", c);
         }
         return 0;
       }
@@ -5176,7 +5176,7 @@ parser_yylex(parser_state *p)
 
     default:
       if (!identchar(c)) {
-        yyerror_i(p,  "Invalid char `\\x%02X' in expression", c);
+        yyerror_i(p,  "Invalid char '\\x%02X' in expression", c);
         goto retry;
       }
 
diff --git a/mrbgems/mruby-hash-ext/mrblib/hash.rb b/mrbgems/mruby-hash-ext/mrblib/hash.rb
index ea5e6bc1b..c970b9d02 100644
--- a/mrbgems/mruby-hash-ext/mrblib/hash.rb
+++ b/mrbgems/mruby-hash-ext/mrblib/hash.rb
@@ -119,7 +119,7 @@ class Hash
   #
   #  <em>produces:</em>
   #
-  #     prog.rb:2:in `fetch': key not found (KeyError)
+  #     prog.rb:2:in 'fetch': key not found (KeyError)
   #      from prog.rb:2
   #
 
diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c
index d88e242c6..de216f69f 100644
--- a/mrbgems/mruby-sprintf/src/sprintf.c
+++ b/mrbgems/mruby-sprintf/src/sprintf.c
@@ -234,20 +234,20 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *      ------+--------------------------------------------------------------
  *        b   | Convert argument as a binary number.
  *            | Negative numbers will be displayed as a two's complement
- *            | prefixed with `..1'.
- *        B   | Equivalent to `b', but uses an uppercase 0B for prefix
+ *            | prefixed with '..1'.
+ *        B   | Equivalent to 'b', but uses an uppercase 0B for prefix
  *            | in the alternative format by #.
  *        d   | Convert argument as a decimal number.
- *        i   | Identical to `d'.
+ *        i   | Identical to 'd'.
  *        o   | Convert argument as an octal number.
  *            | Negative numbers will be displayed as a two's complement
- *            | prefixed with `..7'.
- *        u   | Identical to `d'.
+ *            | prefixed with '..7'.
+ *        u   | Identical to 'd'.
  *        x   | Convert argument as a hexadecimal number.
  *            | Negative numbers will be displayed as a two's complement
- *            | prefixed with `..f' (representing an infinite string of
+ *            | prefixed with '..f' (representing an infinite string of
  *            | leading 'ff's).
- *        X   | Equivalent to `x', but uses uppercase letters.
+ *        X   | Equivalent to 'x', but uses uppercase letters.
  *
  *      Field |  Float Format
  *      ------+--------------------------------------------------------------
@@ -255,7 +255,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *            | with one digit before the decimal point as [-]d.dddddde[+-]dd.
  *            | The precision specifies the number of digits after the decimal
  *            | point (defaulting to six).
- *        E   | Equivalent to `e', but uses an uppercase E to indicate
+ *        E   | Equivalent to 'e', but uses an uppercase E to indicate
  *            | the exponent.
  *        f   | Convert floating point argument as [-]ddd.dddddd,
  *            | where the precision specifies the number of digits after
@@ -264,11 +264,11 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *            | if the exponent is less than -4 or greater than or
  *            | equal to the precision, or in dd.dddd form otherwise.
  *            | The precision specifies the number of significant digits.
- *        G   | Equivalent to `g', but use an uppercase `E' in exponent form.
+ *        G   | Equivalent to 'g', but use an uppercase 'E' in exponent form.
  *        a   | Convert floating point argument as [-]0xh.hhhhp[+-]dd,
  *            | which is consisted from optional sign, "0x", fraction part
  *            | as hexadecimal, "p", and exponential part as decimal.
- *        A   | Equivalent to `a', but use uppercase `X' and `P'.
+ *        A   | Equivalent to 'a', but use uppercase 'X' and 'P'.
  *
  *      Field |  Other Format
  *      ------+--------------------------------------------------------------
@@ -287,7 +287,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *    ---------+---------------+-----------------------------------------
  *    space    | bBdiouxX      | Leave a space at the start of
  *             | aAeEfgG       | non-negative numbers.
- *             | (numeric fmt) | For `o', `x', `X', `b' and `B', use
+ *             | (numeric fmt) | For 'o', 'x', 'X', 'b' and 'B', use
  *             |               | a minus sign with absolute value for
  *             |               | negative values.
  *    ---------+---------------+-----------------------------------------
@@ -297,27 +297,27 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *             |               | sprintf string.
  *    ---------+---------------+-----------------------------------------
  *     #       | bBoxX         | Use an alternative format.
- *             | aAeEfgG       | For the conversions `o', increase the precision
- *             |               | until the first digit will be `0' if
+ *             | aAeEfgG       | For the conversions 'o', increase the precision
+ *             |               | until the first digit will be '0' if
  *             |               | it is not formatted as complements.
- *             |               | For the conversions `x', `X', `b' and `B'
- *             |               | on non-zero, prefix the result with ``0x'',
- *             |               | ``0X'', ``0b'' and ``0B'', respectively.
- *             |               | For `a', `A', `e', `E', `f', `g', and 'G',
+ *             |               | For the conversions 'x', 'X', 'b' and 'B'
+ *             |               | on non-zero, prefix the result with "0x",
+ *             |               | "0X", "0b" and "0B", respectively.
+ *             |               | For 'a', 'A', 'e', 'E', 'f', 'g', and 'G',
  *             |               | force a decimal point to be added,
  *             |               | even if no digits follow.
- *             |               | For `g' and 'G', do not remove trailing zeros.
+ *             |               | For 'g' and 'G', do not remove trailing zeros.
  *    ---------+---------------+-----------------------------------------
  *    +        | bBdiouxX      | Add a leading plus sign to non-negative
  *             | aAeEfgG       | numbers.
- *             | (numeric fmt) | For `o', `x', `X', `b' and `B', use
+ *             | (numeric fmt) | For 'o', 'x', 'X', 'b' and 'B', use
  *             |               | a minus sign with absolute value for
  *             |               | negative values.
  *    ---------+---------------+-----------------------------------------
  *    -        | all           | Left-justify the result of this conversion.
  *    ---------+---------------+-----------------------------------------
  *    0 (zero) | bBdiouxX      | Pad with zeros, not spaces.
- *             | aAeEfgG       | For `o', `x', `X', `b' and `B', radix-1
+ *             | aAeEfgG       | For 'o', 'x', 'X', 'b' and 'B', radix-1
  *             | (numeric fmt) | is used for negative numbers formatted as
  *             |               | complements.
  *    ---------+---------------+-----------------------------------------
@@ -328,21 +328,21 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *
  *  Examples of flags:
  *
- *   # `+' and space flag specifies the sign of non-negative numbers.
+ *   # '+' and space flag specifies the sign of non-negative numbers.
  *   sprintf("%d", 123)  #=> "123"
  *   sprintf("%+d", 123) #=> "+123"
  *   sprintf("% d", 123) #=> " 123"
  *
- *   # `#' flag for `o' increases number of digits to show `0'.
- *   # `+' and space flag changes format of negative numbers.
+ *   # '#' flag for 'o' increases number of digits to show '0'.
+ *   # '+' and space flag changes format of negative numbers.
  *   sprintf("%o", 123)   #=> "173"
  *   sprintf("%#o", 123)  #=> "0173"
  *   sprintf("%+o", -123) #=> "-173"
  *   sprintf("%o", -123)  #=> "..7605"
  *   sprintf("%#o", -123) #=> "..7605"
  *
- *   # `#' flag for `x' add a prefix `0x' for non-zero numbers.
- *   # `+' and space flag disables complements for negative numbers.
+ *   # '#' flag for 'x' add a prefix '0x' for non-zero numbers.
+ *   # '+' and space flag disables complements for negative numbers.
  *   sprintf("%x", 123)   #=> "7b"
  *   sprintf("%#x", 123)  #=> "0x7b"
  *   sprintf("%+x", -123) #=> "-7b"
@@ -350,12 +350,12 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *   sprintf("%#x", -123) #=> "0x..f85"
  *   sprintf("%#x", 0)    #=> "0"
  *
- *   # `#' for `X' uses the prefix `0X'.
+ *   # '#' for 'X' uses the prefix '0X'.
  *   sprintf("%X", 123)  #=> "7B"
  *   sprintf("%#X", 123) #=> "0X7B"
  *
- *   # `#' flag for `b' add a prefix `0b' for non-zero numbers.
- *   # `+' and space flag disables complements for negative numbers.
+ *   # '#' flag for 'b' add a prefix '0b' for non-zero numbers.
+ *   # '+' and space flag disables complements for negative numbers.
  *   sprintf("%b", 123)   #=> "1111011"
  *   sprintf("%#b", 123)  #=> "0b1111011"
  *   sprintf("%+b", -123) #=> "-1111011"
@@ -363,19 +363,19 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *   sprintf("%#b", -123) #=> "0b..10000101"
  *   sprintf("%#b", 0)    #=> "0"
  *
- *   # `#' for `B' uses the prefix `0B'.
+ *   # '#' for 'B' uses the prefix '0B'.
  *   sprintf("%B", 123)  #=> "1111011"
  *   sprintf("%#B", 123) #=> "0B1111011"
  *
- *   # `#' for `e' forces to show the decimal point.
+ *   # '#' for 'e' forces to show the decimal point.
  *   sprintf("%.0e", 1)  #=> "1e+00"
  *   sprintf("%#.0e", 1) #=> "1.e+00"
  *
- *   # `#' for `f' forces to show the decimal point.
+ *   # '#' for 'f' forces to show the decimal point.
  *   sprintf("%.0f", 1234)  #=> "1234"
  *   sprintf("%#.0f", 1234) #=> "1234."
  *
- *   # `#' for `g' forces to show the decimal point.
+ *   # '#' for 'g' forces to show the decimal point.
  *   # It also disables stripping lowest zeros.
  *   sprintf("%g", 123.4)   #=> "123.4"
  *   sprintf("%#g", 123.4)  #=> "123.400"
@@ -409,7 +409,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *
  *  Examples of precisions:
  *
- *   # precision for `d', 'o', 'x' and 'b' is
+ *   # precision for 'd', 'o', 'x' and 'b' is
  *   # minimum number of digits               <------>
  *   sprintf("%20.8d", 123)  #=> "            00000123"
  *   sprintf("%20.8o", 123)  #=> "            00000173"
@@ -420,8 +420,8 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *   sprintf("%20.8x", -123) #=> "            ..ffff85"
  *   sprintf("%20.8b", -11)  #=> "            ..110101"
  *
- *   # "0x" and "0b" for `#x' and `#b' is not counted for
- *   # precision but "0" for `#o' is counted.  <------>
+ *   # "0x" and "0b" for '#x' and '#b' is not counted for
+ *   # precision but "0" for '#o' is counted.  <------>
  *   sprintf("%#20.8d", 123)  #=> "            00000123"
  *   sprintf("%#20.8o", 123)  #=> "            00000173"
  *   sprintf("%#20.8x", 123)  #=> "          0x0000007b"
@@ -431,22 +431,22 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
  *   sprintf("%#20.8x", -123) #=> "          0x..ffff85"
  *   sprintf("%#20.8b", -11)  #=> "          0b..110101"
  *
- *   # precision for `e' is number of
+ *   # precision for 'e' is number of
  *   # digits after the decimal point           <------>
  *   sprintf("%20.8e", 1234.56789) #=> "      1.23456789e+03"
  *
- *   # precision for `f' is number of
+ *   # precision for 'f' is number of
  *   # digits after the decimal point               <------>
  *   sprintf("%20.8f", 1234.56789) #=> "       1234.56789000"
  *
- *   # precision for `g' is number of
+ *   # precision for 'g' is number of
  *   # significant digits                          <------->
  *   sprintf("%20.8g", 1234.56789) #=> "           1234.5679"
  *
  *   #                                         <------->
  *   sprintf("%20.8g", 123456789)  #=> "       1.2345679e+08"
  *
- *   # precision for `s' is
+ *   # precision for 's' is
  *   # maximum number of characters                    <------>
  *   sprintf("%20.8s", "string test") #=> "            string t"
  *
@@ -539,7 +539,7 @@ mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt)
     if (t >= end)
       goto sprint_exit; /* end of fmt string */
 
-    p = t + 1;    /* skip `%' */
+    p = t + 1;    /* skip '%' */
 
     width = prec = -1;
     nextvalue = mrb_undef_value();
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index d2187a2d1..ce8d8d832 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -114,7 +114,7 @@ mrb_struct_getmember(mrb_state *mrb, mrb_value obj, mrb_sym id)
       return ptr[i];
     }
   }
-  mrb_raisef(mrb, E_INDEX_ERROR, "`%S' is not a struct member", mrb_sym2str(mrb, id));
+  mrb_raisef(mrb, E_INDEX_ERROR, "'%S' is not a struct member", mrb_sym2str(mrb, id));
   return mrb_nil_value();       /* not reached */
 }
 
@@ -193,7 +193,7 @@ mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val)
       return ptr[i] = val;
     }
   }
-  mrb_raisef(mrb, E_INDEX_ERROR, "`%S' is not a struct member", mrb_sym2str(mrb, mid));
+  mrb_raisef(mrb, E_INDEX_ERROR, "'%S' is not a struct member", mrb_sym2str(mrb, mid));
   return mrb_nil_value();       /* not reached */
 }
 
@@ -749,8 +749,8 @@ mrb_struct_values_at(mrb_state *mrb, mrb_value self)
  *  The <code>Struct</code> class is a generator of specific classes,
  *  each one of which is defined to hold a set of variables and their
  *  accessors. In these examples, we'll call the generated class
- *  ``<i>Customer</i>Class,'' and we'll show an example instance of that
- *  class as ``<i>Customer</i>Inst.''
+ *  "<i>Customer</i>Class," and we'll show an example instance of that
+ *  class as "<i>Customer</i>Inst."
  *
  *  In the descriptions that follow, the parameter <i>symbol</i> refers
  *  to a symbol, which is either a quoted string or a
diff --git a/mrblib/array.rb b/mrblib/array.rb
index 83a42c62d..933f822db 100644
--- a/mrblib/array.rb
+++ b/mrblib/array.rb
@@ -146,7 +146,7 @@ class Array
   #  equal, then that inequality is the return value. If all the
   #  values found are equal, then the return is based on a
   #  comparison of the array lengths.  Thus, two arrays are
-  #  ``equal'' according to <code>Array#<=></code> if and only if they have
+  #  "equal" according to <code>Array#<=></code> if and only if they have
   #  the same length and the value of each element is equal to the
   #  value of the corresponding element in the other array.
   #
diff --git a/src/class.c b/src/class.c
index 05b549b3e..e9cbc592d 100644
--- a/src/class.c
+++ b/src/class.c
@@ -212,7 +212,7 @@ MRB_API struct RClass*
 mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super)
 {
   if (!super) {
-    mrb_warn(mrb, "no super class for `%S', Object assumed", mrb_sym2str(mrb, name));
+    mrb_warn(mrb, "no super class for '%S', Object assumed", mrb_sym2str(mrb, name));
   }
   return define_class(mrb, name, super, mrb->object_class);
 }
@@ -311,7 +311,7 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s
 
 #if 0
   if (!super) {
-    mrb_warn(mrb, "no super class for `%S::%S', Object assumed",
+    mrb_warn(mrb, "no super class for '%S::%S', Object assumed",
              mrb_obj_value(outer), mrb_sym2str(mrb, id));
   }
 #endif
@@ -1658,7 +1658,7 @@ check_cv_name_str(mrb_state *mrb, mrb_value str)
   mrb_int len = RSTRING_LEN(str);
 
   if (len < 3 || !(s[0] == '@' && s[1] == '@')) {
-    mrb_name_error(mrb, mrb_intern_str(mrb, str), "`%S' is not allowed as a class variable name", str);
+    mrb_name_error(mrb, mrb_intern_str(mrb, str), "'%S' is not allowed as a class variable name", str);
   }
 }
 
@@ -1846,7 +1846,7 @@ remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
     }
   }
 
-  mrb_name_error(mrb, mid, "method `%S' not defined in %S",
+  mrb_name_error(mrb, mid, "method '%S' not defined in %S",
     mrb_sym2str(mrb, mid), mod);
 }
 
diff --git a/src/numeric.c b/src/numeric.c
index 8b6ec4c88..013273232 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -110,8 +110,8 @@ num_div(mrb_state *mrb, mrb_value x)
  *
  *  Returns a string containing a representation of self. As well as a
  *  fixed or exponential form of the number, the call may return
- *  ``<code>NaN</code>'', ``<code>Infinity</code>'', and
- *  ``<code>-Infinity</code>''.
+ *  "<code>NaN</code>", "<code>Infinity</code>", and
+ *  "<code>-Infinity</code>".
  */
 
 static mrb_value
diff --git a/src/object.c b/src/object.c
index c5fb74575..f8f41bfe8 100644
--- a/src/object.c
+++ b/src/object.c
@@ -428,7 +428,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
  *  Returns a string representing <i>obj</i>. The default
  *  <code>to_s</code> prints the object's class and an encoding of the
  *  object id. As a special case, the top-level object that is the
- *  initial execution context of Ruby programs returns ``main.''
+ *  initial execution context of Ruby programs returns "main."
  */
 
 MRB_API mrb_value
diff --git a/src/string.c b/src/string.c
index 22a289ade..8df79d4c0 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1100,7 +1100,7 @@ mrb_str_downcase_bang(mrb_state *mrb, mrb_value str)
  *
  *  Returns a copy of <i>str</i> with all uppercase letters replaced with their
  *  lowercase counterparts. The operation is locale insensitive---only
- *  characters ``A'' to ``Z'' are affected.
+ *  characters 'A' to 'Z' are affected.
  *
  *     "hEllO".downcase   #=> "hello"
  */
@@ -1703,7 +1703,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
  *
  *  If <i>pattern</i> is omitted, the value of <code>$;</code> is used.  If
  *  <code>$;</code> is <code>nil</code> (which is the default), <i>str</i> is
- *  split on whitespace as if ` ' were specified.
+ *  split on whitespace as if ' ' were specified.
  *
  *  If the <i>limit</i> parameter is omitted, trailing null fields are
  *  suppressed. If <i>limit</i> is a positive number, at most that number of
@@ -2211,7 +2211,7 @@ mrb_str_upcase_bang(mrb_state *mrb, mrb_value str)
  *
  *  Returns a copy of <i>str</i> with all lowercase letters replaced with their
  *  uppercase counterparts. The operation is locale insensitive---only
- *  characters ``a'' to ``z'' are affected.
+ *  characters 'a' to 'z' are affected.
  *
  *     "hEllO".upcase   #=> "HELLO"
  */
diff --git a/src/variable.c b/src/variable.c
index 3e451df05..1b2ad56a7 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -563,7 +563,7 @@ MRB_API void
 mrb_iv_check(mrb_state *mrb, mrb_sym iv_name)
 {
   if (!mrb_iv_p(mrb, iv_name)) {
-    mrb_name_error(mrb, iv_name, "`%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name));
+    mrb_name_error(mrb, iv_name, "'%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name));
   }
 }
 
-- 
cgit v1.2.3


From 9c311ddc938ad2cc88e4119374e47cd496e15a94 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Mon, 13 Jul 2015 07:08:01 +0900
Subject: refactor mrb_bob_missing to share raising NoMethodError code; fix
 #2878

Note: arguments of mrb_no_method_error() has changed. You need to replace
3rd and 4th argument (say n, argv) to mrb_ary_new_from_values(mrb, n, argv).
---
 include/mruby/error.h |  2 +-
 src/class.c           | 45 ++++++++++++++++++++++++++-------------------
 src/error.c           |  5 ++---
 src/vm.c              | 13 +++++++++++--
 4 files changed, 40 insertions(+), 25 deletions(-)

(limited to 'include')

diff --git a/include/mruby/error.h b/include/mruby/error.h
index 52f6772bd..282be0a24 100644
--- a/include/mruby/error.h
+++ b/include/mruby/error.h
@@ -24,7 +24,7 @@ MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value st
 MRB_API mrb_value mrb_make_exception(mrb_state *mrb, int argc, const mrb_value *argv);
 MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
 MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
-MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_int argc, const mrb_value *argv, const char *fmt, ...);
+MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
 
 /* declaration for fail method */
 MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
diff --git a/src/class.c b/src/class.c
index e9cbc592d..0f9a77b2a 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1262,6 +1262,31 @@ mrb_bob_not(mrb_state *mrb, mrb_value cv)
   return mrb_bool_value(!mrb_test(cv));
 }
 
+void
+mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args)
+{
+  mrb_sym inspect;
+  mrb_value repr;
+
+  inspect = mrb_intern_lit(mrb, "inspect");
+  if (mrb->c->ci > mrb->c->cibase && mrb->c->ci[-1].mid == inspect) {
+    /* method missing in inspect; avoid recursion */
+    repr = mrb_any_to_s(mrb, self);
+  }
+  else if (mrb_respond_to(mrb, self, inspect) && mrb->c->ci - mrb->c->cibase < 64) {
+    repr = mrb_funcall_argv(mrb, self, inspect, 0, 0);
+    if (mrb_string_p(repr) && RSTRING_LEN(repr) > 64) {
+      repr = mrb_any_to_s(mrb, self);
+    }
+  }
+  else {
+    repr = mrb_any_to_s(mrb, self);
+  }
+
+  mrb_no_method_error(mrb, name, args, "undefined method '%S' for %S",
+                      mrb_sym2str(mrb, name), repr);
+}
+
 /* 15.3.1.3.30 */
 /*
  *  call-seq:
@@ -1301,27 +1326,9 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
   mrb_sym name;
   mrb_value *a;
   mrb_int alen;
-  mrb_sym inspect;
-  mrb_value repr;
 
   mrb_get_args(mrb, "n*", &name, &a, &alen);
-
-  inspect = mrb_intern_lit(mrb, "inspect");
-  if (mrb->c->ci > mrb->c->cibase && mrb->c->ci[-1].mid == inspect) {
-    /* method missing in inspect; avoid recursion */
-    repr = mrb_any_to_s(mrb, mod);
-  }
-  else if (mrb_respond_to(mrb, mod, inspect) && mrb->c->ci - mrb->c->cibase < 64) {
-    repr = mrb_funcall_argv(mrb, mod, inspect, 0, 0);
-    if (mrb_string_p(repr) && RSTRING_LEN(repr) > 64) {
-      repr = mrb_any_to_s(mrb, mod);
-    }
-  }
-  else {
-    repr = mrb_any_to_s(mrb, mod);
-  }
-
-  mrb_no_method_error(mrb, name, alen, a, "undefined method '%S' for %S", mrb_sym2str(mrb, name), repr);
+  mrb_method_missing(mrb, name, mod, mrb_ary_new_from_values(mrb, alen, a));
   /* not reached */
   return mrb_nil_value();
 }
diff --git a/src/error.c b/src/error.c
index a800f77f9..20c63bd43 100644
--- a/src/error.c
+++ b/src/error.c
@@ -424,15 +424,14 @@ mrb_sys_fail(mrb_state *mrb, const char *mesg)
 }
 
 MRB_API mrb_noreturn void
-mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_int argc, const mrb_value *argv, char const* fmt, ...)
+mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, char const* fmt, ...)
 {
   mrb_value exc;
   va_list ap;
 
   va_start(ap, fmt);
   exc = mrb_funcall(mrb, mrb_obj_value(E_NOMETHOD_ERROR), "new", 3,
-                    mrb_vformat(mrb, fmt, ap), mrb_symbol_value(id),
-                    mrb_ary_new_from_values(mrb, argc, argv));
+                    mrb_vformat(mrb, fmt, ap), mrb_symbol_value(id), args);
   va_end(ap);
   mrb_exc_raise(mrb, exc);
 }
diff --git a/src/vm.c b/src/vm.c
index 15a3926e3..22ea177e0 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -723,6 +723,8 @@ argnum_error(mrb_state *mrb, mrb_int num)
 
 #define CALL_MAXARGS 127
 
+void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args);
+
 MRB_API mrb_value
 mrb_context_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
 {
@@ -1078,8 +1080,15 @@ RETRY_TRY_BLOCK:
 
         m = mrb_method_search_vm(mrb, &c, missing);
         if (!m) {
-          mrb_no_method_error(mrb, mid, n, regs+a+1,
-                              "undefined method '%S' for %S", mrb_sym2str(mrb, mid), recv);
+          mrb_value args;
+
+          if (n == CALL_MAXARGS) {
+            args = regs[a+1];
+          }
+          else {
+            args = mrb_ary_new_from_values(mrb, n, regs+a+1);
+          }
+          mrb_method_missing(mrb, mid, recv, args);
         }
         mid = missing;
         if (n == CALL_MAXARGS) {
-- 
cgit v1.2.3


From f962890a928b566c0f5ca7fdff5ef4ce19207e65 Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Thu, 9 Jul 2015 23:46:54 +0200
Subject: Implement Module#prepend.

---
 include/mruby/class.h |  1 +
 src/class.c           | 67 +++++++++++++++++++++++++++++++++++++++++++++++++--
 test/t/module.rb      | 33 +++++++++++++++++++++++++
 3 files changed, 99 insertions(+), 2 deletions(-)

(limited to 'include')

diff --git a/include/mruby/class.h b/include/mruby/class.h
index 9d5260a24..60310ae9d 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -16,6 +16,7 @@ struct RClass {
   struct iv_tbl *iv;
   struct kh_mt *mt;
   struct RClass *super;
+  struct RClass *origin;
 };
 
 #define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
diff --git a/src/class.c b/src/class.c
index 8a9fdaca6..3b1ea2321 100644
--- a/src/class.c
+++ b/src/class.c
@@ -194,6 +194,7 @@ define_class(mrb_state *mrb, mrb_sym name, struct RClass *super, struct RClass *
 
   if (mrb_const_defined_at(mrb, mrb_obj_value(outer), name)) {
     c = class_from_sym(mrb, outer, name);
+    c = c->origin;
     if (super && mrb_class_real(c->super) != super) {
       mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for Class %S (%S not %S)",
                  mrb_sym2str(mrb, name),
@@ -763,12 +764,13 @@ boot_defclass(mrb_state *mrb, struct RClass *super)
   else {
     c->super = mrb->object_class;
   }
+  c->origin = c;
   c->mt = kh_init(mt, mrb);
   return c;
 }
 
-MRB_API void
-mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
+MRB_API inline void
+include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *m, int search_super)
 {
   struct RClass *ins_pos;
 
@@ -782,6 +784,7 @@ mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
     }
     while (p) {
       if (c != p && p->tt == MRB_TT_CLASS) {
+        if (!search_super) break;
         superclass_seen = 1;
       }
       else if (p->mt == m->mt) {
@@ -810,6 +813,63 @@ mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
   }
 }
 
+MRB_API void
+mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
+{
+  include_module_at(mrb, c, m, FALSE);
+}
+
+MRB_API void
+mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
+{
+  struct RClass *origin;
+  int changed = 0;
+
+  origin = c->origin;
+  if (origin == c) {
+    origin = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, c);
+    //OBJ_WB_UNPROTECT(origin); /* TODO: conservative shading. Need more survey. */
+    origin->super = c->super;
+    c->super = origin;
+    c->origin = origin;
+    origin->mt = c->mt;
+    c->mt = kh_init(mt, mrb);
+  }
+  include_module_at(mrb, c, m, FALSE); // changed =
+  if (changed) {
+    //rb_vm_check_redefinition_by_prepend(klass);
+  }
+}
+
+static mrb_value
+mrb_mod_prepend_features(mrb_state *mrb, mrb_value mod)
+{
+  mrb_value klass;
+
+  mrb_check_type(mrb, mod, MRB_TT_MODULE);
+  mrb_get_args(mrb, "C", &klass);
+  mrb_prepend_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod));
+  return mod;
+}
+
+static mrb_value
+mrb_mod_prepend(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value *argv;
+  mrb_int argc, i;
+
+  mrb_get_args(mrb, "*", &argv, &argc);
+  for (i=0; i<argc; i++) {
+    mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
+  }
+  while (argc--) {
+    mrb_funcall(mrb, argv[argc], "prepend_features", 1, klass);
+    mrb_funcall(mrb, argv[argc], "prepended", 1, klass);
+  }
+
+  return klass;
+}
+
 static mrb_value
 mrb_mod_append_features(mrb_state *mrb, mrb_value mod)
 {
@@ -2090,6 +2150,9 @@ mrb_init_class(mrb_state *mrb)
   mrb_define_method(mrb, mod, "class_variable_set",      mrb_mod_cvar_set,         MRB_ARGS_REQ(2)); /* 15.2.2.4.18 */
   mrb_define_method(mrb, mod, "extend_object",           mrb_mod_extend_object,    MRB_ARGS_REQ(1)); /* 15.2.2.4.25 */
   mrb_define_method(mrb, mod, "extended",                mrb_bob_init,             MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */
+  mrb_define_method(mrb, mod, "prepend",                 mrb_mod_prepend,          MRB_ARGS_ANY());
+  mrb_define_method(mrb, mod, "prepended",               mrb_bob_init,             MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, mod, "prepend_features",        mrb_mod_prepend_features, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, mod, "include",                 mrb_mod_include,          MRB_ARGS_ANY());  /* 15.2.2.4.27 */
   mrb_define_method(mrb, mod, "include?",                mrb_mod_include_p,        MRB_ARGS_REQ(1)); /* 15.2.2.4.28 */
   mrb_define_method(mrb, mod, "append_features",         mrb_mod_append_features,  MRB_ARGS_REQ(1)); /* 15.2.2.4.10 */
diff --git a/test/t/module.rb b/test/t/module.rb
index ecb969475..9faaf6e2c 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -474,6 +474,39 @@ end
 
 # Not ISO specified
 
+assert('Module#prepend') do
+  module M0
+    def m1; [:M0] end
+  end
+  module M1
+    def m1; [:M1, super, :M1] end
+  end
+  module M2
+    def m1; [:M2, super, :M2] end
+  end
+  M3 = Module.new do
+    def m1; [:M3, super, :M3] end
+  end
+  module M4
+    def m1; [:M4, super, :M4] end
+  end
+
+  class C0
+    include M0
+    prepend M1
+    def m1; [:C0, super, :C0] end
+  end
+  class C1 < C0
+    prepend M2, M3
+    include M4
+    def m1; [:C1, super, :C1] end
+  end
+
+  obj = C1.new
+  expected = [:M2,[:M3,[:C1,[:M4,[:M1,[:C0,[:M0],:C0],:M1],:M4],:C1],:M3],:M2]
+  assert_equal(expected, obj.m1)
+end
+
 assert('Module#to_s') do
   module Test4to_sModules
   end
-- 
cgit v1.2.3


From eb172c28d79b4fdf978e78fc7e929caa855dd29b Mon Sep 17 00:00:00 2001
From: Corey Powell <mistdragon100@gmail.com>
Date: Tue, 14 Jul 2015 09:44:04 -0500
Subject: Applied gc patch to fix ORIGIN ICLASS method table leak

Based on the gc patch by ko1

https://github.com/ruby/ruby/commit/5922c954614e5947a548780bb3b894626affe6dd
---
 include/mruby/class.h  |  7 +++++--
 include/mruby/object.h |  2 ++
 src/class.c            |  1 +
 src/gc.c               | 12 ++++++++++--
 4 files changed, 18 insertions(+), 4 deletions(-)

(limited to 'include')

diff --git a/include/mruby/class.h b/include/mruby/class.h
index 60310ae9d..9f2c32bb0 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -49,8 +49,11 @@ mrb_class(mrb_state *mrb, mrb_value v)
   }
 }
 
-#define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~0xff) | (char)tt)
-#define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & 0xff)
+// TODO: figure out where to put user flags
+#define MRB_FLAG_IS_ORIGIN (1 << 20)
+#define MRB_FLAG_IS_INSTANCE (0xFF)
+#define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~MRB_FLAG_IS_INSTANCE) | (char)tt)
+#define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & MRB_FLAG_IS_INSTANCE)
 
 MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
 MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
diff --git a/include/mruby/object.h b/include/mruby/object.h
index fe55620fe..6633a23e8 100644
--- a/include/mruby/object.h
+++ b/include/mruby/object.h
@@ -14,6 +14,8 @@
   struct RClass *c;\
   struct RBasic *gcnext
 
+#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & flag)
+
 /* white: 011, black: 100, gray: 000 */
 #define MRB_GC_GRAY 0
 #define MRB_GC_WHITE_A 1
diff --git a/src/class.c b/src/class.c
index 14d81495e..58742299b 100644
--- a/src/class.c
+++ b/src/class.c
@@ -856,6 +856,7 @@ mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
   origin = c->origin;
   if (origin == c) {
     origin = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, c);
+    origin->flags |= MRB_FLAG_IS_ORIGIN;
     origin->origin = origin;
     origin->super = c->super;
     c->super = origin;
diff --git a/src/gc.c b/src/gc.c
index 8bd8243f1..15e1bd423 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -498,7 +498,12 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj)
   mrb_gc_mark(mrb, (struct RBasic*)obj->c);
   switch (obj->tt) {
   case MRB_TT_ICLASS:
-    mrb_gc_mark(mrb, (struct RBasic*)((struct RClass*)obj)->super);
+    {
+      struct RClass *c = (struct RClass*)obj;
+      if (MRB_FLAG_TEST(c, MRB_FLAG_IS_ORIGIN))
+        mrb_gc_mark_mt(mrb, c);
+      mrb_gc_mark(mrb, (struct RBasic*)((struct RClass*)obj)->super);
+    }
     break;
 
   case MRB_TT_CLASS:
@@ -624,7 +629,10 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
     mrb_gc_free_mt(mrb, (struct RClass*)obj);
     mrb_gc_free_iv(mrb, (struct RObject*)obj);
     break;
-
+  case MRB_TT_ICLASS:
+    if (MRB_FLAG_TEST(obj, MRB_FLAG_IS_ORIGIN))
+      mrb_gc_free_mt(mrb, (struct RClass*)obj);
+    break;
   case MRB_TT_ENV:
     {
       struct REnv *e = (struct REnv*)obj;
-- 
cgit v1.2.3


From cdd72d9c3783749c979edf62522cf9636681538d Mon Sep 17 00:00:00 2001
From: take_cheeze <takechi101010@gmail.com>
Date: Mon, 22 Jun 2015 00:05:45 +0900
Subject: Implement `mrb_protect`, `mrb_ensure`, `mrb_rescue`,
 `mrb_rescue_exceptions`. (`mrb_rescue_exceptions` is mruby implementation of
 `rb_rescue2`.) Closes #2844, closes #2837.

---
 include/mruby/error.h                 |   8 +++
 mrbgems/mruby-error/mrbgem.rake       |  10 ++++
 mrbgems/mruby-error/src/exception.c   | 102 ++++++++++++++++++++++++++++++++++
 mrbgems/mruby-error/test/exception.c  |  57 +++++++++++++++++++
 mrbgems/mruby-error/test/exception.rb |  53 ++++++++++++++++++
 5 files changed, 230 insertions(+)
 create mode 100644 mrbgems/mruby-error/mrbgem.rake
 create mode 100644 mrbgems/mruby-error/src/exception.c
 create mode 100644 mrbgems/mruby-error/test/exception.c
 create mode 100644 mrbgems/mruby-error/test/exception.rb

(limited to 'include')

diff --git a/include/mruby/error.h b/include/mruby/error.h
index 282be0a24..3a985236a 100644
--- a/include/mruby/error.h
+++ b/include/mruby/error.h
@@ -29,6 +29,14 @@ MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_va
 /* declaration for fail method */
 MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
 
+MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
+MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                             mrb_func_t ensure, mrb_value e_data);
+MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                             mrb_func_t rescue, mrb_value r_data);
+MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                                        mrb_func_t rescue, mrb_value r_data, ...);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/mrbgems/mruby-error/mrbgem.rake b/mrbgems/mruby-error/mrbgem.rake
new file mode 100644
index 000000000..b8281b17e
--- /dev/null
+++ b/mrbgems/mruby-error/mrbgem.rake
@@ -0,0 +1,10 @@
+MRuby::Gem::Specification.new('mruby-error') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'extensional error handling'
+
+  if build.cxx_abi_enabled?
+    @objs << build.compile_as_cxx("#{spec.dir}/src/exception.c", "#{spec.build_dir}/src/exception.cxx")
+    @objs.delete_if { |v| v == objfile("#{spec.build_dir}/src/exception") }
+  end
+end
diff --git a/mrbgems/mruby-error/src/exception.c b/mrbgems/mruby-error/src/exception.c
new file mode 100644
index 000000000..abd03bc29
--- /dev/null
+++ b/mrbgems/mruby-error/src/exception.c
@@ -0,0 +1,102 @@
+#include <stdarg.h>
+#include "mruby.h"
+#include "mruby/throw.h"
+#include "mruby/error.h"
+
+MRB_API mrb_value
+mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state)
+{
+  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
+  struct mrb_jmpbuf c_jmp;
+  mrb_value result = mrb_nil_value();
+
+  if (state) { *state = FALSE; }
+
+  MRB_TRY(&c_jmp) {
+    mrb->jmp = &c_jmp;
+    result = body(mrb, data);
+    mrb->jmp = prev_jmp;
+  } MRB_CATCH(&c_jmp) {
+    mrb->jmp = prev_jmp;
+    mrb->exc = NULL;
+    if (state) { *state = TRUE; }
+  } MRB_END_EXC(&c_jmp);
+
+  mrb_gc_protect(mrb, result);
+  return result;
+}
+
+MRB_API mrb_value
+mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t ensure, mrb_value e_data)
+{
+  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
+  struct mrb_jmpbuf c_jmp;
+  mrb_value result;
+
+  MRB_TRY(&c_jmp) {
+    mrb->jmp = &c_jmp;
+    result = body(mrb, b_data);
+    mrb->jmp = prev_jmp;
+  } MRB_CATCH(&c_jmp) {
+    mrb->jmp = prev_jmp;
+    ensure(mrb, e_data);
+    MRB_THROW(mrb->jmp); /* rethrow catched exceptions */
+  } MRB_END_EXC(&c_jmp);
+
+  ensure(mrb, e_data);
+  mrb_gc_protect(mrb, result);
+  return result;
+}
+
+MRB_API mrb_value
+mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+           mrb_func_t rescue, mrb_value r_data)
+{
+  return mrb_rescue_exceptions(mrb, body, b_data, rescue, r_data, mrb->eStandardError_class, NULL);
+}
+
+MRB_API mrb_value
+mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t rescue, mrb_value r_data, ...)
+{
+  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
+  struct mrb_jmpbuf c_jmp;
+  mrb_value result;
+  va_list excs;
+  struct RClass *cls;
+  mrb_bool error_matched = FALSE;
+
+  MRB_TRY(&c_jmp) {
+    mrb->jmp = &c_jmp;
+    result = body(mrb, b_data);
+    mrb->jmp = prev_jmp;
+  } MRB_CATCH(&c_jmp) {
+    mrb->jmp = prev_jmp;
+
+    va_start(excs, r_data);
+    while((cls = va_arg(excs, struct RClass*))) {
+      if (mrb_obj_is_kind_of(mrb, mrb_obj_value(mrb->exc), cls)) {
+        error_matched = TRUE;
+        break;
+      }
+    }
+    va_end(excs);
+
+    if (!error_matched) { MRB_THROW(mrb->jmp); }
+
+    mrb->exc = NULL;
+    result = rescue(mrb, r_data);
+  } MRB_END_EXC(&c_jmp);
+
+  mrb_gc_protect(mrb, result);
+  return result;
+}
+
+void
+mrb_mruby_error_gem_init(mrb_state *mrb)
+{
+}
+
+void
+mrb_mruby_error_gem_final(mrb_state *mrb)
+{
+}
diff --git a/mrbgems/mruby-error/test/exception.c b/mrbgems/mruby-error/test/exception.c
new file mode 100644
index 000000000..7c15fb457
--- /dev/null
+++ b/mrbgems/mruby-error/test/exception.c
@@ -0,0 +1,57 @@
+#include "mruby.h"
+#include "mruby/error.h"
+#include "mruby/array.h"
+
+static mrb_value
+protect_cb(mrb_state *mrb, mrb_value b)
+{
+  return mrb_yield_argv(mrb, b, 0, NULL);
+}
+
+static mrb_value
+run_protect(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b;
+  mrb_value ret[2];
+  mrb_bool state;
+  mrb_get_args(mrb, "&", &b);
+  ret[0] = mrb_protect(mrb, protect_cb, b, &state);
+  ret[1] = mrb_bool_value(state);
+  return mrb_ary_new_from_values(mrb, 2, ret);
+}
+
+static mrb_value
+run_ensure(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b, e;
+  mrb_get_args(mrb, "oo", &b, &e);
+  return mrb_ensure(mrb, protect_cb, b, protect_cb, e);
+}
+
+static mrb_value
+run_rescue(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b, r;
+  mrb_get_args(mrb, "oo", &b, &r);
+  return mrb_rescue(mrb, protect_cb, b, protect_cb, r);
+}
+
+static mrb_value
+run_rescue_exceptions(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b, r;
+  mrb_get_args(mrb, "oo", &b, &r);
+  return mrb_rescue_exceptions(mrb, protect_cb, b, protect_cb, r, E_TYPE_ERROR, NULL);
+}
+
+void
+mrb_mruby_error_gem_test(mrb_state *mrb)
+{
+  struct RClass *cls;
+
+  cls = mrb_define_class(mrb, "ExceptionTest", mrb->object_class);
+  mrb_define_module_function(mrb, cls, "mrb_protect", run_protect, MRB_ARGS_NONE() | MRB_ARGS_BLOCK());
+  mrb_define_module_function(mrb, cls, "mrb_ensure", run_ensure, MRB_ARGS_REQ(2));
+  mrb_define_module_function(mrb, cls, "mrb_rescue", run_rescue, MRB_ARGS_REQ(2));
+  mrb_define_module_function(mrb, cls, "mrb_rescue_exceptions", run_rescue_exceptions, MRB_ARGS_REQ(2));
+}
diff --git a/mrbgems/mruby-error/test/exception.rb b/mrbgems/mruby-error/test/exception.rb
new file mode 100644
index 000000000..b5ea719a2
--- /dev/null
+++ b/mrbgems/mruby-error/test/exception.rb
@@ -0,0 +1,53 @@
+assert 'mrb_protect' do
+  assert_equal ['test', false] do
+    ExceptionTest.mrb_protect { 'test' }
+  end
+  assert_equal [nil, true] do
+    ExceptionTest.mrb_protect { raise 'test' }
+  end
+end
+
+assert 'mrb_ensure' do
+  a = false
+  assert_equal 'test' do
+    ExceptionTest.mrb_ensure Proc.new { 'test' }, Proc.new { a = true }
+  end
+  assert_true a
+
+  a = false
+  assert_raise RuntimeError do
+    ExceptionTest.mrb_ensure Proc.new { raise 'test' }, Proc.new { a = true }
+  end
+  assert_true a
+end
+
+assert 'mrb_rescue' do
+  assert_equal 'test' do
+    ExceptionTest.mrb_rescue Proc.new { 'test' }, Proc.new {}
+  end
+
+  class CustomExp < Exception
+  end
+
+  assert_raise CustomExp do
+    ExceptionTest.mrb_rescue Proc.new { raise CustomExp.new 'test' }, Proc.new { 'rescue' }
+  end
+
+  assert_equal 'rescue' do
+    ExceptionTest.mrb_rescue Proc.new { raise 'test' }, Proc.new { 'rescue' }
+  end
+end
+
+assert 'mrb_rescue_exceptions' do
+  assert_equal 'test' do
+    ExceptionTest.mrb_rescue_exceptions Proc.new { 'test' }, Proc.new {}
+  end
+
+  assert_raise RangeError do
+    ExceptionTest.mrb_rescue_exceptions Proc.new { raise RangeError.new 'test' }, Proc.new { 'rescue' }
+  end
+
+  assert_equal 'rescue' do
+    ExceptionTest.mrb_rescue_exceptions Proc.new { raise TypeError.new 'test' }, Proc.new { 'rescue' }
+  end
+end
-- 
cgit v1.2.3


From f6b5a829729479d4ae557effc15656605ca71781 Mon Sep 17 00:00:00 2001
From: take_cheeze <takechi101010@gmail.com>
Date: Mon, 22 Jun 2015 10:49:37 +0900
Subject: Use class array instead of variadic.

---
 include/mruby/error.h                |  3 ++-
 mrbgems/mruby-error/src/exception.c  | 14 ++++++--------
 mrbgems/mruby-error/test/exception.c |  4 +++-
 3 files changed, 11 insertions(+), 10 deletions(-)

(limited to 'include')

diff --git a/include/mruby/error.h b/include/mruby/error.h
index 3a985236a..d02e9166c 100644
--- a/include/mruby/error.h
+++ b/include/mruby/error.h
@@ -35,7 +35,8 @@ MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
 MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                              mrb_func_t rescue, mrb_value r_data);
 MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
-                                        mrb_func_t rescue, mrb_value r_data, ...);
+                                        mrb_func_t rescue, mrb_value r_data,
+                                        mrb_int len, struct RClass **classes);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/mrbgems/mruby-error/src/exception.c b/mrbgems/mruby-error/src/exception.c
index abd03bc29..7199e0801 100644
--- a/mrbgems/mruby-error/src/exception.c
+++ b/mrbgems/mruby-error/src/exception.c
@@ -1,4 +1,3 @@
-#include <stdarg.h>
 #include "mruby.h"
 #include "mruby/throw.h"
 #include "mruby/error.h"
@@ -52,18 +51,19 @@ MRB_API mrb_value
 mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
            mrb_func_t rescue, mrb_value r_data)
 {
-  return mrb_rescue_exceptions(mrb, body, b_data, rescue, r_data, mrb->eStandardError_class, NULL);
+  return mrb_rescue_exceptions(mrb, body, b_data, rescue, r_data, 1, &mrb->eStandardError_class);
 }
 
 MRB_API mrb_value
-mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t rescue, mrb_value r_data, ...)
+mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t rescue, mrb_value r_data,
+                      mrb_int len, struct RClass **classes)
 {
   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
   struct mrb_jmpbuf c_jmp;
   mrb_value result;
-  va_list excs;
   struct RClass *cls;
   mrb_bool error_matched = FALSE;
+  mrb_int i;
 
   MRB_TRY(&c_jmp) {
     mrb->jmp = &c_jmp;
@@ -72,14 +72,12 @@ mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_fun
   } MRB_CATCH(&c_jmp) {
     mrb->jmp = prev_jmp;
 
-    va_start(excs, r_data);
-    while((cls = va_arg(excs, struct RClass*))) {
-      if (mrb_obj_is_kind_of(mrb, mrb_obj_value(mrb->exc), cls)) {
+    for (i = 0; i < len; ++i) {
+      if (mrb_obj_is_kind_of(mrb, mrb_obj_value(mrb->exc), classes[i])) {
         error_matched = TRUE;
         break;
       }
     }
-    va_end(excs);
 
     if (!error_matched) { MRB_THROW(mrb->jmp); }
 
diff --git a/mrbgems/mruby-error/test/exception.c b/mrbgems/mruby-error/test/exception.c
index 7c15fb457..2a943aaae 100644
--- a/mrbgems/mruby-error/test/exception.c
+++ b/mrbgems/mruby-error/test/exception.c
@@ -40,8 +40,10 @@ static mrb_value
 run_rescue_exceptions(mrb_state *mrb, mrb_value self)
 {
   mrb_value b, r;
+  struct RClass *cls[1];
   mrb_get_args(mrb, "oo", &b, &r);
-  return mrb_rescue_exceptions(mrb, protect_cb, b, protect_cb, r, E_TYPE_ERROR, NULL);
+  cls[0] = E_TYPE_ERROR;
+  return mrb_rescue_exceptions(mrb, protect_cb, b, protect_cb, r, 1, cls);
 }
 
 void
-- 
cgit v1.2.3


From 1085167fefe010be8e2d39e2adb31134a5512b15 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Wed, 15 Jul 2015 14:44:19 +0900
Subject: add an small comment description in mruby/error.h header

---
 include/mruby/error.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'include')

diff --git a/include/mruby/error.h b/include/mruby/error.h
index d02e9166c..e3e2b25e2 100644
--- a/include/mruby/error.h
+++ b/include/mruby/error.h
@@ -29,6 +29,7 @@ MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_va
 /* declaration for fail method */
 MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
 
+/* functions defined in mruby-error mrbgem */
 MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
 MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                              mrb_func_t ensure, mrb_value e_data);
-- 
cgit v1.2.3


From 667f7788db2b3b78cc4cc65c0f37ab38347116c5 Mon Sep 17 00:00:00 2001
From: Corey Powell <mistdragon100@gmail.com>
Date: Wed, 15 Jul 2015 07:27:31 -0500
Subject: Renamed MRB_FLAG_IS_INSTANCE to MRB_INSTANCE_TT_MASK

---
 include/mruby/class.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'include')

diff --git a/include/mruby/class.h b/include/mruby/class.h
index 9f2c32bb0..80a0cbe35 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -51,9 +51,9 @@ mrb_class(mrb_state *mrb, mrb_value v)
 
 // TODO: figure out where to put user flags
 #define MRB_FLAG_IS_ORIGIN (1 << 20)
-#define MRB_FLAG_IS_INSTANCE (0xFF)
-#define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~MRB_FLAG_IS_INSTANCE) | (char)tt)
-#define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & MRB_FLAG_IS_INSTANCE)
+#define MRB_INSTANCE_TT_MASK (0xFF)
+#define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~MRB_INSTANCE_TT_MASK) | (char)tt)
+#define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & MRB_INSTANCE_TT_MASK)
 
 MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
 MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
-- 
cgit v1.2.3


From 26bee4a16b5763b407a842bd1697389961600d68 Mon Sep 17 00:00:00 2001
From: Corey Powell <mistdragon100@gmail.com>
Date: Thu, 16 Jul 2015 15:25:27 -0500
Subject: Added mrb_prepend_module to mruby header

---
 include/mruby.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 1b792ce90..b4ec13fdc 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -206,6 +206,7 @@ MRB_API struct RClass *mrb_define_class(mrb_state *, const char*, struct RClass*
 MRB_API struct RClass *mrb_define_module(mrb_state *, const char*);
 MRB_API mrb_value mrb_singleton_class(mrb_state*, mrb_value);
 MRB_API void mrb_include_module(mrb_state*, struct RClass*, struct RClass*);
+MRB_API void mrb_prepend_module(mrb_state*, struct RClass*, struct RClass*);
 
 MRB_API void mrb_define_method(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec);
 MRB_API void mrb_define_class_method(mrb_state *, struct RClass *, const char *, mrb_func_t, mrb_aspec);
-- 
cgit v1.2.3


From 1a45447b8b66159a4a7d0348c4a01a175b3778fd Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Thu, 27 Aug 2015 17:54:30 +0900
Subject: add String#freeze to the core

---
 include/mruby/string.h | 11 ++++++++---
 src/string.c           | 21 +++++++++++++++++++++
 2 files changed, 29 insertions(+), 3 deletions(-)

(limited to 'include')

diff --git a/include/mruby/string.h b/include/mruby/string.h
index 5228dcbca..c4b31216e 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -59,6 +59,10 @@ struct RString {
 #define RSTR_SET_NOFREE_FLAG(s) ((s)->flags |= MRB_STR_NOFREE)
 #define RSTR_UNSET_NOFREE_FLAG(s) ((s)->flags &= ~MRB_STR_NOFREE)
 
+#define RSTR_FROZEN_P(s) ((s)->flags & MRB_STR_FROZEN)
+#define RSTR_SET_FROZEN_FLAG(s) ((s)->flags |= MRB_STR_FROZEN)
+#define RSTR_UNSET_FROZEN_FLAG(s) ((s)->flags &= ~MRB_STR_FROZEN)
+
 #define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
 #define RSTRING(s)           mrb_str_ptr(s)
 #define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
@@ -70,9 +74,10 @@ mrb_int mrb_str_strlen(mrb_state*, struct RString*);
 
 #define MRB_STR_SHARED    1
 #define MRB_STR_NOFREE    2
-#define MRB_STR_EMBED     4
-#define MRB_STR_EMBED_LEN_MASK 0xf8
-#define MRB_STR_EMBED_LEN_SHIFT 3
+#define MRB_STR_FROZEN    4
+#define MRB_STR_EMBED     8
+#define MRB_STR_EMBED_LEN_MASK 0x1f0
+#define MRB_STR_EMBED_LEN_SHIFT 4
 
 void mrb_gc_free_str(mrb_state*, struct RString*);
 MRB_API void mrb_str_modify(mrb_state*, struct RString*);
diff --git a/src/string.c b/src/string.c
index 45ba38c9d..e5f446bde 100644
--- a/src/string.c
+++ b/src/string.c
@@ -75,9 +75,18 @@ str_decref(mrb_state *mrb, mrb_shared_string *shared)
   }
 }
 
+static void
+check_frozen(mrb_state *mrb, struct RString *s)
+{
+  if (RSTR_FROZEN_P(s)) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen string");
+  }
+}
+
 MRB_API void
 mrb_str_modify(mrb_state *mrb, struct RString *s)
 {
+  check_frozen(mrb, s);
   if (RSTR_SHARED_P(s)) {
     mrb_shared_string *shared = s->as.heap.aux.shared;
 
@@ -119,6 +128,15 @@ mrb_str_modify(mrb_state *mrb, struct RString *s)
   }
 }
 
+static mrb_value
+mrb_str_freeze(mrb_state *mrb, mrb_value str)
+{
+  struct RString *s = mrb_str_ptr(str);
+
+  RSTR_SET_FROZEN_FLAG(s);
+  return str;
+}
+
 MRB_API mrb_value
 mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len)
 {
@@ -1345,6 +1363,7 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)
 {
   long len;
 
+  check_frozen(mrb, s1);
   len = RSTR_LEN(s2);
   if (RSTR_SHARED_P(s1)) {
     str_decref(mrb, s1->as.heap.aux.shared);
@@ -2514,4 +2533,6 @@ mrb_init_string(mrb_state *mrb)
   mrb_define_method(mrb, s, "upcase!",         mrb_str_upcase_bang,     MRB_ARGS_NONE()); /* 15.2.10.5.43 */
   mrb_define_method(mrb, s, "inspect",         mrb_str_inspect,         MRB_ARGS_NONE()); /* 15.2.10.5.46(x) */
   mrb_define_method(mrb, s, "bytes",           mrb_str_bytes,           MRB_ARGS_NONE());
+
+  mrb_define_method(mrb, s, "freeze",          mrb_str_freeze,          MRB_ARGS_NONE());
 }
-- 
cgit v1.2.3


From a2385c05f5f07b30c039a46b497ae22bc0c5e212 Mon Sep 17 00:00:00 2001
From: Jun Hiroe <Jun.Hiroe@gmail.com>
Date: Mon, 31 Aug 2015 20:36:33 +0900
Subject: Refactor version.h macros

---
 include/mruby/version.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'include')

diff --git a/include/mruby/version.h b/include/mruby/version.h
index ea044d6da..b3e4df029 100644
--- a/include/mruby/version.h
+++ b/include/mruby/version.h
@@ -7,25 +7,27 @@
 #ifndef MRUBY_VERSION_H
 #define MRUBY_VERSION_H
 
+#define MRB_STRINGIZE0(expr) #expr
+#define MRB_STRINGIZE(expr) MRB_STRINGIZE0(expr)
+
 #define MRUBY_RUBY_VERSION "1.9"
 #define MRUBY_RUBY_ENGINE  "mruby"
 
-#define MRUBY_VERSION "1.1.0"
 #define MRUBY_RELEASE_MAJOR 1
 #define MRUBY_RELEASE_MINOR 1
 #define MRUBY_RELEASE_TEENY 1
-#define MRUBY_RELEASE_NO 10101
-#define MRUBY_RELEASE_DATE "2014-11-19"
+
+#define MRUBY_VERSION MRB_STRINGIZE(MRUBY_RELEASE_MAJOR)"."MRB_STRINGIZE(MRUBY_RELEASE_MINOR)"."MRB_STRINGIZE(MRUBY_RELEASE_TEENY)
+#define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
 #define MRUBY_RELEASE_YEAR 2014
 #define MRUBY_RELEASE_MONTH 11
 #define MRUBY_RELEASE_DAY 19
+#define MRUBY_RELEASE_DATE MRB_STRINGIZE(MRUBY_RELEASE_YEAR)"-"MRB_STRINGIZE(MRUBY_RELEASE_MONTH)"-"MRB_STRINGIZE(MRUBY_RELEASE_DAY)
 
 #define MRUBY_BIRTH_YEAR 2010
 
 #define MRUBY_AUTHOR "mruby developers"
 
-#define MRB_STRINGIZE0(expr) #expr
-#define MRB_STRINGIZE(expr) MRB_STRINGIZE0(expr)
 
 #define MRUBY_DESCRIPTION      \
   "mruby " MRUBY_VERSION       \
-- 
cgit v1.2.3


From 5ed13da7d6056c76a5f8063a2b9b2cd57ac323bf Mon Sep 17 00:00:00 2001
From: jbreeden <jared.breeden@gmail.com>
Date: Tue, 1 Sep 2015 18:09:32 -0700
Subject: C++ 11 requires a space between literal and identifiers

---
 include/mruby/version.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'include')

diff --git a/include/mruby/version.h b/include/mruby/version.h
index b3e4df029..c2a9b6306 100644
--- a/include/mruby/version.h
+++ b/include/mruby/version.h
@@ -17,12 +17,12 @@
 #define MRUBY_RELEASE_MINOR 1
 #define MRUBY_RELEASE_TEENY 1
 
-#define MRUBY_VERSION MRB_STRINGIZE(MRUBY_RELEASE_MAJOR)"."MRB_STRINGIZE(MRUBY_RELEASE_MINOR)"."MRB_STRINGIZE(MRUBY_RELEASE_TEENY)
+#define MRUBY_VERSION MRB_STRINGIZE(MRUBY_RELEASE_MAJOR) "." MRB_STRINGIZE(MRUBY_RELEASE_MINOR) "." MRB_STRINGIZE(MRUBY_RELEASE_TEENY)
 #define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
 #define MRUBY_RELEASE_YEAR 2014
 #define MRUBY_RELEASE_MONTH 11
 #define MRUBY_RELEASE_DAY 19
-#define MRUBY_RELEASE_DATE MRB_STRINGIZE(MRUBY_RELEASE_YEAR)"-"MRB_STRINGIZE(MRUBY_RELEASE_MONTH)"-"MRB_STRINGIZE(MRUBY_RELEASE_DAY)
+#define MRUBY_RELEASE_DATE MRB_STRINGIZE(MRUBY_RELEASE_YEAR) "-" MRB_STRINGIZE(MRUBY_RELEASE_MONTH) "-" MRB_STRINGIZE(MRUBY_RELEASE_DAY)
 
 #define MRUBY_BIRTH_YEAR 2010
 
-- 
cgit v1.2.3


From 7b5f8b07285eeb9900ef1a85cb2c764fbbd34461 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Thu, 3 Sep 2015 01:39:17 +0900
Subject: remove trailing spaces from bc9c47d5

---
 build_config.rb      | 3 ++-
 include/mruby/dump.h | 4 ++--
 src/load.c           | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'include')

diff --git a/build_config.rb b/build_config.rb
index e1178d6b2..34b92637c 100644
--- a/build_config.rb
+++ b/build_config.rb
@@ -21,6 +21,7 @@ MRuby::Build.new do |conf|
 
   # include the default GEMs
   conf.gembox 'default'
+  conf.gem :core => 'mruby-eval'
 
   # C compiler settings
   # conf.cc do |cc|
@@ -105,7 +106,7 @@ MRuby::Build.new('host-debug') do |conf|
   conf.gem :core => "mruby-bin-debugger"
 
   # bintest
-  # conf.enable_bintest
+  conf.enable_bintest
 end
 
 MRuby::Build.new('test') do |conf|
diff --git a/include/mruby/dump.h b/include/mruby/dump.h
index 45774d872..4cee3c0ac 100644
--- a/include/mruby/dump.h
+++ b/include/mruby/dump.h
@@ -17,8 +17,8 @@ extern "C" {
 #define DUMP_DEBUG_INFO 1
 #define DUMP_ENDIAN_BIG 2
 #define DUMP_ENDIAN_LIL 4
-#define DUMP_ENDIAN_NAT 6 
-#define DUMP_ENDIAN_MASK 6 
+#define DUMP_ENDIAN_NAT 6
+#define DUMP_ENDIAN_MASK 6
 
 int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
 #ifdef ENABLE_STDIO
diff --git a/src/load.c b/src/load.c
index a9f1641bf..36fae9aee 100644
--- a/src/load.c
+++ b/src/load.c
@@ -529,7 +529,7 @@ read_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc, uint8_t
   else if (memcmp(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident)) == 0) {
     if (bigendian_p())
       *flags |= FLAG_BYTEORDER_LIL;
-    else 
+    else
       *flags |= FLAG_BYTEORDER_NATIVE;
   }
   else {
-- 
cgit v1.2.3


From 2550edd570f1d7485e862ce11ceb50ea59dee3c5 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Sat, 5 Sep 2015 02:01:02 +0900
Subject: remove `origin` member to implement prepend from struct RClass; ref
 #2885

instead origin is saved in ICLASS with MRB_FLAG_IS_ORIGIN set.
---
 include/mruby/class.h | 10 +++++++++-
 src/class.c           | 44 ++++++++++++++++++++++++--------------------
 src/kernel.c          | 29 +++++++++++++++--------------
 src/object.c          |  2 +-
 4 files changed, 49 insertions(+), 36 deletions(-)

(limited to 'include')

diff --git a/include/mruby/class.h b/include/mruby/class.h
index 80a0cbe35..85f3e12c6 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -16,7 +16,6 @@ struct RClass {
   struct iv_tbl *iv;
   struct kh_mt *mt;
   struct RClass *super;
-  struct RClass *origin;
 };
 
 #define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
@@ -50,7 +49,16 @@ mrb_class(mrb_state *mrb, mrb_value v)
 }
 
 // TODO: figure out where to put user flags
+#define MRB_FLAG_IS_PREPENDED (1 << 19)
 #define MRB_FLAG_IS_ORIGIN (1 << 20)
+#define MRB_CLASS_ORIGIN(c) do {\
+  if (c->flags & MRB_FLAG_IS_PREPENDED) {\
+    c = c->super;\
+    while (!(c->flags & MRB_FLAG_IS_ORIGIN)) {\
+      c = c->super;\
+    }\
+  }\
+} while (0)
 #define MRB_INSTANCE_TT_MASK (0xFF)
 #define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~MRB_INSTANCE_TT_MASK) | (char)tt)
 #define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & MRB_INSTANCE_TT_MASK)
diff --git a/src/class.c b/src/class.c
index 462ab40b5..c3c3e0b8f 100644
--- a/src/class.c
+++ b/src/class.c
@@ -76,7 +76,6 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o)
 
   if (o->c->tt == MRB_TT_SCLASS) return;
   sc = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_SCLASS, mrb->class_class);
-  sc->origin = sc;
   sc->mt = kh_init(mt, mrb);
   sc->iv = 0;
   if (o->tt == MRB_TT_CLASS) {
@@ -188,6 +187,13 @@ mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
   return c;
 }
 
+static struct RClass*
+find_origin(struct RClass *c)
+{
+  MRB_CLASS_ORIGIN(c);
+  return c;
+}
+
 static struct RClass*
 define_class(mrb_state *mrb, mrb_sym name, struct RClass *super, struct RClass *outer)
 {
@@ -195,7 +201,7 @@ define_class(mrb_state *mrb, mrb_sym name, struct RClass *super, struct RClass *
 
   if (mrb_const_defined_at(mrb, mrb_obj_value(outer), name)) {
     c = class_from_sym(mrb, outer, name);
-    c = c->origin;
+    MRB_CLASS_ORIGIN(c);
     if (super && mrb_class_real(c->super) != super) {
       mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for Class %S (%S not %S)",
                  mrb_sym2str(mrb, name),
@@ -327,7 +333,8 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, struct RPro
 {
   khash_t(mt) *h;
   khiter_t k;
-  h = c->origin->mt;
+  MRB_CLASS_ORIGIN(c);
+  h = c->mt;
 
   if (!h) h = c->mt = kh_init(mt, mrb);
   k = kh_put(mt, mrb, h, mid);
@@ -809,7 +816,6 @@ boot_defclass(mrb_state *mrb, struct RClass *super)
   struct RClass *c;
 
   c = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_CLASS, mrb->class_class);
-  c->origin = c;
   if (super) {
     c->super = super;
     mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)super);
@@ -824,7 +830,6 @@ boot_defclass(mrb_state *mrb, struct RClass *super)
 static void
 boot_initmod(mrb_state *mrb, struct RClass *mod)
 {
-  mod->origin = mod;
   mod->mt = kh_init(mt, mrb);
 }
 
@@ -835,9 +840,9 @@ include_class_new(mrb_state *mrb, struct RClass *m, struct RClass *super)
   if (m->tt == MRB_TT_ICLASS) {
     m = m->c;
   }
-  ic->origin = ic;
+  MRB_CLASS_ORIGIN(m);
   ic->iv = m->iv;
-  ic->mt = m->origin->mt;
+  ic->mt = m->mt;
   ic->super = super;
   if (m->tt == MRB_TT_ICLASS) {
     ic->c = m->c;
@@ -851,12 +856,12 @@ static int
 include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *ins_pos, struct RClass *m, int search_super)
 {
   struct RClass *p, *ic;
-  void *klass_mt = c->origin->mt;
+  void *klass_mt = find_origin(c)->mt;
 
   while (m) {
     int superclass_seen = 0;
 
-    if (m->origin != m)
+    if (m->flags & MRB_FLAG_IS_PREPENDED)
       goto skip;
 
     if (klass_mt && klass_mt == m->mt)
@@ -891,7 +896,7 @@ include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *ins_pos, stru
 MRB_API void
 mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
 {
-  int changed = include_module_at(mrb, c, c->origin, m, 1);
+  int changed = include_module_at(mrb, c, find_origin(c), m, 1);
   if (changed < 0) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "cyclic include detected");
   }
@@ -903,17 +908,15 @@ mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
   struct RClass *origin;
   int changed = 0;
 
-  origin = c->origin;
-  if (origin == c) {
+  if (!(c->flags & MRB_FLAG_IS_PREPENDED)) {
     origin = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, c);
     origin->flags |= MRB_FLAG_IS_ORIGIN;
-    origin->origin = origin;
     origin->super = c->super;
     c->super = origin;
-    c->origin = origin;
     origin->mt = c->mt;
     c->mt = kh_init(mt, mrb);
-    mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)c->origin);
+    mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)origin);
+    c->flags |= MRB_FLAG_IS_PREPENDED;
   }
   changed = include_module_at(mrb, c, c, m, 0);
   if (changed < 0) {
@@ -1026,7 +1029,7 @@ mrb_mod_ancestors(mrb_state *mrb, mrb_value self)
     if (c->tt == MRB_TT_ICLASS) {
       mrb_ary_push(mrb, result, mrb_obj_value(c->c));
     }
-    else if (c->origin == c) {
+    else if (!(c->flags & MRB_FLAG_IS_PREPENDED)) {
       mrb_ary_push(mrb, result, mrb_obj_value(c));
     }
     c = c->super;
@@ -1051,8 +1054,9 @@ mrb_mod_included_modules(mrb_state *mrb, mrb_value self)
 {
   mrb_value result;
   struct RClass *c = mrb_class_ptr(self);
-  struct RClass *origin = c->origin;
+  struct RClass *origin = c;
 
+  MRB_CLASS_ORIGIN(origin);
   result = mrb_ary_new(mrb);
   while (c) {
     if (c != origin && c->tt == MRB_TT_ICLASS) {
@@ -1391,9 +1395,9 @@ mrb_class_superclass(mrb_state *mrb, mrb_value klass)
   struct RClass *c;
 
   c = mrb_class_ptr(klass);
-  c = c->origin->super;
+  c = find_origin(c)->super;
   while (c && c->tt == MRB_TT_ICLASS) {
-    c = c->origin->super;
+    c = find_origin(c)->super;
   }
   if (!c) return mrb_nil_value();
   return mrb_obj_value(c);
@@ -1990,7 +1994,7 @@ static void
 remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
 {
   struct RClass *c = mrb_class_ptr(mod);
-  khash_t(mt) *h = c->origin->mt;
+  khash_t(mt) *h = find_origin(c)->mt;
   khiter_t k;
 
   if (h) {
diff --git a/src/kernel.c b/src/kernel.c
index 36ad683ee..225f7fa54 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -240,19 +240,12 @@ mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
     /* copy singleton(unnamed) class */
     struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
 
-    if ((mrb_type(obj) == MRB_TT_CLASS) ||
-      (mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */
+    if ((mrb_type(obj) == MRB_TT_CLASS) || (mrb_type(obj) == MRB_TT_SCLASS)) {
       clone->c = clone;
     }
     else {
       clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
     }
-
-    if (klass->origin != klass)
-      clone->origin = klass->origin;
-    else
-      clone->origin = clone;
-
     clone->super = klass->super;
     if (klass->iv) {
       mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass));
@@ -276,10 +269,18 @@ copy_class(mrb_state *mrb, mrb_value dst, mrb_value src)
   struct RClass *sc = mrb_class_ptr(src);
   /* if the origin is not the same as the class, then the origin and
      the current class need to be copied */
-  if (sc->origin != sc) {
-    dc->origin = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(sc->origin)));
-  } else {
-    dc->origin = dc;
+  if (sc->flags & MRB_FLAG_IS_PREPENDED) {
+    struct RClass *c0 = sc->super;
+    struct RClass *c1 = dc;
+
+    /* copy prepended iclasses */
+    while (!(c0->flags & MRB_FLAG_IS_ORIGIN)) {
+      c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
+      c1 = c1->super;
+      c0 = c0->super;
+    }
+    c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
+    c1->super->flags |= MRB_FLAG_IS_ORIGIN;
   }
   dc->mt = kh_copy(mt, mrb, sc->mt);
   dc->super = sc->super;
@@ -657,8 +658,8 @@ mrb_class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* kl
   struct RClass* oldklass;
   khash_t(st)* set = kh_init(st, mrb);
 
-  if (!recur && klass->origin != klass) {
-    klass = klass->origin;
+  if (!recur && (klass->flags & MRB_FLAG_IS_PREPENDED)) {
+    MRB_CLASS_ORIGIN(klass);
     prepended = 1;
   }
 
diff --git a/src/object.c b/src/object.c
index c834ee04f..2e0bd245f 100644
--- a/src/object.c
+++ b/src/object.c
@@ -487,7 +487,7 @@ mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c)
       mrb_raise(mrb, E_TYPE_ERROR, "class or module required");
   }
 
-  c = c->origin;
+  MRB_CLASS_ORIGIN(c);
   while (cl) {
     if (cl == c || cl->mt == c->mt)
       return TRUE;
-- 
cgit v1.2.3


From 8277e950eee4e8c6135eca281a7d5ca91077d2b4 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 11 Sep 2015 11:12:03 +0900
Subject: Support windows locale

Add mrb_utf8_from_locale, mrb_utf8_free, mrb_locale_from_utf8, mrb_locale_free. Just works for windows.
---
 include/mruby.h                             | 12 ++++++
 mrbgems/mruby-bin-mirb/tools/mirb/mirb.c    | 10 ++++-
 mrbgems/mruby-bin-mruby/tools/mruby/mruby.c | 11 ++++-
 mrbgems/mruby-print/src/print.c             | 13 +++---
 src/string.c                                | 63 +++++++++++++++++++++++++++++
 5 files changed, 99 insertions(+), 10 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index b4ec13fdc..dedbd0748 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -292,6 +292,18 @@ MRB_API mrb_value mrb_str_new_cstr(mrb_state*, const char*);
 MRB_API mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len);
 #define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
 
+#ifdef _WIN32
+char* mrb_utf8_from_locale(const char *p, size_t len);
+char* mrb_locale_from_utf8(const char *p, size_t len);
+#define mrb_locale_free(p) free(p)
+#define mrb_utf8_free(p) free(p)
+#else
+#define mrb_utf8_from_locale(p, l) (p)
+#define mrb_locale_from_utf8(p, l) (p)
+#define mrb_locale_free(p)
+#define mrb_utf8_free(p)
+#endif
+
 MRB_API mrb_state* mrb_open(void);
 MRB_API mrb_state* mrb_open_allocf(mrb_allocf, void *ud);
 MRB_API mrb_state* mrb_open_core(mrb_allocf, void *ud);
diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
index 0f3649a35..37fda352c 100644
--- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
+++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
@@ -366,6 +366,8 @@ main(int argc, char **argv)
   ai = mrb_gc_arena_save(mrb);
 
   while (TRUE) {
+    char *utf8;
+
 #ifndef ENABLE_READLINE
     print_cmdline(code_block_open);
 
@@ -415,17 +417,21 @@ main(int argc, char **argv)
       strcpy(ruby_code, last_code_line);
     }
 
+    utf8 = mrb_utf8_from_locale(ruby_code, -1);
+    if (!utf8) abort();
+
     /* parse code */
     parser = mrb_parser_new(mrb);
     if (parser == NULL) {
       fputs("create parser state error\n", stderr);
       break;
     }
-    parser->s = ruby_code;
-    parser->send = ruby_code + strlen(ruby_code);
+    parser->s = utf8;
+    parser->send = utf8 + strlen(utf8);
     parser->lineno = cxt->lineno;
     mrb_parser_parse(parser, cxt);
     code_block_open = is_code_block_open(parser);
+    mrb_utf8_free(utf8);
 
     if (code_block_open) {
       /* no evaluation of code */
diff --git a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c
index 5ca744388..cc1ca3055 100644
--- a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c
+++ b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c
@@ -191,7 +191,11 @@ main(int argc, char **argv)
 
   ARGV = mrb_ary_new_capa(mrb, args.argc);
   for (i = 0; i < args.argc; i++) {
-    mrb_ary_push(mrb, ARGV, mrb_str_new_cstr(mrb, args.argv[i]));
+    char* utf8 = mrb_utf8_from_locale(args.argv[i], -1);
+    if (utf8) {
+      mrb_ary_push(mrb, ARGV, mrb_str_new_cstr(mrb, utf8));
+      mrb_utf8_free(utf8);
+    }
   }
   mrb_define_global_const(mrb, "ARGV", ARGV);
 
@@ -222,7 +226,10 @@ main(int argc, char **argv)
     v = mrb_load_file_cxt(mrb, args.rfp, c);
   }
   else {
-    v = mrb_load_string_cxt(mrb, args.cmdline, c);
+    char* utf8 = mrb_utf8_from_locale(args.cmdline, -1);
+    if (!utf8) abort();
+    v = mrb_load_string_cxt(mrb, utf8, c);
+    mrb_utf8_free(utf8);
   }
 
   mrbc_context_free(mrb, c);
diff --git a/mrbgems/mruby-print/src/print.c b/mrbgems/mruby-print/src/print.c
index 673ba2172..e7e21dd4b 100644
--- a/mrbgems/mruby-print/src/print.c
+++ b/mrbgems/mruby-print/src/print.c
@@ -1,17 +1,18 @@
 #include "mruby.h"
 #include "mruby/string.h"
 #include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
 
 static void
 printstr(mrb_state *mrb, mrb_value obj)
 {
-  char *s;
-  mrb_int len;
-
   if (mrb_string_p(obj)) {
-    s = RSTRING_PTR(obj);
-    len = RSTRING_LEN(obj);
-    fwrite(s, len, 1, stdout);
+    char* ptr = mrb_locale_from_utf8(RSTRING_PTR(obj), RSTRING_LEN(obj));
+    if (ptr) {
+      fwrite(ptr, strlen(ptr), 1, stdout);
+      mrb_locale_free(ptr);
+    }
   }
 }
 
diff --git a/src/string.c b/src/string.c
index 08caf3bae..e93fd4606 100644
--- a/src/string.c
+++ b/src/string.c
@@ -43,6 +43,69 @@ mrb_str_strlen(mrb_state *mrb, struct RString *s)
   return max;
 }
 
+#ifdef _WIN32
+#include <windows.h>
+
+char*
+mrb_utf8_from_locale(const char *str, size_t len)
+{
+  wchar_t* wcsp;
+  char* mbsp;
+  size_t mbssize, wcssize;
+
+  if (len == 0)
+    return strdup("");
+  if (len == -1)
+	len = strlen(str);
+  wcssize = MultiByteToWideChar(GetACP(), 0, str, len,  NULL, 0);
+  wcsp = (wchar_t*) malloc((wcssize + 1) * sizeof(wchar_t));
+  if (!wcsp)
+    return NULL;
+  wcssize = MultiByteToWideChar(GetACP(), 0, str, len, wcsp, wcssize + 1);
+  wcsp[wcssize] = 0;
+
+  mbssize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR) wcsp, -1, NULL, 0, NULL, NULL);
+  mbsp = (char*) malloc((mbssize + 1));
+  if (!mbsp) {
+    free(wcsp);
+    return NULL;
+  }
+  mbssize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR) wcsp, -1, mbsp, mbssize, NULL, NULL);
+  mbsp[mbssize] = 0;
+  free(wcsp);
+  return mbsp;
+}
+
+char*
+mrb_locale_from_utf8(const char *utf8, size_t len)
+{
+  wchar_t* wcsp;
+  char* mbsp;
+  size_t mbssize, wcssize;
+
+  if (len == 0)
+    return strdup("");
+  if (len == -1)
+	len = strlen(utf8);
+  wcssize = MultiByteToWideChar(CP_UTF8, 0, utf8, len,  NULL, 0);
+  wcsp = (wchar_t*) malloc((wcssize + 1) * sizeof(wchar_t));
+  if (!wcsp)
+    return NULL;
+  wcssize = MultiByteToWideChar(CP_UTF8, 0, utf8, len, wcsp, wcssize + 1);
+  wcsp[wcssize] = 0;
+  mbssize = WideCharToMultiByte(GetACP(), 0, (LPCWSTR) wcsp, -1, NULL, 0, NULL, NULL);
+  mbsp = (char*) malloc((mbssize + 1));
+  if (!mbsp) {
+    free(wcsp);
+    return NULL;
+  }
+  mbssize = WideCharToMultiByte(GetACP(), 0, (LPCWSTR) wcsp, -1, mbsp, mbssize, NULL, NULL);
+  mbsp[mbssize] = 0;
+  free(wcsp);
+  return mbsp;
+}
+#endif
+
 static inline void
 resize_capa(mrb_state *mrb, struct RString *s, mrb_int capacity)
 {
-- 
cgit v1.2.3