private void WriteRegex(RubyRegex /*!*/ value)
{
WriteSubclassData(value, typeof(RubyRegex));
_writer.Write((byte)'/');
WriteStringValue(value.Pattern);
_writer.Write((byte)value.Options);
}
public override Content /*!*/ EscapeRegularExpression()
{
// TODO:
StringBuilder sb = RubyRegex.EscapeToStringBuilder(ToString());
return((sb != null) ? new CharArrayContent(sb.ToString().ToCharArray(), _owner) : this);
}
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(self.ToMutableString());
}
private void WriteRegex(RubyRegex /*!*/ value)
{
SubclassData instanceWriter = new SubclassData(this, value, typeof(RubyRegex));
_writer.Write((byte)'/');
WriteStringValue(value.GetPattern());
_writer.Write((byte)value.Options);
}
public static bool CaseCompare(RubyContext /*!*/ context, RubyRegex /*!*/ self, object str)
{
MutableString asString = Protocols.AsString(context, str);
if (asString == null)
{
return(false);
}
return(CaseCompare(context, self, asString));
}
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 override Content /*!*/ EscapeRegularExpression()
{
// TODO:
var a = ToByteArray();
return(Create(
BinaryEncoding.Instance.GetBytes(RubyRegex.Escape(BinaryEncoding.Instance.GetString(a, 0, a.Length))),
_owner
));
}
private static MutableString /*!*/ Append(RubyRegex /*!*/ self, MutableString /*!*/ result)
{
Assert.NotNull(self, result);
result.Append("(?");
if (AppendOptionString(result, self.Options, true, false) < 3)
{
result.Append('-');
}
AppendOptionString(result, self.Options, false, false);
result.Append(':');
AppendEscapeForwardSlash(result, self.GetPattern());
result.Append(')');
return(result);
}
public static MutableString GetKCode(RubyRegex /*!*/ self)
{
switch (self.Options & RubyRegexOptions.EncodingMask)
{
case RubyRegexOptions.NONE: return(null);
case RubyRegexOptions.EUC: return(MutableString.CreateAscii("euc"));
case RubyRegexOptions.FIXED: return(MutableString.CreateAscii("none"));
case RubyRegexOptions.UTF8: return(MutableString.CreateAscii("utf8"));
case RubyRegexOptions.SJIS: return(MutableString.CreateAscii("sjis"));
default: throw Assert.Unreachable;
}
}
public static string GetSubstring(RubyScope /*!*/ scope, string /*!*/ self, [NotNull] RubyRegex /*!*/ regex, [DefaultProtocol] int occurrance)
{
if (regex.IsEmpty)
{
return(String.Empty);
}
MatchData match = RegexpOps.Match(scope, regex, MutableString.Create(self, RubyEncoding.UTF8));
if (match == null || !RegexpOps.NormalizeGroupIndex(ref occurrance, match.GroupCount))
{
return(null);
}
MutableString result = match.GetGroupValue(occurrance);
return(result != null?result.ToString() : null);
}
public static RubyRegex /*!*/ Union(ConversionStorage <MutableString> /*!*/ stringCast, ConversionStorage <IList> /*!*/ toAry, RubyClass /*!*/ self, [NotNull] object /*!*/ obj)
{
IList list = Protocols.TryCastToArray(toAry, obj);
if (list != null)
{
return(Union(stringCast, list));
}
// TODO: to_regexp
RubyRegex regex = obj as RubyRegex;
if (regex != null)
{
return(regex);
}
return(new RubyRegex(RubyRegex.Escape(Protocols.CastToString(stringCast, obj)), RubyRegexOptions.NONE));
}
internal protected StringRegex(string /*!*/ pattern, RubyRegexOptions options)
: base(options)
{
Assert.NotNull(pattern);
_pattern = pattern;
string transformed = TransformPattern(pattern, options);
try {
_regex = new Regex(transformed, RubyRegex.ToClrOptions(options));
} catch (ArgumentException e) {
Utils.Log("-- original ---" + new String('-', 50), "REGEX_ERROR");
Utils.Log(pattern, "REGEX_ERROR");
Utils.Log("-- transformed " + new String('-', 50), "REGEX_ERROR");
Utils.Log(transformed, "REGEX_ERROR");
Utils.Log("---------------" + new String('-', 50), "REGEX_ERROR");
throw new RegexpError(e.Message, e);
}
}
public static string GetSubstring(RubyScope /*!*/ scope, string /*!*/ self, [NotNull] RubyRegex /*!*/ regex)
{
if (regex.IsEmpty)
{
return(String.Empty);
}
// TODO (opt): don't create a new mutable string:
MatchData match = RegexpOps.Match(scope, regex, MutableString.Create(self, RubyEncoding.UTF8));
if (match == null)
{
return(null);
}
var result = match.GetValue();
return(result != null?result.ToString() : null);
}
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 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 static RubyRegex /*!*/ Create(RubyClass /*!*/ self,
[NotNull] RubyRegex /*!*/ other, [DefaultParameterValue(null)] object options, [Optional] object encoding)
{
ReportParametersIgnoredWarning(self.Context, encoding);
return(new RubyRegex(other));
}
public static RubyRegex /*!*/ Create(RubyClass /*!*/ self,
[NotNull] RubyRegex /*!*/ other, int options, [Optional] object encoding)
{
return(Create(self, other, (object)options, encoding));
}
public static RubyRegex /*!*/ Create(RubyClass /*!*/ self,
[NotNull] RubyRegex /*!*/ other)
{
return(new RubyRegex(other));
}
public static MutableString /*!*/ Escape(RubyClass /*!*/ self, [DefaultProtocol, NotNull] MutableString /*!*/ str)
{
return(RubyRegex.Escape(str).TaintBy(str));
}
public static MutableString /*!*/ Source(RubyRegex /*!*/ self)
{
return(self.Pattern.Clone());
}
public static object ImplicitMatch(ConversionStorage <MutableString> /*!*/ stringCast, RubyScope /*!*/ scope, RubyRegex /*!*/ self)
{
return(MatchIndex(scope, self, Protocols.CastToString(stringCast, scope.GetInnerMostClosureScope().LastInputLine)));
}
public static RubyRegex /*!*/ Reinitialize(RubyRegex /*!*/ self, [NotNull] RubyRegex /*!*/ other)
{
self.Set(other.Pattern, other.Options);
return(self);
}
public override Content /*!*/ EscapeRegularExpression()
{
StringBuilder sb = RubyRegex.EscapeToStringBuilder(_data);
return((sb != null) ? new StringContent(sb.ToString(), _owner) : this);
}
public static int GetHash(RubyRegex /*!*/ self)
{
return(self.GetHashCode());
}
public static bool Equals(RubyRegex /*!*/ self, object other)
{
return(false);
}
public static bool CaseCompare(ConversionStorage <MutableString> /*!*/ stringTryCast, RubyScope /*!*/ scope, RubyRegex /*!*/ self, object obj)
{
MutableString str = Protocols.TryCastToString(stringTryCast, obj);
return(str != null && Match(scope, self, str) != null);
}
public static object Match(BinaryOpStorageWithScope /*!*/ storage, RubyScope /*!*/ scope, ClrName /*!*/ self, [NotNull] RubyRegex /*!*/ regex)
{
return(MutableStringOps.Match(storage, scope, GetRubyName(scope.RubyContext, self), regex));
}
public static bool Equals(RubyContext /*!*/ context, RubyRegex /*!*/ self, [NotNull] RubyRegex /*!*/ other)
{
return(self.Equals(other));
}
private object /*!*/ ReadUserClass()
{
object obj = UnmarshalNewObject();
bool loaded = false;
int typeFlag = _reader.ReadByte();
switch (typeFlag)
{
case '"':
MutableString msc = (obj as MutableString);
if (msc != null)
{
msc.Replace(0, msc.Length, ReadString());
loaded = true;
}
break;
case '/':
RubyRegex rsc = (obj as RubyRegex);
if (rsc != null)
{
RubyRegex regex = ReadRegex();
rsc.Set(regex.Pattern, regex.Options);
loaded = true;
}
break;
case '[':
RubyArray asc = (obj as RubyArray);
if (asc != null)
{
asc.AddRange(ReadArray());
loaded = true;
}
break;
case '{':
case '}':
Hash hsc = (obj as Hash);
if (hsc != null)
{
Hash hash = ReadHash(typeFlag);
hsc.DefaultProc = hash.DefaultProc;
hsc.DefaultValue = hash.DefaultValue;
foreach (var pair in hash)
{
hsc.Add(pair.Key, pair.Value);
}
loaded = true;
}
break;
default:
break;
}
if (!loaded)
{
throw RubyExceptions.CreateArgumentError("incompatible base type");
}
return(obj);
}
public static object MatchIndex(RubyScope /*!*/ scope, RubyRegex /*!*/ self, [DefaultProtocol] MutableString /*!*/ str)
{
MatchData match = RubyRegex.SetCurrentMatchData(scope, self, str);
return((match != null) ? ScriptingRuntimeHelpers.Int32ToObject(match.Index) : null);
}