internal RubyMethodBody(MethodDeclaration/*!*/ ast, MSA.SymbolDocumentInfo document, RubyEncoding/*!*/ encoding) {
Assert.NotNull(ast, encoding);
_ast = ast;
_document = document;
_encoding = encoding;
}
public static RubyArray GetAllNames(RubyContext/*!*/ context, RubyEncoding/*!*/ self)
{
var result = new RubyArray();
string name = self.Name;
result.Add(MutableString.Create(name));
foreach (var alias in RubyEncoding.Aliases) {
if (StringComparer.OrdinalIgnoreCase.Equals(alias.Value, name)) {
result.Add(MutableString.CreateAscii(alias.Key));
}
}
if (self == context.RubyOptions.LocaleEncoding) {
result.Add(MutableString.CreateAscii("locale"));
}
if (self == context.DefaultExternalEncoding) {
result.Add(MutableString.CreateAscii("external"));
}
if (self == context.GetPathEncoding()) {
result.Add(MutableString.CreateAscii("filesystem"));
}
return result;
}
private MutableString /*!*/ ConsumeLine(RubyEncoding /*!*/ encoding, int lineLength, int consume, bool bufferResized)
{
Debug.Assert(consume >= lineLength);
Debug.Assert(consume <= _bufferCount);
MutableString line;
if (bufferResized || _bufferStart == 0 && !Utils.IsSparse(lineLength, _buffer.Length))
{
Debug.Assert(_bufferStart == 0);
line = new MutableString(_buffer, lineLength, encoding);
if (_bufferCount > consume)
{
var newBuffer = new byte[Math.Max(_defaultBufferSize, _bufferCount - consume)];
Buffer.BlockCopy(_buffer, consume, newBuffer, 0, _bufferCount - consume);
_buffer = newBuffer;
}
else
{
_buffer = null;
}
// consume as if we kept the same buffer and then adjust start:
ConsumeBuffered(consume);
_bufferStart = 0;
}
else
{
line = MutableString.CreateBinary(encoding).Append(_buffer, _bufferStart, lineLength);
ConsumeBuffered(consume);
}
return(line);
}
/// <summary>
/// Start is a number of bytes if kcode is given, otherwise it's a number of characters.
/// </summary>
public MatchData Match(RubyEncoding kcode, MutableString /*!*/ input, int start, bool freezeInput)
{
string str;
Regex regex = Transform(ref kcode, input, start, out str);
Match match;
if (kcode != null)
{
if (str == null)
{
return(null);
}
match = regex.Match(str, 0);
}
else
{
if (start < 0)
{
start += str.Length;
}
if (start < 0 || start > str.Length)
{
return(null);
}
match = regex.Match(str, start);
}
return(MatchData.Create(match, input, freezeInput, str, kcode, start));
}
private static RubyEncoding/*!*/ CreateKCoding(int codepage, RubyEncoding/*!*/ realEncoding) {
#if SILVERLIGHT
return new RubyEncoding(new UTF8Encoding(false, false), new UTF8Encoding(false, true), realEncoding);
#else
return new RubyEncoding(KCoding.Create(codepage, false), KCoding.Create(codepage, true), realEncoding);
#endif
}
private Regex /*!*/ TransformPattern(RubyEncoding encoding, RubyRegexOptions kc)
{
// We can reuse cached CLR regex if it was created for the same k-coding:
if (_cachedRegex != null && kc == _cachedKCode)
{
return(_cachedRegex);
}
string pattern;
if (kc != 0 || encoding == RubyEncoding.Binary)
{
pattern = _pattern.ToString(encoding.Encoding);
}
else
{
pattern = _pattern.ConvertToString();
}
Regex result;
try {
result = new Regex(RegexpTransformer.Transform(pattern, _options, out _hasGAnchor), ToClrOptions(_options));
} catch (Exception e) {
throw new RegexpError(e.Message);
}
_cachedKCode = kc;
_cachedRegex = result;
return(result);
}
public static RubyArray /*!*/ GetAllNames(RubyContext /*!*/ context, RubyEncoding /*!*/ self)
{
var result = new RubyArray();
string name = self.Name;
result.Add(MutableString.Create(name));
foreach (var alias in RubyEncoding.Aliases)
{
if (StringComparer.OrdinalIgnoreCase.Equals(alias.Value, name))
{
result.Add(MutableString.CreateAscii(alias.Key));
}
}
if (self == context.RubyOptions.LocaleEncoding)
{
result.Add(MutableString.CreateAscii("locale"));
}
if (self == context.DefaultExternalEncoding)
{
result.Add(MutableString.CreateAscii("external"));
}
if (self == context.GetPathEncoding())
{
result.Add(MutableString.CreateAscii("filesystem"));
}
return(result);
}
public MutableString ReadLine(MutableString /*!*/ separator, RubyEncoding /*!*/ encoding, bool preserveEndOfLines)
{
int b = ReadByteNormalizeEoln(preserveEndOfLines);
if (b == -1)
{
return(null);
}
int separatorOffset = 0;
int separatorLength = separator.GetByteCount();
MutableString result = MutableString.CreateBinary(encoding);
do
{
result.Append((byte)b);
if (b == separator.GetByte(separatorOffset))
{
if (separatorOffset == separatorLength - 1)
{
break;
}
separatorOffset++;
}
else if (separatorOffset > 0)
{
separatorOffset = 0;
}
b = ReadByteNormalizeEoln(preserveEndOfLines);
} while (b != -1);
return(result);
}
public MutableString ReadLineOrParagraph(MutableString separator, RubyEncoding /*!*/ encoding, bool preserveEndOfLines, int limit)
{
ContractUtils.Requires(limit >= 0);
if (limit == 0)
{
return(MutableString.CreateEmpty());
}
else if (separator == null)
{
var result = MutableString.CreateBinary();
return(AppendBytes(result, limit, preserveEndOfLines) == 0 ? null : result);
}
else if (separator.StartsWith('\n') && separator.GetLength() == 1)
{
return(ReadLine(encoding, preserveEndOfLines, limit));
}
else if (separator.IsEmpty)
{
return(ReadParagraph(encoding, preserveEndOfLines, limit));
}
else
{
return(ReadLine(separator, encoding, preserveEndOfLines, limit));
}
}
private Regex /*!*/ Transform(ref RubyEncoding encoding, MutableString /*!*/ input, int start, out string strInput)
{
ContractUtils.RequiresNotNull(input, "input");
// K-coding of the current operation (the current KCODE gets preference over the KCODE regex option):
RubyRegexOptions kc = _options & RubyRegexOptions.EncodingMask;
if (kc != 0)
{
encoding = _pattern.Encoding;
}
else
{
kc = RubyEncoding.ToRegexOption(encoding);
}
// Convert input to a string. Force k-coding if necessary.
if (kc != 0)
{
// Handling multi-byte K-coded characters is not entirely correct here.
// Three cases to be considered:
// 1) Multi-byte character is explicitly contained in the pattern: /�*/
// 2) Subsequent escapes form a complete character: /\342\202\254*/ or /\xe2\x82\xac*/
// 3) Subsequent escapes form an incomplete character: /[\x7f-\xff]{1,3}/
//
// In the first two cases we want to "group" the byte triplet so that regex operators like *, +, ? and {n,m} operate on
// the entire character, not just the last byte. We could unescape the bytes and replace them with complete Unicode characters.
// Then we could encode the input using the same K-coding and we would get a match.
// However, case 3) requires the opposite: to match the bytes we need to encode the input using binary encoding.
// Using this encoding makes *+? operators operate on the last byte (encoded as UTF16 character).
//
// The right solution would require the regex engine to handle multi-byte escaped characters, which it doesn't.
//
// TODO:
// A correct workaround would be to wrap the byte sequence that forms a character into a non-capturing group,
// for example transform /\342\202\254*/ to /(?:\342\202\254)*/ and use binary encoding on both input and pattern.
// For now, we just detect if there are any non-ascii character escapes. If so we use a binary encoding accomodating case 3),
// but breaking cases 1 and 2. Otherwise we encode using k-coding to make case 1 match.
if (HasEscapedNonAsciiBytes(_pattern))
{
encoding = RubyEncoding.Binary;
kc = 0;
}
strInput = ForceEncoding(input, encoding.Encoding, start);
}
else if (input.Encoding.IsKCoding)
{
strInput = input.ToString(BinaryEncoding.Instance);
}
else
{
_pattern.RequireCompatibleEncoding(input);
input.PrepareForCharacterRead();
strInput = input.ConvertToString();
}
return(TransformPattern(encoding, kc));
}
public MutableString/*!*/ GetMutableString(RubyEncoding/*!*/ encoding) {
string str = _value as string;
if (str != null) {
return MutableString.Create(str, encoding);
} else {
return MutableString.CreateBinary((byte[])_value, encoding);
}
}
internal StringLiteral(object/*!*/ value, RubyEncoding/*!*/ encoding, SourceSpan location)
: base(location)
{
Debug.Assert(value is string || value is byte[]);
Debug.Assert(encoding != null);
_value = value;
_encoding = encoding;
}
public RubyIO(RubyContext/*!*/ context) {
ContractUtils.RequiresNotNull(context, "context");
_context = context;
_fileDescriptor = -1;
_stream = null;
_externalEncoding = context.DefaultExternalEncoding;
_internalEncoding = context.DefaultInternalEncoding;
}
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(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 RubyIO(RubyContext /*!*/ context)
{
ContractUtils.RequiresNotNull(context, "context");
_context = context;
_fileDescriptor = -1;
_stream = null;
_externalEncoding = context.DefaultExternalEncoding;
_internalEncoding = context.DefaultInternalEncoding;
}
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;
}
// TODO: remove
internal StringFormatter(RubyContext /*!*/ context, string /*!*/ format, RubyEncoding /*!*/ encoding, IList /*!*/ data)
{
Assert.NotNull(context, format, data, encoding);
_context = context;
_format = format;
_data = data;
// TODO (encoding):
_encoding = encoding;
}
public RubyIO(RubyContext/*!*/ context) {
ContractUtils.RequiresNotNull(context, "context");
_context = context;
_fileDescriptor = -1;
_stream = null;
// TODO (encoding): enable setting
_externalEncoding = RubyEncoding.Binary;
_internalEncoding = null;
}
public static RubyArray /*!*/ GetNameList(RubyClass /*!*/ self)
{
var result = new RubyArray();
foreach (string name in RubyEncoding.GetEncodingNames())
{
result.Add(MutableString.Create(name));
}
return(result);
}
private RubyEncoding(Encoding /*!*/ encoding, Encoding /*!*/ strictEncoding, RubyEncoding realEncoding, int ordinal)
{
Assert.NotNull(encoding, strictEncoding);
Debug.Assert(encoding is KCoding == strictEncoding is KCoding);
_isKCoding = encoding is KCoding;
_ordinal = ordinal;
_encoding = encoding;
_strictEncoding = strictEncoding;
_realEncoding = realEncoding ?? this;
_maxBytesPerChar = strictEncoding.GetMaxByteCount(1);
}
public static RubyArray /*!*/ GetAvailableEncodings(RubyClass /*!*/ self)
{
var result = new RubyArray();
foreach (int codePage in RubyEncoding.GetEncodingCodePages())
{
result.Add(RubyEncoding.GetRubyEncoding(codePage));
}
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 MutableString ReadLine(RubyEncoding /*!*/ encoding, bool preserveEndOfLines, int limit)
{
// TODO: limit
if (_bufferCount == 0)
{
if (LoadBuffer(_defaultBufferSize) == 0)
{
return(null);
}
}
bool bufferResized = false;
int lf = Array.IndexOf(_buffer, LF, _bufferStart, _bufferCount);
while (lf < 0)
{
int s = _bufferCount;
LoadBuffer(_buffer.Length - _bufferCount);
Debug.Assert(_bufferStart == 0);
lf = Array.IndexOf(_buffer, LF, s, _bufferCount - s);
if (lf >= 0)
{
break;
}
// end of stream:
if (_bufferCount < _buffer.Length)
{
return(ConsumeLine(encoding, _bufferCount, _bufferCount, bufferResized));
}
Array.Resize(ref _buffer, _buffer.Length << 1);
bufferResized = true;
_bufferStart = 0;
}
int lineLength;
int consume = lf + 1 - _bufferStart;
if (!preserveEndOfLines && lf - 1 >= _bufferStart && _buffer[lf - 1] == CR)
{
_buffer[lf - 1] = LF;
lineLength = consume - 1;
}
else
{
lineLength = consume;
}
return(ConsumeLine(encoding, lineLength, consume, bufferResized));
}
public RubyIO(RubyContext /*!*/ context)
{
ContractUtils.RequiresNotNull(context, "context");
_context = context;
_fileDescriptor = -1;
_stream = null;
// TODO (encoding): enable setting
_externalEncoding = RubyEncoding.Binary;
_internalEncoding = null;
}
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);
}
/// <summary>
/// Finds the last match whose index is less than or equal to "start".
/// Captures are ordered in the same way as with forward match. This is different from .NET reverse matching.
/// Start is a number of bytes if kcode is given, otherwise it's a number of characters.
/// </summary>
public MatchData LastMatch(MutableString /*!*/ input, int start)
{
string str;
RubyEncoding kcode = null;
Regex regex = Transform(ref kcode, input, 0, out str);
Debug.Assert(str != null);
if (kcode != null)
{
int byteCount;
byte[] bytes = input.GetByteArray(out byteCount);
if (start < 0)
{
start += byteCount;
}
// GetCharCount returns the number of whole characters:
start = (start >= byteCount) ? str.Length : kcode.Encoding.GetCharCount(bytes, 0, start + 1) - 1;
}
else
{
if (start < 0)
{
start += str.Length;
}
if (start > str.Length)
{
start = str.Length;
}
}
Match match;
if (_hasGAnchor)
{
// This only makes some \G anchors work. It seems that CLR doesn't support \G if preceeded by some characters.
// For example, this works in MRI but doesn't in CLR: "abcabczzz".rindex(/.+\G.+/, 3)
match = regex.Match(str, start);
}
else
{
match = LastMatch(regex, str, start);
if (match == null)
{
return(null);
}
}
return(MatchData.Create(match, input, true, str));
}
public RubyConstructor(RubyGlobalScope/*!*/ scope, NodeProvider/*!*/ nodeProvider)
: base(nodeProvider, scope) {
_encoding = RubyEncoding.GetRubyEncoding(nodeProvider.Encoding);
_newSite = CallSite<Func<CallSite, RubyModule, object, object, object, object>>.Create(
RubyCallAction.Make(scope.Context, "new", RubyCallSignature.WithImplicitSelf(3))
);
_yamlInitializeSite = CallSite<Func<CallSite, object, object, Hash, object>>.Create(
RubyCallAction.Make(scope.Context, "yaml_initialize", RubyCallSignature.WithImplicitSelf(3))
);
}
public static RubyArray /*!*/ GetAvailableEncodings(RubyClass /*!*/ self)
{
var infos = Encoding.GetEncodings();
var result = new RubyArray(1 + infos.Length);
// Ruby specific:
result.Add(RubyEncoding.Binary);
foreach (var info in infos)
{
result.Add(RubyEncoding.GetRubyEncoding(info.CodePage));
}
return(result);
}
internal RubyInputProvider(RubyContext/*!*/ context, ICollection<string>/*!*/ arguments, RubyEncoding/*!*/ encoding) {
Assert.NotNull(context, encoding);
Assert.NotNullItems(arguments);
_context = context;
var args = new RubyArray();
foreach (var arg in arguments) {
ExpandArgument(args, arg, encoding);
}
_commandLineArguments = args;
_lastInputLineNumber = 1;
_singleton = new object();
}
private MSA.Expression _sourcePathConstant; // lazy
internal AstGenerator(RubyContext/*!*/ context, RubyCompilerOptions/*!*/ options, MSA.SymbolDocumentInfo document, RubyEncoding/*!*/ encoding,
bool printInteractiveResult) {
Assert.NotNull(context, options, encoding);
_context = context;
_compilerOptions = options;
_debugCompiler = Snippets.Shared.SaveSnippets;
_debugMode = context.DomainManager.Configuration.DebugMode;
_traceEnabled = context.RubyOptions.EnableTracing;
_document = document;
_encoding = encoding;
_profiler = context.RubyOptions.Profile ? Profiler.Instance : null;
_savingToDisk = context.RubyOptions.SavePath != null;
_printInteractiveResult = printInteractiveResult;
}
internal AstGenerator(RubyCompilerOptions/*!*/ options, SourceUnit/*!*/ sourceUnit, RubyEncoding/*!*/ encoding,
bool debugCompiler, bool debugMode, bool traceEnabled, bool profilerEnabled, bool savingToDisk) {
Assert.NotNull(options, encoding, sourceUnit);
_context = (RubyContext)sourceUnit.LanguageContext;
_compilerOptions = options;
_debugCompiler = debugCompiler;
_debugMode = debugMode;
_traceEnabled = traceEnabled;
_sourceUnit = sourceUnit;
_document = sourceUnit.Document;
_encoding = encoding;
_profiler = profilerEnabled ? Profiler.Instance : null;
_savingToDisk = savingToDisk;
}
private void ExpandArgument(RubyArray/*!*/ args, string/*!*/ arg, RubyEncoding/*!*/ encoding) {
if (arg.IndexOf('*') != -1 || arg.IndexOf('?') != -1) {
bool added = false;
foreach (string path in Glob.GlobResults(_context.DomainManager.Platform, arg, 0)) {
args.Add(MutableString.Create(path, encoding));
added = true;
}
if (!added) {
args.Add(MutableString.Create(arg, encoding));
}
} else {
args.Add(MutableString.Create(arg, encoding));
}
}
public static RubyArray /*!*/ GetAvailableEncodings(RubyClass /*!*/ self)
{
// TODO: loads all encodings, we should be lazy with encoding creation
var infos = Encoding.GetEncodings();
var result = new RubyArray(1 + infos.Length);
// Ruby specific:
result.Add(RubyEncoding.Binary);
foreach (var info in infos)
{
result.Add(RubyEncoding.GetRubyEncoding(info.GetEncoding()));
}
return(result);
}
private void WriteSymbol(string /*!*/ value, RubyEncoding /*!*/ encoding)
{
int position;
if (_symbols.TryGetValue(value, out position))
{
_writer.Write((byte)';');
WriteInt32(position);
}
else
{
position = _symbols.Count;
_symbols[value] = position;
_writer.Write((byte)':');
WriteStringValue(value, encoding);
}
}
public MutableString ReadParagraph(RubyEncoding /*!*/ encoding, bool preserveEndOfLines)
{
var result = ReadLine(MutableString.CreateAscii("\n\n"), encoding, preserveEndOfLines);
int c;
while ((c = PeekByteNormalizeEoln(preserveEndOfLines)) != -1)
{
if (c != '\n')
{
break;
}
ReadByteNormalizeEoln(preserveEndOfLines);
}
return(result);
}
public static RubyIO /*!*/ SetEncodings(ConversionStorage <IDictionary <object, object> > /*!*/ toHash, ConversionStorage <MutableString> /*!*/ toStr,
RubyIO /*!*/ self, object external, [Optional] object @internal, [Optional] IDictionary <object, object> options)
{
TryConvertToOptions(toHash, ref options, ref external, ref @internal);
// TODO: options
RubyEncoding externalEncoding = null, internalEncoding = null;
if (external != Missing.Value)
{
externalEncoding = ToEncoding(toStr, external);
}
if (@internal != Missing.Value)
{
internalEncoding = ToEncoding(toStr, @internal);
}
return(SetEncodings(self, externalEncoding, internalEncoding));
}
/// <summary>
/// Returns a collection of fresh MatchData objects.
/// </summary>
public IList <MatchData> /*!*/ Matches(RubyEncoding kcode, MutableString /*!*/ input, bool inputMayMutate)
{
string str;
MatchCollection matches = Transform(ref kcode, input, 0, out str).Matches(str);
var result = new MatchData[matches.Count];
if (result.Length > 0 && inputMayMutate)
{
// clone and freeze the string once so that it can be shared by all the MatchData objects
input = input.Clone().Freeze();
}
for (int i = 0; i < result.Length; i++)
{
result[i] = MatchData.Create(matches[i], input, false, str, kcode, 0);
}
return(result);
}
public RubyOptions(IDictionary<string, object>/*!*/ options)
: base(options)
{
_arguments = GetStringCollectionOption(options, "Arguments") ?? EmptyStringCollection;
_localeEncoding = GetOption(options, "LocaleEncoding", RubyEncoding.UTF8);
_defaultEncoding = GetOption<RubyEncoding>(options, "DefaultEncoding", null);
_mainFile = GetOption(options, "MainFile", (string)null);
_verbosity = GetOption(options, "Verbosity", 1);
_debugVariable = GetOption(options, "DebugVariable", false);
_enableTracing = GetOption(options, "EnableTracing", false);
_savePath = GetOption(options, "SavePath", (string)null);
_loadFromDisk = GetOption(options, "LoadFromDisk", false);
_profile = GetOption(options, "Profile", false);
_noAssemblyResolveHook = GetOption(options, "NoAssemblyResolveHook", false);
_requirePaths = GetStringCollectionOption(options, "RequiredPaths", ';', ',');
_hasSearchPaths = GetOption<object>(options, "SearchPaths", null) != null;
_standardLibraryPath = GetOption(options, "StandardLibrary", (string)null);
_applicationBase = GetOption(options, "ApplicationBase", (string)null);
}
public MutableString ReadLineOrParagraph(MutableString separator, RubyEncoding /*!*/ encoding, bool preserveEndOfLines)
{
if (separator == null)
{
var result = MutableString.CreateBinary();
return(AppendBytes(result, Int32.MaxValue, preserveEndOfLines) == 0 ? null : result);
}
else if (separator.StartsWith('\n') && separator.GetLength() == 1)
{
return(ReadLine(encoding, preserveEndOfLines));
}
else if (separator.IsEmpty)
{
return(ReadParagraph(encoding, preserveEndOfLines));
}
else
{
return(ReadLine(separator, encoding, preserveEndOfLines));
}
}
internal AstGenerator(RubyContext/*!*/ context, RubyCompilerOptions/*!*/ options, MSA.SymbolDocumentInfo document, RubyEncoding/*!*/ encoding,
bool printInteractiveResult) {
Assert.NotNull(context, options, encoding);
_context = context;
_compilerOptions = options;
_debugMode = context.DomainManager.Configuration.DebugMode;
_traceEnabled = context.RubyOptions.EnableTracing;
_document = document;
_sequencePointClearance = (document != null) ? Ast.ClearDebugInfo(document) : null;
_encoding = encoding;
_encodingConstant = Ast.Constant(encoding);
_profiler = context.RubyOptions.Profile ? Profiler.Instance : null;
_savingToDisk = context.RubyOptions.SavePath != null;
_printInteractiveResult = printInteractiveResult;
#if SILVERLIGHT
_debugCompiler = false;
#else
_debugCompiler = Snippets.Shared.SaveSnippets;
#endif
}
public void Set(MutableString /*!*/ pattern, RubyRegexOptions options)
{
ContractUtils.RequiresNotNull(pattern, "pattern");
// RubyRegexOptions.Once is only used to determine how the Regexp object should be created and cached.
// It is not a property of the final object. /foo/ should compare equal with /foo/o.
_options = options & ~RubyRegexOptions.Once;
RubyEncoding encoding = RubyEncoding.GetRegexEncoding(options);
if (encoding != null || pattern.Encoding.IsKCoding)
{
_pattern = MutableString.CreateBinary(pattern.ToByteArray(), encoding ?? RubyEncoding.Binary).Freeze();
}
else
{
_pattern = pattern.PrepareForCharacterRead().Clone().Freeze();
}
TransformPattern(encoding, options & RubyRegexOptions.EncodingMask);
}
private void ExpandArgument(RubyArray /*!*/ args, string /*!*/ arg, RubyEncoding /*!*/ encoding)
{
if (arg.IndexOf('*') != -1 || arg.IndexOf('?') != -1)
{
bool added = false;
foreach (string path in Glob.GetMatches(_context.DomainManager.Platform, arg, 0))
{
args.Add(MutableString.Create(path, encoding));
added = true;
}
if (!added)
{
args.Add(MutableString.Create(arg, encoding));
}
}
else
{
args.Add(MutableString.Create(arg, encoding));
}
}
/// <summary>
/// Returns Ruby names of all available encodings including their aliases.
/// </summary>
public static IEnumerable <string> GetEncodingNames()
{
// Ruby specific:
yield return(RubyEncoding.Binary.Name);
foreach (var info in Encoding.GetEncodings())
{
yield return(RubyEncoding.GetRubySpecificName(info.CodePage) ?? info.Name);
}
foreach (var alias in RubyEncoding.Aliases.Keys)
{
yield return(alias);
}
yield return("locale");
yield return("external");
yield return("filesystem");
}
internal static RubyEncoding /*!*/ GetRubyEncoding(int codepage)
{
switch (codepage)
{
case CodePageBinary: return(Binary);
case CodePageUTF8: return(UTF8);
}
if (_Encodings == null)
{
Interlocked.CompareExchange(ref _Encodings, new Dictionary <int, RubyEncoding>(), null);
}
RubyEncoding result;
lock (_Encodings) {
if (!_Encodings.TryGetValue(codepage, out result))
{
result = new RubyEncoding(
CreateEncoding(codepage, false),
CreateEncoding(codepage, true),
null,
codepage
);
// Some MutableString operations (GetHashCode, SetChar, etc.) assume that the encoding maps each and every
// character \u0000..\u007f to a corresponding byte 0..0x7f and back.
if (!IsAsciiIdentity(result.Encoding))
{
throw new NotSupportedException(String.Format("Encoding code page {0} is not supported", codepage));
}
_Encodings.Add(codepage, result);
}
}
return(result);
}
public static RubyEncoding /*!*/ GetRubyEncoding(int codepage)
{
switch (codepage)
{
case CodePageBinary: return(Binary);
case CodePageAscii: return(Ascii);
case CodePageUTF8: return(UTF8);
#if FEATURE_ENCODING
case CodePageSJIS: return(SJIS);
case CodePageEUCJP: return(EUCJP);
#endif
}
if (_Encodings == null)
{
Interlocked.CompareExchange(ref _Encodings, new Dictionary <int, RubyEncoding>(), null);
}
RubyEncoding result;
lock (_Encodings) {
if (!_Encodings.TryGetValue(codepage, out result))
{
result = new RubyEncoding(
CreateEncoding(codepage, false),
CreateEncoding(codepage, true),
codepage
);
_Encodings.Add(codepage, result);
}
}
return(result);
}
public static Exception/*!*/ CreateArgumentError(DecoderFallbackException/*!*/ e, RubyEncoding/*!*/ encoding) {
return RubyExceptions.CreateArgumentError(String.Format("invalid byte sequence {0} in {1}",
BitConverter.ToString(e.BytesUnknown), encoding));
}
public static Exception/*!*/ CreateArgumentError(EncoderFallbackException/*!*/ e, RubyEncoding/*!*/ encoding) {
return RubyExceptions.CreateArgumentError(String.Format("character U+{0:X4} can't be encoded in {1}",
e.CharUnknownHigh != '\0' ? Tokenizer.ToCodePoint(e.CharUnknownHigh, e.CharUnknownLow) : (int)e.CharUnknown, encoding));
}
public static bool IsDummy(RubyEncoding/*!*/ self) {
return false;
}
public static RubyEncoding BasedEncoding(RubyEncoding/*!*/ self) {
return null;
}
public IOInfo(IOMode? mode, RubyEncoding externalEncoding, RubyEncoding internalEncoding) {
_mode = mode;
_externalEncoding = externalEncoding;
_internalEncoding = internalEncoding;
}
private void Test_Translate(
byte[]/*!*/ bself, RubyEncoding/*!*/ eself,
byte[]/*!*/ bfrom, RubyEncoding/*!*/ efrom,
byte[]/*!*/ bto, RubyEncoding/*!*/ eto,
byte[]/*!*/ expected, RubyEncoding/*!*/ expectedEncoding) {
var self = MutableString.CreateBinary(bself, eself);
var from = MutableString.CreateBinary(bfrom, efrom);
var to = MutableString.CreateBinary(bto, eto);
var result = MutableStringOps.GetTranslated(self, from, to);
Assert(result.Encoding == expectedEncoding);
var b = result.ToByteArray();
Assert(b.ValueEquals(expected));
}
public void Test_Reverse(byte[]/*!*/ b, RubyEncoding/*!*/ e, byte[]/*!*/ expected) {
var s = MutableString.CreateBinary(b, e);
MutableStringOps.Reverse(s);
var actual = s.ToByteArray();
Assert(actual.ValueEquals(expected));
}
private void Test_Concatenate(byte[]/*!*/ b1, RubyEncoding/*!*/ e1, byte[]/*!*/ b2, RubyEncoding/*!*/ e2, RubyEncoding/*!*/ resultEncoding) {
var s1 = MutableString.CreateBinary(b1, e1).PrepareForCharacterRead();
var s2 = MutableString.CreateBinary(b2, e2).PrepareForCharacterRead();
var s = MutableStringOps.Concatenate(s1, s2);
Assert(s.Encoding == resultEncoding);
var b = s.ToByteArray();
Assert(b.ValueCompareTo(b.Length, Utils.Concatenate(b1, b2)) == 0);
}
private MutableString/*!*/ MS(byte[]/*!*/ data, RubyEncoding/*!*/ e) {
return MutableString.CreateBinary(data.Length * 3, e).Append(data);
}
public static Exception/*!*/ CreateEncodingCompatibilityError(RubyEncoding/*!*/ encoding1, RubyEncoding/*!*/ encoding2) {
return new EncodingCompatibilityError(
FormatMessage("incompatible character encodings: {0}{1} and {2}{3}",
encoding1.Name, encoding1.IsKCoding ? " (KCODE)" : null, encoding2.Name, encoding2.IsKCoding ? " (KCODE)" : null
)
);
}
public static RubyEncoding/*!*/ SetDefaultInternalEncoding(RubyClass/*!*/ self, RubyEncoding encoding) {
// TODO:
return RubyEncoding.Default;
}
public static MutableString/*!*/ ToS(RubyEncoding/*!*/ self) {
return MutableString.CreateAscii(self.Name);
}
public static RubyIO/*!*/ SetEncodings(RubyIO/*!*/ self, RubyEncoding external, [DefaultParameterValue(null)]RubyEncoding @internal) {
self.ExternalEncoding = external ?? self.Context.RubyOptions.LocaleEncoding;
self.InternalEncoding = @internal;
return self;
}
/*!*/
MSA.Expression StringConstructor.IFactory.CreateExpression(AstGenerator/*!*/ gen, byte[]/*!*/ literal, RubyEncoding/*!*/ encoding)
{
// TODO: create the regex here, not at runtime:
return Methods.CreateRegexB.OpCall(
Ast.Constant(literal), encoding.Expression, AstUtils.Constant(_options), AstUtils.Constant(new StrongBox<RubyRegex>(null))
);
}
