/// <summary> /// Initializes a new instance of the <see cref="SimpleKey"/> class. /// </summary> public SimpleKey(bool isPossible, bool isRequired, int tokenNumber, Mark mark) { this.isPossible = isPossible; this.isRequired = isRequired; this.tokenNumber = tokenNumber; this.mark = mark; }
public Region(Mark start, Mark end) { Debug.Assert(start.Line < end.Line || (start.Line == end.Line && start.Column <= end.Column)); Start = start; End = end; }
/// <summary> /// Loads the specified event. /// </summary> /// <param name="yamlEvent">The event.</param> /// <param name="state">The state of the document.</param> internal void Load(NodeEvent yamlEvent, DocumentLoadingState state) { Tag = yamlEvent.Tag; if (yamlEvent.Anchor != null) { Anchor = yamlEvent.Anchor; state.AddAnchor(this); } Start = yamlEvent.Start; End = yamlEvent.End; }
/// <summary> /// Gets the node with the specified anchor. /// </summary> /// <param name="anchor">The anchor.</param> /// <param name="throwException">if set to <c>true</c>, the method should throw an exception if there is no node with that anchor.</param> /// <param name="start">The start position.</param> /// <param name="end">The end position.</param> /// <returns></returns> public YamlNode GetNode(string anchor, bool throwException, Mark start, Mark end) { YamlNode target; if (anchors.TryGetValue(anchor, out target)) { return target; } else if (throwException) { throw new AnchorNotFoundException(start, end, string.Format(CultureInfo.InvariantCulture, "The anchor '{0}' does not exists", anchor)); } else { return null; } }
/// <summary> /// Scan a tag. /// </summary> private string ScanTagUri(string head, Mark start) { StringBuilder tag = new StringBuilder(); if (head != null && head.Length > 1) { tag.Append(head.Substring(1)); } // Scan the tag. // The set of characters that may appear in URI is as follows: // '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&', // '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']', // '%'. while (analyzer.IsAlpha() || analyzer.Check(";/?:@&=+$,.!~*'()[]%")) { // Check if it is a URI-escape sequence. if (analyzer.Check('%')) { tag.Append(ScanUriEscapes(start)); } else { tag.Append(ReadCurrentCharacter()); } } // Check if the tag is non-empty. if (tag.Length == 0) { throw new SyntaxErrorException(start, mark, "While parsing a tag, did not find expected tag URI."); } return tag.ToString(); }
/// <summary> /// Initializes a new instance of the <see cref="AnchorNotFoundException"/> class. /// </summary> public ForwardAnchorNotSupportedException(Mark start, Mark end, string message) : base(start, end, message) { }
/// <summary> /// Initializes a new instance of the <see cref="DuplicateAnchorException"/> class. /// </summary> public DuplicateAnchorException(Mark start, Mark end, string message) : base(start, end, message) { }
/// <summary> /// Initializes a new instance of the <see cref="YamlException"/> class. /// </summary> public YamlException(Mark start, Mark end, string message, Exception innerException) : base(string.Format("({0}) - ({1}): {2}", start, end, message), innerException) { Start = start; End = end; }
/// <summary> /// Initializes a new instance of the <see cref="YamlException"/> class. /// </summary> /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param> /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="info"/> parameter is null. </exception> /// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0). </exception> protected YamlException(SerializationInfo info, StreamingContext context) : base(info, context) { Start = (Mark)info.GetValue("Start", typeof(Mark)); End = (Mark)info.GetValue("End", typeof(Mark)); }
/// <summary> /// Initializes a new instance of the <see cref="SemanticErrorException"/> class. /// </summary> public SemanticErrorException(Mark start, Mark end, string message) : base(start, end, message) { }
/// <summary> /// Scan the value of VERSION-DIRECTIVE. /// /// Scope: /// %YAML 1.1 # a comment \n /// ^^^^^^ /// </summary> private Token ScanVersionDirectiveValue(Mark start) { SkipWhitespaces(); // Consume the major version number. int major = ScanVersionDirectiveNumber(start); // Eat '.'. if (!analyzer.Check('.')) { throw new SyntaxErrorException(start, mark, "While scanning a %YAML directive, did not find expected digit or '.' character."); } Skip(); // Consume the minor version number. int minor = ScanVersionDirectiveNumber(start); return new VersionDirective(new Version(major, minor), start, start); }
/// <summary> /// Decode an URI-escape sequence corresponding to a single UTF-8 character. /// </summary> private string ScanUriEscapes(Mark start) { // Decode the required number of characters. byte[] charBytes = null; int nextInsertionIndex = 0; int width = 0; do { // Check for a URI-escaped octet. if (!(analyzer.Check('%') && analyzer.IsHex(1) && analyzer.IsHex(2))) { throw new SyntaxErrorException(start, cursor.Mark(), "While parsing a tag, did not find URI escaped octet."); } // Get the octet. int octet = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2); // If it is the leading octet, determine the length of the UTF-8 sequence. if (width == 0) { width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : (octet & 0xF8) == 0xF0 ? 4 : 0; if (width == 0) { throw new SyntaxErrorException(start, cursor.Mark(), "While parsing a tag, find an incorrect leading UTF-8 octet."); } charBytes = new byte[width]; } else { // Check if the trailing octet is correct. if ((octet & 0xC0) != 0x80) { throw new SyntaxErrorException(start, cursor.Mark(), "While parsing a tag, find an incorrect trailing UTF-8 octet."); } } // Copy the octet and move the pointers. charBytes[nextInsertionIndex++] = (byte)octet; Skip(); Skip(); Skip(); } while (--width > 0); var result = Encoding.UTF8.GetString(charBytes, 0, nextInsertionIndex); if (result.Length == 0 || result.Length > 2) { throw new SyntaxErrorException(start, cursor.Mark(), "While parsing a tag, find an incorrect UTF-8 sequence."); } return result; }
/// <summary> /// Initializes a new instance of the <see cref="MaximumRecursionLevelReachedException"/> class. /// </summary> public MaximumRecursionLevelReachedException(Mark start, Mark end, string message) : base(start, end, message) { }
public SyntaxErrorToken(SyntaxErrorException exception, Mark start, Mark end) : base(start, end) { Exception = exception; }
/// <summary> /// Decode an URI-escape sequence corresponding to a single UTF-8 character. /// </summary> private char ScanUriEscapes(Mark start) { // Decode the required number of characters. List<byte> charBytes = new List<byte>(); int width = 0; do { // Check for a URI-escaped octet. if (!(analyzer.Check('%') && analyzer.IsHex(1) && analyzer.IsHex(2))) { throw new SyntaxErrorException(start, mark, "While parsing a tag, did not find URI escaped octet."); } // Get the octet. int octet = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2); // If it is the leading octet, determine the length of the UTF-8 sequence. if (width == 0) { width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : (octet & 0xF8) == 0xF0 ? 4 : 0; if (width == 0) { throw new SyntaxErrorException(start, mark, "While parsing a tag, find an incorrect leading UTF-8 octet."); } } else { // Check if the trailing octet is correct. if ((octet & 0xC0) != 0x80) { throw new SyntaxErrorException(start, mark, "While parsing a tag, find an incorrect trailing UTF-8 octet."); } } // Copy the octet and move the pointers. charBytes.Add((byte)octet); Skip(); Skip(); Skip(); } while (--width > 0); char[] characters = Encoding.UTF8.GetChars(charBytes.ToArray()); if (characters.Length != 1) { throw new SyntaxErrorException(start, mark, "While parsing a tag, find an incorrect UTF-8 sequence."); } return characters[0]; }
/// <summary> /// Scan the version number of VERSION-DIRECTIVE. /// /// Scope: /// %YAML 1.1 # a comment \n /// ^ /// %YAML 1.1 # a comment \n /// ^ /// </summary> private int ScanVersionDirectiveNumber(Mark start) { int value = 0; int length = 0; // Repeat while the next character is digit. while (analyzer.IsDigit()) { // Check if the number is too long. if (++length > MaxVersionNumberLength) { throw new SyntaxErrorException(start, mark, "While scanning a %YAML directive, find extremely long version number."); } value = value * 10 + analyzer.AsDigit(); Skip(); } // Check if the number was present. if (length == 0) { throw new SyntaxErrorException(start, mark, "While scanning a %YAML directive, did not find expected version number."); } return value; }
/// <summary> /// Push the current indentation level to the stack and set the new level /// the current column is greater than the indentation level. In this case, /// append or insert the specified token into the token queue. /// </summary> private void RollIndent(int column, int number, bool isSequence, Mark position) { // In the flow context, do nothing. if (flowLevel > 0) { return; } if (indent < column) { // Push the current indentation level to the stack and set the new // indentation level. indents.Push(indent); indent = column; // Create a token and insert it into the queue. Token token; if (isSequence) { token = new BlockSequenceStart(position, position); } else { token = new BlockMappingStart(position, position); } if (number == -1) { tokens.Enqueue(token); } else { tokens.Insert(number - tokensParsed, token); } } }
/// <summary> /// Scan intendation spaces and line breaks for a block scalar. Determine the /// intendation level if needed. /// </summary> private int ScanBlockScalarBreaks(int currentIndent, StringBuilder breaks, Mark start, ref Mark end) { int maxIndent = 0; end = mark; // Eat the intendation spaces and line breaks. for (; ;) { // Eat the intendation spaces. while ((currentIndent == 0 || mark.Column < currentIndent) && analyzer.IsSpace()) { Skip(); } if (mark.Column > maxIndent) { maxIndent = mark.Column; } // Check for a tab character messing the intendation. if ((currentIndent == 0 || mark.Column < currentIndent) && analyzer.IsTab()) { throw new SyntaxErrorException(start, mark, "While scanning a block scalar, find a tab character where an intendation space is expected."); } // Have we find a non-empty line? if (!analyzer.IsBreak()) { break; } // Consume the line break. breaks.Append(ReadLine()); end = mark; } // Determine the indentation level if needed. if (currentIndent == 0) { currentIndent = Math.Max(maxIndent, Math.Max(indent + 1, 1)); } return currentIndent; }
/// <summary> /// Initializes a new instance of the <see cref="AnchorNotFoundException"/> class. /// </summary> public AnchorNotFoundException(Mark start, Mark end, string message) : base(start, end, message) { }
/// <summary> /// Scan the directive name. /// /// Scope: /// %YAML 1.1 # a comment \n /// ^^^^ /// %TAG !yaml! tag:yaml.org,2002: \n /// ^^^ /// </summary> private string ScanDirectiveName(Mark start) { StringBuilder name = new StringBuilder(); // Consume the directive name. while (analyzer.IsAlpha()) { name.Append(ReadCurrentCharacter()); } // Check if the name is empty. if (name.Length == 0) { throw new SyntaxErrorException(start, mark, "While scanning a directive, could not find expected directive name."); } // Check for an blank character after the name. if (!analyzer.IsBlankOrBreakOrZero()) { throw new SyntaxErrorException(start, mark, "While scanning a directive, find unexpected non-alphabetical character."); } return name.ToString(); }
/// <summary> /// Initializes a new instance of the <see cref="YamlException"/> class. /// </summary> public YamlException(Mark start, Mark end, string message) : this(start, end, message, null) { }
/// <summary> /// Scan the value of a TAG-DIRECTIVE token. /// /// Scope: /// %TAG !yaml! tag:yaml.org,2002: \n /// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /// </summary> private Token ScanTagDirectiveValue(Mark start) { SkipWhitespaces(); // Scan a handle. string handle = ScanTagHandle(true, start); // Expect a whitespace. if (!analyzer.IsBlank()) { throw new SyntaxErrorException(start, mark, "While scanning a %TAG directive, did not find expected whitespace."); } SkipWhitespaces(); // Scan a prefix. string prefix = ScanTagUri(null, start); // Expect a whitespace or line break. if (!analyzer.IsBlankOrBreakOrZero()) { throw new SyntaxErrorException(start, mark, "While scanning a %TAG directive, did not find expected whitespace or line break."); } return new TagDirective(handle, prefix, start, start); }
/// <summary> /// Initializes a new instance of the <see cref="SyntaxErrorException"/> class. /// </summary> public SyntaxErrorException(Mark start, Mark end, string message) : base(start, end, message) { }
/// <summary> /// Scan a tag handle. /// </summary> private string ScanTagHandle(bool isDirective, Mark start) { // Check the initial '!' character. if (!analyzer.Check('!')) { throw new SyntaxErrorException(start, mark, "While scanning a tag, did not find expected '!'."); } // Copy the '!' character. StringBuilder tagHandle = new StringBuilder(); tagHandle.Append(ReadCurrentCharacter()); // Copy all subsequent alphabetical and numerical characters. while (analyzer.IsAlpha()) { tagHandle.Append(ReadCurrentCharacter()); } // Check if the trailing character is '!' and copy it. if (analyzer.Check('!')) { tagHandle.Append(ReadCurrentCharacter()); } else { // It's either the '!' tag or not really a tag handle. If it's a %TAG // directive, it's an error. If it's a tag token, it must be a part of // URI. if (isDirective && (tagHandle.Length != 1 || tagHandle[0] != '!')) { throw new SyntaxErrorException(start, mark, "While parsing a tag directive, did not find expected '!'."); } } return tagHandle.ToString(); }
/// <summary> /// Generate an empty scalar event. /// </summary> private static ParsingEvent ProcessEmptyScalar(Mark position) { return new Events.Scalar(null, null, string.Empty, ScalarStyle.Plain, true, false, position, position); }