rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/IronRuby/Languages/Ruby/Ruby/Runtime/RubyUtils.cs

@@ -0,0 +1,1476 @@
+/* ****************************************************************************
+ *
+ * Copyright (c) Microsoft Corporation. 
+ *
+ * This source code is subject to terms and conditions of the Apache License, Version 2.0. A 
+ * copy of the license can be found in the License.html file at the root of this distribution. If 
+ * you cannot locate the  Apache License, Version 2.0, please send an email to 
+ * ironruby@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
+ * by the terms of the Apache License, Version 2.0.
+ *
+ * You must not remove this notice, or any other, from this software.
+ *
+ *
+ * ***************************************************************************/
+
+#if !CLR2
+using System.Linq.Expressions;
+#else
+using Microsoft.Scripting.Ast;
+#endif
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading;
+using IronRuby.Builtins;
+using IronRuby.Compiler;
+using IronRuby.Runtime.Calls;
+using Microsoft.Scripting;
+using Microsoft.Scripting.Math;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+using IronRuby.Runtime.Conversions;
+
+namespace IronRuby.Runtime {
+    using EvalEntryPointDelegate = Func<RubyScope, object, RubyModule, Proc, object>;
+    using Microsoft.Scripting.Actions.Calls;
+
+    public static class RubyUtils {
+        #region Objects
+
+        public static readonly int FalseObjectId = 0;
+        public static readonly int TrueObjectId = 2;
+        public static readonly int NilObjectId = 4;
+
+        /// <summary>
+        /// Ruby value types:
+        /// 
+        /// NilClass
+        /// TrueClass
+        /// FalseClass
+        /// Fixnum
+        /// Symbol
+        /// + CLR structs
+        /// </summary>
+        public static bool IsRubyValueType(object obj) {
+            return (obj == null || obj is ValueType || obj is RubySymbol) && !(obj is float || obj is double);
+        }
+
+        /// <summary>
+        /// The object maintains a state (frozen, tainted flags and instance variables).
+        /// <code>
+        /// obj.instance_variable_set(:@foo, 'bar')
+        /// puts obj.instance_variable_get(:@foo)     # => 'bar'
+        /// puts obj.taint.tainted?                   # => true
+        /// </code>
+        /// </summary>
+        public static bool HasObjectState(object obj) {
+            return !IsRubyValueType(obj);
+        }
+
+        /// <summary>
+        /// Can the object be cloned?
+        /// </summary>
+        public static bool CanClone(object obj) {
+            return !IsRubyValueType(obj);
+        }
+
+        /// <summary>
+        /// Is it allowed to define a sigleton method for the object?
+        /// </summary>
+        public static bool CanDefineSingletonMethod(object obj) {
+            return !(obj is ValueType || obj is RubySymbol || obj is BigInteger) || obj is bool;
+        }
+
+        /// <summary>
+        /// Does the object have a sigleton class?
+        /// </summary>
+        public static bool HasSingletonClass(object obj) {
+            return !(obj is int || obj is RubySymbol);
+        }
+        
+        public static MutableString/*!*/ InspectObject(UnaryOpStorage/*!*/ inspectStorage, ConversionStorage<MutableString>/*!*/ tosConversion, 
+            object obj) {
+
+            var context = tosConversion.Context;
+            using (IDisposable handle = RubyUtils.InfiniteInspectTracker.TrackObject(obj)) {
+                if (handle == null) {
+                    return MutableString.CreateAscii("...");
+                }
+
+                MutableString str = MutableString.CreateMutable(context.GetIdentifierEncoding());
+                str.Append("#<");
+                str.Append(context.GetClassDisplayName(obj));
+
+                // Ruby prints 2*object_id for objects
+                str.Append(':');
+                AppendFormatHexObjectId(str, GetObjectId(context, obj));
+
+                RubyInstanceData data = context.TryGetInstanceData(obj);
+                if (data != null) {
+                    var vars = data.GetInstanceVariablePairs();
+                    bool first = true;
+                    foreach (KeyValuePair<string, object> var in vars) {
+                        if (first) {
+                            str.Append(' ');
+                            first = false;
+                        } else {
+                            str.Append(", ");
+                        }
+                        // TODO (encoding):
+                        str.Append(var.Key);
+                        str.Append('=');
+
+                        var inspectSite = inspectStorage.GetCallSite("inspect");
+                        object inspectedValue = inspectSite.Target(inspectSite, var.Value);
+
+                        var tosSite = tosConversion.GetSite(ConvertToSAction.Make(context));
+                        str.Append(tosSite.Target(tosSite, inspectedValue));
+
+                        str.TaintBy(var.Value, context);
+                    }
+                }
+                str.Append(">");
+
+                str.TaintBy(obj, context);
+                return str;
+            }
+        }
+
+        public static MutableString/*!*/ FormatObjectPrefix(RubyContext/*!*/ context, string/*!*/ className, long objectId, bool isTainted, bool isUntrusted) {
+            MutableString str = MutableString.CreateMutable(context.GetIdentifierEncoding());
+            str.Append("#<");
+            str.Append(className);
+
+            // Ruby prints 2*object_id for objects
+            str.Append(':');
+            AppendFormatHexObjectId(str, objectId);
+
+            str.IsTainted |= isTainted;
+            str.IsUntrusted |= isUntrusted;
+            return str;
+        }
+
+        public static MutableString/*!*/ FormatObject(RubyContext/*!*/ context, string/*!*/ className, long objectId, bool isTainted, bool isUntrusted) {
+            return FormatObjectPrefix(context, className, objectId, isTainted, isUntrusted).Append(">");
+        }
+
+        public static MutableString/*!*/ ObjectToMutableString(RubyContext/*!*/ context, object obj) {
+            bool tainted, untrusted;
+            context.GetObjectTrust(obj, out tainted, out untrusted);
+            return FormatObject(context, context.GetClassDisplayName(obj), GetObjectId(context, obj), tainted, untrusted);
+        }
+
+        public static MutableString/*!*/ ObjectToMutableStringPrefix(RubyContext/*!*/ context, object obj) {
+            bool tainted, untrusted;
+            context.GetObjectTrust(obj, out tainted, out untrusted);
+            return FormatObjectPrefix(context, context.GetClassDisplayName(obj), GetObjectId(context, obj), tainted, untrusted);
+        }
+
+        public static MutableString/*!*/ AppendFormatHexObjectId(MutableString/*!*/ str, long objectId) {
+            return str.AppendFormat("0x{0:x7}", 2 * objectId);
+        }
+
+        public static MutableString/*!*/ ObjectToMutableString(IRubyObject/*!*/ self) {
+            return RubyUtils.FormatObject(
+                self.ImmediateClass.Context, 
+                self.ImmediateClass.GetNonSingletonClass().Name, 
+                self.GetInstanceData().ObjectId, 
+                self.IsTainted,
+                self.IsUntrusted
+            );
+        }
+
+        public static MutableString/*!*/ ObjectBaseToMutableString(IRubyObject/*!*/ self) {
+            if (self is RubyObject) {
+                return RubyUtils.ObjectToMutableString(self);
+            } else {
+                return MutableString.CreateMutable(self.BaseToString(), RubyEncoding.UTF8);
+            }
+        }
+
+        public static bool TryDuplicateObject(
+            CallSiteStorage<Func<CallSite, object, object, object>>/*!*/ initializeCopyStorage,
+            CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, 
+            object obj, bool cloneSemantics, out object copy) {
+
+            // Ruby value types can't be cloned
+            if (!RubyUtils.CanClone(obj)) {
+                copy = null;
+                return false;
+            }
+
+            var context = allocateStorage.Context;
+
+            IDuplicable clonable = obj as IDuplicable;
+            if (clonable != null) {
+                copy = clonable.Duplicate(context, cloneSemantics);
+            } else {
+                // .NET and library classes that don't implement IDuplicable:
+                var allocateSite = allocateStorage.GetCallSite("allocate", 0);
+                copy = allocateSite.Target(allocateSite, context.GetClassOf(obj));
+
+                context.CopyInstanceData(obj, copy, cloneSemantics);
+            }
+
+            var initializeCopySite = initializeCopyStorage.GetCallSite("initialize_copy", 1);
+            initializeCopySite.Target(initializeCopySite, copy, obj);
+            if (cloneSemantics) {
+                context.FreezeObjectBy(copy, obj);
+            }
+
+            return true;
+        }        
+
+        public static long GetFixnumId(int number) {
+            return ((long)number << 1) + 1;
+        }
+
+        public static long GetObjectId(RubyContext/*!*/ context, object obj) {
+            if (obj == null) return NilObjectId;
+            if (obj is bool) return (bool)obj ? TrueObjectId : FalseObjectId;
+            if (obj is int) return GetFixnumId((int)obj);
+
+            return context.GetInstanceData(obj).ObjectId;
+        }
+
+        private const int CachedCharCount = 256;
+        private static object[] _charCache = new object[CachedCharCount];
+
+        public static object/*!*/ CharToObject(char ch) {
+            return (ch < CachedCharCount) ? (_charCache[(int)ch] ?? (_charCache[(int)ch] = (object)ch)) : (object)ch;
+        }
+
+        
+
+        #endregion
+
+        #region Names
+
+        public static bool HasUnmangledName(string/*!*/ name) {
+            return !NotUnmangledObject.Contains(name);
+        }
+        
+        public static string TryUnmangleMethodName(string/*!*/ name) {
+            return HasUnmangledName(name) ? TryUnmangleName(name) : null;
+        }
+
+        /// <summary>
+        /// Converts a Ruby name to PascalCase name (foo_bar -> FooBar).
+        /// Returns null if the name is not a well-formed Ruby name (it contains upper-case latter or subsequent underscores).
+        /// Characters that are not upper case letters are treated as lower-case letters.
+        /// </summary>
+        public static string TryUnmangleName(string/*!*/ name) {
+            ContractUtils.RequiresNotNull(name, "name");
+            if (name.Length == 0) {
+                return null;
+            }
+
+            StringBuilder mangled = new StringBuilder();
+
+            bool lastWasSpecial = false;
+            int i = 0, j = 0;
+            while (i < name.Length) {
+                char c;
+                while (j < name.Length && (c = name[j]) != '_') {
+                    if (Char.IsUpper(c)) {
+                        return null;
+                    }
+                    j++;
+                }
+
+                if (j == i || j == name.Length - 1) {
+                    return null;
+                }
+
+                if (j - i == 1) {
+                    // "ip_f_xxx" -/-> "IPFXxx"
+                    if (lastWasSpecial) {
+                        return null;
+                    }
+                    mangled.Append(name[i].ToUpperInvariant());
+                    lastWasSpecial = false;
+                } else {
+                    string special = MapSpecialWord(name, i, j - i);
+                    if (special != null) {
+                        // "ip_ip" -/-> "IPIP"
+                        if (lastWasSpecial) {
+                            return null;
+                        }
+                        mangled.Append(special.ToUpperInvariant());
+                        lastWasSpecial = true;
+                    } else {
+                        mangled.Append(name[i].ToUpperInvariant());
+                        mangled.Append(name, i + 1, j - i - 1);
+                        lastWasSpecial = false;
+                    }
+                }
+
+                i = ++j;
+            }
+
+            return mangled.ToString();
+        }
+
+        public static bool HasMangledName(string/*!*/ name) {
+            return !NotMangledObject.Contains(name);
+        }
+
+        public static string TryMangleMethodName(string/*!*/ name) {
+            return HasMangledName(name) ? TryMangleName(name) : null;
+        }
+
+        /// <summary>
+        /// Converts a camelCase or PascalCase name to a Ruby name (FooBar -> foo_bar).
+        /// Returns null if the name is not in camelCase or PascalCase (FooBAR, foo, etc.).
+        /// Characters that are not upper case letters are treated as lower-case letters.
+        /// </summary>
+        public static string TryMangleName(string/*!*/ name) {
+            ContractUtils.RequiresNotNull(name, "name");
+
+            StringBuilder mangled = null;
+            int i = 0;
+            while (i < name.Length) {
+                char c = name[i];
+                if (Char.IsUpper(c)) {
+                    int j = i + 1;
+                    while (j < name.Length && Char.IsUpper(name, j)) {
+                        j++;
+                    }
+
+                    if (j < name.Length) {
+                        j--;
+                    }
+
+                    if (mangled == null) {
+                        mangled = new StringBuilder();
+                        mangled.Append(name, 0, i);
+                    } 
+
+                    if (i > 0) {
+                        mangled.Append('_');
+                    }
+
+                    int count = j - i;
+                    if (count == 0) {
+                        // NaN{end}, NaNXxx
+                        if (i + 2 < name.Length && 
+                            Char.IsUpper(name[i + 2]) && 
+                            (i + 3 == name.Length || Char.IsUpper(name[i + 3]) && 
+                            (i + 4 < name.Length && !Char.IsUpper(name[i + 4])))) {
+                            return null;
+                        } else {
+                            // X{end}, In, NaN, Xml, Html, ...
+                            mangled.Append(c.ToLowerInvariant());
+                            i++;
+                        }
+                    } else if (count == 1) {
+                        // FXx
+                        mangled.Append(c.ToLowerInvariant());
+                        i++;
+                    } else {
+                        // FOXxx, FOOXxx, FOOOXxx, ...
+                        string special = MapSpecialWord(name, i, count);
+                        if (special != null) {
+                            mangled.Append(special.ToLowerInvariant());
+                            i = j;
+                        } else {
+                            return null;
+                        }
+                    }
+                } else if (c == '_') {
+                    return null;
+                } else {
+                    if (mangled != null) {
+                        mangled.Append(c);
+                    }
+                    i++;
+                }
+            }
+
+            return mangled != null ? mangled.ToString() : null;
+        }
+
+        private static string MapSpecialWord(string/*!*/ name, int start, int count) {
+            if (count == 2) {
+                return IsTwoLetterWord(name, start) ? null : name.Substring(start, count);
+            }
+
+            return null;
+        }
+
+        private static bool IsTwoLetterWord(string/*!*/ str, int index) {
+            int c = LetterPair(str, index);
+            switch (c) {
+                case ('a' << 8) | 't':
+                case ('a' << 8) | 's':
+                case ('b' << 8) | 'y':
+                case ('d' << 8) | 'o':
+                case ('i' << 8) | 'd':
+                case ('i' << 8) | 't':
+                case ('i' << 8) | 'f':
+                case ('i' << 8) | 'n':
+                case ('i' << 8) | 's':
+                case ('g' << 8) | 'o':
+                case ('m' << 8) | 'e':
+                case ('m' << 8) | 'y':
+                case ('n' << 8) | 'o':
+                case ('o' << 8) | 'f':
+                case ('o' << 8) | 'k':
+                case ('o' << 8) | 'n':
+                case ('o' << 8) | 'r':
+                case ('t' << 8) | 'o':
+                case ('u' << 8) | 'p':
+                    return true;
+            }
+            return false;
+        }
+
+        private static int LetterPair(string/*!*/ str, int index) {
+            return (str[index + 1] & 0xff00) == 0 ? (str[index].ToLowerInvariant() << 8) | str[index + 1].ToLowerInvariant() : -1;
+        }
+
+        /// <summary>
+        /// A list of Kernel/Object methods that are expected by common Ruby libraries to work on all objects.
+        /// We don't unmangled them to allow Ruby programs work with .NET objects that define e.g. Class property. 
+        /// </summary>
+        internal static readonly HashSet<string> NotUnmangledObject = new HashSet<string>() {
+            // Kernel
+            "class",
+            "clone",
+            "display",
+            "dup",
+            "extend",
+            "freeze",
+            "hash",
+            // "id", Kernel#id is deprecated
+            "initialize",
+            "inspect",
+            "instance_eval",
+            "instance_exec",
+            "instance_variable_get",
+            "instance_variable_set",
+            "instance_variables",
+            "method",
+            "methods",
+            "object_id",
+            "private_methods",
+            "protected_methods",
+            "public_methods",
+            "send",
+            "singleton_methods",
+            "taint",
+            // "type", Kernel#type is deprecated
+            "untaint",
+        };
+
+        internal static readonly HashSet<string> NotMangledObject = new HashSet<string>() {
+            "Class",
+            "Clone",
+            "Display",
+            "Dup",
+            "Extend",
+            "Freeze",
+            "Hash",
+            // "Id", Kernel#id is deprecated
+            "Initialize",
+            "Inspect",
+            "InstanceEval",
+            "InstanceExec",
+            "InstanceVariableGet",
+            "InstanceVariableSet",
+            "InstanceVariables",
+            "Method",
+            "Methods",
+            "ObjectId",
+            "PrivateMethods",
+            "ProtectedMethods",
+            "PublicMethods",
+            "Send",
+            "SingletonMethods",
+            "Taint",
+            // "Type", Kernel#type is deprecated
+            "Untaint",
+        };
+
+        public static void CheckConstantName(string name) {
+            if (!Tokenizer.IsConstantName(name)) {
+                throw RubyExceptions.CreateNameError(String.Format("`{0}' is not allowed as a constant name", name));
+            }
+        }
+
+        public static void CheckClassVariableName(string name) {
+            if (!Tokenizer.IsClassVariableName(name)) {
+                throw RubyExceptions.CreateNameError(String.Format("`{0}' is not allowed as a class variable name", name));
+            }
+        }
+
+        public static void CheckInstanceVariableName(string name) {
+            if (!Tokenizer.IsInstanceVariableName(name)) {
+                throw RubyExceptions.CreateNameError(String.Format("`{0}' is not allowed as an instance variable name", name));
+            }
+        }
+
+        #endregion
+
+        #region Constants
+
+        // thread-safe:
+        public static object GetConstant(RubyGlobalScope/*!*/ globalScope, RubyModule/*!*/ owner, string/*!*/ name, bool lookupObject) {
+            Assert.NotNull(globalScope, owner, name);
+
+            using (owner.Context.ClassHierarchyLocker()) {
+                ConstantStorage storage;
+                if (owner.TryResolveConstantNoLock(globalScope, name, out storage)) {
+                    return storage.Value;
+                }
+
+                RubyClass objectClass = owner.Context.ObjectClass;
+                if (owner != objectClass && lookupObject && objectClass.TryResolveConstantNoLock(globalScope, name, out storage)) {
+                    return storage.Value;
+                }
+            }
+
+            RubyUtils.CheckConstantName(name);
+            return owner.ConstantMissing(name);
+        }
+
+        public static void SetConstant(RubyModule/*!*/ owner, string/*!*/ name, object value) {
+            Assert.NotNull(owner, name);
+
+            if (owner.SetConstantChecked(name, value)) {
+                owner.Context.ReportWarning(String.Format("already initialized constant {0}", name));
+            }
+
+            // Initializes anonymous module's name, publishes the module:
+            RubyModule module = value as RubyModule;
+            if (module != null) {
+                if (module.Name == null) {
+                    module.Name = owner.MakeNestedModuleName(name);
+                }
+                if (owner.IsObjectClass) {
+                    module.Publish(name);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Methods
+
+        public static RubyMethodVisibility GetSpecialMethodVisibility(RubyMethodVisibility/*!*/ visibility, string/*!*/ methodName) {
+            return (methodName == Symbols.Initialize || methodName == Symbols.InitializeCopy) ? RubyMethodVisibility.Private : visibility;
+        }
+
+        internal static string ToClrOperatorName(string/*!*/ rubyName) {
+            switch (rubyName) {
+                case "+": return "op_Addition";
+                case "-": return "op_Subtraction";
+                case "/": return "op_Division";
+                case "*": return "op_Multiply";
+                case "%": return "op_Modulus";
+                case "==": return "op_Equality";
+                case "!=": return "op_Inequality";
+                case ">": return "op_GreaterThan";
+                case ">=": return "op_GreaterThanOrEqual";
+                case "<": return "op_LessThan";
+                case "<=": return "op_LessThanOrEqual";
+                case "-@": return "op_UnaryNegation";
+                case "+@": return "op_UnaryPlus";
+                case "<<": return "op_LeftShift";
+                case ">>": return "op_RightShift";
+                case "^": return "op_ExclusiveOr";
+                case "~": return "op_OnesComplement";
+                case "&": return "op_BitwiseAnd";
+                case "|": return "op_BitwiseOr";
+                
+                case "**": return "Power";
+                case "<=>": return "Compare";
+
+                default:
+                    return null;
+            }
+        }
+
+        internal static string ToRubyOperatorName(string/*!*/ clrName) {
+            switch (clrName) {
+                case "op_Addition": return "+";
+                case "op_Subtraction": return "-";
+                case "op_Division": return "/";
+                case "op_Multiply": return "*";
+                case "op_Modulus": return "%";
+                case "op_Equality": return "==";
+                case "op_Inequality": return "!=";
+                case "op_GreaterThan": return ">";
+                case "op_GreaterThanOrEqual": return ">=";
+                case "op_LessThan": return "<";
+                case "op_LessThanOrEqual": return "<=";
+                case "op_UnaryNegation": return "-@";
+                case "op_UnaryPlus": return "+@";
+                case "op_LeftShift": return "<<";
+                case "op_RightShift": return ">>";
+                case "op_BitwiseAnd": return "&";
+                case "op_BitwiseOr": return "|";
+                case "op_ExclusiveOr": return "^";
+                case "op_OnesComplement": return "~";
+
+                case "Power": return "**";
+                case "Compare": return "<=>";
+                
+                default:
+                    return null;
+            }
+        }
+
+        internal static string MapOperator(OverloadInfo/*!*/ method) {
+            return method.IsStatic && method.IsSpecialName ? ToRubyOperatorName(method.Name) : null;
+        }
+
+        internal static string MapOperator(MethodInfo/*!*/ method) {
+            return method.IsStatic && method.IsSpecialName ? ToRubyOperatorName(method.Name) : null;
+        }
+
+        internal static bool IsOperator(OverloadInfo/*!*/ method) {
+            return MapOperator(method) != null;
+        }
+
+        internal static string MapOperator(ExpressionType op) {
+            string methodName;
+            TryMapOperator(op, out methodName);
+            return methodName;
+        }
+
+        internal static int TryMapOperator(ExpressionType op, out string methodName) {
+            switch (op) {
+                case ExpressionType.Add: methodName = "+"; return 2;
+                case ExpressionType.Subtract: methodName = "-"; return 2;
+                case ExpressionType.Divide: methodName = "/"; return 2;
+                case ExpressionType.Multiply: methodName = "*"; return 2;
+                case ExpressionType.Modulo: methodName = "%"; return 2;
+                case ExpressionType.Equal: methodName = "=="; return 2;
+                case ExpressionType.NotEqual: methodName = "!="; return 2;
+                case ExpressionType.GreaterThan: methodName = ">"; return 2;
+                case ExpressionType.GreaterThanOrEqual: methodName = ">="; return 2;
+                case ExpressionType.LessThan: methodName = "<"; return 2;
+                case ExpressionType.LessThanOrEqual: methodName = "<="; return 2;
+                case ExpressionType.LeftShift: methodName = "<<"; return 2;
+                case ExpressionType.RightShift: methodName = ">>"; return 2;
+                case ExpressionType.And: methodName = "&"; return 2;
+                case ExpressionType.Or: methodName = "|"; return 2;
+                case ExpressionType.ExclusiveOr: methodName = "^"; return 2;
+                case ExpressionType.Power: methodName = "**"; return 2;
+
+                case ExpressionType.Negate: methodName = "-@"; return 1;
+                case ExpressionType.UnaryPlus: methodName = "+@"; return 1;
+                case ExpressionType.OnesComplement: methodName = "~"; return 1;
+                case ExpressionType.Not: methodName = "!"; return 1;
+            }
+
+            methodName = null;
+            return 0;
+        }
+
+        internal static int TryMapOperator(string/*!*/ methodName, out ExpressionType op) {
+            switch (methodName) {
+                case "+": op = ExpressionType.Add; return 2;
+                case "-": op = ExpressionType.Subtract; return 2;
+                case "/": op = ExpressionType.Divide; return 2;
+                case "*": op = ExpressionType.Multiply; return 2;
+                case "%": op = ExpressionType.Modulo; return 2;
+                case "==": op = ExpressionType.Equal; return 2;
+                case "!=": op = ExpressionType.NotEqual; return 2;
+                case ">": op = ExpressionType.GreaterThan; return 2;
+                case ">=": op = ExpressionType.GreaterThanOrEqual; return 2;
+                case "<": op = ExpressionType.LessThan; return 2;
+                case "<=": op = ExpressionType.LessThanOrEqual; return 2;
+                case "<<": op = ExpressionType.LeftShift; return 2;
+                case ">>": op = ExpressionType.RightShift; return 2;
+                case "&": op = ExpressionType.And; return 2;
+                case "|": op = ExpressionType.Or; return 2;
+                case "^": op = ExpressionType.ExclusiveOr; return 2;
+                case "**": op = ExpressionType.Power; return 2;
+
+                case "-@": op = ExpressionType.Negate; return 1;
+                case "+@": op = ExpressionType.UnaryPlus; return 1;
+                case "~": op = ExpressionType.OnesComplement; return 1;
+                case "!": op = ExpressionType.Not; return 1;
+            }
+
+            op = default(ExpressionType);
+            return 0;
+        }
+
+        #endregion
+
+        #region Modules, Classes
+        
+        internal static RubyModule/*!*/ GetModuleFromObject(RubyScope/*!*/ scope, object obj) {
+            RubyModule module = obj as RubyModule;
+            if (module == null) {
+                throw CreateNotModuleException(scope, obj);
+            }
+            return module;
+        }
+
+        internal static Exception/*!*/ CreateNotModuleException(RubyScope/*!*/ scope, object obj) {
+            return RubyExceptions.CreateTypeError(String.Format("{0} is not a class/module", scope.RubyContext.GetClassOf(obj)));
+        }
+
+        public static void RequireMixins(RubyModule/*!*/ target, params RubyModule[]/*!*/ modules) {
+            foreach (RubyModule module in modules) {
+                if (module == null) {
+                    throw RubyExceptions.CreateTypeError("wrong argument type nil (expected Module)");
+                }
+
+                if (module == target) {
+                    throw RubyExceptions.CreateArgumentError("cyclic include detected");
+                }
+
+                if (module.IsClass) {
+                    throw RubyExceptions.CreateTypeError("wrong argument type Class (expected Module)");
+                }
+
+                if (module.Context != target.Context) {
+                    throw RubyExceptions.CreateTypeError(String.Format("cannot mix a foreign module `{0}' into `{1}' (runtime mismatch)", 
+                        module.GetName(target.Context), target.GetName(module.Context)
+                    ));
+                }
+            }
+        }
+
+        #endregion
+
+        #region Tracking operations that have the potential for infinite recursion
+
+        public static readonly MutableString InfiniteRecursionMarker = MutableString.CreateAscii("[...]").Freeze();
+
+        public class RecursionTracker {
+            [ThreadStatic]
+            private Dictionary<object, bool> _infiniteTracker;
+
+            private Dictionary<object, bool> TryPushInfinite(object obj) {
+                if (_infiniteTracker == null) {
+                    _infiniteTracker = new Dictionary<object, bool>(ReferenceEqualityComparer<object>.Instance);
+                }
+                Dictionary<object, bool> infinite = _infiniteTracker;
+                if (infinite.ContainsKey(obj)) {
+                    return null;
+                }
+                infinite.Add(obj, true);
+                return infinite;
+            }
+
+            public IDisposable TrackObject(object obj) {
+                obj = CustomStringDictionary.NullToObj(obj);
+                Dictionary<object, bool> tracker = TryPushInfinite(obj);
+                return (tracker == null) ? null : new RecursionHandle(tracker, obj);
+            }
+
+            private class RecursionHandle : IDisposable {
+                private readonly Dictionary<object, bool>/*!*/ _tracker;
+                private readonly object _obj;
+
+                internal RecursionHandle(Dictionary<object, bool>/*!*/ tracker, object obj) {
+                    _tracker = tracker;
+                    _obj = obj;
+                }
+
+                public void Dispose() {
+                    _tracker.Remove(_obj);
+                }
+            }
+        }
+
+        [MultiRuntimeAware]
+        private static readonly RecursionTracker _infiniteInspectTracker = new RecursionTracker();
+
+        public static RecursionTracker InfiniteInspectTracker {
+            get { return _infiniteInspectTracker; }
+        }
+
+        [MultiRuntimeAware]
+        private static readonly RecursionTracker _infiniteToSTracker = new RecursionTracker();
+
+        public static RecursionTracker InfiniteToSTracker {
+            get { return _infiniteToSTracker; }
+        }
+
+        #endregion
+
+        #region Arrays, Hashes
+
+        // MRI checks for a subtype of RubyArray of subtypes of MutableString.
+        internal static RubyArray AsArrayOfStrings(object value) {
+            RubyArray array = value as RubyArray;
+            if (array != null) {
+                foreach (object obj in array) {
+                    MutableString str = obj as MutableString;
+                    if (str == null) {
+                        return null;
+                    }
+                }
+                return array;
+            }
+            return null;
+        }
+
+        public static object SetHashElement(RubyContext/*!*/ context, IDictionary<object, object>/*!*/ obj, object key, object value) {
+            MutableString str = key as MutableString;
+            if (str != null) {
+                key = str.Duplicate(context, false, str.Clone()).Freeze();
+            } else {
+                key = CustomStringDictionary.NullToObj(key);
+            }
+            return obj[key] = value;
+        }
+
+        public static Hash/*!*/ SetHashElements(RubyContext/*!*/ context, Hash/*!*/ hash, object[]/*!*/ items) {
+            Assert.NotNull(context, hash, items);
+            Debug.Assert(items != null && items.Length % 2 == 0);
+
+            for (int i = 0; i < items.Length; i += 2) {
+                Debug.Assert(i + 1 < items.Length);
+                SetHashElement(context, hash, items[i], items[i + 1]);
+            }
+
+            return hash;
+        }
+
+        #endregion
+
+        #region Evals
+
+        //                         scope                   parent scope            self
+        // M.module_eval {}        block                   current                 M 
+        // x.instance_eval {}      block                   current                 x
+        // M.module_eval ""        ModEval(module: M)      current                 M
+        // x.instance_eval ""      ModEval(module: S(x))   current                 x 
+        // eval "", binding        binding.scope           binding.scope.parent    binding.scope.self
+        //
+
+#if DEBUG
+        private static int _stringEvalCounter;
+#endif
+
+        public static RubyCompilerOptions/*!*/ CreateCompilerOptionsForEval(RubyScope/*!*/ targetScope, int line) {
+            return CreateCompilerOptionsForEval(targetScope, targetScope.GetInnerMostMethodScope(), false, line);
+        }
+
+        private static RubyCompilerOptions/*!*/ CreateCompilerOptionsForEval(RubyScope/*!*/ targetScope, RubyMethodScope methodScope,
+            bool isModuleEval, int line) {
+
+            return new RubyCompilerOptions(targetScope.RubyContext.RubyOptions) {
+                IsEval = true,
+                FactoryKind = isModuleEval ? TopScopeFactoryKind.ModuleEval : TopScopeFactoryKind.None,
+                LocalNames = targetScope.GetVisibleLocalNames(),
+                TopLevelMethodName = (methodScope != null) ? methodScope.DefinitionName : null,
+                TopLevelParameterNames = (methodScope != null) ? methodScope.GetVisibleParameterNames() : null,
+                TopLevelHasUnsplatParameter = (methodScope != null) ? methodScope.HasUnsplatParameter : false,
+                InitialLocation = new SourceLocation(0, line <= 0 ? 1 : line, 1),
+            };
+        }
+
+        private static SourceUnit/*!*/ CreateRubySourceUnit(RubyContext/*!*/ context, MutableString/*!*/ code, string path) {
+            return context.CreateSourceUnit(new BinaryContentProvider(code.ToByteArray()), path, code.Encoding.Encoding, SourceCodeKind.File);
+        }
+
+        public static object Evaluate(MutableString/*!*/ code, RubyScope/*!*/ targetScope, object self, RubyModule module, MutableString file, int line) {
+            Assert.NotNull(code, targetScope);
+
+            RubyContext context = targetScope.RubyContext;
+            RubyMethodScope methodScope = targetScope.GetInnerMostMethodScope();
+
+#if DEBUG
+            Utils.Log(Interlocked.Increment(ref _stringEvalCounter).ToString() + ": " + (file != null ? file.ToString() : "?") + " : " + line, "EVAL");
+#endif
+
+            // we want to create a new top-level local scope:
+            var options = CreateCompilerOptionsForEval(targetScope, methodScope, module != null, line);
+            var source = CreateRubySourceUnit(context, code, file != null ? file.ConvertToString() : "(eval)");
+
+            Expression<EvalEntryPointDelegate> lambda;
+            try {
+                lambda = context.ParseSourceCode<EvalEntryPointDelegate>(source, options, context.RuntimeErrorSink);
+            } catch (SyntaxError e) {
+                Utils.Log(e.Message, "EVAL_ERROR");
+                Utils.Log(new String('-', 50), "EVAL_ERROR");
+                Utils.Log(source.GetCode(), "EVAL_ERROR");
+                Utils.Log(new String('-', 50), "EVAL_ERROR");
+                throw;
+            }
+            Debug.Assert(lambda != null);
+
+            // module-eval:
+            if (module != null) {
+                targetScope = CreateModuleEvalScope(targetScope, self, module);
+            }
+
+            return ((EvalEntryPointDelegate)RubyScriptCode.CompileLambda(lambda, context))(
+                targetScope,
+                self,
+                module,
+                (methodScope != null) ? methodScope.BlockParameter : null
+            );
+        }
+
+        private static RubyScope/*!*/ CreateModuleEvalScope(RubyScope/*!*/ parent, object self, RubyModule/*!*/ module) {
+            var scope = new RubyModuleEvalScope(parent, module, self);
+            scope.SetDebugName("instance/module-eval");
+            return scope;
+        }
+
+        public static object EvaluateInModule(RubyModule/*!*/ self, BlockParam/*!*/ block, object[] args) {
+            object result;
+            EvaluateBlock(block, self, self, args, out result);
+            return result;
+        }
+
+        public static object EvaluateInModule(RubyModule/*!*/ self, BlockParam/*!*/ block, object[] args, object defaultReturnValue) {
+            object result;
+            return EvaluateBlock(block, self, self, args, out result) ? result : defaultReturnValue;
+        }
+
+        public static object EvaluateInSingleton(object self, BlockParam/*!*/ block, object[] args) {
+            // TODO: this is checked in method definition, if no method is defined it is ok.
+            // => singleton is created in method definition also.
+            if (!RubyUtils.CanDefineSingletonMethod(self)) {
+                throw RubyExceptions.CreateTypeError("can't define singleton method for literals");
+            }
+
+            object result;
+            EvaluateBlock(block, block.RubyContext.GetOrCreateSingletonClass(self), self, args, out result);
+            return result;
+        }
+
+        private static bool EvaluateBlock(BlockParam/*!*/ block, RubyModule/*!*/ module, object self, object[] args, out object result) {
+            Assert.NotNull(block, module);
+            block.MethodLookupModule = module;
+
+            if (args != null) {
+                result = RubyOps.Yield(args, null, self, block);
+            } else {
+                result = RubyOps.Yield0(null, self, block);
+            }
+
+            return block.BlockJumped(result);
+        }
+
+        #endregion
+
+        #region Object Construction
+
+        private static readonly Type[] _ccTypes1 = new Type[] { typeof(RubyClass) };
+        private static readonly Type[] _ccTypes2 = new Type[] { typeof(RubyContext) };
+#if !SILVERLIGHT // serialization
+        private static readonly Type[] _serializableTypeSignature = new Type[] { typeof(SerializationInfo), typeof(StreamingContext) };
+#endif
+
+        public static readonly string SerializationInfoClassKey = "#immediateClass";
+
+        public static object/*!*/ CreateObject(RubyClass/*!*/ theclass, IEnumerable<KeyValuePair<string, object>>/*!*/ attributes) {
+            Assert.NotNull(theclass, attributes);
+
+            Type baseType = theclass.GetUnderlyingSystemType();
+            object obj;
+            if (typeof(ISerializable).IsAssignableFrom(baseType)) {
+#if !SILVERLIGHT // serialization
+                BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
+                ConstructorInfo ci = baseType.GetConstructor(bindingFlags, null, _serializableTypeSignature, null);
+                if (ci == null) {
+#endif
+                string message = String.Format("Class {0} does not have a valid deserializing constructor", baseType.FullName);
+                    throw new NotSupportedException(message);
+#if !SILVERLIGHT // serialization
+                }
+                SerializationInfo info = new SerializationInfo(baseType, new FormatterConverter());
+                info.AddValue(SerializationInfoClassKey, theclass);
+                foreach (var pair in attributes) {
+                    info.AddValue(pair.Key, pair.Value);
+                }
+                obj = ci.Invoke(new object[2] { info, new StreamingContext(StreamingContextStates.Other, theclass) });
+#endif
+            } else {
+                obj = CreateObject(theclass);
+                foreach (var pair in attributes) {
+                    theclass.Context.SetInstanceVariable(obj, pair.Key, pair.Value);
+                }
+            }
+            return obj;
+        }
+
+        private static bool IsAvailable(MethodBase method) {
+            return method != null && !method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly;
+        }
+
+        // TODO: remove
+        public static object/*!*/ CreateObject(RubyClass/*!*/ theClass) {
+            Assert.NotNull(theClass);
+
+            Type baseType = theClass.GetUnderlyingSystemType();
+            if (baseType == typeof(RubyStruct)) {
+                return RubyStruct.Create(theClass);
+            }
+
+            object result;
+            BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
+            ConstructorInfo ci;
+            if (IsAvailable(ci = baseType.GetConstructor(bindingFlags, null, Type.EmptyTypes, null))) {
+                result = ci.Invoke(new object[0] { });
+            } else if (IsAvailable(ci = baseType.GetConstructor(bindingFlags, null, _ccTypes1, null))) {
+                result = ci.Invoke(new object[1] { theClass });
+            } else if (IsAvailable(ci = baseType.GetConstructor(bindingFlags, null, _ccTypes2, null))) {
+                result = ci.Invoke(new object[1] { theClass.Context });
+            } else {
+                string message = String.Format("Class {0} does not have a valid constructor", theClass.Name);
+                throw new NotSupportedException(message);
+            }
+            return result;
+        }
+
+        #endregion
+
+        #region Call Site Storage Extensions
+
+        public static CallSite<TCallSiteFunc>/*!*/ GetCallSite<TCallSiteFunc>(ref CallSite<TCallSiteFunc>/*!*/ site, RubyContext/*!*/ context,
+            string/*!*/ methodName, int argumentCount) where TCallSiteFunc : class {
+
+            if (site == null) {
+                Interlocked.CompareExchange(ref site,
+                    CallSite<TCallSiteFunc>.Create(RubyCallAction.Make(context, methodName, RubyCallSignature.WithImplicitSelf(argumentCount))), null);
+            }
+            return site;
+        }
+
+        public static CallSite<TCallSiteFunc>/*!*/ GetCallSite<TCallSiteFunc>(ref CallSite<TCallSiteFunc>/*!*/ site, RubyContext/*!*/ context,
+            string/*!*/ methodName, RubyCallSignature signature) where TCallSiteFunc : class {
+
+            if (site == null) {
+                Interlocked.CompareExchange(ref site,
+                    CallSite<TCallSiteFunc>.Create(RubyCallAction.Make(context, methodName, signature)), null);
+            }
+            return site;
+        }
+
+        public static CallSite<Func<CallSite, object, TResult>>/*!*/ GetCallSite<TResult>(
+            ref CallSite<Func<CallSite, object, TResult>>/*!*/ site, RubyConversionAction/*!*/ conversion) {
+
+            if (site == null) {
+                Interlocked.CompareExchange(ref site, CallSite<Func<CallSite, object, TResult>>.Create(conversion), null);
+            }
+            return site;
+        }
+
+        #endregion
+
+        #region Exceptions
+
+#if SILVERLIGHT // Thread.ExceptionState, Thread.Abort(stateInfo)
+        public static Exception GetVisibleException(Exception e) { return e; }
+
+        public static void ExitThread(Thread/*!*/ thread) {
+            thread.Abort();
+        }
+
+        public static bool IsRubyThreadExit(Exception e) {
+            return e is ThreadAbortException;
+        }
+#else
+        /// <summary>
+        /// Thread#raise is implemented on top of System.Threading.Thread.ThreadAbort, and squirreling
+        /// the Ruby exception expected by the use in ThreadAbortException.ExceptionState.
+        /// </summary>
+        private class AsyncExceptionMarker {
+            internal Exception Exception { get; set; }
+            internal AsyncExceptionMarker(Exception e) {
+                this.Exception = e;
+            }
+        }
+
+        public static void RaiseAsyncException(Thread thread, Exception e) {
+            thread.Abort(new AsyncExceptionMarker(e));
+        }
+
+        // TODO: This is redundant with ThreadOps.RubyThreadInfo.ExitRequested. However, we cannot access that
+        // from here as it is in a separate assembly.
+        private class ThreadExitMarker {
+        }
+
+        public static void ExitThread(Thread/*!*/ thread) {
+            thread.Abort(new ThreadExitMarker());
+        }
+
+        /// <summary>
+        /// Thread#exit is implemented by calling Thread.Abort. However, we need to distinguish a call to Thread#exit
+        /// from a raw call to Thread.Abort.
+        /// 
+        /// Note that if a finally block raises an exception while an Abort is pending, that exception can be propagated instead of a ThreadAbortException.
+        /// </summary>
+        public static bool IsRubyThreadExit(Exception e) {
+            ThreadAbortException tae = e as ThreadAbortException;
+            if (tae != null) {
+                if (tae.ExceptionState is ThreadExitMarker) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Can return null for Thread#kill
+        /// </summary>
+        public static Exception GetVisibleException(Exception e) {
+            ThreadAbortException tae = e as ThreadAbortException;
+            if (tae != null) {
+                if (IsRubyThreadExit(e)) {
+                    return null;
+                }
+                AsyncExceptionMarker asyncExceptionMarker = tae.ExceptionState as AsyncExceptionMarker;
+                if (asyncExceptionMarker != null) {
+                    return asyncExceptionMarker.Exception;
+                }
+            }
+            return e;
+        }
+
+#endif
+
+        #endregion
+
+        #region Paths
+
+        public static MutableString CanonicalizePath(MutableString path) {
+            for (int i = 0; i < path.Length; i++) {
+                if (path.GetChar(i) == '\\')
+                    path.SetChar(i, '/');
+            }
+            return path;
+        }
+
+        public static String CanonicalizePath(string path) {
+            return path.Replace('\\', '/');
+        }
+
+        public static String CombinePaths(string basePath, string path) {
+            return basePath.Length == 0 || basePath.EndsWith("\\", StringComparison.Ordinal) || basePath.EndsWith("/", StringComparison.Ordinal) ? 
+                basePath + path :
+                basePath + "/" + path;
+        }
+
+        // TODO: virtualize via PAL
+        //RHO
+#if !SILVERLIGHT
+        public static bool FileSystemUsesDriveLetters { get { return Path.DirectorySeparatorChar == '\\'; } }
+#else
+        public static bool FileSystemUsesDriveLetters { get { return false; } }
+#endif
+        //RHO
+
+        // Is path something like "/foo/bar" (or "c:/foo/bar" on Windows)
+        // We need this instead of Path.IsPathRooted since we need to be able to deal with Unix-style path names even on Windows
+        public static bool IsAbsolutePath(string path) {
+            if (IsAbsoluteDriveLetterPath(path)) {
+                return true;
+            }
+
+            if (String.IsNullOrEmpty(path)) {
+                return false;
+            }
+
+            return path[0] == '/';
+        }
+
+        // Is path something like "c:/foo/bar" (on Windows)
+        public static bool IsAbsoluteDriveLetterPath(string path) {
+            if (String.IsNullOrEmpty(path)) {
+                return false;
+            }
+
+            if (!FileSystemUsesDriveLetters) {
+                return false;
+            }
+
+            return Tokenizer.IsLetter(path[0]) && path.Length >= 2 && path[1] == ':' && path[2] == '/';
+        }
+
+        // returns "//", "///", ... or something like "c:/"
+        public static string GetPathRoot(PlatformAdaptationLayer/*!*/ platform, string path, out string pathAfterRoot) {
+            Debug.Assert(IsAbsolutePath(path));
+            if (IsAbsoluteDriveLetterPath(path)) {
+                pathAfterRoot = path.Substring(3);
+                return path.Substring(0, 3);
+            } else {
+                Debug.Assert(path[0] == '/');
+
+                // The root for "////foo" is "/////"
+                string withoutInitialSlashes = path.TrimStart('/');
+                int initialSlashesCount = path.Length - withoutInitialSlashes.Length;
+                string initialSlashes = path.Substring(0, initialSlashesCount);
+                pathAfterRoot = path.Substring(initialSlashesCount);
+
+                if (!FileSystemUsesDriveLetters || initialSlashesCount > 1) {
+                    return initialSlashes;
+                } else {
+                    string currentDirectory = RubyUtils.CanonicalizePath(platform.CurrentDirectory);
+                    Debug.Assert(IsAbsoluteDriveLetterPath(currentDirectory));
+                    string temp;
+                    return GetPathRoot(platform, currentDirectory, out temp);
+                }
+            }
+        }
+
+        // Is path something like "c:foo" (note that this is not "c:/foo")
+        public static bool HasPartialDriveLetter(string path, out char partialDriveLetter, out string relativePath) {
+            partialDriveLetter = '\0';
+            relativePath = null;
+
+            if (String.IsNullOrEmpty(path)) {
+                return false;
+            }
+
+            if (!FileSystemUsesDriveLetters) {
+                return false;
+            }
+
+            if (Tokenizer.IsLetter(path[0]) && path.Length >= 2 && path[1] == ':' && (path.Length == 2 || path[2] != '/')) {
+                partialDriveLetter = path[0];
+                relativePath = path.Substring(2);
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        #region expand_path
+
+        // Algorithm to find HOME equivalents under Windows. This is equivalent to Ruby 1.9 behavior:
+        // 
+        // 1. Try get HOME
+        // 2. Try to generate HOME equivalent using HOMEDRIVE + HOMEPATH
+        // 3. Try to generate HOME equivalent from USERPROFILE
+        // 4. Try to generate HOME equivalent from Personal special folder 
+
+        public static string/*!*/ GetHomeDirectory(PlatformAdaptationLayer/*!*/ pal) {
+            string result = pal.GetEnvironmentVariable("HOME");
+            if (result == null) {
+                string homeDrive = pal.GetEnvironmentVariable("HOMEDRIVE");
+                string homePath = pal.GetEnvironmentVariable("HOMEPATH");
+                if (homeDrive == null && homePath == null) {
+                    string userEnvironment = pal.GetEnvironmentVariable("USERPROFILE");
+                    if (userEnvironment == null) {
+                        // This will always succeed with a non-null string, but it can fail
+                        // if the Personal folder was renamed or deleted. In this case it returns
+                        // an empty string.
+                        result = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
+                    } else {
+                        result = userEnvironment;
+                    }
+                } else if (homeDrive == null) {
+                    result = homePath;
+                } else if (homePath == null) {
+                    result = homeDrive + Path.DirectorySeparatorChar;
+                } else {
+                    result = homeDrive + homePath;
+                }
+
+                if (result != null) {
+                    result = ExpandPath(pal, result);
+                }
+            }
+
+            return result;
+        }
+
+        class PathExpander {
+            List<string> _pathComponents = new List<string>(); // does not include the root
+            string _root; // Typically "c:/" on Windows, and "/" on Unix
+
+            internal PathExpander(PlatformAdaptationLayer/*!*/ platform, string absoluteBasePath) {
+                Debug.Assert(RubyUtils.IsAbsolutePath(absoluteBasePath));
+
+                string basePathAfterRoot = null;
+                _root = RubyUtils.GetPathRoot(platform, absoluteBasePath, out basePathAfterRoot);
+
+                // Normally, basePathAfterRoot[0] will not be '/', but here we deal with cases like "c:////foo"
+                basePathAfterRoot = basePathAfterRoot.TrimStart('/');
+
+                AddRelativePath(basePathAfterRoot);
+            }
+
+            internal void AddRelativePath(string relPath) {
+                Debug.Assert(!RubyUtils.IsAbsolutePath(relPath));
+
+                string[] relPathComponents = relPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
+
+                foreach (string pathComponent in relPathComponents) {
+                    if (pathComponent == "..") {
+                        if (_pathComponents.Count == 0) {
+                            // MRI allows more pops than the base path components
+                            continue;
+                        }
+                        _pathComponents.RemoveAt(_pathComponents.Count - 1);
+                    } else if (pathComponent == ".") {
+                        continue;
+                    } else {
+                        _pathComponents.Add(pathComponent);
+                    }
+                }
+            }
+
+            internal string/*!*/ GetResult() {
+                StringBuilder result = new StringBuilder(_root);
+
+                if (_pathComponents.Count >= 1) {
+                    // Here we make this work:
+                    //   File.expand_path("c:/..a..") -> "c:/..a"
+                    string lastComponent = _pathComponents[_pathComponents.Count - 1];
+                    if (RubyUtils.FileSystemUsesDriveLetters && !String.IsNullOrEmpty(lastComponent.TrimEnd('.'))) {
+                        _pathComponents[_pathComponents.Count - 1] = lastComponent.TrimEnd('.');
+                    }
+                }
+
+                for (int i = 0; i < _pathComponents.Count; i++) {
+                    result.Append(_pathComponents[i]);
+                    if (i < (_pathComponents.Count - 1)) {
+                        result.Append('/');
+                    }
+                }
+#if DEBUG
+                _pathComponents = null;
+                _root = null;
+#endif
+                return result.ToString();
+            }
+        }
+
+        // Expand directory path - these cases exist:
+        //
+        // 1. Empty string or nil means return current directory
+        // 2. ~ with non-existent HOME directory throws exception
+        // 3. ~, ~/ or ~\ which expands to HOME
+        // 4. ~foo is left unexpanded
+        // 5. Expand to full path if path is a relative path
+        // 
+        // No attempt is made to determine whether the path is valid or not
+        // Returned path is always canonicalized to forward slashes
+
+        public static string/*!*/ ExpandPath(PlatformAdaptationLayer/*!*/ platform, string/*!*/ path) {
+            return ExpandPath(platform, path, platform.CurrentDirectory, true);
+        }
+
+        public static string/*!*/ ExpandPath(PlatformAdaptationLayer/*!*/ platform, string/*!*/ path, string/*!*/ basePath, bool expandHome) {
+            return ExpandPath(platform, path, basePath, expandHome, true);
+        }
+
+        private static string/*!*/ ExpandPath(PlatformAdaptationLayer/*!*/ platform, string/*!*/ path, string/*!*/ basePath, bool expandHome, bool expandBase) {
+            Assert.NotNull(platform, path, basePath);
+
+            if (expandHome) {
+                int length = path.Length;
+                if (length > 0 && path[0] == '~') {
+                    if (length == 1 || (path[1] == '/' || path[1] == '\\')) {
+                        string homeDirectory = platform.GetEnvironmentVariable("HOME");
+                        if (homeDirectory == null) {
+                            throw RubyExceptions.CreateArgumentError("couldn't find HOME environment -- expanding `~'");
+                        }
+
+                        if (length <= 2) {
+                            path = homeDirectory;
+                        } else {
+                            path = Path.Combine(homeDirectory, path.Substring(2));
+                        }
+                    } else {
+                        // MRI doesn't expand path that starts with ~, seems like a bug
+                        // http://redmine.ruby-lang.org/issues/show/3629
+                        return path;
+                    }
+                }
+                // MRI deosn't expand content of HOME variable (could be a relative path). We do.
+                // See http://redmine.ruby-lang.org/issues/show/3630
+            }
+
+            path = RubyUtils.CanonicalizePath(path);
+            basePath = RubyUtils.CanonicalizePath(basePath);
+
+            if (RubyUtils.IsAbsolutePath(path)) {
+                // "basePath" can be ignored if "path" is an absolute path
+                return new PathExpander(platform, path).GetResult();
+            }
+
+            // expand base path:
+            string expandedBasePath = expandBase ? ExpandPath(platform, basePath, platform.CurrentDirectory, expandHome, false) : basePath;
+
+            char drive;
+            string relativePath;
+            if (RubyUtils.HasPartialDriveLetter(path, out drive, out relativePath)) {
+                string _;
+                string root = RubyUtils.GetPathRoot(platform, expandedBasePath, out _);
+                if (root[0].ToLowerInvariant() != drive.ToLowerInvariant()) {
+                    expandedBasePath = RubyUtils.CanonicalizePath(platform.CurrentDirectory);
+                    root = RubyUtils.GetPathRoot(platform, expandedBasePath, out _);
+                    if (root[0].ToLowerInvariant() != drive.ToLowerInvariant()) {
+                        // MRI: Converts "X:path" to "X:/path" if X != base drive or current drive:
+                        return new PathExpander(platform, drive.ToString() + ":/" + relativePath).GetResult();
+                    }
+                }
+                path = relativePath;
+            }
+
+            PathExpander pathExpander = new PathExpander(platform, expandedBasePath);
+            pathExpander.AddRelativePath(path);
+            return pathExpander.GetResult();
+        }
+
+        /// <summary>
+        /// Returns the extension of given path.
+        /// Equivalent to <see cref="Path.GetExtension"/> but it doesn't check for an invalid path and 
+        /// it considers ".foo" to be a file name with no extension rather than an extension with an empty file name.
+        /// </summary>
+        /// <returns>Null iff path is null. Empty string if the path doesn't have any extension.</returns>
+        public static string GetExtension(string path) {
+            if (path == null) {
+                return null;
+            }
+
+            int length = path.Length;
+            int i = length;
+            while (--i >= 0) {
+                char c = path[i];
+                if (c == '.') {
+                    if (i != length - 1 && i > 0) {
+                        return path.Substring(i, length - i);
+                    }
+                    return String.Empty;
+                }
+                if (c == Path.DirectorySeparatorChar || c == Path.AltDirectorySeparatorChar || c == Path.VolumeSeparatorChar) {
+                    break;
+                }
+            }
+            return String.Empty;
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Streams
+
+        /// <summary>
+        /// Writes binary content of <see cref="MutableString"/> into the given buffer.
+        /// </summary>
+        public static void Write(this Stream/*!*/ stream, MutableString/*!*/ str, int start, int count) {
+            int byteCount;
+            byte[] bytes = str.GetByteArray(out byteCount);
+            if (start < byteCount) {
+                stream.Write(bytes, start, Math.Min(byteCount - start, count));
+            }
+        }
+
+        #endregion
+    }
+}