public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, Thread /*!*/ self)
{
RubyThreadInfo.RegisterThread(Thread.CurrentThread);
MutableString result = MutableString.CreateMutable();
result.Append("#<");
result.Append(RubyUtils.GetClassName(context, self));
result.Append(':');
RubyUtils.AppendFormatHexObjectId(result, RubyUtils.GetObjectId(context, self));
result.Append(' ');
if ((self.ThreadState & ThreadState.WaitSleepJoin) != 0)
{
result.Append("sleep");
}
else if ((self.ThreadState & (ThreadState.Stopped | ThreadState.Aborted | ThreadState.AbortRequested)) != 0)
{
result.Append("dead");
}
else
{
result.Append("run");
}
result.Append('>');
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, TypeGroup /*!*/ self)
{
var result = MutableString.CreateMutable(context.GetIdentifierEncoding());
result.Append("#<TypeGroup: ");
bool isFirst = true;
foreach (var entry in self.TypesByArity.ToSortedList((x, y) => x.Key - y.Key))
{
Type type = entry.Value;
if (!isFirst)
{
result.Append(", ");
}
else
{
isFirst = false;
}
result.Append(context.GetTypeName(type, true));
}
result.Append('>');
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, Hash /*!*/ self)
{
using (IDisposable handle = RubyUtils.InfiniteInspectTracker.TrackObject(self)) {
if (handle == null)
{
return(MutableString.CreateAscii("{...}"));
}
MutableString str = MutableString.CreateMutable(RubyEncoding.Binary);
str.Append('{');
bool first = true;
foreach (var entry in self)
{
if (first)
{
first = false;
}
else
{
str.Append(", ");
}
str.Append(context.Inspect(BaseSymbolDictionary.ObjToNull(entry.Key)));
str.Append("=>");
str.Append(context.Inspect(entry.Value));
}
str.Append('}');
return(str);
}
}
public static MutableString /*!*/ Inspect(RubyStruct /*!*/ self)
{
RubyContext context = self.ImmediateClass.Context;
using (IDisposable handle = RubyUtils.InfiniteInspectTracker.TrackObject(self)) {
// #<struct Struct::Foo name=nil, val=nil>
var result = MutableString.CreateMutable(RubyEncoding.Binary);
result.Append("#<struct ");
result.Append(context.Inspect(context.GetClassOf(self)));
if (handle == null)
{
return(result.Append(":...>"));
}
result.Append(' ');
object[] data = self.Values;
var members = self.GetNames();
for (int i = 0; i < data.Length; i++)
{
if (i != 0)
{
result.Append(", ");
}
// TODO (encoding):
result.Append(members[i]);
result.Append('=');
result.Append(context.Inspect(data[i]));
}
result.Append('>');
return(result);
}
}
internal static MutableString /*!*/ ToS(string /*!*/ methodName, RubyModule /*!*/ declaringModule, RubyModule /*!*/ targetModule,
string /*!*/ classDisplayName)
{
MutableString result = MutableString.CreateMutable();
result.Append("#<");
result.Append(classDisplayName);
result.Append(": ");
if (ReferenceEquals(targetModule, declaringModule))
{
result.Append(declaringModule.Name);
}
else
{
result.Append(targetModule.Name);
result.Append('(');
result.Append(declaringModule.Name);
result.Append(')');
}
result.Append('#');
result.Append(methodName);
result.Append('>');
return(result);
}
internal static MutableString /*!*/ ToS(RubyContext /*!*/ context, string /*!*/ methodName, RubyModule /*!*/ declaringModule, RubyModule /*!*/ targetModule,
string /*!*/ classDisplayName)
{
MutableString result = MutableString.CreateMutable(context.GetIdentifierEncoding());
result.Append("#<");
result.Append(classDisplayName);
result.Append(": ");
if (ReferenceEquals(targetModule, declaringModule))
{
result.Append(declaringModule.GetDisplayName(context, true));
}
else
{
result.Append(targetModule.GetDisplayName(context, true));
result.Append('(');
result.Append(declaringModule.GetDisplayName(context, true));
result.Append(')');
}
result.Append('#');
result.Append(methodName);
result.Append('>');
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, RubyFile /*!*/ self)
{
return(MutableString.CreateMutable(context.GetPathEncoding()).
Append("#<File:").
Append(self.Path).
Append(self.Closed ? " (closed)" : "").
Append('>'));
}
public static MutableString /*!*/ ToS(RubyRegex /*!*/ self)
{
// Ruby: doesn't wrap if there is a single embedded expression that evaluates to non-nil:
// puts(/#{nil}#{/a/}#{nil}/)
// We don't do that.
return(Append(self, MutableString.CreateMutable()));
}
public MutableString /*!*/ Inspect(RubyContext /*!*/ context)
{
var result = MutableString.CreateMutable(RubyEncoding.Binary);
result.Append(context.Inspect(_begin));
result.Append(Separator);
result.Append(context.Inspect(_end));
return(result);
}
public static MutableString Join(ConversionStorage <MutableString> /*!*/ stringCast, RubyClass /*!*/ self, params object[] /*!*/ parts)
{
MutableString result = MutableString.CreateMutable(RubyEncoding.Binary);
Dictionary <object, bool> visitedLists = null;
var worklist = new Stack <object>();
int current = 0;
MutableString str;
Push(worklist, parts);
while (worklist.Count > 0)
{
object part = worklist.Pop();
var list = part as IList;
if (list != null)
{
if (list.Count == 0)
{
str = MutableString.FrozenEmpty;
}
else if (visitedLists != null && visitedLists.ContainsKey(list))
{
str = RubyUtils.InfiniteRecursionMarker;
}
else
{
if (visitedLists == null)
{
visitedLists = new Dictionary <object, bool>(ReferenceEqualityComparer.Instance);
}
visitedLists.Add(list, true);
Push(worklist, list);
continue;
}
}
else if (part == null)
{
throw RubyExceptions.CreateTypeConversionError("NilClass", "String");
}
else
{
str = Protocols.CastToString(stringCast, part);
}
if (current > 0)
{
AppendDirectoryName(result, str);
}
else
{
result.Append(str);
}
current++;
}
return(result);
}
internal static MutableString /*!*/ ToChr(RubyEncoding /*!*/ encoding, RubyEncoding /*!*/ resultEncoding, int codepoint)
{
if (codepoint < 0)
{
throw RubyExceptions.CreateRangeError("{0} out of char range", codepoint);
}
switch (encoding.CodePage)
{
case RubyEncoding.CodePageUTF7:
case RubyEncoding.CodePageUTF8:
case RubyEncoding.CodePageUTF16BE:
case RubyEncoding.CodePageUTF16LE:
case RubyEncoding.CodePageUTF32BE:
case RubyEncoding.CodePageUTF32LE:
if (codepoint > 0x10ffff)
{
throw RubyExceptions.CreateRangeError("{0} is not a valid Unicode code point (0..0x10ffff)", codepoint);
}
return(MutableString.CreateMutable(Tokenizer.UnicodeCodePointToString(codepoint), resultEncoding));
case RubyEncoding.CodePageSJIS:
if (codepoint >= 0x81 && codepoint <= 0x9f || codepoint >= 0xe0 && codepoint <= 0xfc)
{
throw RubyExceptions.CreateArgumentError("invalid codepoint 0x{0:x2} in Shift_JIS", codepoint);
}
goto default;
case RubyEncoding.CodePageEUCJP:
// MRI's bahavior is strange - bug?
if (codepoint >= 0x80)
{
throw RubyExceptions.CreateRangeError("{0} out of char range", codepoint);
}
goto default;
default:
if (codepoint <= 0xff)
{
return(MutableString.CreateBinary(new[] { (byte)codepoint }, resultEncoding));
}
if (encoding.IsDoubleByteCharacterSet)
{
if (codepoint <= 0xffff)
{
return(MutableString.CreateBinary(new[] { (byte)(codepoint >> 8), (byte)(codepoint & 0xff) }, resultEncoding));
}
throw RubyExceptions.CreateRangeError("{0} out of char range", codepoint);
}
if (encoding.IsSingleByteCharacterSet)
{
throw RubyExceptions.CreateRangeError("{0} out of char range", codepoint);
}
throw new NotSupportedException(RubyExceptions.FormatMessage("Encoding {0} code points not supported", encoding));
}
}
public static MutableString /*!*/ Inspect(RubyRegex /*!*/ self)
{
MutableString result = MutableString.CreateMutable();
result.Append('/');
AppendEscapeForwardSlash(result, self.GetPattern());
result.Append('/');
AppendOptionString(result, self.Options, true, true);
return(result);
}
public MutableString /*!*/ Inspect()
{
MutableString result = MutableString.CreateMutable(RubyEncoding.Binary);
result.Append('/');
AppendEscapeForwardSlash(result, _pattern);
result.Append('/');
AppendOptionString(result, true, true);
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, RubyEncoding /*!*/ self)
{
// TODO: to_s overridden
MutableString result = MutableString.CreateMutable();
result.Append("#<");
result.Append(RubyUtils.GetClassName(context, self));
result.Append(':');
result.Append(self.Name);
result.Append(">");
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, RubyEncoding /*!*/ self)
{
// TODO: to_s overridden
MutableString result = MutableString.CreateMutable(context.GetIdentifierEncoding());
result.Append("#<");
result.Append(context.GetClassDisplayName(self));
result.Append(':');
result.Append(self.Name);
result.Append('>');
return(result);
}
public static MutableString Join(RubyClass /*!*/ self, [NotNull] params object[] strings)
{
MutableString result = MutableString.CreateMutable();
for (int i = 0; i < strings.Length; ++i)
{
result.Append(Protocols.ConvertToString(self.Context, strings[i]));
if (i < strings.Length - 1)
{
result.Append(SEPARATOR);
}
}
return(result);
}
private static MutableString /*!*/ JoinArguments(MutableString /*!*/[] /*!*/ args)
{
MutableString result = MutableString.CreateMutable(RubyEncoding.Binary);
for (int i = 0; i < args.Length; i++)
{
result.Append(args[i]);
if (args.Length > 1 && i < args.Length - 1)
{
result.Append(' ');
}
}
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, Thread /*!*/ self)
{
RubyThreadInfo.RegisterThread(Thread.CurrentThread);
MutableString result = MutableString.CreateMutable(context.GetIdentifierEncoding());
result.Append("#<");
result.Append(context.GetClassDisplayName(self));
result.Append(':');
RubyUtils.AppendFormatHexObjectId(result, RubyUtils.GetObjectId(context, self));
result.Append(' ');
RubyThreadStatus status = GetStatus(self);
switch (status)
{
case RubyThreadStatus.Unstarted:
result.Append("unstarted");
break;
case RubyThreadStatus.Running:
result.Append("run");
break;
case RubyThreadStatus.Sleeping:
result.Append("sleep");
break;
case RubyThreadStatus.Aborting:
result.Append("aborting");
break;
case RubyThreadStatus.Completed:
case RubyThreadStatus.Aborted:
result.Append("dead");
break;
}
result.Append('>');
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, Exception /*!*/ self)
{
object message = RubyExceptionData.GetInstance(self).Message;
string className = RubyUtils.GetClassName(context, self);
MutableString result = MutableString.CreateMutable();
result.Append("#<");
result.Append(className);
result.Append(": ");
if (message != null)
{
result.Append(KernelOps.Inspect(context, message));
}
else
{
result.Append(className);
}
result.Append('>');
return(result);
}
public static MutableString /*!*/ Inspect(UnaryOpStorage /*!*/ inspectStorage, ConversionStorage <MutableString> /*!*/ tosConversion, Exception /*!*/ self)
{
object message = RubyExceptionData.GetInstance(self).Message;
string className = inspectStorage.Context.GetClassDisplayName(self);
MutableString result = MutableString.CreateMutable(inspectStorage.Context.GetIdentifierEncoding());
result.Append("#<");
result.Append(className);
result.Append(": ");
if (message != null)
{
result.Append(KernelOps.Inspect(inspectStorage, tosConversion, message));
}
else
{
result.Append(className);
}
result.Append('>');
return(result);
}
private static RubyRegex /*!*/ Union(ConversionStorage <MutableString> /*!*/ stringCast, ICollection /*!*/ objs)
{
if (objs.Count == 0)
{
return(new RubyRegex(MutableString.CreateAscii("(?!)"), RubyRegexOptions.NONE));
}
MutableString result = MutableString.CreateMutable(RubyEncoding.Binary);
int i = 0;
foreach (var obj in objs)
{
if (i > 0)
{
result.Append('|');
}
// TODO: to_regexp
RubyRegex regex = obj as RubyRegex;
if (regex != null)
{
if (objs.Count == 1)
{
return(regex);
}
regex.AppendTo(result);
}
else
{
result.Append(RubyRegex.Escape(Protocols.CastToString(stringCast, obj)));
}
i++;
}
return(new RubyRegex(result, RubyRegexOptions.NONE));
}
public static MutableString Inspect(RubyContext /*!*/ context, IDictionary <object, object> /*!*/ self)
{
using (IDisposable handle = RubyUtils.InfiniteInspectTracker.TrackObject(self)) {
if (handle == null)
{
return(MutableString.CreateAscii("{...}"));
}
MutableString str = MutableString.CreateMutable(RubyEncoding.Binary);
str.Append('{');
foreach (KeyValuePair <object, object> pair in self)
{
if (str.Length != 1)
{
str.Append(", ");
}
str.Append(context.Inspect(CustomStringDictionary.ObjToNull(pair.Key)));
str.Append("=>");
str.Append(context.Inspect(pair.Value));
}
str.Append('}');
return(str);
}
}
public static RubyRegex /*!*/ Union(ConversionStorage <MutableString> /*!*/ stringCast, RubyClass /*!*/ self, params object[] /*!*/ strings)
{
if (strings.Length == 0)
{
return(new RubyRegex(MutableString.CreateAscii("(?!)"), RubyRegexOptions.NONE));
}
MutableString result = MutableString.CreateMutable(RubyEncoding.Binary);
for (int i = 0; i < strings.Length; i++)
{
if (i > 0)
{
result.Append('|');
}
RubyRegex regex = strings[i] as RubyRegex;
if (regex != null)
{
if (strings.Length == 1)
{
return(regex);
}
regex.AppendTo(result);
}
else
{
result.Append(RubyRegex.Escape(Protocols.CastToString(stringCast, strings[i])));
}
}
// TODO:
//RubyClass regexClass = RubyUtils.GetExecutionContext(context).GetClass(typeof(RubyRegex));
//return NewCallSite3.Invoke(context, regexClass, result, null, null);
return(new RubyRegex(result, RubyRegexOptions.NONE));
}
public MutableString ReadLine(MutableString separator)
{
AssertOpenedForReading();
int c = ReadByteNormalizeEoln();
if (c == -1)
{
return(null);
}
int separatorOffset = 0;
MutableString result = MutableString.CreateMutable();
do
{
result.Append((char)c);
if (separator != null && c == separator.GetChar(separatorOffset))
{
if (separatorOffset == separator.Length - 1)
{
break;
}
separatorOffset++;
}
else if (separatorOffset > 0)
{
separatorOffset = 0;
}
c = ReadByteNormalizeEoln();
} while (c != -1);
return(result);
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, RubyFile /*!*/ self)
{
return(MutableString.CreateMutable("#<File:").Append(self.Path).Append('>'));
}
public static MutableString /*!*/ Basename(RubyClass /*!*/ self,
[DefaultProtocol, NotNull] MutableString /*!*/ path, [DefaultProtocol, NotNull, Optional] MutableString extensionFilter)
{
if (path.IsEmpty)
{
return(path);
}
MutableString trimmedPath = TrimTrailingSlashes(path);
// Special cases of drive letters C:\\ or C:/
if (trimmedPath.Length == 2)
{
if (Char.IsLetter(trimmedPath.GetChar(0)) && trimmedPath.GetChar(1) == ':')
{
var result = (path.Length > 2 ? MutableString.Create(path.GetChar(2).ToString()) : MutableString.CreateMutable());
return(result.TaintBy(path));
}
}
string trimmedPathAsString = trimmedPath.ConvertToString();
if (trimmedPathAsString == "/")
{
return(trimmedPath);
}
string filename = Path.GetFileName(trimmedPath.ConvertToString());
// Handle UNC host names correctly
string root = Path.GetPathRoot(trimmedPath.ConvertToString());
if (MutableString.IsNullOrEmpty(extensionFilter))
{
return(MutableString.Create(trimmedPathAsString == root ? root : filename));
}
string fileExtension = Path.GetExtension(filename);
string basename = Path.GetFileNameWithoutExtension(filename);
string strResult = WildcardExtensionMatch(fileExtension, extensionFilter.ConvertToString()) ? basename : filename;
return(Glob.CanonicalizePath(MutableString.Create(strResult)).TaintBy(path));
}
public static MutableString /*!*/ Basename(RubyClass /*!*/ self,
[DefaultProtocol, NotNull] MutableString /*!*/ path, [DefaultProtocol, NotNull, Optional] MutableString suffix)
{
if (path.IsEmpty)
{
return(path);
}
string strPath = path.ConvertToString();
string[] parts = strPath.Split(new[] { DirectorySeparatorChar, AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 0)
{
return(MutableString.CreateMutable(path.Encoding).Append((char)path.GetLastChar()).TaintBy(path));
}
if (Environment.OSVersion.Platform != PlatformID.Unix && Environment.OSVersion.Platform != PlatformID.MacOSX)
{
string first = parts[0];
if (strPath.Length >= 2 && IsDirectorySeparator(strPath[0]) && IsDirectorySeparator(strPath[1]))
{
// UNC: skip 2 parts
if (parts.Length <= 2)
{
return(MutableString.CreateMutable(path.Encoding).Append(DirectorySeparatorChar).TaintBy(path));
}
}
else if (first.Length == 2 && Tokenizer.IsLetter(first[0]) && first[1] == ':')
{
// skip drive letter "X:"
if (parts.Length <= 1)
{
var result = MutableString.CreateMutable(path.Encoding).TaintBy(path);
if (strPath.Length > 2)
{
result.Append(strPath[2]);
}
return(result);
}
}
}
string last = parts[parts.Length - 1];
if (MutableString.IsNullOrEmpty(suffix))
{
return(MutableString.CreateMutable(last, path.Encoding));
}
StringComparison comparison = Environment.OSVersion.Platform == PlatformID.Unix ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
int matchLength = last.Length;
if (suffix != null)
{
string strSuffix = suffix.ToString();
if (strSuffix.LastCharacter() == '*' && strSuffix.Length > 1)
{
int suffixIdx = last.LastIndexOf(
strSuffix.Substring(0, strSuffix.Length - 1),
comparison
);
if (suffixIdx >= 0 && suffixIdx + strSuffix.Length <= last.Length)
{
matchLength = suffixIdx;
}
}
else if (last.EndsWith(strSuffix, comparison))
{
matchLength = last.Length - strSuffix.Length;
}
}
return(MutableString.CreateMutable(path.Encoding).Append(last, 0, matchLength).TaintBy(path));
}
public MutableString /*!*/ ToMutableString()
{
return(AppendTo(MutableString.CreateMutable(RubyEncoding.Binary)));
}
public static MutableString /*!*/ Inspect(object /*!*/ self)
{
return(MutableString.CreateMutable(RubyEncoding.Binary).Append(self.ToString()).Append(" (Decimal)"));
}
public static MutableString /*!*/ FormatTime(RubyContext /*!*/ context, RubyTime /*!*/ self,
[DefaultProtocol, NotNull] MutableString /*!*/ format)
{
MutableString result = MutableString.CreateMutable(format.Encoding);
bool inFormat = false;
var charEnum = format.GetCharacters();
while (charEnum.MoveNext())
{
var character = charEnum.Current;
int c = character.IsValid ? character.Value : -1;
if (!inFormat)
{
if (c == '%')
{
inFormat = true;
}
else
{
result.Append(character);
}
continue;
}
inFormat = false;
string dateTimeFormat = null;
switch (c)
{
case '%':
result.Append('%');
break;
case 'a':
dateTimeFormat = "ddd";
break;
case 'A':
dateTimeFormat = "dddd";
break;
case 'b':
dateTimeFormat = "MMM";
break;
case 'B':
dateTimeFormat = "MMMM";
break;
case 'c':
dateTimeFormat = "g";
break;
case 'd':
dateTimeFormat = "dd";
break;
case 'D':
dateTimeFormat = "MM/dd/yy";
break;
case 'e': { // Day of the month, blank-padded ( 1..31)
int day = self.DateTime.Day;
if (day < 10)
{
result.Append(' ');
}
result.Append(day.ToString(CultureInfo.InvariantCulture));
break;
}
case 'H':
dateTimeFormat = "HH";
break;
case 'I':
dateTimeFormat = "hh";
break;
case 'j':
result.AppendFormat("{0:000}", self.DateTime.DayOfYear);
break;
case 'l': {
int hour = self.DateTime.Hour;
if (hour == 0)
{
hour = 12;
}
else if (hour > 12)
{
hour -= 12;
}
if (hour < 10)
{
result.Append(' ');
}
result.Append(hour.ToString(CultureInfo.InvariantCulture));
break;
}
case 'm':
dateTimeFormat = "MM";
break;
case 'M':
dateTimeFormat = "mm";
break;
case 'p':
dateTimeFormat = "tt";
break;
case 'S':
dateTimeFormat = "ss";
break;
case 'T':
dateTimeFormat = "HH:mm:ss";
break;
case 'U':
FormatDayOfWeek(result, self.DateTime, 7);
break;
case 'W':
FormatDayOfWeek(result, self.DateTime, 8);
break;
case 'w':
result.Append(((int)self.DateTime.DayOfWeek).ToString(CultureInfo.InvariantCulture));
break;
case 'x':
dateTimeFormat = "d";
break;
case 'X':
dateTimeFormat = "t";
break;
case 'y':
dateTimeFormat = "yy";
break;
case 'Y':
dateTimeFormat = "yyyy";
break;
case 'Z':
dateTimeFormat = "%K";
break;
case 'z':
if (context.RubyOptions.Compatibility > RubyCompatibility.Ruby186)
{
result.Append(self.FormatUtcOffset());
}
else
{
result.Append(RubyTime.GetCurrentZoneName());
}
break;
default:
if (context.RubyOptions.Compatibility > RubyCompatibility.Ruby186)
{
result.Append(character);
break;
}
return(MutableString.CreateEmpty());
}
if (dateTimeFormat != null)
{
result.Append(self.ToString(dateTimeFormat, CultureInfo.InvariantCulture));
}
}
if (inFormat)
{
if (context.RubyOptions.Compatibility > RubyCompatibility.Ruby186)
{
return(result.Append('%'));
}
return(MutableString.CreateEmpty());
}
return(result);
}
