private PartialParseResult HandleInsertion( Span target, char previousChar, TextChange change ) { // What are we inserting after? if (previousChar == '.') { return(HandleInsertionAfterDot(target, change)); } else if ( ParserHelpers.IsIdentifierPart(previousChar) || previousChar == ')' || previousChar == ']' ) { return(HandleInsertionAfterIdPart(target, change)); } else { return(PartialParseResult.Rejected); } }
internal static void ParseSummary(IStringReader reader, ChangeSetDetail detail) { reader.SkipWhitespace(); while (!reader.Done) { string line = reader.ReadLine(); if (ParserHelpers.IsSingleNewLine(line)) { break; } else if (line.Contains('\t')) { // n n path string[] parts = line.Split('\t'); int insertions; Int32.TryParse(parts[0], out insertions); int deletions; Int32.TryParse(parts[1], out deletions); string path = parts[2].TrimEnd(); detail.Files[path] = new FileInfo { Insertions = insertions, Deletions = deletions, Binary = parts[0] == "-" && parts[1] == "-" }; } else { // n files changed, n insertions(+), n deletions(-) ParserHelpers.ParseSummaryFooter(line, detail); } } }
private StateResult QuotedLiteral(char quote, CSharpSymbolType literalType) { TakeUntil(c => c == '\\' || c == quote || ParserHelpers.IsNewLine(c)); if (CurrentCharacter == '\\') { TakeCurrent(); // Take the '\' // If the next char is the same quote that started this if (CurrentCharacter == quote || CurrentCharacter == '\\') { TakeCurrent(); // Take it so that we don't prematurely end the literal. } return(Stay()); } else if (EndOfFile || ParserHelpers.IsNewLine(CurrentCharacter)) { CurrentErrors.Add(new RazorError(RazorResources.ParseError_Unterminated_String_Literal, CurrentStart)); } else { TakeCurrent(); // No-op if at EOF } return(Transition(EndSymbol(literalType), Data)); }
public Tag Parse(TemplateParser parser, TokenCollection tc) { if (tc.Count > 3 && ParserHelpers.IsEqual(tc.First.Text, Field.KEY_ELSEIF)) { if (tc[1].TokenKind == TokenKind.LeftParentheses && tc.Last.TokenKind == TokenKind.RightParentheses) { ElseifTag tag = new ElseifTag(); TokenCollection coll = new TokenCollection(); coll.Add(tc, 2, tc.Count - 2); tag.Test = parser.Read(coll); return(tag); } else { throw new ParseException(string.Concat("syntax error near if:", tc), parser.Context.CurrentPath, tc.First.BeginLine, tc.First.BeginColumn); } } return(null); }
public StringTextSnapshot(string content, int versionNumber) { Content = content; _lines = new List <ITextSnapshotLine>(); var start = 0; var delimiterIndex = 0; while (delimiterIndex != -1) { var delimiterLength = 2; delimiterIndex = Content.IndexOf("\r\n", start, StringComparison.Ordinal); if (delimiterIndex == -1) { delimiterLength = 1; for (var i = start; i < Content.Length; i++) { if (ParserHelpers.IsNewLine(content[i])) { delimiterIndex = i; break; } } } var nextLineStartIndex = delimiterIndex != -1 ? delimiterIndex + delimiterLength : Content.Length; var lineText = Content.Substring(start, nextLineStartIndex - start); _lines.Add(new SnapshotLine(lineText, start, this)); start = nextLineStartIndex; Version = new TextVersion(versionNumber); } }
private bool ParseResourceStatement(CodeBlockInfo block) { End(MetaCodeSpan.Create); SourceLocation endModelLocation = CurrentLocation; if (_modelStatementFound) { OnError(endModelLocation, String.Format(CultureInfo.CurrentCulture, "Only one '{0}' statement is allowed in a file.", ResourceKeyword)); } _modelStatementFound = true; // Accept Whitespace up to the new line or non-whitespace character Context.AcceptWhiteSpace(false); string typeName = null; if (ParserHelpers.IsIdentifierStart(CurrentCharacter)) { using (Context.StartTemporaryBuffer()) { // Accept a dotted-identifier, but allow <> AcceptTypeName(); typeName = Context.ContentBuffer.ToString(); Context.AcceptTemporaryBuffer(); } } else { OnError(endModelLocation, String.Format(CultureInfo.CurrentCulture, "The '{0}' keyword must be followed by a type name on the same line.", ResourceKeyword)); } CheckForInheritsAndResourceStatements(); End(ResourceSpan.Create(Context, typeName)); return(false); }
protected Func <char, bool> CharOrWhiteSpace(char character) { return(c => c == character || ParserHelpers.IsWhitespace(c) || ParserHelpers.IsNewLine(c)); }
public async Task <IReplayHeader> ReadReplayAsync(FileStream fileStream) { if (!fileStream.CanRead) { throw new IOException($"{exceptionOriginName} - Stream does not support reading"); } // Read and check Magic Numbers ReplayType type; try { type = await ParserHelpers.GetReplayTypeAsync(fileStream); } catch (Exception ex) { throw new IOException($"{exceptionOriginName} - Reading Magic Number: " + ex.Message, ex); } if (type != ReplayType.ROFL) { throw new Exception($"{exceptionOriginName} - Selected file is not in valid ROFL format"); } // Read and deserialize length fields byte[] lengthFieldBuffer; try { lengthFieldBuffer = await ParserHelpers.ReadBytesAsync(fileStream, 26, 262, SeekOrigin.Begin); } catch (Exception ex) { throw new IOException($"{exceptionOriginName} - Reading Length Header: " + ex.Message, ex); } LengthFields lengthFields; try { lengthFields = ParseLengthFields(lengthFieldBuffer); } catch (Exception ex) { throw new Exception($"{exceptionOriginName} - Parsing Length Header: " + ex.Message, ex); } // Read and deserialize metadata byte[] metadataBuffer; try { metadataBuffer = await ParserHelpers.ReadBytesAsync(fileStream, (int)lengthFields.MetadataLength, (int)lengthFields.MetadataOffset, SeekOrigin.Begin); } catch (Exception ex) { throw new IOException($"{exceptionOriginName} - Reading JSON Metadata: " + ex.Message, ex); } MatchMetadata metadataFields; try { metadataFields = ParseMetadata(metadataBuffer); } catch (Exception ex) { throw new Exception($"{exceptionOriginName} - Parsing Metadata Header: " + ex.Message, ex); } // Read and deserialize payload fields byte[] payloadBuffer; try { payloadBuffer = await ParserHelpers.ReadBytesAsync(fileStream, (int)lengthFields.PayloadHeaderLength, (int)lengthFields.PayloadHeaderOffset, SeekOrigin.Begin); } catch (Exception ex) { throw new IOException($"{exceptionOriginName} - Reading Match Header: " + ex.Message, ex); } PayloadFields payloadFields; try { payloadFields = ParsePayloadHeader(payloadBuffer); } catch (Exception ex) { throw new Exception($"{exceptionOriginName} - Parsing Payload Header: " + ex.Message, ex); } // Combine objects to create header ROFLHeader result = new ROFLHeader { LengthFields = lengthFields, MatchMetadata = metadataFields, PayloadFields = payloadFields }; // Create json of entire contents string jsonString = JsonConvert.SerializeObject(result); // throw it back on the object and return result.RawJsonString = jsonString; return(result); }
private static bool TryParseUInt16D(ReadOnlySpan <byte> source, out ushort value, out int bytesConsumed) { if (source.Length < 1) { goto FalseExit; } int index = 0; int num = source[index]; int answer = 0; if (ParserHelpers.IsDigit(num)) { if (num == '0') { do { index++; if ((uint)index >= (uint)source.Length) { goto Done; } num = source[index]; } while (num == '0'); if (!ParserHelpers.IsDigit(num)) { goto Done; } } answer = num - '0'; index++; if ((uint)index >= (uint)source.Length) { goto Done; } num = source[index]; if (!ParserHelpers.IsDigit(num)) { goto Done; } index++; answer = 10 * answer + num - '0'; if ((uint)index >= (uint)source.Length) { goto Done; } num = source[index]; if (!ParserHelpers.IsDigit(num)) { goto Done; } index++; answer = 10 * answer + num - '0'; if ((uint)index >= (uint)source.Length) { goto Done; } num = source[index]; if (!ParserHelpers.IsDigit(num)) { goto Done; } index++; answer = 10 * answer + num - '0'; // Potential overflow if ((uint)index >= (uint)source.Length) { goto Done; } num = source[index]; if (!ParserHelpers.IsDigit(num)) { goto Done; } index++; answer = answer * 10 + num - '0'; if ((uint)answer > ushort.MaxValue) { goto FalseExit; // Overflow } if ((uint)index >= (uint)source.Length) { goto Done; } if (!ParserHelpers.IsDigit(source[index])) { goto Done; } // Guaranteed overflow goto FalseExit; } FalseExit: bytesConsumed = default; value = default; return(false); Done: bytesConsumed = index; value = (ushort)answer; return(true); }
private IField ReadFieldFromTable(DataRow dr, string elementName, SortedList <string, int> bitmapLows, SortedList <string, int> bitmapHighs) { FieldLength length; Enum.TryParse <FieldLength>((string)dr["FieldLength"], out length); FieldFormat format; Enum.TryParse <FieldFormat>((string)dr["FieldFormat"], out format); Messages.Core.Field.Empty empty; if (elementName != "Group" && Convert.ToBoolean(dr["Bitmap"])) { if (Convert.ToBoolean(dr["HexBitmap"])) { empty = new BitmapHex(Convert.ToInt32(dr["BitmapFirst"])); } else { empty = new Bitmap(Convert.ToInt32(dr["BitmapFirst"])); } bitmapLows.Add((string)dr[elementName], Convert.ToInt32(dr["BitmapStartRange"])); bitmapHighs.Add((string)dr[elementName], Convert.ToInt32(dr["BitmapEndRange"])); } else { empty = new Messages.Core.Field.Empty(); } empty.Configure((string)dr[elementName], Convert.ToInt32(dr["Size"]), Convert.ToInt32(dr["Number"]), length, format, FormatHelpers.GetFormatter((string)dr["Formatter"]), ValidatorHelpers.GetValidator((string)dr["Validator"]), ParserHelpers.GetParser((string)dr["Parser"])); return(empty); }
public async Task <ReplayFile> ReadFile(string filePath) { // Make sure file exists if (String.IsNullOrEmpty(filePath)) { _log.Error("File reference is null"); throw new ArgumentNullException($"File reference is null"); } if (!File.Exists(filePath)) { _log.Error("File path not found, does the file exist?"); throw new FileNotFoundException($"File path not found, does the file exist?"); } // Reads the first 4 bytes and tries to find out the replay type ReplayType type = await ParserHelpers.GetReplayTypeAsync(filePath); // Match parsers to file types ReplayFile result; switch (type) { case ReplayType.ROFL: // Official Replays result = await ReadROFL(filePath); break; //case ReplayType.LRF: // LOLReplay // file.Type = ReplayType.LRF; // file.Data = await ReadLRF(file.Location); // break; //case ReplayType.LPR: // BaronReplays // file.Type = ReplayType.LPR; // file.Data = null; // break; default: _log.Error($"File {filePath} is not an accepted format: rofl"); return(null); } // Make some educated guesses GameDetailsInferrer detailsInferrer = new GameDetailsInferrer(); result.Players = result.BluePlayers.Union(result.RedPlayers).ToArray(); try { result.MapId = detailsInferrer.InferMap(result.Players); } catch (ArgumentNullException ex) { _log.Warning("Could not infer map type\n" + ex.ToString()); result.MapId = MapCode.Unknown; } result.MapName = detailsInferrer.GetMapName(result.MapId); result.IsBlueVictorious = detailsInferrer.InferBlueVictory(result.BluePlayers, result.RedPlayers); foreach (var player in result.Players) { player.Id = $"{result.MatchId}_{player.PlayerID}"; } // Set the alternate name to the default result.AlternativeName = result.Name; return(result); }
private StateResult HexLiteral() { TakeUntil(c => !ParserHelpers.IsHexDigit(c)); TakeIntegerSuffix(); return(Stay(EndSymbol(CSharpSymbolType.IntegerLiteral))); }
/// <summary> /// Continues the content of the tag. /// </summary> /// <param name="raw">True if we are expected a raw tag.</param> /// <returns>The state result.</returns> private StateResult ContinueTagContent(bool raw) { if (CurrentCharacter == '@') { TakeCurrent(); return(Stay(EndSymbol(HandlebarsSymbolType.At))); } if (HandlebarsHelpers.IsIdentifierStart(CurrentCharacter)) { return(Identifier()); } if (Char.IsDigit(CurrentCharacter)) { return(NumericLiteral()); } switch (CurrentCharacter) { case '.': { TakeCurrent(); if (CurrentCharacter == '/') { // We've matched a link to the current context. TakeCurrent(); return(Stay(EndSymbol(HandlebarsSymbolType.CurrentContext))); } if (CurrentCharacter == '.' && Peek() == '/') { // We've matched a link to the parent context. TakeCurrent(); TakeCurrent(); return(Stay(EndSymbol(HandlebarsSymbolType.ParentContext))); } // We've matched a dot, which could be part of an expression. return(Stay(EndSymbol(HandlebarsSymbolType.Dot))); } case '/': { TakeCurrent(); // We've matched a forward-slash, which could be part of an expression. return(Stay(EndSymbol(HandlebarsSymbolType.Slash))); } case ' ': { // Take all the available whitespace. TakeUntil(c => !ParserHelpers.IsWhiteSpace(c)); return(Stay(EndSymbol(HandlebarsSymbolType.WhiteSpace))); } case '~': { TakeCurrent(); // We've reached a '~' character, so jump to the end of the tag. return(Transition(EndSymbol(HandlebarsSymbolType.Tilde), () => EndTag(raw))); } case '"': case '\'': { var quote = CurrentCharacter; TakeCurrent(); // We've reached a quoted literal. return(QuotedLiteral(quote)); } case '=': { // We're reached a map assignment. TakeCurrent(); return(Stay(EndSymbol(HandlebarsSymbolType.Assign))); } case '}': { // We've reached a closing tag, so transition away. return(Transition(() => EndTag(raw))); } default: { CurrentErrors.Add(new Error("Unexpected character: " + CurrentCharacter, CurrentLocation)); return(Transition(Stop)); } } }
/// <inheritdoc /> public UnaryNode ParseStatement(string statement, string type = null) { var first = statement.First(); var last = statement.Last(); bool lowerInclusive; switch (first) { case '[': lowerInclusive = false; break; case '{': lowerInclusive = true; break; default: throw new InvalidOperationException($"Character '{first}' is not a valid part of a range query"); } bool upperInclusive; switch (last) { case ']': upperInclusive = false; break; case '}': upperInclusive = true; break; default: throw new InvalidOperationException($"Character '{last}' is not a valid part of a range query"); } var parts = statement .Substring(1, statement.Length - 2) .Split(',') .Select(s => s.Trim()) .ToList(); // If the first part is a wildcard, determine the last part only if (parts[0] == "*") { var lowerVal = ParserHelpers.Parse(parts[1], type); return(new LessThanOperator { Value = lowerVal, Inclusive = upperInclusive, Name = null, Statement = statement, }); } // If the last part is a wildcard, determine the first part only if (parts[1] == "*") { var upperVal = ParserHelpers.Parse(parts[0], type); return(new GreaterThanOperator { Value = upperVal, Inclusive = lowerInclusive, Name = null, Statement = statement, }); } var lower = ParserHelpers.Parse(parts[0], type); var upper = ParserHelpers.Parse(parts[1], type); return(new RangeOperator { LowerInclusive = lowerInclusive, UpperInclusive = upperInclusive, Lower = lower, Upper = upper, Name = null, Statement = statement, }); }
public static FormattingContext Create( Uri uri, DocumentSnapshot originalSnapshot, RazorCodeDocument codedocument, FormattingOptions options, Range range = null, bool isFormatOnType = false) { if (uri is null) { throw new ArgumentNullException(nameof(uri)); } if (originalSnapshot is null) { throw new ArgumentNullException(nameof(originalSnapshot)); } if (codedocument is null) { throw new ArgumentNullException(nameof(codedocument)); } if (options is null) { throw new ArgumentNullException(nameof(options)); } var text = codedocument.GetSourceText(); range ??= TextSpan.FromBounds(0, text.Length).AsRange(text); var result = new FormattingContext() { Uri = uri, OriginalSnapshot = originalSnapshot, CodeDocument = codedocument, Range = range, Options = options, IsFormatOnType = isFormatOnType }; var source = codedocument.Source; var syntaxTree = codedocument.GetSyntaxTree(); var formattingSpans = syntaxTree.GetFormattingSpans(); var total = 0; var previousIndentationLevel = 0; for (var i = 0; i < source.Lines.Count; i++) { // Get first non-whitespace character position var lineLength = source.Lines.GetLineLength(i); var nonWsChar = 0; for (var j = 0; j < lineLength; j++) { var ch = source[total + j]; if (!char.IsWhiteSpace(ch) && !ParserHelpers.IsNewLine(ch)) { nonWsChar = j; break; } } // position now contains the first non-whitespace character or 0. Get the corresponding FormattingSpan. if (TryGetFormattingSpan(total + nonWsChar, formattingSpans, out var span)) { result.Indentations[i] = new IndentationContext { Line = i, IndentationLevel = span.IndentationLevel, RelativeIndentationLevel = span.IndentationLevel - previousIndentationLevel, ExistingIndentation = nonWsChar, FirstSpan = span, }; previousIndentationLevel = span.IndentationLevel; } else { // Couldn't find a corresponding FormattingSpan. result.Indentations[i] = new IndentationContext { Line = i, IndentationLevel = -1, RelativeIndentationLevel = previousIndentationLevel, ExistingIndentation = nonWsChar, }; } total += lineLength; } return(result); }
protected virtual string GetClassName() { return(ParserHelpers.SanitizeClassName(_baseRelativePath)); }
// CSharp Spec §2.3.2 private StateResult SingleLineComment() { TakeUntil(c => ParserHelpers.IsNewLine(c)); return(Stay(EndSymbol(CSharpSymbolType.Comment))); }
/// <summary> /// Tokenizes a hex literal. /// </summary> /// <returns>The state result.</returns> private StateResult HexLiteral() { TakeUntil(c => !ParserHelpers.IsHexDigit(c)); return(Stay(EndSymbol(HandlebarsSymbolType.IntegerLiteral))); }
private StateResult Data() { if (ParserHelpers.IsNewLine(CurrentCharacter)) { // CSharp Spec §2.3.1 var checkTwoCharNewline = CurrentCharacter == '\r'; TakeCurrent(); if (checkTwoCharNewline && CurrentCharacter == '\n') { TakeCurrent(); } return(Stay(EndSymbol(CSharpSymbolType.NewLine))); } else if (ParserHelpers.IsWhitespace(CurrentCharacter)) { // CSharp Spec §2.3.3 TakeUntil(c => !ParserHelpers.IsWhitespace(c)); return(Stay(EndSymbol(CSharpSymbolType.WhiteSpace))); } else if (CSharpHelpers.IsIdentifierStart(CurrentCharacter)) { return(Identifier()); } else if (Char.IsDigit(CurrentCharacter)) { return(NumericLiteral()); } switch (CurrentCharacter) { case '@': return(AtSymbol()); case '\'': TakeCurrent(); return(Transition(() => QuotedLiteral('\'', CSharpSymbolType.CharacterLiteral))); case '"': TakeCurrent(); return(Transition(() => QuotedLiteral('"', CSharpSymbolType.StringLiteral))); case '.': if (Char.IsDigit(Peek())) { return(RealLiteral()); } return(Stay(Single(CSharpSymbolType.Dot))); case '/': TakeCurrent(); if (CurrentCharacter == '/') { TakeCurrent(); return(SingleLineComment()); } else if (CurrentCharacter == '*') { TakeCurrent(); return(Transition(BlockComment)); } else if (CurrentCharacter == '=') { TakeCurrent(); return(Stay(EndSymbol(CSharpSymbolType.DivideAssign))); } else { return(Stay(EndSymbol(CSharpSymbolType.Slash))); } default: return(Stay(EndSymbol(Operator()))); } }
// Internal for testing internal static FormattingContext CreateFormattingContext(Uri uri, RazorCodeDocument codedocument, Range range, FormattingOptions options) { var result = new FormattingContext() { Uri = uri, CodeDocument = codedocument, Range = range, Options = options }; var source = codedocument.Source; var syntaxTree = codedocument.GetSyntaxTree(); var formattingSpans = syntaxTree.GetFormattingSpans(); var total = 0; var previousIndentationLevel = 0; for (var i = 0; i < source.Lines.Count; i++) { // Get first non-whitespace character position var lineLength = source.Lines.GetLineLength(i); var nonWsChar = 0; for (var j = 0; j < lineLength; j++) { var ch = source[total + j]; if (!char.IsWhiteSpace(ch) && !ParserHelpers.IsNewLine(ch)) { nonWsChar = j; break; } } // position now contains the first non-whitespace character or 0. Get the corresponding FormattingSpan. if (TryGetFormattingSpan(total + nonWsChar, formattingSpans, out var span)) { result.Indentations[i] = new IndentationContext { Line = i, IndentationLevel = span.IndentationLevel, RelativeIndentationLevel = span.IndentationLevel - previousIndentationLevel, ExistingIndentation = nonWsChar, FirstSpan = span, }; previousIndentationLevel = span.IndentationLevel; } else { // Couldn't find a corresponding FormattingSpan. result.Indentations[i] = new IndentationContext { Line = i, IndentationLevel = -1, RelativeIndentationLevel = previousIndentationLevel, ExistingIndentation = nonWsChar, }; } total += lineLength; } return(result); }
public void Append(string content) { for (int i = 0; i < content.Length; i++) { AppendCore(content[i]); // \r on it's own: Start a new line, otherwise wait for \n // Other Newline: Start a new line if ((content[i] == '\r' && (i + 1 == content.Length || content[i + 1] != '\n')) || (content[i] != '\r' && ParserHelpers.IsNewLine(content[i]))) { PushNewLine(); } } }
/// <summary> /// DO NOT USE /// </summary> /// <param name="fileStream"></param> /// <returns></returns> public async Task <ReplayHeader> ReadReplayAsync(FileStream fileStream) { if (!fileStream.CanRead) { throw new IOException($"{_exceptionOriginName} - Stream does not support reading"); } // Create ne LprHeader LprHeader header = new LprHeader(); // These buffers will be used and reused to read data byte[] int32ByteBuffer = new byte[4]; byte[] int64ByteBuffer = new byte[8]; //// Try reading the "Magic number" it's actually the file version await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Magic Number", fileStream, int32ByteBuffer, 4); header.LprFileVersion = BitConverter.ToInt32(int32ByteBuffer, 0); // BaronReplay implements this check, not sure why if (!(header.LprFileVersion >= 0)) { throw new IOException($"{_exceptionOriginName} - Lpr File Version Unsupported"); } //// Try reading the length of the next section, so we can skip it await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Length of Spectator client version", fileStream, int32ByteBuffer, 4); //// Use the result of previous operation to make new array and pull string byte[] spectatorClientVersionBytes = new byte[BitConverter.ToInt32(int32ByteBuffer, 0)]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Spectator client version", fileStream, spectatorClientVersionBytes, BitConverter.ToInt32(int32ByteBuffer, 0)); header.SpectatorClientVersion = Encoding.UTF8.GetString(spectatorClientVersionBytes); //// Read the game ID await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Game ID", fileStream, int64ByteBuffer, 8); header.GameID = BitConverter.ToInt64(int64ByteBuffer, 0); //// Read Chunk data await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.GameEndStartupChunk = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.StartChunk = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.EndChunk = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.EndKeyframe = BitConverter.ToInt32(int32ByteBuffer, 0); //// Read game length await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Game length", fileStream, int32ByteBuffer, 4); header.GameLength = BitConverter.ToInt32(int32ByteBuffer, 0); //// Read more chunk/replay information await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.GameDelayTime = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.ClientAddLag = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.ChunkTimeInterval = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.KeyframeTimeInterval = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.ELOLevel = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.LastChunkTime = BitConverter.ToInt32(int32ByteBuffer, 0); await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Chunks", fileStream, int32ByteBuffer, 4); header.LastChunkDuration = BitConverter.ToInt32(int32ByteBuffer, 0); //// Read game region length await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Game region length", fileStream, int32ByteBuffer, 4); //// Use the length to make a new byte array to read the region string byte[] gameRegionBytes = new byte[BitConverter.ToInt32(int32ByteBuffer, 0)]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Game region", fileStream, gameRegionBytes, BitConverter.ToInt32(int32ByteBuffer, 0)); header.GamePlatform = Encoding.UTF8.GetString(gameRegionBytes); //// Get length of spectator encryption key await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Spectator encryption key length", fileStream, int32ByteBuffer, 4); //// Use the length of spectator encryption key to make a new array to put the encryption key byte[] spectatorEncryptionKeyBytes = new byte[BitConverter.ToInt32(int32ByteBuffer, 0)]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading Spectator encryption key", fileStream, spectatorEncryptionKeyBytes, BitConverter.ToInt32(int32ByteBuffer, 0)); header.SpectatorEncryptionKey = Encoding.UTF8.GetString(spectatorEncryptionKeyBytes); //// Get length of creation time await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading creation time length", fileStream, int32ByteBuffer, 4); //// Use the length of creation time to make a new array to put the creation time byte[] creationTimeBytes = new byte[BitConverter.ToInt32(int32ByteBuffer, 0)]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading creation time", fileStream, creationTimeBytes, BitConverter.ToInt32(int32ByteBuffer, 0)); header.CreateTime = Encoding.UTF8.GetString(creationTimeBytes); //// Get length of start time await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading start time length", fileStream, int32ByteBuffer, 4); //// Use the length of start time to make a new array to put the start time byte[] startTimeBytes = new byte[BitConverter.ToInt32(int32ByteBuffer, 0)]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading creation time", fileStream, startTimeBytes, BitConverter.ToInt32(int32ByteBuffer, 0)); header.StartTime = Encoding.UTF8.GetString(startTimeBytes); //// Get length of end time await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading end time length", fileStream, int32ByteBuffer, 4); //// Use the length of start time to make a new array to put the start time byte[] endTimeBytes = new byte[BitConverter.ToInt32(int32ByteBuffer, 0)]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading end time", fileStream, endTimeBytes, BitConverter.ToInt32(int32ByteBuffer, 0)); header.EndTime = Encoding.UTF8.GetString(endTimeBytes); //// Get length of league of legends version await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading league of legends version length", fileStream, int32ByteBuffer, 4); //// Use the length of start time to make a new array to put the start time byte[] leagueVersionBytes = new byte[BitConverter.ToInt32(int32ByteBuffer, 0)]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading end time", fileStream, leagueVersionBytes, BitConverter.ToInt32(int32ByteBuffer, 0)); // TODO header.LeagueVersion = Encoding.UTF8.GetString(leagueVersionBytes); //// Do end game result exists? byte[] resultsExistByte = new byte[1]; await ParserHelpers.ReadBytes($"{_exceptionOriginName} - Reading result boolean", fileStream, resultsExistByte, 1); // TODO bool resultsExist = BitConverter.ToBoolean(resultsExistByte, 0); if (resultsExist) { //await ReadEndGameResults(fileStream); } else { header.OldResults = await ReadOldEndGameResults(fileStream); } // TODO BROKEN return(null); }
internal static ChangeSet ParseCommit(IStringReader reader) { // commit hash reader.ReadUntilWhitespace(); reader.SkipWhitespace(); string id = reader.ReadUntilWhitespace(); // Merges will have (from hash) so we're skipping that reader.ReadLine(); string author = null; string email = null; string date = null; while (!reader.Done) { string line = reader.ReadLine(); if (ParserHelpers.IsSingleNewLine(line)) { break; } var subReader = line.AsReader(); string key = subReader.ReadUntil(':'); // Skip : subReader.Skip(); subReader.SkipWhitespace(); string value = subReader.ReadToEnd().Trim(); if (key.Equals("Author", StringComparison.OrdinalIgnoreCase)) { // Author <email> var authorReader = value.AsReader(); author = authorReader.ReadUntil('<').Trim(); authorReader.Skip(); email = authorReader.ReadUntil('>'); } else if (key.Equals("Date", StringComparison.OrdinalIgnoreCase)) { date = value; } } var messageBuilder = new StringBuilder(); while (!reader.Done) { string line = reader.ReadLine(); if (ParserHelpers.IsSingleNewLine(line)) { break; } messageBuilder.Append(line); } string message = messageBuilder.ToString().Trim(); return(new ChangeSet(id, author, email, message, DateTimeOffset.ParseExact(date, "ddd MMM d HH:mm:ss yyyy zzz", CultureInfo.InvariantCulture))); }
// CSharp Spec §2.3.2 private StateResult SingleLineComment() { TakeUntil(c => ParserHelpers.IsNewLine(c)); return(Stay(EndToken(SyntaxKind.CSharpComment))); }
private static bool TryParseSByteN(ReadOnlySpan <byte> source, out sbyte value, out int bytesConsumed) { if (source.Length < 1) { goto FalseExit; } int sign = 1; int index = 0; int c = source[index]; if (c == '-') { sign = -1; index++; if ((uint)index >= (uint)source.Length) { goto FalseExit; } c = source[index]; } else if (c == '+') { index++; if ((uint)index >= (uint)source.Length) { goto FalseExit; } c = source[index]; } int answer; // Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior with the classic parse routines // (at least one digit must precede any commas, and a string without any digits prior to the decimal point must have at least // one digit after the decimal point.) if (c == Utf8Constants.Period) { goto FractionalPartWithoutLeadingDigits; } if (!ParserHelpers.IsDigit(c)) { goto FalseExit; } answer = c - '0'; for (; ;) { index++; if ((uint)index >= (uint)source.Length) { goto Done; } c = source[index]; if (c == Utf8Constants.Comma) { continue; } if (c == Utf8Constants.Period) { goto FractionalDigits; } if (!ParserHelpers.IsDigit(c)) { goto Done; } answer = answer * 10 + c - '0'; // if sign < 0, (-1 * sign + 1) / 2 = 1 // else, (-1 * sign + 1) / 2 = 0 if (answer > sbyte.MaxValue + (-1 * sign + 1) / 2) { goto FalseExit; // Overflow } } FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is legal as long as there's at least one zero after the decimal point. answer = 0; index++; if ((uint)index >= (uint)source.Length) { goto FalseExit; } if (source[index] != '0') { goto FalseExit; } FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fraction digits are all 0. do { index++; if ((uint)index >= (uint)source.Length) { goto Done; } c = source[index]; }while (c == '0'); if (ParserHelpers.IsDigit(c)) { goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an early termination. } goto Done; FalseExit: bytesConsumed = default; value = default; return(false); Done: bytesConsumed = index; value = (sbyte)(answer * sign); return(true); }
protected override string GetClassName(string virtualPath) { return(ParserHelpers.SanitizeClassName(Path.GetFileNameWithoutExtension(virtualPath))); }
private StateResult Data() { // We are accepting more characters and whitespace/newlines then the VB Spec defines, to simplify things // Since the code must still be compiled by a VB compiler, this will not cause adverse effects. if (ParserHelpers.IsNewLine(CurrentCharacter)) { // VB Spec §2.1.1 bool checkTwoCharNewline = CurrentCharacter == '\r'; TakeCurrent(); if (checkTwoCharNewline && CurrentCharacter == '\n') { TakeCurrent(); } return(Stay(EndSymbol(VBSymbolType.NewLine))); } else if (ParserHelpers.IsWhitespace(CurrentCharacter)) { // CSharp Spec §2.1.3 TakeUntil(c => !ParserHelpers.IsWhitespace(c)); return(Stay(EndSymbol(VBSymbolType.WhiteSpace))); } else if (VBHelpers.IsSingleQuote(CurrentCharacter)) { TakeCurrent(); return(CommentBody()); } else if (IsIdentifierStart()) { return(Identifier()); } else if (Char.IsDigit(CurrentCharacter)) { return(DecimalLiteral()); } else if (CurrentCharacter == '&') { char next = Char.ToLower(Peek(), CultureInfo.InvariantCulture); if (next == 'h') { return(HexLiteral()); } else if (next == 'o') { return(OctLiteral()); } } else if (CurrentCharacter == '.' && Char.IsDigit(Peek())) { return(FloatingPointLiteralEnd()); } else if (VBHelpers.IsDoubleQuote(CurrentCharacter)) { TakeCurrent(); return(Transition(QuotedLiteral)); } else if (AtDateLiteral()) { return(DateLiteral()); } else if (CurrentCharacter == '@') { TakeCurrent(); if (CurrentCharacter == '*') { return(Transition(EndSymbol(VBSymbolType.RazorCommentTransition), AfterRazorCommentTransition)); } else if (CurrentCharacter == '@') { // Could be escaped comment transition return(Transition(EndSymbol(VBSymbolType.Transition), () => { TakeCurrent(); return Transition(EndSymbol(VBSymbolType.Transition), Data); })); } else { return(Stay(EndSymbol(VBSymbolType.Transition))); } } return(Stay(EndSymbol(Operator()))); }
public void RootContextTest() { var code = File.ReadAllText(@"DataBiTemporal\Parser\simple.sql"); Assert.IsNotNull(ParserHelpers.GetRootContext(code) as BiTempDefParser.CompileUnitContext); }
protected virtual string GetClassName() { string filename = Path.GetFileNameWithoutExtension(this.File.VirtualPath); return("__" + ParserHelpers.SanitizeClassName(filename)); }
public void WalkTest() { var code = File.ReadAllText(@"DataBiTemporal\Parser\simple.sql"); Assert.AreEqual(33, ParserHelpers.WalkTree(code)); }