internal static int Process(zlib.ZStream /*!*/ zst, MutableString str, zlib.FlushStrategy flush, bool compress,
out MutableString /*!*/ result, ref MutableString trailingUncompressedData)
{
result = MutableString.CreateBinary();
// add previously compressed data to the output:
if (zst.next_out != null)
{
result.Append(zst.next_out, 0, zst.next_out_index);
}
int err;
int bufferStart = zst.next_out_index;
err = Process(zst, str, flush, compress, ref trailingUncompressedData);
result.Append(zst.next_out, bufferStart, zst.next_out_index - bufferStart);
if (err == Z_STREAM_END && (flush == zlib.FlushStrategy.Z_FINISH || str == null))
{
err = compress ? zst.deflateEnd() : zst.inflateEnd();
}
zst.next_out = null;
zst.next_out_index = 0;
zst.avail_out = 0;
return(err);
}
public static MutableString Read(GZipReader /*!*/ self, [DefaultProtocol, Optional] int?bytes)
{
if (bytes.HasValue && bytes.Value < 0)
{
throw RubyExceptions.CreateArgumentError("negative length -1 given");
}
var stream = self.GetStream();
MutableString result = MutableString.CreateBinary(self._encoding ?? RubyEncoding.Binary);
if (bytes.HasValue)
{
int bytesRead = result.Append(stream, bytes.Value);
if (bytesRead == 0 && bytes.Value != 0)
{
return(null);
}
}
else
{
result.Append(stream);
}
return(result);
}
public static void SetPreviousByte(StringIO /*!*/ self, [DefaultProtocol] int b)
{
// MRI: this checks if the IO is readable although it actually modifies the string:
MutableString content = self.GetReadableContent();
int pos = self._position - 1;
if (pos >= 0)
{
int length = content.GetByteCount();
try {
if (pos >= length)
{
content.Append(0, pos - length);
content.Append(unchecked ((byte)b));
}
else
{
content.SetByte(pos, unchecked ((byte)b));
}
self._position = pos;
} catch (InvalidOperationException) {
throw RubyExceptions.CreateIOError("not modifiable string");
}
}
}
public static MutableString ToJson(MutableString self)
{
MutableString result = MutableString.CreateMutable(self.Length + 2, RubyEncoding.UTF8);
char[] chars = Encoding.UTF8.GetChars(self.ToByteArray());
byte[] escapeSequence = new byte[] { (byte)'\\', 0 };
result.Append('"');
foreach (char c in chars)
{
switch (c)
{
case '"':
case '/':
case '\\':
escapeSequence[1] = (byte)c;
result.Append(escapeSequence);
break;
case '\n':
escapeSequence[1] = (byte)'n';
result.Append(escapeSequence);
break;
case '\r':
escapeSequence[1] = (byte)'r';
result.Append(escapeSequence);
break;
case '\t':
escapeSequence[1] = (byte)'t';
result.Append(escapeSequence);
break;
case '\f':
escapeSequence[1] = (byte)'f';
result.Append(escapeSequence);
break;
case '\b':
escapeSequence[1] = (byte)'b';
result.Append(escapeSequence);
break;
default:
if (c >= 0x20 && c <= 0x7F)
{
result.Append((byte)c);
}
else
{
result.Append(Helpers.EscapeUnicodeChar(c));
}
break;
}
}
result.Append('"');
return(result);
}
public static void DisplayNumber(float value, MutableString displayValue, uint decimalPlaces = 0, string postFix = "")
{
//var numberFormat = MutableString.NumberFormat(decimalPlaces);
//if (decimalPlaces > 0) {
displayValue.Append(value, decimalPlaces);
//} else {
// displayValue.Builder.Concat(Mathf.RoundToInt(value));
//}
displayValue.Append(postFix);
}
/// <summary>
/// Takes away all occurences of PreciseTime formatting. Lefts DateTime format.
/// </summary>
/// <param name="timeFormat"></param>
/// <param name="dateTimeFormat"></param>
/// <param name="preciseTimeFormatAndPosition"></param>
/// <returns></returns>
internal static Boolean TakeAwayPreciseTimeFormat(
String timeFormat,
out MutableString dateTimeFormat,
out IDictionary <Int32, String> preciseTimeFormatAndPosition)
{
Int32 startPosition, endPosition, caretPosition = 0;
Boolean isFormatFound = TryFindPreciseTimeFormat(timeFormat, caretPosition, out startPosition, out endPosition);
if (!isFormatFound)
{
dateTimeFormat = null;
preciseTimeFormatAndPosition = null;
return(false);
}
Dictionary <Int32, String> preciseTimeFormats = new Dictionary <Int32, String>();
dateTimeFormat = new MutableString();
Int32 length = endPosition - startPosition + 1;
preciseTimeFormats.Add(startPosition, timeFormat.Substring(startPosition, length));
dateTimeFormat.Append(timeFormat.Substring(caretPosition, startPosition - caretPosition));
caretPosition = endPosition;
isFormatFound = TryFindPreciseTimeFormat(timeFormat, caretPosition, out startPosition, out endPosition);
while (isFormatFound)
{
length = endPosition - startPosition + 1;
preciseTimeFormats.Add(startPosition, timeFormat.Substring(startPosition, length));
dateTimeFormat.Append(timeFormat.Substring(caretPosition + 1, startPosition - caretPosition - 1));
caretPosition = endPosition;
isFormatFound = TryFindPreciseTimeFormat(timeFormat, caretPosition, out startPosition, out endPosition);
}
// at least length >= 1
// append the last part of date time format, in case, if it exists.
if (caretPosition + length < timeFormat.Length)
{
dateTimeFormat.Append(timeFormat.Substring(caretPosition + 1));
}
preciseTimeFormatAndPosition = preciseTimeFormats;
return(true);
}
void Awake()
{
_overviewStr = new MutableString(1024);
var renderableBindings = _inputMappingsViewModel
.InputMappings
.Select(bindings => {
return(bindings
.Where(binding => RenderableActions.Contains(binding.Id))
.OrderBy(binding => RenderableActions.IndexOf(binding.Id)));
});
renderableBindings.Subscribe(bindings => {
_overviewStr.Clear();
foreach (var binding in bindings)
{
_overviewStr
.Append("<i>")
.Append(binding.Group)
.Append("</i>")
.Append(" - ")
.Append(binding.Name)
.Append(": <b>")
.Append(binding.Binding)
.Append("</b>")
.Append(Environment.NewLine);
}
_overviewText.SetMutableString(_overviewStr);
});
}
public static MutableString /*!*/ Read(StringIO /*!*/ self, MutableString buffer, bool eofError)
{
var content = self.GetReadableContent();
int start = self._position;
int length = content.GetByteCount();
if (buffer != null)
{
buffer.Clear();
}
else
{
buffer = MutableString.CreateBinary();
}
if (start < length)
{
self._position = length;
buffer.Append(content, start, length - start).TaintBy(content);
}
else if (eofError)
{
throw new EOFError("end of file reached");
}
return(buffer);
}
private void WriteToObject(byte[] /*!*/ buffer, int offset, int count)
{
MutableString argument = MutableString.CreateBinary(count);
argument.Append(buffer, offset, count);
WriteSite.Target(WriteSite, _io, argument);
}
public static MutableString TagUri(RubyContext /*!*/ context, object self)
{
MutableString str = MutableString.Create("!ruby/object:");
str.Append(RubyUtils.GetClassName(context, self));
return(str);
}
public static MutableString Read(StringIO /*!*/ self, [DefaultProtocol] int count, [DefaultProtocol, Optional, NotNull] MutableString buffer)
{
var content = self.GetReadableContent();
if (count < 0)
{
throw RubyExceptions.CreateArgumentError("negative length -1 given");
}
if (buffer != null)
{
buffer.Clear();
}
int length = content.GetByteCount();
if (self._position >= length)
{
return(null);
}
if (buffer == null)
{
buffer = MutableString.CreateBinary();
}
int bytesRead = Math.Min(count, length - self._position);
buffer.Append(content, self._position, bytesRead).TaintBy(content);
self._position += bytesRead;
return(buffer);
}
private bool LoadFromPath(Scope /*!*/ globalScope, object self, string /*!*/ path, LoadFlags flags)
{
Assert.NotNull(globalScope, path);
ResolvedFile file = FindFile(globalScope, path, (flags & LoadFlags.AppendExtensions) != 0);
if (file == null)
{
throw new LoadError(String.Format("no such file to load -- {0}", path));
}
MutableString pathWithExtension = MutableString.Create(path);
if (file.AppendedExtension != null)
{
pathWithExtension.Append(file.AppendedExtension);
}
if (AlreadyLoaded(pathWithExtension, flags) || _unfinishedFiles.Contains(pathWithExtension.ToString()))
{
return(false);
}
try {
// save path as is, no canonicalization nor combination with an extension or directory:
_unfinishedFiles.Push(pathWithExtension.ToString());
if (file.SourceUnit != null)
{
RubyContext rubySource = file.SourceUnit.LanguageContext as RubyContext;
if (rubySource != null)
{
ExecuteRubySourceUnit(file.SourceUnit, globalScope, flags);
}
else
{
file.SourceUnit.Execute();
}
}
else
{
Debug.Assert(file.Path != null);
try {
Assembly asm = Platform.LoadAssemblyFromPath(Platform.GetFullPath(file.Path));
DomainManager.LoadAssembly(asm);
} catch (Exception e) {
throw new LoadError(e.Message, e);
}
}
FileLoaded(pathWithExtension, flags);
} finally {
_unfinishedFiles.Pop();
}
return(true);
}
public void HashCodeTest()
{
MutableString ar = new MutableString();
ar.Clear();
ar.Append("aba");
ar.Append("caba");
ar.Append("abacaba");
MutableString ar1 = new MutableString();
ar1.Clear();
ar1.Append("abacaba");
ar1.Append("abacaba");
MutableString ar2 = new MutableString();
ar2.Assign("abacabaabacaba");
Assert.AreEqual(ar1.GetHashCode(), ar2.GetHashCode());
Assert.AreEqual(ar1.GetHashCode(), ar.GetHashCode());
}
public static MutableString TagUri(RubyStruct /*!*/ self)
{
MutableString str = MutableString.Create("tag:ruby.yaml.org,2002:struct:");
string name = self.Class.Name;
string structPrefix = "Struct::";
if (name.StartsWith(structPrefix))
{
name = name.Substring(structPrefix.Length);
}
return(str.Append(name));
}
public override string ToString()
{
MutableString mutableString = new MutableString();
mutableString.Append("First: ");
if (First != null)
{
mutableString.Append(First.ToString()).Append("; ");
}
else
{
mutableString.Append("null; ");
}
mutableString.Append("Second: ");
if (Second != null)
{
mutableString.Append(Second.ToString());
}
else
{
mutableString.Append("null");
}
return(mutableString.ToString());
}
public static RubyArray /*!*/ ReceiveFrom(RubyContext /*!*/ context, RubySocket /*!*/ self, int length, object /*Numeric*/ flags)
{
SocketFlags sFlags = ConvertToSocketFlag(context, flags);
byte[] buffer = new byte[length];
EndPoint fromEP = new IPEndPoint(IPAddress.Any, 0);
int received = self.Socket.ReceiveFrom(buffer, sFlags, ref fromEP);
MutableString str = MutableString.CreateBinary();
str.Append(buffer, 0, received);
str.IsTainted = true;
return(RubyOps.MakeArray2(str, GetAddressArray(context, fromEP)));
}
public static MutableString /*!*/ Convert(RubyClass /*!*/ self,
[DefaultProtocol, NotNull] MutableString /*!*/ toEncoding, [DefaultProtocol, NotNull] MutableString /*!*/ fromEncoding,
[DefaultProtocol] MutableString str)
{
MutableString[] convertedStrings = Convert(toEncoding, fromEncoding, new MutableString[] { str, null });
MutableString result = MutableString.CreateEmpty();
foreach (MutableString s in convertedStrings)
{
result.Append(s);
}
return(result);
}
public static MutableString /*!*/ ObjectToMutableString(RubyContext /*!*/ context, object obj)
{
using (IDisposable handle = RubyUtils.InfiniteInspectTracker.TrackObject(obj)) {
if (handle == null)
{
return(MutableString.Create("..."));
}
MutableString str = MutableString.CreateMutable();
str.Append("#<");
str.Append(context.GetClassOf(obj).Name);
// Ruby prints 2*object_id for objects
str.Append(':');
AppendFormatHexObjectId(str, GetObjectId(context, obj));
// display instance variables
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(", ");
}
str.Append(var.Key);
str.Append("=");
str.Append(RubySites.Inspect(context, var.Value));
}
}
str.Append(">");
return(str);
}
}
public static MutableString Receive(RubyContext /*!*/ context, RubyBasicSocket /*!*/ self,
[DefaultProtocol] int length, [DefaultParameterValue(null)] object flags)
{
SocketFlags sFlags = ConvertToSocketFlag(context, flags);
byte[] buffer = new byte[length];
int received = self.Socket.Receive(buffer, 0, length, sFlags);
MutableString str = MutableString.CreateBinary(received);
str.Append(buffer, 0, received);
context.SetObjectTaint(str, true);
return(str);
}
public static MutableString Receive(ConversionStorage <int> /*!*/ fixnumCast, RubyBasicSocket /*!*/ self,
[DefaultProtocol] int length, [DefaultParameterValue(null)] object flags)
{
SocketFlags sFlags = ConvertToSocketFlag(fixnumCast, flags);
byte[] buffer = new byte[length];
int received = self.Socket.Receive(buffer, 0, length, sFlags);
MutableString str = MutableString.CreateBinary(received);
str.Append(buffer, 0, received);
str.IsTainted = true;
return(str);
}
private static IEnumerable <string> PartsWithin(IList <string> parts)
{
if (null == parts)
{
yield break;
}
if (0 == parts.Count)
{
yield break;
}
foreach (var part in parts)
{
yield return(part);
}
for (var i = 2; i < parts.Count; i++)
{
for (var j = 0; j < parts.Count; j++)
{
if (i + j > parts.Count)
{
break;
}
var result = new MutableString();
for (var x = j; x < j + i; x++)
{
result.Append(' ');
result.Append(parts[x]);
}
yield return(result.Trim());
}
}
}
public static RubyArray /*!*/ ReceiveFrom(ConversionStorage <int> /*!*/ conversionStorage, IPSocket /*!*/ self,
int length, [DefaultParameterValue(null)] object /*Numeric*/ flags)
{
SocketFlags sFlags = ConvertToSocketFlag(conversionStorage, flags);
byte[] buffer = new byte[length];
EndPoint fromEP = new IPEndPoint(IPAddress.Any, 0);
int received = self.Socket.ReceiveFrom(buffer, sFlags, ref fromEP);
MutableString str = MutableString.CreateBinary();
str.Append(buffer, 0, received);
str.IsTainted = true;
return(RubyOps.MakeArray2(str, self.GetAddressArray(fromEP)));
}
public static MutableString /*!*/ TagUri(RubyStruct /*!*/ self)
{
MutableString str = MutableString.CreateMutable("tag:ruby.yaml.org,2002:struct:", self.ImmediateClass.Context.GetIdentifierEncoding());
string name = self.ImmediateClass.GetNonSingletonClass().Name;
if (name != null)
{
string structPrefix = "Struct::";
if (name.StartsWith(structPrefix, StringComparison.Ordinal))
{
name = name.Substring(structPrefix.Length);
}
}
return(str.Append(name));
}
public void TestUpperAndLowerCaseMethod()
{
MutableString s1 = new MutableString("aza23523aza");
MutableString s2 = new MutableString("AzA23523Aza");
MutableString s3 = new MutableString("AZA23523AZA");
MutableString s4 = new MutableString();
s1.CopyTo(s4);
s4.Append("a");
Assert.IsTrue(s1.ToUpperCase().Equals(s2.ToUpperCase()));
Assert.IsTrue(s3.Equals(s2));
s1.Append("a");
s3.Append("A");
Assert.IsFalse(s1.Equals(s3));
Assert.IsTrue(s1.ToLowerCase().Equals(s3.ToLowerCase().ToUpperCase().ToLowerCase()));
Assert.IsTrue(s1.Equals(s4));
}
/// <summary>
/// If the SCRIPT_LINES__ constant is set, we need to publish the file being loaded,
/// along with the contents of the file
/// </summary>
private void AddScriptLines(SourceUnit file)
{
ConstantStorage storage;
if (!_context.ObjectClass.TryResolveConstant(null, "SCRIPT_LINES__", out storage))
{
return;
}
IDictionary scriptLines = storage.Value as IDictionary;
if (scriptLines == null)
{
return;
}
lock (scriptLines) {
// Read in the contents of the file
RubyArray lines = new RubyArray();
SourceCodeReader reader = file.GetReader();
RubyEncoding encoding = RubyEncoding.GetRubyEncoding(reader.Encoding);
using (reader) {
reader.SeekLine(1);
while (true)
{
string lineStr = reader.ReadLine();
if (lineStr == null)
{
break;
}
MutableString line = MutableString.CreateMutable(lineStr.Length + 1, encoding);
line.Append(lineStr).Append('\n');
lines.Add(line);
}
}
// Publish the contents of the file, keyed by the file name
MutableString path = MutableString.Create(file.Document.FileName, _context.GetPathEncoding());
scriptLines[path] = lines;
}
}
public void SetData(MeasurementViewData data)
{
_leftLinePullGauge.SetPullForce(data.LineColor, data.LeftLinePull);
_rightLinePullGauge.SetPullForce(data.LineColor, data.RightLinePull);
_holdLines.color = data.LineColor;
_holdLines.SetMutableString(data.HoldLines);
_speedStr
.Clear()
.Append("↘ ")
.Append(data.Speed)
.Append(" ")
.Append(data.SpeedUnit);
_speed.SetValue(_speedStr);
_speedDetailStr.Clear();
const string indentation = " ";
_speedDetailStr.Append(indentation)
.Append("→ ")
.Append(data.HorizontalSpeed)
.Append(" ")
.Append(data.SpeedUnit)
.Append(Environment.NewLine)
.Append(indentation)
.Append("↓ ")
.Append(data.VerticalSpeed)
.Append(" ")
.Append(data.SpeedUnit);
_speedDetail.SetMutableString(_speedDetailStr);
_altitudeStr
.Clear()
.Append("↕ ")
.Append(data.Altitude)
.Append(data.AltitudeUnit);
_altitude.SetValue(_altitudeStr);
WriteValue(_glideRatio, _glideRatioStr, data.GlideRatio);
WriteValue(_gforce, _gForceStr, data.GForce);
}
private void DrawStatisticsGui()
{
GUILayout.Label("Framerate: " + (1f / _smoothDeltaTime));
const float epsilon = 0.001f;
float maxDeltaTime = 1f / Application.targetFrameRate + epsilon;
GUILayout.Label("Performance Ratio: " + maxDeltaTime / _deltaTime);
GUILayout.Label("Fixed Frames: " + _fixedFrameCountGui);
GUI.color = Color.red;
_deltaTimeErrorString.Clear();
for (int i = 0; i < _deltaTimes.Count; i++)
{
_deltaTimeErrorString.Append(_deltaTimes[i] > maxDeltaTime ? "|" : " ");
}
GUILayout.Label(_deltaTimeErrorString.ToString());
GUI.color = Color.white;
}
public void MutableStringSpanTest()
{
char[] charArray = { 'a', 'b', 'c', 'd', 'e' };
Span <char> testCharSpan = new Span <char>(charArray);
MutableString mutableString = new MutableString();
mutableString.Assign(testCharSpan);
Assert.AreEqual(5, mutableString.Count);
Assert.AreEqual("abcde", mutableString.ToString());
mutableString.Append(testCharSpan);
Assert.AreEqual(10, mutableString.Count);
Assert.AreEqual("abcdeabcde", mutableString.ToString());
mutableString.Insert(5, testCharSpan);
Assert.AreEqual("abcdeabcdeabcde", mutableString.ToString());
Span <char> span = new Span <char>(new char[15]);
mutableString.ToCharArray(span);
MutableString ar1 = new MutableString(span);
Assert.AreEqual("abcdeabcdeabcde", ar1.ToString());
}
public MutableString addHttpCommand(HttpCommand pCmd)
{
pCmd.setLog(LOG);
pCmd.setInternal(m_bInternal);
if (!m_bInternal && pCmd.m_strCallback.length() == 0)
{
processCommandBase(pCmd);
return(pCmd.getRetValue());
}
else
{
if (m_bInternal)
{
lock (getCommandLock())
{
if (getCommands().isEmpty())
{
addQueueCommand(pCmd);
}
else
{
HttpCommand cmd = getCommands().get(0) as HttpCommand;
MutableString rString = cmd.m_params.findHashParam("body") as MutableString;
MutableString rString2 = pCmd.m_params.findHashParam("body") as MutableString;
rString.Append(rString2);
}
}
}
else
{
addQueueCommand(pCmd);
}
start(epLow);
return(pCmd.getRetValue());
}
}
internal static RubyArray /*!*/ CreateHostEntryArray(RubyContext /*!*/ context, IPHostEntry /*!*/ hostEntry, bool packIpAddresses)
{
RubyArray result = new RubyArray(4);
// host name:
result.Add(HostNameToMutableString(context, hostEntry.HostName));
// aliases:
RubyArray aliases = new RubyArray(hostEntry.Aliases.Length);
foreach (string alias in hostEntry.Aliases)
{
aliases.Add(HostNameToMutableString(context, alias));
}
result.Add(aliases);
// address (the first IPv4):
foreach (IPAddress address in hostEntry.AddressList)
{
if (address.AddressFamily == AddressFamily.InterNetwork)
{
result.Add((int)address.AddressFamily);
if (packIpAddresses)
{
byte[] bytes = address.GetAddressBytes();
MutableString str = MutableString.CreateBinary();
str.Append(bytes, 0, bytes.Length);
result.Add(str);
}
else
{
result.Add(MutableString.CreateAscii(address.ToString()));
}
break;
}
}
return(result);
}
// returns true if block jumped
// "result" will be null if there is no successful match
private static bool BlockReplaceAll(ConversionStorage<MutableString>/*!*/ tosConversion,
RubyScope/*!*/ scope, MutableString/*!*/ input, BlockParam/*!*/ block,
RubyRegex/*!*/ regex, out object blockResult, out MutableString result) {
var matchScope = scope.GetInnerMostClosureScope();
var matches = regex.Matches(tosConversion.Context.KCode, input);
if (matches.Count == 0) {
result = null;
blockResult = null;
matchScope.CurrentMatch = null;
return false;
}
// create an empty result:
result = input.CreateInstance().TaintBy(input);
int offset = 0;
foreach (MatchData match in matches) {
matchScope.CurrentMatch = match;
input.TrackChanges();
if (block.Yield(match.GetValue(), out blockResult)) {
return true;
}
if (input.HasChanged) {
return false;
}
// resets the $~ scope variable to the last match (skipd if block jumped):
matchScope.CurrentMatch = match;
MutableString replacement = Protocols.ConvertToString(tosConversion, blockResult);
result.TaintBy(replacement);
// prematch:
result.Append(input, offset, match.Index - offset);
// replacement (unlike ReplaceAll, don't interpolate special sequences like \1 in block return value):
result.Append(replacement);
offset = match.Index + match.Length;
}
// post-last-match:
result.Append(input, offset, input.Length - offset);
blockResult = null;
return false;
}
private void AppendRawBytes(MutableString/*!*/ buffer, int count) {
Debug.Assert(count > 0);
if (_peekAhead != -1) {
buffer.Append((byte)_peekAhead);
_peekAhead = -1;
count--;
}
buffer.Append(_stream, count);
}
private static void AppendReplacementExpression(ConversionStorage<MutableString> toS, BinaryOpStorage hashDefault,
MutableString/*!*/ input, MatchData/*!*/ match, MutableString/*!*/ result, Union<IDictionary<object, object>, MutableString>/*!*/ replacement) {
if (replacement.Second != null) {
AppendReplacementExpression(input, match, result, replacement.Second);
} else {
Debug.Assert(toS != null && hashDefault != null);
object replacementObj = HashOps.GetElement(hashDefault, replacement.First, match.GetValue());
if (replacementObj != null) {
var replacementStr = Protocols.ConvertToString(toS, replacementObj);
result.Append(replacementStr).TaintBy(replacementStr);
}
}
}
private static void AppendReplacementExpression(MutableString input, GroupCollection/*!*/ groups, MutableString/*!*/ result, MutableString/*!*/ replacement) {
int backslashCount = 0;
for (int i = 0; i < replacement.Length; i++) {
char c = replacement.GetChar(i);
if (c == '\\')
backslashCount++;
else if (backslashCount == 0)
result.Append(c);
else {
AppendBackslashes(backslashCount, result, 0);
// Odd number of \'s + digit means insert replacement expression
if ((backslashCount & 1) == 1) {
if (Char.IsDigit(c)) {
AppendGroupByIndex(groups, c - '0', backslashCount, result);
} else if (c == '&') {
AppendGroupByIndex(groups, groups.Count - 1, backslashCount, result);
} else if (c == '`') {
// Replace with everything in the input string BEFORE the match
result.Append(input, 0, groups[0].Index);
} else if (c == '\'') {
// Replace with everything in the input string AFTER the match
int start = groups[0].Index + groups[0].Length;
result.Append(input, start, input.Length - start);
} else if (c == '+') {
// Replace last character in last successful match group
AppendLastCharOfLastMatchGroup(groups, result);
} else {
// unknown escaped replacement char, go ahead and replace untouched
result.Append('\\');
result.Append(c);
}
} else {
// Any other # of \'s or a non-digit character means insert literal \'s and character
AppendBackslashes(backslashCount, result, 1);
result.Append(c);
}
backslashCount = 0;
}
}
AppendBackslashes(backslashCount, result, 1);
}
private static void AppendGroupByIndex(GroupCollection/*!*/ groups, int index, int backslashCount, MutableString/*!*/ result) {
if (groups[index].Success) {
result.Append(groups[index].Value);
}
}
public static MutableString/*!*/ Reinitialize(MutableString/*!*/ self, [NotNull]byte[] other) {
self.Clear();
self.Append(other);
return self;
}
// returns true if block jumped
// "result" will be null if there is no successful match
private static bool BlockReplaceAll(RubyScope/*!*/ scope, MutableString/*!*/ input, BlockParam/*!*/ block,
RubyRegex/*!*/ regex, out object blockResult, out MutableString result) {
var matchScope = scope.GetInnerMostClosureScope();
MatchCollection matches = regex.Matches(input);
if (matches.Count == 0) {
result = null;
blockResult = null;
matchScope.CurrentMatch = null;
return false;
}
// create an empty result:
result = input.CreateInstance().TaintBy(input);
int offset = 0;
foreach (Match match in matches) {
MatchData currentMatch = new MatchData(match, input);
matchScope.CurrentMatch = currentMatch;
uint version = input.Version;
if (block.Yield(MutableString.Create(match.Value), out blockResult)) {
return true;
}
if (input.Version != version) {
return false;
}
// resets the $~ scope variable to the last match (skipd if block jumped):
matchScope.CurrentMatch = currentMatch;
MutableString replacement = Protocols.ConvertToString(scope.RubyContext, blockResult);
result.TaintBy(replacement);
// prematch:
result.Append(input, offset, match.Index - offset);
// replacement (unlike ReplaceAll, don't interpolate special sequences like \1 in block return value):
result.Append(replacement);
offset = match.Index + match.Length;
}
// post-last-match:
result.Append(input, offset, input.Length - offset);
blockResult = null;
return false;
}
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;
}
private static void AppendDirectoryName(MutableString/*!*/ result, MutableString/*!*/ name) {
int resultLength = result.GetCharCount();
int i;
for (i = resultLength - 1; i >= 0; i--) {
if (!IsDirectorySeparator(result.GetChar(i))) {
break;
}
}
if (i == resultLength - 1) {
if (!IsDirectorySeparator(name.GetFirstChar())) {
result.Append(DirectorySeparatorChar);
}
result.Append(name);
} else if (IsDirectorySeparator(name.GetFirstChar())) {
result.Replace(i + 1, resultLength - i - 1, name);
} else {
result.Append(name);
}
}
public static void RecursiveJoin(ConversionStorage<MutableString>/*!*/ tosConversion,
IList/*!*/ list, MutableString/*!*/ separator, MutableString/*!*/ result, Dictionary<object, bool>/*!*/ seen) {
Assert.NotNull(list, separator, result, seen);
// TODO: can we get by only tracking List<> ?
// (inspect needs to track everything)
bool found;
if (seen.TryGetValue(list, out found)) {
result.Append("[...]");
return;
}
seen.Add(list, true); // push
for (int i = 0; i < list.Count; ++i) {
object item = list[i];
if (item is ValueType) {
result.Append(Protocols.ConvertToString(tosConversion, item));
} else if (item == null) {
// append nothing
} else {
IList listItem = item as IList;
if (listItem != null) {
RecursiveJoin(tosConversion, listItem, separator, result, seen);
} else {
result.Append(Protocols.ConvertToString(tosConversion, item));
}
}
if (i < list.Count - 1) {
result.Append(separator);
}
}
seen.Remove(list);
}
internal static MutableString/*!*/ AppendEscapeForwardSlash(MutableString/*!*/ result, MutableString/*!*/ pattern) {
int first = 0;
int i = SkipToUnescapedForwardSlash(pattern, 0);
while (i >= 0) {
Debug.Assert(i < pattern.Length);
Debug.Assert(pattern.GetChar(i) == '/' && (i == 0 || pattern.GetChar(i - 1) != '\\'));
result.Append(pattern, first, i - first);
result.Append('\\');
first = i; // include forward slash in the next append
i = SkipToUnescapedForwardSlash(pattern, i + 1);
}
result.Append(pattern, first, pattern.Length - first);
return result;
}
public MutableString AppendGroupValue(int index, MutableString/*!*/ result) {
// we don't need to check index range, Groups indexer returns an unsuccessful group if out of range:
return GroupSuccess(index) ? result.Append(_originalString, GetGroupStart(index), GetGroupLength(index)).TaintBy(this) : null;
}
private static int AppendOptionString(MutableString/*!*/ result, RubyRegexOptions options, bool enabled, bool includeEncoding) {
int count = 0;
if (((options & RubyRegexOptions.Multiline) != 0) == enabled) {
result.Append('m');
count++;
}
if (((options & RubyRegexOptions.IgnoreCase) != 0) == enabled) {
result.Append('i');
count++;
}
if (((options & RubyRegexOptions.Extended) != 0) == enabled) {
result.Append('x');
count++;
}
if (includeEncoding) {
switch (options & RubyRegexOptions.EncodingMask) {
case RubyRegexOptions.NONE: break;
case RubyRegexOptions.EUC: result.Append('e'); break;
case RubyRegexOptions.FIXED: result.Append('n'); break;
case RubyRegexOptions.UTF8: result.Append('u'); break;
case RubyRegexOptions.SJIS: result.Append('s'); break;
default: throw Assert.Unreachable;
}
}
return count;
}
private void AppendRawBytes(MutableString/*!*/ buffer, int count) {
Debug.Assert(count > 0);
int remaining = count;
if (_bufferCount > 0) {
int c = Math.Min(_bufferCount, count);
buffer.Append(_buffer, _bufferStart, c);
ConsumeBuffered(c);
remaining -= c;
}
if (count == Int32.MaxValue) {
const int chunk = 1024;
int done = buffer.GetByteCount();
int bytesRead;
do {
buffer.Append(_stream, chunk);
bytesRead = buffer.GetByteCount() - done;
done += bytesRead;
} while (bytesRead == chunk);
} else {
buffer.Append(_stream, remaining);
}
}
private static void AppendLastCharOfLastMatchGroup(MatchData/*!*/ match, MutableString/*!*/ result) {
int i = match.GroupCount - 1;
// move to last successful match group
while (i > 0 && !match.GroupSuccess(i)) {
i--;
}
if (i > 0 && match.GroupSuccess(i)) {
int length = match.GetGroupLength(i);
if (length > 0) {
result.Append(match.OriginalString, match.GetGroupStart(i) + length - 1, 1);
}
}
}
private void AppendRawBytes(MutableString/*!*/ buffer, int count) {
Debug.Assert(count > 0);
int remaining = count;
while (_bufferSize > 0) {
buffer.Append(ReadBufferByte());
remaining--;
}
if (count == Int32.MaxValue) {
const int chunk = 1024;
int done = buffer.GetByteCount();
int bytesRead;
do {
buffer.Append(_stream, chunk);
bytesRead = buffer.GetByteCount() - done;
done += bytesRead;
} while (bytesRead == chunk);
} else {
buffer.Append(_stream, remaining);
}
}
private static void AppendGroupByIndex(MatchData/*!*/ match, int index, MutableString/*!*/ result) {
var value = match.GetGroupValue(index);
if (value != null) {
result.Append(value);
}
}
internal static int Process(zlib.ZStream/*!*/ zst, MutableString str, zlib.FlushStrategy flush, bool compress,
out MutableString/*!*/ result, ref MutableString trailingUncompressedData)
{
result = MutableString.CreateBinary();
// add previously compressed data to the output:
if (zst.next_out != null) {
result.Append(zst.next_out, 0, zst.next_out_index);
}
int err;
int bufferStart = zst.next_out_index;
err = Process(zst, str, flush, compress, ref trailingUncompressedData);
result.Append(zst.next_out, bufferStart, zst.next_out_index - bufferStart);
if (err == Z_STREAM_END && (flush == zlib.FlushStrategy.Z_FINISH || str == null)) {
err = compress ? zst.deflateEnd() : zst.inflateEnd();
}
zst.next_out = null;
zst.next_out_index = 0;
zst.avail_out = 0;
return err;
}
public static MutableString ChompInPlace(MutableString/*!*/ self, [DefaultProtocol]MutableString separator) {
MutableString result = InternalChomp(self, separator);
if (result.Equals(self) || result == null) {
return null;
}
self.Clear();
self.Append(result);
return self;
}
private static int Process(zlib.ZStream/*!*/ zst, zlib.FlushStrategy flush, bool compress,
ref MutableString trailingUncompressedData)
{
if (zst.next_out == null) {
zst.next_out = new byte[DEFAULTALLOC];
zst.next_out_index = 0;
zst.avail_out = zst.next_out.Length;
}
int result = compress ? zst.deflate(flush) : zst.inflate(flush);
while (result == Z_OK && zst.avail_out == 0) {
byte[] output = zst.next_out;
int oldLength = output.Length;
Array.Resize(ref output, oldLength * 2);
zst.next_out = output;
zst.avail_out = oldLength;
result = compress ? zst.deflate(flush) : zst.inflate(flush);
}
if (!compress && (result == Z_STREAM_END || result == Z_STREAM_ERROR && !zst.IsInitialized)) {
// MRI hack: any data left in the stream are saved into a separate buffer and returned when "finish" is called
// This is weird behavior, one would expect the rest of the stream is either ignored or copied to the output buffer.
#if COPY_UNCOMPRESSED_DATA_TO_OUTPUT_BUFFER
Debug.Assert(zst.next_in_index + zst.avail_in <= zst.next_in.Length);
Debug.Assert(zst.next_out_index + zst.avail_out <= zst.next_out.Length);
if (zst.avail_in > zst.avail_out) {
byte[] output = zst.next_out;
int oldLength = output.Length;
Array.Resize(ref output, Math.Max(zst.next_out_index + zst.avail_in, oldLength * 2));
zst.next_out = output;
}
Buffer.BlockCopy(zst.next_in, zst.next_in_index, zst.next_out, zst.next_out_index, zst.avail_in);
// MRI subtracts till 0 is reached:
zst.avail_out = Math.Max(zst.avail_out - zst.avail_in, 0);
zst.next_out_index += zst.avail_in;
zst.avail_in = 0;
#else
if (trailingUncompressedData == null) {
trailingUncompressedData = MutableString.CreateBinary();
}
trailingUncompressedData.Append(zst.next_in, zst.next_in_index, zst.avail_in);
// MRI subtracts till 0 is reached:
zst.avail_out = Math.Max(zst.avail_out - zst.avail_in, 0);
zst.avail_in = 0;
#endif
result = Z_STREAM_END;
}
return result;
}
private static void AppendBackslashes(int backslashCount, MutableString/*!*/ result, int minBackslashes) {
for (int j = 0; j < ((backslashCount - 1) >> 1) + minBackslashes; j++) {
result.Append('\\');
}
}
public static MutableString/*!*/ Replace(MutableString/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ other) {
// Handle case where objects are the same identity
if (ReferenceEquals(self, other)) {
return self;
}
self.Clear();
self.Append(other);
return self.TaintBy(other);
}
private static void AppendLastCharOfLastMatchGroup(GroupCollection groups, MutableString result) {
int i = groups.Count - 1;
// move to last successful match group
while (i > 0 && !groups[i].Success) {
i--;
}
if (i > 0 && groups[i].Value.Length > 0) {
result.Append(groups[i].Value[groups[i].Length - 1]);
}
}
public static MutableString/*!*/ Append(MutableString/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ other) {
return self.Append(other).TaintBy(other);
}
private static MutableString/*!*/ InternalDeleteInPlace(MutableString/*!*/ self, MutableString[]/*!*/ ranges) {
MutableString result = InternalDelete(self, ranges);
if (self.Equals(result)) {
return null;
}
self.Clear();
self.Append(result);
return self;
}
public static MutableString/*!*/ Read(StringIO/*!*/ self, MutableString buffer, bool eofError) {
var content = self.GetReadableContent();
int start = self._position;
int length = content.GetByteCount();
if (buffer != null) {
buffer.Clear();
} else {
buffer = MutableString.CreateBinary();
}
if (start < length) {
self._position = length;
buffer.Append(content, start, length - start).TaintBy(content);
} else if (eofError) {
throw new EOFError("end of file reached");
}
return buffer;
}
public static MutableString/*!*/ TrSqueezeInPlace(MutableString/*!*/ self,
[DefaultProtocol, NotNull]MutableString/*!*/ from, [DefaultProtocol, NotNull]MutableString/*!*/ to) {
MutableString result = TrInternal(self, from, to, true);
if (self.Equals(result)) {
return null;
}
self.Clear();
self.Append(result);
return self;
}
public static MutableString Append(MutableString/*!*/ self, int c)
{
return self.Append(Integer.ToChr(self.Encoding, self.Encoding, c));
}
public static MutableString/*!*/ Append(MutableString/*!*/ self, int c) {
if (c < 0 || c > 255) {
throw RubyExceptions.CreateTypeConversionError("Fixnum", "String");
}
return self.Append((byte)c);
}
public static MutableString/*!*/ Reinitialize(MutableString/*!*/ self, [DefaultProtocol, NotNull]MutableString other) {
if (ReferenceEquals(self, other)) {
return self;
}
self.Clear();
self.Append(other);
return self.TaintBy(other);
}