private int ReadNumberOrStar()
{
int res = 0; // default value
if (_curCh == '*')
{
int?argindex = TryReadArgumentIndex();
_curCh = _format[_index++];
res = Protocols.CastToFixnum(_context, GetData(argindex));
}
else
{
if (Char.IsDigit(_curCh))
{
res = 0;
while (Char.IsDigit(_curCh) && _index < this._format.Length)
{
res = res * 10 + ((int)(_curCh - '0'));
_curCh = _format[_index++];
}
}
}
return(res);
}
internal static AddressFamily ConvertToAddressFamily(ConversionStorage <MutableString> /*!*/ stringCast, ConversionStorage <int> /*!*/ fixnumCast,
object family)
{
// Default is AF_INET
if (family == null)
{
return(AddressFamily.InterNetwork);
}
// If it is a Fixnum then assume it is just the constant value
if (family is int)
{
return((AddressFamily)(int)family);
}
// Convert to a string (using to_str) and then look up the value
MutableString strFamily = Protocols.CastToString(stringCast, family);
foreach (AddressFamilyName name in FamilyNames)
{
if (name.Name.Equals(strFamily))
{
return(name.Family);
}
}
// Convert to a Fixnum (using to_i) and hope it is a valid AddressFamily constant
return((AddressFamily)Protocols.CastToFixnum(fixnumCast, strFamily));
}
public static object Step(RubyContext /*!*/ context, BlockParam block, Range /*!*/ self, object step)
{
// We attempt to cast step to Fixnum here even though if we were iterating over Floats, for instance, we use step as is.
// This prevents cases such as (1.0..2.0).step(0x800000000000000) {|x| x } from working but that is what MRI does.
int intStep = Protocols.CastToFixnum(context, step);
if (self.Begin is int && self.End is int)
{
// self.begin is Fixnum; directly call item = item + 1 instead of succ
return(StepFixnum(context, block, self, (int)self.Begin, (int)self.End, intStep));
}
else if (self.Begin is MutableString)
{
// self.begin is String; use item.succ and item <=> self.end but make sure you check the length of the strings
return(StepString(context, block, self, (MutableString)self.Begin, (MutableString)self.End, intStep));
}
else if (context.IsInstanceOf(self.Begin, context.GetClass(typeof(Numeric))))
{
// self.begin is Numeric; invoke item = item + 1 instead of succ and invoke < or <= for compare
return(StepNumeric(context, block, self, self.Begin, self.End, step));
}
else
{
// self.begin is not Numeric or String; just invoke item.succ and item <=> self.end
CheckBegin(context, self.Begin);
return(StepObject(context, block, self, self.Begin, self.End, intStep));
}
}
private static int GetComponent(ConversionStorage <int> /*!*/ conversionStorage, object[] components, int index, int defValue, bool zeroOk)
{
if (index >= components.Length || components[index] == null)
{
return(defValue);
}
object component = components[index];
int result;
try {
result = Protocols.CastToFixnum(conversionStorage, component);
} catch (InvalidOperationException) {
MutableString str = component as MutableString;
if (str == null)
{
throw;
}
result = checked ((int)MutableStringOps.ToInteger(str, 10));
}
if (result == 0 && !zeroOk)
{
return(defValue);
}
else
{
return(result);
}
}
private static int GetComponent(RubyContext /*!*/ context, object[] components, int index, int defValue)
{
if (index >= components.Length || components[index] == null)
{
return(defValue);
}
return(Protocols.CastToFixnum(context, components[index]));
}
internal static SocketFlags ConvertToSocketFlag(ConversionStorage <int> /*!*/ conversionStorage, object flags)
{
if (flags == null)
{
return(SocketFlags.None);
}
return((SocketFlags)Protocols.CastToFixnum(conversionStorage, flags));
}
internal static SocketFlags ConvertToSocketFlag(RubyContext /*!*/ context, object flags)
{
if (flags == null)
{
return(SocketFlags.None);
}
return((SocketFlags)Protocols.CastToFixnum(context, flags));
}
public static void SetSocketOption(RubyContext /*!*/ context, RubyBasicSocket /*!*/ self, object /*Numeric*/ level, object /*Numeric*/ optname, bool value)
{
Protocols.CheckSafeLevel(context, 2, "setsockopt");
int iLevel = Protocols.CastToFixnum(context, level);
int iOptname = Protocols.CastToFixnum(context, optname);
self.Socket.SetSocketOption((SocketOptionLevel)iLevel, (SocketOptionName)iOptname, value);
}
public static MutableString GetSocketOption(RubyContext /*!*/ context, RubyBasicSocket /*!*/ self, object /*Numeric*/ level, object /*Numeric*/ optname)
{
Protocols.CheckSafeLevel(context, 2, "getsockopt");
int iLevel = Protocols.CastToFixnum(context, Protocols.ConvertToInteger(context, level));
int iOptname = Protocols.CastToFixnum(context, Protocols.ConvertToInteger(context, optname));
byte[] value = self.Socket.GetSocketOption((SocketOptionLevel)iLevel, (SocketOptionName)iOptname, 4);
return(MutableString.CreateBinary(value));
}
public static void SetSocketOption(RubyContext /*!*/ context, RubyBasicSocket /*!*/ self, object /*Numeric*/ level, object /*Numeric*/ optname, object value)
{
Protocols.CheckSafeLevel(context, 2, "setsockopt");
MutableString strValue = Protocols.CastToString(context, value);
int iLevel = Protocols.CastToFixnum(context, Protocols.ConvertToInteger(context, level));
int iOptname = Protocols.CastToFixnum(context, Protocols.ConvertToInteger(context, optname));
self.Socket.SetSocketOption((SocketOptionLevel)iLevel, (SocketOptionName)iOptname, strValue.ConvertToBytes());
}
public static int Shutdown(RubyContext /*!*/ context, RubyBasicSocket /*!*/ self, object /*Numeric*/ how)
{
int iHow = 2;
if (how != null)
{
iHow = Protocols.CastToFixnum(context, how);
}
return(Shutdown(context, self, iHow));
}
public static DateTime CreateGmtTime(RubyContext /*!*/ context, object /*!*/ self, [NotNull] params object[] /*!*/ components)
{
if (components.Length > 7 || components.Length == 0)
{
throw RubyExceptions.CreateArgumentError(String.Format("wrong number of arguments ({0} for 7)", components.Length));
}
return(new DateTime(Protocols.CastToFixnum(context, components[0]), GetComponent(context, components, 1, 1),
GetComponent(context, components, 2, 1), GetComponent(context, components, 3, 0), GetComponent(context, components, 4, 0),
GetComponent(context, components, 5, 0), DateTimeKind.Utc).AddTicks(GetComponent(context, components, 6, 0) * 10));
}
public static MutableString /*!*/ ToChr(RubyContext /*!*/ context, object self)
{
int intSelf = Protocols.CastToFixnum(context, self);
if (intSelf < 0 || intSelf > 255)
{
throw RubyExceptions.CreateRangeError(String.Format("{0} out of char range", intSelf));
}
return(MutableString.CreateBinary(new byte[] { (byte)intSelf }));
}
public static RubyArray /*!*/ ValuesAt(RubyContext /*!*/ context, MatchData /*!*/ self, [NotNull] params object[] /*!*/ indices)
{
RubyArray result = new RubyArray();
for (int i = 0; i < indices.Length; i++)
{
result.Add(GetGroup(context, self, Protocols.CastToFixnum(context, indices[i])));
}
return(result);
}
public static object SetLength(ConversionStorage <int> /*!*/ fixnumCast, StringIO /*!*/ self, object lengthObj)
{
int length = Protocols.CastToFixnum(fixnumCast, lengthObj);
if (length < 0)
{
throw RubyExceptions.CreateEINVAL("negative length");
}
self.GetWritableContent().SetByteCount(length);
return(lengthObj);
}
public static object Step(
ConversionStorage <MutableString> /*!*/ stringCast,
ConversionStorage <int> /*!*/ fixnumCast,
RespondToStorage /*!*/ respondToStorage,
BinaryOpStorage /*!*/ comparisonStorage,
BinaryOpStorage /*!*/ lessThanStorage,
BinaryOpStorage /*!*/ lessThanEqualsStorage,
BinaryOpStorage /*!*/ greaterThanStorage,
BinaryOpStorage /*!*/ equalsStorage,
BinaryOpStorage /*!*/ addStorage,
UnaryOpStorage /*!*/ succStorage,
BlockParam block, Range /*!*/ self, [Optional] object step)
{
if (step == Missing.Value)
{
step = ClrInteger.One;
}
// We attempt to cast step to Fixnum here even though if we were iterating over Floats, for instance, we use step as is.
// This prevents cases such as (1.0..2.0).step(0x800000000000000) {|x| x } from working but that is what MRI does.
if (self.Begin is int && self.End is int)
{
// self.begin is Fixnum; directly call item = item + 1 instead of succ
int intStep = Protocols.CastToFixnum(fixnumCast, step);
return(StepFixnum(block, self, (int)self.Begin, (int)self.End, intStep));
}
else if (self.Begin is MutableString)
{
// self.begin is String; use item.succ and item <=> self.end but make sure you check the length of the strings
int intStep = Protocols.CastToFixnum(fixnumCast, step);
return(StepString(stringCast, comparisonStorage, lessThanStorage, greaterThanStorage, succStorage,
block, self, (MutableString)self.Begin, (MutableString)self.End, intStep
));
}
else if (succStorage.Context.IsInstanceOf(self.Begin, succStorage.Context.GetClass(typeof(Numeric))))
{
// self.begin is Numeric; invoke item = item + 1 instead of succ and invoke < or <= for compare
return(StepNumeric(lessThanStorage, lessThanEqualsStorage, equalsStorage, addStorage,
block, self, self.Begin, self.End, step
));
}
else
{
// self.begin is not Numeric or String; just invoke item.succ and item <=> self.end
CheckBegin(respondToStorage, self.Begin);
int intStep = Protocols.CastToFixnum(fixnumCast, step);
return(StepObject(comparisonStorage, lessThanStorage, greaterThanStorage, equalsStorage, succStorage,
block, self, self.Begin, self.End, intStep
));
}
}
public static RubyArray GetAddressInfo(RubyContext /*!*/ context, RubyClass /*!*/ self, object hostname, object port,
[DefaultParameterValue(null)] object family,
[DefaultParameterValue(0)] object socktype,
[DefaultParameterValue(0)] object protocol,
[DefaultParameterValue(null)] object flags)
{
MutableString strHostname = ConvertToHostString(context, hostname);
int iPort = ConvertToPortNum(context, port);
// Sadly the family, socktype, protocol and flags get passed through at best and ignored at worst,
// since System.Net does not provide for them
AddressFamily addrFamily = ConvertToAddressFamily(context, family);
int socketType = Protocols.CastToFixnum(context, socktype);
int protocolType = Protocols.CastToFixnum(context, protocol);
RubyArray results = new RubyArray();
IPHostEntry entry = (strHostname != null) ? GetHostEntry(strHostname.ConvertToString()) : MakeEntry(IPAddress.Any);
for (int i = 0; i < entry.AddressList.Length; ++i)
{
IPAddress address = entry.AddressList[i];
RubyArray result = new RubyArray();
result.Add(ToAddressFamilyString(address.AddressFamily));
result.Add(iPort);
if (DoNotReverseLookup(context).Value)
{
result.Add(MutableString.Create(address.ToString()));
}
else
{
IPHostEntry alias = GetHostEntry(address);
result.Add(MutableString.Create(alias.HostName));
}
result.Add(MutableString.Create(address.ToString()));
result.Add((int)address.AddressFamily);
result.Add(socketType);
// TODO: protocol type:
result.Add(protocolType);
results.Add(result);
}
return(results);
}
public static RubyArray /*!*/ ValuesAt(RubyStruct /*!*/ self, [NotNull] params object[] values)
{
RubyArray result = new RubyArray();
object[] data = self.Values;
for (int i = 0; i < values.Length; ++i)
{
Range range = values[i] as Range;
if (range != null)
{
bool excludeEnd;
int begin, end;
Protocols.ConvertToIntegerRange(self.Class.Context, range, out begin, out end, out excludeEnd);
if (excludeEnd)
{
end -= 1;
}
begin = NormalizeIndex(data.Length, begin);
end = NormalizeIndex(data.Length, end);
Debug.Assert(end - begin <= data.Length); // because we normalized the indicies
if (end - begin > 0)
{
result.Capacity += (end - begin);
for (int j = begin; j <= end; j++)
{
result.Add(data[j]);
}
}
}
else
{
int index = NormalizeIndex(data.Length, Protocols.CastToFixnum(self.Class.Context, values[i]));
result.Add(data[index]);
}
}
return(result);
}
public static RubyArray GetAddressInfo(
ConversionStorage <MutableString> /*!*/ stringCast, ConversionStorage <int> /*!*/ fixnumCast,
RubyClass /*!*/ self, object hostNameOrAddress, object port,
[DefaultParameterValue(null)] object family,
[DefaultParameterValue(0)] object socktype,
[DefaultParameterValue(0)] object protocol,
[DefaultParameterValue(null)] object flags)
{
RubyContext context = self.Context;
IPHostEntry entry = (hostNameOrAddress != null) ?
GetHostEntry(ConvertToHostString(stringCast, hostNameOrAddress), DoNotReverseLookup(context).Value) :
MakeEntry(IPAddress.Any, DoNotReverseLookup(context).Value);
int iPort = ConvertToPortNum(stringCast, fixnumCast, port);
// TODO: ignore family, the only supported families are InterNetwork and InterNetworkV6
ConvertToAddressFamily(stringCast, fixnumCast, family);
int socketType = Protocols.CastToFixnum(fixnumCast, socktype);
int protocolType = Protocols.CastToFixnum(fixnumCast, protocol);
RubyArray results = new RubyArray(entry.AddressList.Length);
for (int i = 0; i < entry.AddressList.Length; ++i)
{
IPAddress address = entry.AddressList[i];
RubyArray result = new RubyArray(9);
result.Add(ToAddressFamilyString(address.AddressFamily));
result.Add(iPort);
result.Add(HostNameToMutableString(context, IPAddressToHostName(address, DoNotReverseLookup(context).Value)));
result.Add(MutableString.CreateAscii(address.ToString()));
result.Add((int)address.AddressFamily);
result.Add(socketType);
// TODO: protocol type:
result.Add(protocolType);
results.Add(result);
}
return(results);
}
public static RubyArray /*!*/ ValuesAt(ConversionStorage <int> /*!*/ fixnumCast, RubyStruct /*!*/ self, params object[] /*!*/ values)
{
RubyArray result = new RubyArray();
object[] data = self.Values;
for (int i = 0; i < values.Length; ++i)
{
Range range = values[i] as Range;
if (range != null)
{
int begin = Protocols.CastToFixnum(fixnumCast, range.Begin);
int end = Protocols.CastToFixnum(fixnumCast, range.End);
if (range.ExcludeEnd)
{
end -= 1;
}
begin = NormalizeIndex(data.Length, begin);
end = NormalizeIndex(data.Length, end);
Debug.Assert(end - begin <= data.Length); // because we normalized the indicies
if (end - begin > 0)
{
result.AddCapacity(end - begin);
for (int j = begin; j <= end; j++)
{
result.Add(data[j]);
}
}
}
else
{
int index = NormalizeIndex(data.Length, Protocols.CastToFixnum(fixnumCast, values[i]));
result.Add(data[index]);
}
}
return(result);
}
public static object CreateArray(BlockParam block, RubyClass /*!*/ self,
[NotNull] object /*!*/ arrayOrSize)
{
IList array = Protocols.AsArray(self.Context, arrayOrSize);
if (array != null)
{
// block ignored
return(CreateArray(array));
}
int size = Protocols.CastToFixnum(self.Context, arrayOrSize);
if (block != null)
{
return(CreateArray(block, size));
}
else
{
return(CreateArray(self, size, null));
}
}
private void AppendChar()
{
int fixChar = Protocols.CastToFixnum(_context, _opts.Value);
fixChar = fixChar > 0 ? fixChar % 256 : ((-fixChar / 256) + 1) * 256 + fixChar;
char val = (char)fixChar;
if (_opts.FieldWidth > 1)
{
if (!_opts.LeftAdj)
{
_buf.Append(' ', _opts.FieldWidth - 1);
}
_buf.Append(val);
if (_opts.LeftAdj)
{
_buf.Append(' ', _opts.FieldWidth - 1);
}
}
else
{
_buf.Append(val);
}
}
public static object Reinitialize(RubyContext /*!*/ context, BlockParam block, RubyArray /*!*/ self,
[NotNull] object /*!*/ arrayOrSize)
{
RubyUtils.RequiresNotFrozen(context, self);
IList array = Protocols.AsArray(context, arrayOrSize);
if (array != null)
{
// block ignored
return(Reinitialize(self, array));
}
int size = Protocols.CastToFixnum(context, arrayOrSize);
if (block != null)
{
return(Reinitialize(block, self, size));
}
else
{
return(ReinitializeByRepeatedValue(context, self, size, null));
}
}
public static object EditDocument(RubyContext /*!*/ context, YamlStream /*!*/ self, object index, object document)
{
return(IListOps.SetElement(context, self.Documents, Protocols.CastToFixnum(context, index), document));
}
public static object SetValue(ConversionStorage <int> /*!*/ conversionStorage, RubyStruct /*!*/ self, object index, object value)
{
return(self[NormalizeIndex(self.ItemCount, Protocols.CastToFixnum(conversionStorage, index))] = value);
}
public static int InducedFrom(RubyClass /*!*/ self, object obj)
{
return(Protocols.CastToFixnum(self.Context, Protocols.ConvertToInteger(self.Context, obj)));
}
public static object SetValue(RubyStruct /*!*/ self, object index, object value)
{
return(self[NormalizeIndex(self.ItemCount, Protocols.CastToFixnum(self.Class.Context, index))] = value);
}
public static object GetDocument(RubyContext /*!*/ context, YamlStream /*!*/ self, object index)
{
return(IListOps.GetElement(self.Documents, Protocols.CastToFixnum(context, index)));
}
