Index: src/org/jruby/evaluator/EvaluationState.java
===================================================================
--- src/org/jruby/evaluator/EvaluationState.java	(revision 3480)
+++ src/org/jruby/evaluator/EvaluationState.java	(working copy)
@@ -897,7 +897,7 @@
         }
 
         try {
-            return RubyRegexp.newRegexp(runtime, string.toString(), iVisited.getOptions(), lang);
+            return RubyRegexp.newRegexp(runtime, string.getByteList(), iVisited.getOptions(), lang);
         } catch(jregex.PatternSyntaxException e) {
         //                    System.err.println(iVisited.getValue().toString());
         //                    e.printStackTrace();
Index: src/org/jruby/RubyRegexp.java
===================================================================
--- src/org/jruby/RubyRegexp.java	(revision 3480)
+++ src/org/jruby/RubyRegexp.java	(working copy)
@@ -174,14 +174,19 @@
         }
     }
 
+    public void initialize(ByteList regex, int options) {
+        try {
+            pattern = REGEXP_TRANSLATOR.translate(regex, options, code.flags());
+            flags = REGEXP_TRANSLATOR.flagsFor(options, code.flags());
+        } catch(jregex.PatternSyntaxException e) {
+            //            System.err.println(regex);
+            //            e.printStackTrace();
+            throw getRuntime().newRegexpError(e.getMessage());
+        }
+    }
+
     public void initialize(String regex, int options) {
         try {
-            if(getCode() == KCode.UTF8) {
-                try {
-                    regex = new String(ByteList.plain(regex),"UTF8");
-                } catch(Exception e) {
-                }
-            }
             pattern = REGEXP_TRANSLATOR.translate(regex, options, code.flags());
             flags = REGEXP_TRANSLATOR.flagsFor(options, code.flags());
         } catch(jregex.PatternSyntaxException e) {
@@ -218,7 +223,7 @@
     // Methods of the Regexp class (rb_reg_*):
 
     public static RubyRegexp newRegexp(RubyString str, int options, String lang) {
-        return newRegexp(str.getRuntime(), str.toString(), options, lang);
+        return newRegexp(str.getRuntime(), str.getByteList(), options, lang);
     }
     
     public static RubyRegexp newRegexp(Ruby runtime, Pattern pattern, int flags, String lang) {
@@ -236,6 +241,13 @@
         return re;
     }
     
+    public static RubyRegexp newRegexp(Ruby runtime, ByteList str, int options, String kcode) {
+        RubyRegexp re = new RubyRegexp(runtime);
+        re.code = KCode.create(runtime, kcode);
+        re.initialize(str, options);
+        return re;
+    }
+    
     public static RubyRegexp newInstance(IRubyObject recv, IRubyObject[] args) {
         RubyClass klass = (RubyClass)recv;
         
@@ -247,10 +259,10 @@
     }
 
     public IRubyObject initialize(IRubyObject[] args) {
-        String pat =
+        ByteList pat =
             (args[0] instanceof RubyRegexp)
-                ? ((RubyRegexp) args[0]).source().toString()
-                : RubyString.stringValue(args[0]).toString();
+                ? ((RubyRegexp) args[0]).source().getByteList()
+                : RubyString.stringValue(args[0]).getByteList();
         int opts = 0;
         if (args.length > 1) {
             if (args[1] instanceof RubyFixnum) {
@@ -782,7 +794,7 @@
 
     public static RubyRegexp unmarshalFrom(UnmarshalStream input) throws java.io.IOException {
         RubyRegexp result = newRegexp(input.getRuntime(), 
-                                      RubyString.byteListToString(input.unmarshalString()), input.unmarshalInt(), null);
+                                      input.unmarshalString(), input.unmarshalInt(), null);
         input.registerLinkTarget(result);
         return result;
     }
Index: src/org/jruby/RegexpTranslator.java
===================================================================
--- src/org/jruby/RegexpTranslator.java	(revision 3480)
+++ src/org/jruby/RegexpTranslator.java	(working copy)
@@ -1,5 +1,5 @@
 /**
- * 
+ *
  */
 package org.jruby;
 
@@ -11,91 +11,104 @@
 import jregex.TextBuffer;
 
 import org.jruby.parser.ReOptions;
+import org.jruby.util.ByteList;
 
 public class RegexpTranslator {
-
+    
     private static final Pattern SHARP_IN_CHARACTER_CLASS_PATTERN = new Pattern("(\\[[^]]*)#(.*?])");
-	private static final Pattern SPACE_IN_CHARACTER_CLASS_PATTERN = new Pattern("(\\[[^]]*) (.*?])");
-	private static final Pattern COMMENT_PATTERN = new Pattern("\\(\\?#[^)]*\\)");
-	private static final Pattern COMMENT2_PATTERN = new Pattern("(?<!\\\\)#.*");
+    private static final Pattern SPACE_IN_CHARACTER_CLASS_PATTERN = new Pattern("(\\[[^]]*) (.*?])");
+    private static final Pattern COMMENT_PATTERN = new Pattern("\\(\\?#[^)]*\\)");
+    private static final Pattern COMMENT2_PATTERN = new Pattern("(?<!\\\\)#.*");
     private static final Pattern HEX_SINGLE_DIGIT_PATTERN = new Pattern("\\\\x(\\p{XDigit})(?!\\p{XDigit})");
     private static final Pattern OCTAL_SINGLE_ZERO_PATTERN = new Pattern("\\\\(0)(?![0-7])");
     private static final Pattern OCTAL_MISSING_ZERO_PATTERN = new Pattern("\\\\([1-7][0-7]{1,2})");
     private static final Pattern POSIX_NAME = new Pattern("\\[:(\\w+):\\]");
     
     public Pattern translate(String regex, int options, int javaRegexFlags) {
-    	javaRegexFlags |= translateFlags(options);
-		regex = translatePattern(regex, (javaRegexFlags & REFlags.IGNORE_SPACES) != 0);
+        javaRegexFlags |= translateFlags(options);
+        regex = translatePattern(regex, (javaRegexFlags & REFlags.IGNORE_SPACES) != 0);
         return new Pattern(regex, javaRegexFlags);
-	}
+    }
     
+    public Pattern translate(ByteList regex, int options, int javaRegexFlags) {
+        javaRegexFlags |= translateFlags(options);
+        String regexString;
+        if ((options & ReOptions.RE_UNICODE) == 0) {
+            regexString = regex.toString();
+        } else {
+            regexString = regex.toUtf8String();
+        }
+        String newRegex = translatePattern(regexString, (javaRegexFlags & REFlags.IGNORE_SPACES) != 0);
+        return new Pattern(newRegex, javaRegexFlags);
+    }
+    
     public int flagsFor(int options, int javaRegexFlags) {
         return javaRegexFlags | translateFlags(options);
     }
-
+    
     // We do not check for pathological case of [:foo:] outside of [] (bug 1475096).
     private String translatePosixPattern(String regex) {
         Substitution posix=new Substitution(){
-                public void appendSubstitution(MatchResult match, TextBuffer dest){
-                    String value = match.group(1);
-                    if ("alnum".equals(value)) {
-                        dest.append("\\p{Alnum}");
-                    } else if ("alpha".equals(value)) {
-                        dest.append("\\p{Alpha}");
-                    } else if ("blank".equals(value)) {
-                        dest.append("\\p{Blank}");
-                    } else if ("cntrl".equals(value)) {
-                        dest.append("\\p{Cntrl}");
-                    } else if ("digit".equals(value)) {
-                        dest.append("\\p{Digit}");
-                    } else if ("graph".equals(value)) {
-                        dest.append("\\p{Graph}");
-                    } else if ("lower".equals(value)) {
-                        dest.append("\\p{Lower}");
-                    } else if ("print".equals(value)) {
-                        dest.append("\\p{Print}");
-                    } else if ("punct".equals(value)) {
-                        dest.append("\\p{Punct}");
-                    } else if ("space".equals(value)) {
-                        dest.append("\\p{Space}");
-                    } else if ("upper".equals(value)) {
-                        dest.append("\\p{Upper}");
-                    } else if ("xdigit".equals(value)) {
-                        dest.append("\\p{XDigit}");
-                    } else {
-                        dest.append("\\[:" + value + ":\\]");
-                    }
+            public void appendSubstitution(MatchResult match, TextBuffer dest){
+                String value = match.group(1);
+                if ("alnum".equals(value)) {
+                    dest.append("\\p{Alnum}");
+                } else if ("alpha".equals(value)) {
+                    dest.append("\\p{Alpha}");
+                } else if ("blank".equals(value)) {
+                    dest.append("\\p{Blank}");
+                } else if ("cntrl".equals(value)) {
+                    dest.append("\\p{Cntrl}");
+                } else if ("digit".equals(value)) {
+                    dest.append("\\p{Digit}");
+                } else if ("graph".equals(value)) {
+                    dest.append("\\p{Graph}");
+                } else if ("lower".equals(value)) {
+                    dest.append("\\p{Lower}");
+                } else if ("print".equals(value)) {
+                    dest.append("\\p{Print}");
+                } else if ("punct".equals(value)) {
+                    dest.append("\\p{Punct}");
+                } else if ("space".equals(value)) {
+                    dest.append("\\p{Space}");
+                } else if ("upper".equals(value)) {
+                    dest.append("\\p{Upper}");
+                } else if ("xdigit".equals(value)) {
+                    dest.append("\\p{XDigit}");
+                } else {
+                    dest.append("\\[:" + value + ":\\]");
                 }
-            };
+            }
+        };
         Replacer r=POSIX_NAME.replacer(posix);
         return r.replace(regex);
     }
-
-	String translatePattern(String regex, boolean commentsAllowed) {
+    
+    String translatePattern(String regex, boolean commentsAllowed) {
         regex = COMMENT_PATTERN.replacer("").replace(regex);
-		regex = translatePosixPattern(regex); 
+        regex = translatePosixPattern(regex);
         regex = HEX_SINGLE_DIGIT_PATTERN.replacer("\\\\"+"x0$1").replace(regex);
         regex = OCTAL_SINGLE_ZERO_PATTERN.replacer("\\\\"+"0$1").replace(regex);
         regex = OCTAL_MISSING_ZERO_PATTERN.replacer("\\\\"+"0$1").replace(regex);
-		if (commentsAllowed) {
+        if (commentsAllowed) {
             regex = SPACE_IN_CHARACTER_CLASS_PATTERN.replacer("$1\\\\x20$2").replace(regex);
             regex = SHARP_IN_CHARACTER_CLASS_PATTERN.replacer("$1\\\\x23$2").replace(regex);
             regex = COMMENT2_PATTERN.replacer("").replace(regex);
-		}
-		return regex;
-	}
-	
-	int translateFlags(int options) {
-		int flags = REFlags.MULTILINE;
+        }
+        return regex;
+    }
+    
+    int translateFlags(int options) {
+        int flags = REFlags.MULTILINE;
         if ((options & ReOptions.RE_OPTION_IGNORECASE) > 0) {
             flags |= REFlags.IGNORE_CASE;
         }
         if ((options & ReOptions.RE_OPTION_EXTENDED) > 0) {
-        	flags |= REFlags.IGNORE_SPACES;
+            flags |= REFlags.IGNORE_SPACES;
         }
         if ((options & ReOptions.RE_OPTION_MULTILINE) > 0) {
-        	flags |= REFlags.DOTALL;
+            flags |= REFlags.DOTALL;
         }
-		return flags;
-	}
+        return flags;
+    }
 }
Index: src/org/jruby/RubyString.java
===================================================================
--- src/org/jruby/RubyString.java	(revision 3480)
+++ src/org/jruby/RubyString.java	(working copy)
@@ -2283,13 +2283,14 @@
         // get the pattern based on args
         if (args.length == 0 || args[0].isNil()) {
             isWhitespace = true;
-            IRubyObject defaultPattern = runtime.getGlobalVariables().get("$;");
+            // FIXME: Is this cast safe?
+            RubyString defaultPattern = (RubyString)runtime.getGlobalVariables().get("$;");
             
             if (defaultPattern.isNil()) {
                 pattern = RubyRegexp.newRegexp(runtime, "\\s+", 0, null);
             } else {
                 // FIXME: Is toString correct here?
-                pattern = RubyRegexp.newRegexp(runtime, defaultPattern.toString(), 0, null);
+                pattern = RubyRegexp.newRegexp(runtime, defaultPattern.getByteList(), 0, null);
             }
         } else if (args[0] instanceof RubyRegexp) {
             // Even if we have whitespace-only explicit regexp we do not
Index: src/org/jruby/parser/ReOptions.java
===================================================================
--- src/org/jruby/parser/ReOptions.java	(revision 3480)
+++ src/org/jruby/parser/ReOptions.java	(working copy)
@@ -30,12 +30,14 @@
 package org.jruby.parser;
 
 public interface ReOptions {
+    // FIXME: Is there a practical reason these weren't just literal values?
     int RE_OPTION_IGNORECASE   = 1;
-    int RE_OPTION_EXTENDED     = (RE_OPTION_IGNORECASE << 1);
-    int RE_OPTION_MULTILINE    = (RE_OPTION_EXTENDED   << 1);
-    int RE_OPTION_SINGLELINE   = (RE_OPTION_MULTILINE  << 1);
+    int RE_OPTION_EXTENDED     = 2;
+    int RE_OPTION_MULTILINE    = 4;
+    int RE_OPTION_SINGLELINE   = 8;
     int RE_OPTION_POSIXLINE    = (RE_OPTION_MULTILINE | RE_OPTION_SINGLELINE);
-    int RE_OPTION_LONGEST      = (RE_OPTION_SINGLELINE << 1);
-    int RE_MAY_IGNORECASE      = (RE_OPTION_LONGEST    << 1);
+    int RE_OPTION_LONGEST      = 16;
+    int RE_MAY_IGNORECASE      = 32;
+    int RE_UNICODE             = 64;
     int RE_OPTION_ONCE         = 0x80; // odd...but it is odd in ruby too.
 }
Index: src/org/jruby/util/ByteList.java
===================================================================
--- src/org/jruby/util/ByteList.java	(revision 3480)
+++ src/org/jruby/util/ByteList.java	(working copy)
@@ -31,6 +31,7 @@
 package org.jruby.util;
 
 import java.io.Serializable;
+import java.io.UnsupportedEncodingException;
 
 
 /**
@@ -583,8 +584,24 @@
     }
     
     public String toString() {
-        return new String(plain(this.bytes, begin, realSize));
+        try {
+            return toString("ISO-8859-1");
+        } catch (UnsupportedEncodingException uee) {
+            throw new RuntimeException("ISO-8859-1 encoding should never fail; report this at www.jruby.org");
+        }
     }
+    
+    public String toUtf8String() {
+        try {
+            return toString("UTF-8");
+        } catch (UnsupportedEncodingException uee) {
+            throw new RuntimeException("UTF-8 encoding should never fail; report this at www.jruby.org");
+        }
+    }
+    
+    public String toString(String encoding) throws UnsupportedEncodingException {
+        return new String(this.bytes, begin, realSize, encoding);
+    }
 
     public static ByteList create(CharSequence s) {
         return new ByteList(plain(s),false);
Index: src/org/jruby/ast/RegexpNode.java
===================================================================
--- src/org/jruby/ast/RegexpNode.java	(revision 3480)
+++ src/org/jruby/ast/RegexpNode.java	(working copy)
@@ -83,7 +83,7 @@
     
     public int getFlags() {
         if (pattern == null) {
-            pattern = translator.translate(value.toString(), options, 0);
+            pattern = translator.translate(value, options, 0);
             flags = translator.flagsFor(options,0);
         }
         return flags;
@@ -91,7 +91,7 @@
 
     public Pattern getPattern() {
         if (pattern == null) {
-            pattern = translator.translate(value.toString(), options, 0);
+            pattern = translator.translate(value, options, 0);
             flags = translator.flagsFor(options,0);
         }
         return pattern;