niki/vendor/gopkg.in/yaml.v3/scannerc.go

//

// Copyright (c) 2011-2019 Canonical Ltd

// Copyright (c) 2006-2010 Kirill Simonov

//

// Permission is hereby granted, free of charge, to any person obtaining a copy of

// this software and associated documentation files (the "Software"), to deal in

// the Software without restriction, including without limitation the rights to

// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

// of the Software, and to permit persons to whom the Software is furnished to do

// so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in all

// copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

// SOFTWARE.

package yaml

import (
	"bytes"
	"fmt"
)

// Introduction

// ************

//

// The following notes assume that you are familiar with the YAML specification

// (http://yaml.org/spec/1.2/spec.html).  We mostly follow it, although in

// some cases we are less restrictive that it requires.

//

// The process of transforming a YAML stream into a sequence of events is

// divided on two steps: Scanning and Parsing.

//

// The Scanner transforms the input stream into a sequence of tokens, while the

// parser transform the sequence of tokens produced by the Scanner into a

// sequence of parsing events.

//

// The Scanner is rather clever and complicated. The Parser, on the contrary,

// is a straightforward implementation of a recursive-descendant parser (or,

// LL(1) parser, as it is usually called).

//

// Actually there are two issues of Scanning that might be called "clever", the

// rest is quite straightforward.  The issues are "block collection start" and

// "simple keys".  Both issues are explained below in details.

//

// Here the Scanning step is explained and implemented.  We start with the list

// of all the tokens produced by the Scanner together with short descriptions.

//

// Now, tokens:

//

//      STREAM-START(encoding)          # The stream start.

//      STREAM-END                      # The stream end.

//      VERSION-DIRECTIVE(major,minor)  # The '%YAML' directive.

//      TAG-DIRECTIVE(handle,prefix)    # The '%TAG' directive.

//      DOCUMENT-START                  # '---'

//      DOCUMENT-END                    # '...'

//      BLOCK-SEQUENCE-START            # Indentation increase denoting a block

//      BLOCK-MAPPING-START             # sequence or a block mapping.

//      BLOCK-END                       # Indentation decrease.

//      FLOW-SEQUENCE-START             # '['

//      FLOW-SEQUENCE-END               # ']'

//      BLOCK-SEQUENCE-START            # '{'

//      BLOCK-SEQUENCE-END              # '}'

//      BLOCK-ENTRY                     # '-'

//      FLOW-ENTRY                      # ','

//      KEY                             # '?' or nothing (simple keys).

//      VALUE                           # ':'

//      ALIAS(anchor)                   # '*anchor'

//      ANCHOR(anchor)                  # '&anchor'

//      TAG(handle,suffix)              # '!handle!suffix'

//      SCALAR(value,style)             # A scalar.

//

// The following two tokens are "virtual" tokens denoting the beginning and the

// end of the stream:

//

//      STREAM-START(encoding)

//      STREAM-END

//

// We pass the information about the input stream encoding with the

// STREAM-START token.

//

// The next two tokens are responsible for tags:

//

//      VERSION-DIRECTIVE(major,minor)

//      TAG-DIRECTIVE(handle,prefix)

//

// Example:

//

//      %YAML   1.1

//      %TAG    !   !foo

//      %TAG    !yaml!  tag:yaml.org,2002:

//      ---

//

// The correspoding sequence of tokens:

//

//      STREAM-START(utf-8)

//      VERSION-DIRECTIVE(1,1)

//      TAG-DIRECTIVE("!","!foo")

//      TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")

//      DOCUMENT-START

//      STREAM-END

//

// Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole

// line.

//

// The document start and end indicators are represented by:

//

//      DOCUMENT-START

//      DOCUMENT-END

//

// Note that if a YAML stream contains an implicit document (without '---'

// and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be

// produced.

//

// In the following examples, we present whole documents together with the

// produced tokens.

//

//      1. An implicit document:

//

//          'a scalar'

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          SCALAR("a scalar",single-quoted)

//          STREAM-END

//

//      2. An explicit document:

//

//          ---

//          'a scalar'

//          ...

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          DOCUMENT-START

//          SCALAR("a scalar",single-quoted)

//          DOCUMENT-END

//          STREAM-END

//

//      3. Several documents in a stream:

//

//          'a scalar'

//          ---

//          'another scalar'

//          ---

//          'yet another scalar'

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          SCALAR("a scalar",single-quoted)

//          DOCUMENT-START

//          SCALAR("another scalar",single-quoted)

//          DOCUMENT-START

//          SCALAR("yet another scalar",single-quoted)

//          STREAM-END

//

// We have already introduced the SCALAR token above.  The following tokens are

// used to describe aliases, anchors, tag, and scalars:

//

//      ALIAS(anchor)

//      ANCHOR(anchor)

//      TAG(handle,suffix)

//      SCALAR(value,style)

//

// The following series of examples illustrate the usage of these tokens:

//

//      1. A recursive sequence:

//

//          &A [ *A ]

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          ANCHOR("A")

//          FLOW-SEQUENCE-START

//          ALIAS("A")

//          FLOW-SEQUENCE-END

//          STREAM-END

//

//      2. A tagged scalar:

//

//          !!float "3.14"  # A good approximation.

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          TAG("!!","float")

//          SCALAR("3.14",double-quoted)

//          STREAM-END

//

//      3. Various scalar styles:

//

//          --- # Implicit empty plain scalars do not produce tokens.

//          --- a plain scalar

//          --- 'a single-quoted scalar'

//          --- "a double-quoted scalar"

//          --- |-

//            a literal scalar

//          --- >-

//            a folded

//            scalar

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          DOCUMENT-START

//          DOCUMENT-START

//          SCALAR("a plain scalar",plain)

//          DOCUMENT-START

//          SCALAR("a single-quoted scalar",single-quoted)

//          DOCUMENT-START

//          SCALAR("a double-quoted scalar",double-quoted)

//          DOCUMENT-START

//          SCALAR("a literal scalar",literal)

//          DOCUMENT-START

//          SCALAR("a folded scalar",folded)

//          STREAM-END

//

// Now it's time to review collection-related tokens. We will start with

// flow collections:

//

//      FLOW-SEQUENCE-START

//      FLOW-SEQUENCE-END

//      FLOW-MAPPING-START

//      FLOW-MAPPING-END

//      FLOW-ENTRY

//      KEY

//      VALUE

//

// The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and

// FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'

// correspondingly.  FLOW-ENTRY represent the ',' indicator.  Finally the

// indicators '?' and ':', which are used for denoting mapping keys and values,

// are represented by the KEY and VALUE tokens.

//

// The following examples show flow collections:

//

//      1. A flow sequence:

//

//          [item 1, item 2, item 3]

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          FLOW-SEQUENCE-START

//          SCALAR("item 1",plain)

//          FLOW-ENTRY

//          SCALAR("item 2",plain)

//          FLOW-ENTRY

//          SCALAR("item 3",plain)

//          FLOW-SEQUENCE-END

//          STREAM-END

//

//      2. A flow mapping:

//

//          {

//              a simple key: a value,  # Note that the KEY token is produced.

//              ? a complex key: another value,

//          }

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          FLOW-MAPPING-START

//          KEY

//          SCALAR("a simple key",plain)

//          VALUE

//          SCALAR("a value",plain)

//          FLOW-ENTRY

//          KEY

//          SCALAR("a complex key",plain)

//          VALUE

//          SCALAR("another value",plain)

//          FLOW-ENTRY

//          FLOW-MAPPING-END

//          STREAM-END

//

// A simple key is a key which is not denoted by the '?' indicator.  Note that

// the Scanner still produce the KEY token whenever it encounters a simple key.

//

// For scanning block collections, the following tokens are used (note that we

// repeat KEY and VALUE here):

//

//      BLOCK-SEQUENCE-START

//      BLOCK-MAPPING-START

//      BLOCK-END

//      BLOCK-ENTRY

//      KEY

//      VALUE

//

// The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation

// increase that precedes a block collection (cf. the INDENT token in Python).

// The token BLOCK-END denote indentation decrease that ends a block collection

// (cf. the DEDENT token in Python).  However YAML has some syntax pecularities

// that makes detections of these tokens more complex.

//

// The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators

// '-', '?', and ':' correspondingly.

//

// The following examples show how the tokens BLOCK-SEQUENCE-START,

// BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:

//

//      1. Block sequences:

//

//          - item 1

//          - item 2

//          -

//            - item 3.1

//            - item 3.2

//          -

//            key 1: value 1

//            key 2: value 2

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          BLOCK-SEQUENCE-START

//          BLOCK-ENTRY

//          SCALAR("item 1",plain)

//          BLOCK-ENTRY

//          SCALAR("item 2",plain)

//          BLOCK-ENTRY

//          BLOCK-SEQUENCE-START

//          BLOCK-ENTRY

//          SCALAR("item 3.1",plain)

//          BLOCK-ENTRY

//          SCALAR("item 3.2",plain)

//          BLOCK-END

//          BLOCK-ENTRY

//          BLOCK-MAPPING-START

//          KEY

//          SCALAR("key 1",plain)

//          VALUE

//          SCALAR("value 1",plain)

//          KEY

//          SCALAR("key 2",plain)

//          VALUE

//          SCALAR("value 2",plain)

//          BLOCK-END

//          BLOCK-END

//          STREAM-END

//

//      2. Block mappings:

//

//          a simple key: a value   # The KEY token is produced here.

//          ? a complex key

//          : another value

//          a mapping:

//            key 1: value 1

//            key 2: value 2

//          a sequence:

//            - item 1

//            - item 2

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          BLOCK-MAPPING-START

//          KEY

//          SCALAR("a simple key",plain)

//          VALUE

//          SCALAR("a value",plain)

//          KEY

//          SCALAR("a complex key",plain)

//          VALUE

//          SCALAR("another value",plain)

//          KEY

//          SCALAR("a mapping",plain)

//          BLOCK-MAPPING-START

//          KEY

//          SCALAR("key 1",plain)

//          VALUE

//          SCALAR("value 1",plain)

//          KEY

//          SCALAR("key 2",plain)

//          VALUE

//          SCALAR("value 2",plain)

//          BLOCK-END

//          KEY

//          SCALAR("a sequence",plain)

//          VALUE

//          BLOCK-SEQUENCE-START

//          BLOCK-ENTRY

//          SCALAR("item 1",plain)

//          BLOCK-ENTRY

//          SCALAR("item 2",plain)

//          BLOCK-END

//          BLOCK-END

//          STREAM-END

//

// YAML does not always require to start a new block collection from a new

// line.  If the current line contains only '-', '?', and ':' indicators, a new

// block collection may start at the current line.  The following examples

// illustrate this case:

//

//      1. Collections in a sequence:

//

//          - - item 1

//            - item 2

//          - key 1: value 1

//            key 2: value 2

//          - ? complex key

//            : complex value

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          BLOCK-SEQUENCE-START

//          BLOCK-ENTRY

//          BLOCK-SEQUENCE-START

//          BLOCK-ENTRY

//          SCALAR("item 1",plain)

//          BLOCK-ENTRY

//          SCALAR("item 2",plain)

//          BLOCK-END

//          BLOCK-ENTRY

//          BLOCK-MAPPING-START

//          KEY

//          SCALAR("key 1",plain)

//          VALUE

//          SCALAR("value 1",plain)

//          KEY

//          SCALAR("key 2",plain)

//          VALUE

//          SCALAR("value 2",plain)

//          BLOCK-END

//          BLOCK-ENTRY

//          BLOCK-MAPPING-START

//          KEY

//          SCALAR("complex key")

//          VALUE

//          SCALAR("complex value")

//          BLOCK-END

//          BLOCK-END

//          STREAM-END

//

//      2. Collections in a mapping:

//

//          ? a sequence

//          : - item 1

//            - item 2

//          ? a mapping

//          : key 1: value 1

//            key 2: value 2

//

//      Tokens:

//

//          STREAM-START(utf-8)

//          BLOCK-MAPPING-START

//          KEY

//          SCALAR("a sequence",plain)

//          VALUE

//          BLOCK-SEQUENCE-START

//          BLOCK-ENTRY

//          SCALAR("item 1",plain)

//          BLOCK-ENTRY

//          SCALAR("item 2",plain)

//          BLOCK-END

//          KEY

//          SCALAR("a mapping",plain)

//          VALUE

//          BLOCK-MAPPING-START

//          KEY

//          SCALAR("key 1",plain)

//          VALUE

//          SCALAR("value 1",plain)

//          KEY

//          SCALAR("key 2",plain)

//          VALUE

//          SCALAR("value 2",plain)

//          BLOCK-END

//          BLOCK-END

//          STREAM-END

//

// YAML also permits non-indented sequences if they are included into a block

// mapping.  In this case, the token BLOCK-SEQUENCE-START is not produced:

//

//      key:

//      - item 1    # BLOCK-SEQUENCE-START is NOT produced here.

//      - item 2

//

// Tokens:

//

//      STREAM-START(utf-8)

//      BLOCK-MAPPING-START

//      KEY

//      SCALAR("key",plain)

//      VALUE

//      BLOCK-ENTRY

//      SCALAR("item 1",plain)

//      BLOCK-ENTRY

//      SCALAR("item 2",plain)

//      BLOCK-END

//

// Ensure that the buffer contains the required number of characters.

// Return true on success, false on failure (reader error or memory error).

func cache(parser *yaml_parser_t, length int) bool {

	// [Go] This was inlined: !cache(A, B) -> unread < B && !update(A, B)

	return parser.unread >= length || yaml_parser_update_buffer(parser, length)

}

// Advance the buffer pointer.

func skip(parser *yaml_parser_t) {

	if !is_blank(parser.buffer, parser.buffer_pos) {

		parser.newlines = 0

	}

	parser.mark.index++

	parser.mark.column++

	parser.unread--

	parser.buffer_pos += width(parser.buffer[parser.buffer_pos])

}

func skip_line(parser *yaml_parser_t) {

	if is_crlf(parser.buffer, parser.buffer_pos) {

		parser.mark.index += 2

		parser.mark.column = 0

		parser.mark.line++

		parser.unread -= 2

		parser.buffer_pos += 2

		parser.newlines++

	} else if is_break(parser.buffer, parser.buffer_pos) {

		parser.mark.index++

		parser.mark.column = 0

		parser.mark.line++

		parser.unread--

		parser.buffer_pos += width(parser.buffer[parser.buffer_pos])

		parser.newlines++

	}

}

// Copy a character to a string buffer and advance pointers.

func read(parser *yaml_parser_t, s []byte) []byte {

	if !is_blank(parser.buffer, parser.buffer_pos) {

		parser.newlines = 0

	}

	w := width(parser.buffer[parser.buffer_pos])

	if w == 0 {

		panic("invalid character sequence")

	}

	if len(s) == 0 {

		s = make([]byte, 0, 32)

	}

	if w == 1 && len(s)+w <= cap(s) {

		s = s[:len(s)+1]

		s[len(s)-1] = parser.buffer[parser.buffer_pos]

		parser.buffer_pos++

	} else {

		s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...)

		parser.buffer_pos += w

	}

	parser.mark.index++

	parser.mark.column++

	parser.unread--

	return s

}

// Copy a line break character to a string buffer and advance pointers.

func read_line(parser *yaml_parser_t, s []byte) []byte {

	buf := parser.buffer

	pos := parser.buffer_pos

	switch {

	case buf[pos] == '\r' && buf[pos+1] == '\n':

		// CR LF . LF

		s = append(s, '\n')

		parser.buffer_pos += 2

		parser.mark.index++

		parser.unread--

	case buf[pos] == '\r' || buf[pos] == '\n':

		// CR|LF . LF

		s = append(s, '\n')

		parser.buffer_pos += 1

	case buf[pos] == '\xC2' && buf[pos+1] == '\x85':

		// NEL . LF

		s = append(s, '\n')

		parser.buffer_pos += 2

	case buf[pos] == '\xE2' && buf[pos+1] == '\x80' && (buf[pos+2] == '\xA8' || buf[pos+2] == '\xA9'):

		// LS|PS . LS|PS

		s = append(s, buf[parser.buffer_pos:pos+3]...)

		parser.buffer_pos += 3

	default:

		return s

	}

	parser.mark.index++

	parser.mark.column = 0

	parser.mark.line++

	parser.unread--

	parser.newlines++

	return s

}

// Get the next token.

func yaml_parser_scan(parser *yaml_parser_t, token *yaml_token_t) bool {

	// Erase the token object.

	*token = yaml_token_t{} // [Go] Is this necessary?

	// No tokens after STREAM-END or error.

	if parser.stream_end_produced || parser.error != yaml_NO_ERROR {

		return true

	}

	// Ensure that the tokens queue contains enough tokens.

	if !parser.token_available {

		if !yaml_parser_fetch_more_tokens(parser) {

			return false

		}

	}

	// Fetch the next token from the queue.

	*token = parser.tokens[parser.tokens_head]

	parser.tokens_head++

	parser.tokens_parsed++

	parser.token_available = false

	if token.typ == yaml_STREAM_END_TOKEN {

		parser.stream_end_produced = true

	}

	return true

}

// Set the scanner error and return false.

func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string) bool {

	parser.error = yaml_SCANNER_ERROR

	parser.context = context

	parser.context_mark = context_mark

	parser.problem = problem

	parser.problem_mark = parser.mark

	return false

}

func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark yaml_mark_t, problem string) bool {

	context := "while parsing a tag"

	if directive {

		context = "while parsing a %TAG directive"

	}

	return yaml_parser_set_scanner_error(parser, context, context_mark, problem)

}

func trace(args ...interface{}) func() {

	pargs := append([]interface{}{"+++"}, args...)

	fmt.Println(pargs...)

	pargs = append([]interface{}{"---"}, args...)

	return func() { fmt.Println(pargs...) }

}

// Ensure that the tokens queue contains at least one token which can be

// returned to the Parser.

func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {

	// While we need more tokens to fetch, do it.

	for {

		// [Go] The comment parsing logic requires a lookahead of two tokens

		// so that foot comments may be parsed in time of associating them

		// with the tokens that are parsed before them, and also for line

		// comments to be transformed into head comments in some edge cases.

		if parser.tokens_head < len(parser.tokens)-2 {

			// If a potential simple key is at the head position, we need to fetch

			// the next token to disambiguate it.

			head_tok_idx, ok := parser.simple_keys_by_tok[parser.tokens_parsed]

			if !ok {

				break

			} else if valid, ok := yaml_simple_key_is_valid(parser, &parser.simple_keys[head_tok_idx]); !ok {

				return false

			} else if !valid {

				break

			}

		}

		// Fetch the next token.

		if !yaml_parser_fetch_next_token(parser) {

			return false

		}

	}

	parser.token_available = true

	return true

}

// The dispatcher for token fetchers.

func yaml_parser_fetch_next_token(parser *yaml_parser_t) (ok bool) {

	// Ensure that the buffer is initialized.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	// Check if we just started scanning.  Fetch STREAM-START then.

	if !parser.stream_start_produced {

		return yaml_parser_fetch_stream_start(parser)

	}

	scan_mark := parser.mark

	// Eat whitespaces and comments until we reach the next token.

	if !yaml_parser_scan_to_next_token(parser) {

		return false

	}

	// [Go] While unrolling indents, transform the head comments of prior

	// indentation levels observed after scan_start into foot comments at

	// the respective indexes.

	// Check the indentation level against the current column.

	if !yaml_parser_unroll_indent(parser, parser.mark.column, scan_mark) {

		return false

	}

	// Ensure that the buffer contains at least 4 characters.  4 is the length

	// of the longest indicators ('--- ' and '... ').

	if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {

		return false

	}

	// Is it the end of the stream?

	if is_z(parser.buffer, parser.buffer_pos) {

		return yaml_parser_fetch_stream_end(parser)

	}

	// Is it a directive?

	if parser.mark.column == 0 && parser.buffer[parser.buffer_pos] == '%' {

		return yaml_parser_fetch_directive(parser)

	}

	buf := parser.buffer

	pos := parser.buffer_pos

	// Is it the document start indicator?

	if parser.mark.column == 0 && buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && is_blankz(buf, pos+3) {

		return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_START_TOKEN)

	}

	// Is it the document end indicator?

	if parser.mark.column == 0 && buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && is_blankz(buf, pos+3) {

		return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN)

	}

	comment_mark := parser.mark

	if len(parser.tokens) > 0 && (parser.flow_level == 0 && buf[pos] == ':' || parser.flow_level > 0 && buf[pos] == ',') {

		// Associate any following comments with the prior token.

		comment_mark = parser.tokens[len(parser.tokens)-1].start_mark

	}

	defer func() {

		if !ok {

			return

		}

		if len(parser.tokens) > 0 && parser.tokens[len(parser.tokens)-1].typ == yaml_BLOCK_ENTRY_TOKEN {

			// Sequence indicators alone have no line comments. It becomes

			// a head comment for whatever follows.

			return

		}

		if !yaml_parser_scan_line_comment(parser, comment_mark) {

			ok = false

			return

		}

	}()

	// Is it the flow sequence start indicator?

	if buf[pos] == '[' {

		return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN)

	}

	// Is it the flow mapping start indicator?

	if parser.buffer[parser.buffer_pos] == '{' {

		return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_MAPPING_START_TOKEN)

	}

	// Is it the flow sequence end indicator?

	if parser.buffer[parser.buffer_pos] == ']' {

		return yaml_parser_fetch_flow_collection_end(parser,

			yaml_FLOW_SEQUENCE_END_TOKEN)

	}

	// Is it the flow mapping end indicator?

	if parser.buffer[parser.buffer_pos] == '}' {

		return yaml_parser_fetch_flow_collection_end(parser,

			yaml_FLOW_MAPPING_END_TOKEN)

	}

	// Is it the flow entry indicator?

	if parser.buffer[parser.buffer_pos] == ',' {

		return yaml_parser_fetch_flow_entry(parser)

	}

	// Is it the block entry indicator?

	if parser.buffer[parser.buffer_pos] == '-' && is_blankz(parser.buffer, parser.buffer_pos+1) {

		return yaml_parser_fetch_block_entry(parser)

	}

	// Is it the key indicator?

	if parser.buffer[parser.buffer_pos] == '?' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {

		return yaml_parser_fetch_key(parser)

	}

	// Is it the value indicator?

	if parser.buffer[parser.buffer_pos] == ':' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {

		return yaml_parser_fetch_value(parser)

	}

	// Is it an alias?

	if parser.buffer[parser.buffer_pos] == '*' {

		return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN)

	}

	// Is it an anchor?

	if parser.buffer[parser.buffer_pos] == '&' {

		return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN)

	}

	// Is it a tag?

	if parser.buffer[parser.buffer_pos] == '!' {

		return yaml_parser_fetch_tag(parser)

	}

	// Is it a literal scalar?

	if parser.buffer[parser.buffer_pos] == '|' && parser.flow_level == 0 {

		return yaml_parser_fetch_block_scalar(parser, true)

	}

	// Is it a folded scalar?

	if parser.buffer[parser.buffer_pos] == '>' && parser.flow_level == 0 {

		return yaml_parser_fetch_block_scalar(parser, false)

	}

	// Is it a single-quoted scalar?

	if parser.buffer[parser.buffer_pos] == '\'' {

		return yaml_parser_fetch_flow_scalar(parser, true)

	}

	// Is it a double-quoted scalar?

	if parser.buffer[parser.buffer_pos] == '"' {

		return yaml_parser_fetch_flow_scalar(parser, false)

	}

	// Is it a plain scalar?

	//

	// A plain scalar may start with any non-blank characters except

	//

	//      '-', '?', ':', ',', '[', ']', '{', '}',

	//      '#', '&', '*', '!', '|', '>', '\'', '\"',

	//      '%', '@', '`'.

	//

	// In the block context (and, for the '-' indicator, in the flow context

	// too), it may also start with the characters

	//

	//      '-', '?', ':'

	//

	// if it is followed by a non-space character.

	//

	// The last rule is more restrictive than the specification requires.

	// [Go] TODO Make this logic more reasonable.

	//switch parser.buffer[parser.buffer_pos] {

	//case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`':

	//}

	if !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '-' ||

		parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':' ||

		parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '[' ||

		parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||

		parser.buffer[parser.buffer_pos] == '}' || parser.buffer[parser.buffer_pos] == '#' ||

		parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '*' ||

		parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '|' ||

		parser.buffer[parser.buffer_pos] == '>' || parser.buffer[parser.buffer_pos] == '\'' ||

		parser.buffer[parser.buffer_pos] == '"' || parser.buffer[parser.buffer_pos] == '%' ||

		parser.buffer[parser.buffer_pos] == '@' || parser.buffer[parser.buffer_pos] == '`') ||

		(parser.buffer[parser.buffer_pos] == '-' && !is_blank(parser.buffer, parser.buffer_pos+1)) ||

		(parser.flow_level == 0 &&

			(parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':') &&

			!is_blankz(parser.buffer, parser.buffer_pos+1)) {

		return yaml_parser_fetch_plain_scalar(parser)

	}

	// If we don't determine the token type so far, it is an error.

	return yaml_parser_set_scanner_error(parser,

		"while scanning for the next token", parser.mark,

		"found character that cannot start any token")

}

func yaml_simple_key_is_valid(parser *yaml_parser_t, simple_key *yaml_simple_key_t) (valid, ok bool) {

	if !simple_key.possible {

		return false, true

	}

	// The 1.2 specification says:

	//

	//     "If the ? indicator is omitted, parsing needs to see past the

	//     implicit key to recognize it as such. To limit the amount of

	//     lookahead required, the “:” indicator must appear at most 1024

	//     Unicode characters beyond the start of the key. In addition, the key

	//     is restricted to a single line."

	//

	if simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index {

		// Check if the potential simple key to be removed is required.

		if simple_key.required {

			return false, yaml_parser_set_scanner_error(parser,

				"while scanning a simple key", simple_key.mark,

				"could not find expected ':'")

		}

		simple_key.possible = false

		return false, true

	}

	return true, true

}

// Check if a simple key may start at the current position and add it if

// needed.

func yaml_parser_save_simple_key(parser *yaml_parser_t) bool {

	// A simple key is required at the current position if the scanner is in

	// the block context and the current column coincides with the indentation

	// level.

	required := parser.flow_level == 0 && parser.indent == parser.mark.column

	//

	// If the current position may start a simple key, save it.

	//

	if parser.simple_key_allowed {

		simple_key := yaml_simple_key_t{

			possible: true,

			required: required,

			token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),

			mark: parser.mark,
		}

		if !yaml_parser_remove_simple_key(parser) {

			return false

		}

		parser.simple_keys[len(parser.simple_keys)-1] = simple_key

		parser.simple_keys_by_tok[simple_key.token_number] = len(parser.simple_keys) - 1

	}

	return true

}

// Remove a potential simple key at the current flow level.

func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool {

	i := len(parser.simple_keys) - 1

	if parser.simple_keys[i].possible {

		// If the key is required, it is an error.

		if parser.simple_keys[i].required {

			return yaml_parser_set_scanner_error(parser,

				"while scanning a simple key", parser.simple_keys[i].mark,

				"could not find expected ':'")

		}

		// Remove the key from the stack.

		parser.simple_keys[i].possible = false

		delete(parser.simple_keys_by_tok, parser.simple_keys[i].token_number)

	}

	return true

}

// max_flow_level limits the flow_level

const max_flow_level = 10000

// Increase the flow level and resize the simple key list if needed.

func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool {

	// Reset the simple key on the next level.

	parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{

		possible: false,

		required: false,

		token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),

		mark: parser.mark,
	})

	// Increase the flow level.

	parser.flow_level++

	if parser.flow_level > max_flow_level {

		return yaml_parser_set_scanner_error(parser,

			"while increasing flow level", parser.simple_keys[len(parser.simple_keys)-1].mark,

			fmt.Sprintf("exceeded max depth of %d", max_flow_level))

	}

	return true

}

// Decrease the flow level.

func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool {

	if parser.flow_level > 0 {

		parser.flow_level--

		last := len(parser.simple_keys) - 1

		delete(parser.simple_keys_by_tok, parser.simple_keys[last].token_number)

		parser.simple_keys = parser.simple_keys[:last]

	}

	return true

}

// max_indents limits the indents stack size

const max_indents = 10000

// 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.

func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml_token_type_t, mark yaml_mark_t) bool {

	// In the flow context, do nothing.

	if parser.flow_level > 0 {

		return true

	}

	if parser.indent < column {

		// Push the current indentation level to the stack and set the new

		// indentation level.

		parser.indents = append(parser.indents, parser.indent)

		parser.indent = column

		if len(parser.indents) > max_indents {

			return yaml_parser_set_scanner_error(parser,

				"while increasing indent level", parser.simple_keys[len(parser.simple_keys)-1].mark,

				fmt.Sprintf("exceeded max depth of %d", max_indents))

		}

		// Create a token and insert it into the queue.

		token := yaml_token_t{

			typ: typ,

			start_mark: mark,

			end_mark: mark,
		}

		if number > -1 {

			number -= parser.tokens_parsed

		}

		yaml_insert_token(parser, number, &token)

	}

	return true

}

// Pop indentation levels from the indents stack until the current level

// becomes less or equal to the column.  For each indentation level, append

// the BLOCK-END token.

func yaml_parser_unroll_indent(parser *yaml_parser_t, column int, scan_mark yaml_mark_t) bool {

	// In the flow context, do nothing.

	if parser.flow_level > 0 {

		return true

	}

	block_mark := scan_mark

	block_mark.index--

	// Loop through the indentation levels in the stack.

	for parser.indent > column {

		// [Go] Reposition the end token before potential following

		//      foot comments of parent blocks. For that, search

		//      backwards for recent comments that were at the same

		//      indent as the block that is ending now.

		stop_index := block_mark.index

		for i := len(parser.comments) - 1; i >= 0; i-- {

			comment := &parser.comments[i]

			if comment.end_mark.index < stop_index {

				// Don't go back beyond the start of the comment/whitespace scan, unless column < 0.

				// If requested indent column is < 0, then the document is over and everything else

				// is a foot anyway.

				break

			}

			if comment.start_mark.column == parser.indent+1 {

				// This is a good match. But maybe there's a former comment

				// at that same indent level, so keep searching.

				block_mark = comment.start_mark

			}

			// While the end of the former comment matches with

			// the start of the following one, we know there's

			// nothing in between and scanning is still safe.

			stop_index = comment.scan_mark.index

		}

		// Create a token and append it to the queue.

		token := yaml_token_t{

			typ: yaml_BLOCK_END_TOKEN,

			start_mark: block_mark,

			end_mark: block_mark,
		}

		yaml_insert_token(parser, -1, &token)

		// Pop the indentation level.

		parser.indent = parser.indents[len(parser.indents)-1]

		parser.indents = parser.indents[:len(parser.indents)-1]

	}

	return true

}

// Initialize the scanner and produce the STREAM-START token.

func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool {

	// Set the initial indentation.

	parser.indent = -1

	// Initialize the simple key stack.

	parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{})

	parser.simple_keys_by_tok = make(map[int]int)

	// A simple key is allowed at the beginning of the stream.

	parser.simple_key_allowed = true

	// We have started.

	parser.stream_start_produced = true

	// Create the STREAM-START token and append it to the queue.

	token := yaml_token_t{

		typ: yaml_STREAM_START_TOKEN,

		start_mark: parser.mark,

		end_mark: parser.mark,

		encoding: parser.encoding,
	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the STREAM-END token and shut down the scanner.

func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool {

	// Force new line.

	if parser.mark.column != 0 {

		parser.mark.column = 0

		parser.mark.line++

	}

	// Reset the indentation level.

	if !yaml_parser_unroll_indent(parser, -1, parser.mark) {

		return false

	}

	// Reset simple keys.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	parser.simple_key_allowed = false

	// Create the STREAM-END token and append it to the queue.

	token := yaml_token_t{

		typ: yaml_STREAM_END_TOKEN,

		start_mark: parser.mark,

		end_mark: parser.mark,
	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.

func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {

	// Reset the indentation level.

	if !yaml_parser_unroll_indent(parser, -1, parser.mark) {

		return false

	}

	// Reset simple keys.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	parser.simple_key_allowed = false

	// Create the YAML-DIRECTIVE or TAG-DIRECTIVE token.

	token := yaml_token_t{}

	if !yaml_parser_scan_directive(parser, &token) {

		return false

	}

	// Append the token to the queue.

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the DOCUMENT-START or DOCUMENT-END token.

func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool {

	// Reset the indentation level.

	if !yaml_parser_unroll_indent(parser, -1, parser.mark) {

		return false

	}

	// Reset simple keys.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	parser.simple_key_allowed = false

	// Consume the token.

	start_mark := parser.mark

	skip(parser)

	skip(parser)

	skip(parser)

	end_mark := parser.mark

	// Create the DOCUMENT-START or DOCUMENT-END token.

	token := yaml_token_t{

		typ: typ,

		start_mark: start_mark,

		end_mark: end_mark,
	}

	// Append the token to the queue.

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.

func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool {

	// The indicators '[' and '{' may start a simple key.

	if !yaml_parser_save_simple_key(parser) {

		return false

	}

	// Increase the flow level.

	if !yaml_parser_increase_flow_level(parser) {

		return false

	}

	// A simple key may follow the indicators '[' and '{'.

	parser.simple_key_allowed = true

	// Consume the token.

	start_mark := parser.mark

	skip(parser)

	end_mark := parser.mark

	// Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token.

	token := yaml_token_t{

		typ: typ,

		start_mark: start_mark,

		end_mark: end_mark,
	}

	// Append the token to the queue.

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.

func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, typ yaml_token_type_t) bool {

	// Reset any potential simple key on the current flow level.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	// Decrease the flow level.

	if !yaml_parser_decrease_flow_level(parser) {

		return false

	}

	// No simple keys after the indicators ']' and '}'.

	parser.simple_key_allowed = false

	// Consume the token.

	start_mark := parser.mark

	skip(parser)

	end_mark := parser.mark

	// Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token.

	token := yaml_token_t{

		typ: typ,

		start_mark: start_mark,

		end_mark: end_mark,
	}

	// Append the token to the queue.

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the FLOW-ENTRY token.

func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool {

	// Reset any potential simple keys on the current flow level.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	// Simple keys are allowed after ','.

	parser.simple_key_allowed = true

	// Consume the token.

	start_mark := parser.mark

	skip(parser)

	end_mark := parser.mark

	// Create the FLOW-ENTRY token and append it to the queue.

	token := yaml_token_t{

		typ: yaml_FLOW_ENTRY_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,
	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the BLOCK-ENTRY token.

func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool {

	// Check if the scanner is in the block context.

	if parser.flow_level == 0 {

		// Check if we are allowed to start a new entry.

		if !parser.simple_key_allowed {

			return yaml_parser_set_scanner_error(parser, "", parser.mark,

				"block sequence entries are not allowed in this context")

		}

		// Add the BLOCK-SEQUENCE-START token if needed.

		if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) {

			return false

		}

	} else {

		// It is an error for the '-' indicator to occur in the flow context,

		// but we let the Parser detect and report about it because the Parser

		// is able to point to the context.

	}

	// Reset any potential simple keys on the current flow level.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	// Simple keys are allowed after '-'.

	parser.simple_key_allowed = true

	// Consume the token.

	start_mark := parser.mark

	skip(parser)

	end_mark := parser.mark

	// Create the BLOCK-ENTRY token and append it to the queue.

	token := yaml_token_t{

		typ: yaml_BLOCK_ENTRY_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,
	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the KEY token.

func yaml_parser_fetch_key(parser *yaml_parser_t) bool {

	// In the block context, additional checks are required.

	if parser.flow_level == 0 {

		// Check if we are allowed to start a new key (not nessesary simple).

		if !parser.simple_key_allowed {

			return yaml_parser_set_scanner_error(parser, "", parser.mark,

				"mapping keys are not allowed in this context")

		}

		// Add the BLOCK-MAPPING-START token if needed.

		if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {

			return false

		}

	}

	// Reset any potential simple keys on the current flow level.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	// Simple keys are allowed after '?' in the block context.

	parser.simple_key_allowed = parser.flow_level == 0

	// Consume the token.

	start_mark := parser.mark

	skip(parser)

	end_mark := parser.mark

	// Create the KEY token and append it to the queue.

	token := yaml_token_t{

		typ: yaml_KEY_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,
	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the VALUE token.

func yaml_parser_fetch_value(parser *yaml_parser_t) bool {

	simple_key := &parser.simple_keys[len(parser.simple_keys)-1]

	// Have we found a simple key?

	if valid, ok := yaml_simple_key_is_valid(parser, simple_key); !ok {

		return false

	} else if valid {

		// Create the KEY token and insert it into the queue.

		token := yaml_token_t{

			typ: yaml_KEY_TOKEN,

			start_mark: simple_key.mark,

			end_mark: simple_key.mark,
		}

		yaml_insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token)

		// In the block context, we may need to add the BLOCK-MAPPING-START token.

		if !yaml_parser_roll_indent(parser, simple_key.mark.column,

			simple_key.token_number,

			yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) {

			return false

		}

		// Remove the simple key.

		simple_key.possible = false

		delete(parser.simple_keys_by_tok, simple_key.token_number)

		// A simple key cannot follow another simple key.

		parser.simple_key_allowed = false

	} else {

		// The ':' indicator follows a complex key.

		// In the block context, extra checks are required.

		if parser.flow_level == 0 {

			// Check if we are allowed to start a complex value.

			if !parser.simple_key_allowed {

				return yaml_parser_set_scanner_error(parser, "", parser.mark,

					"mapping values are not allowed in this context")

			}

			// Add the BLOCK-MAPPING-START token if needed.

			if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {

				return false

			}

		}

		// Simple keys after ':' are allowed in the block context.

		parser.simple_key_allowed = parser.flow_level == 0

	}

	// Consume the token.

	start_mark := parser.mark

	skip(parser)

	end_mark := parser.mark

	// Create the VALUE token and append it to the queue.

	token := yaml_token_t{

		typ: yaml_VALUE_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,
	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the ALIAS or ANCHOR token.

func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool {

	// An anchor or an alias could be a simple key.

	if !yaml_parser_save_simple_key(parser) {

		return false

	}

	// A simple key cannot follow an anchor or an alias.

	parser.simple_key_allowed = false

	// Create the ALIAS or ANCHOR token and append it to the queue.

	var token yaml_token_t

	if !yaml_parser_scan_anchor(parser, &token, typ) {

		return false

	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the TAG token.

func yaml_parser_fetch_tag(parser *yaml_parser_t) bool {

	// A tag could be a simple key.

	if !yaml_parser_save_simple_key(parser) {

		return false

	}

	// A simple key cannot follow a tag.

	parser.simple_key_allowed = false

	// Create the TAG token and append it to the queue.

	var token yaml_token_t

	if !yaml_parser_scan_tag(parser, &token) {

		return false

	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.

func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool {

	// Remove any potential simple keys.

	if !yaml_parser_remove_simple_key(parser) {

		return false

	}

	// A simple key may follow a block scalar.

	parser.simple_key_allowed = true

	// Create the SCALAR token and append it to the queue.

	var token yaml_token_t

	if !yaml_parser_scan_block_scalar(parser, &token, literal) {

		return false

	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.

func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool {

	// A plain scalar could be a simple key.

	if !yaml_parser_save_simple_key(parser) {

		return false

	}

	// A simple key cannot follow a flow scalar.

	parser.simple_key_allowed = false

	// Create the SCALAR token and append it to the queue.

	var token yaml_token_t

	if !yaml_parser_scan_flow_scalar(parser, &token, single) {

		return false

	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Produce the SCALAR(...,plain) token.

func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool {

	// A plain scalar could be a simple key.

	if !yaml_parser_save_simple_key(parser) {

		return false

	}

	// A simple key cannot follow a flow scalar.

	parser.simple_key_allowed = false

	// Create the SCALAR token and append it to the queue.

	var token yaml_token_t

	if !yaml_parser_scan_plain_scalar(parser, &token) {

		return false

	}

	yaml_insert_token(parser, -1, &token)

	return true

}

// Eat whitespaces and comments until the next token is found.

func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {

	scan_mark := parser.mark

	// Until the next token is not found.

	for {

		// Allow the BOM mark to start a line.

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) {

			skip(parser)

		}

		// Eat whitespaces.

		// Tabs are allowed:

		//  - in the flow context

		//  - in the block context, but not at the beginning of the line or

		//  after '-', '?', or ':' (complex value).

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') {

			skip(parser)

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

		}

		// Check if we just had a line comment under a sequence entry that

		// looks more like a header to the following content. Similar to this:

		//

		// - # The comment

		//   - Some data

		//

		// If so, transform the line comment to a head comment and reposition.

		if len(parser.comments) > 0 && len(parser.tokens) > 1 {

			tokenA := parser.tokens[len(parser.tokens)-2]

			tokenB := parser.tokens[len(parser.tokens)-1]

			comment := &parser.comments[len(parser.comments)-1]

			if tokenA.typ == yaml_BLOCK_SEQUENCE_START_TOKEN && tokenB.typ == yaml_BLOCK_ENTRY_TOKEN && len(comment.line) > 0 && !is_break(parser.buffer, parser.buffer_pos) {

				// If it was in the prior line, reposition so it becomes a

				// header of the follow up token. Otherwise, keep it in place

				// so it becomes a header of the former.

				comment.head = comment.line

				comment.line = nil

				if comment.start_mark.line == parser.mark.line-1 {

					comment.token_mark = parser.mark

				}

			}

		}

		// Eat a comment until a line break.

		if parser.buffer[parser.buffer_pos] == '#' {

			if !yaml_parser_scan_comments(parser, scan_mark) {

				return false

			}

		}

		// If it is a line break, eat it.

		if is_break(parser.buffer, parser.buffer_pos) {

			if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

				return false

			}

			skip_line(parser)

			// In the block context, a new line may start a simple key.

			if parser.flow_level == 0 {

				parser.simple_key_allowed = true

			}

		} else {

			break // We have found a token.

		}

	}

	return true

}

// Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.

//

// Scope:

//

//	%YAML    1.1    # a comment \n

//	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

//	%TAG    !yaml!  tag:yaml.org,2002:  \n

//	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool {

	// Eat '%'.

	start_mark := parser.mark

	skip(parser)

	// Scan the directive name.

	var name []byte

	if !yaml_parser_scan_directive_name(parser, start_mark, &name) {

		return false

	}

	// Is it a YAML directive?

	if bytes.Equal(name, []byte("YAML")) {

		// Scan the VERSION directive value.

		var major, minor int8

		if !yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor) {

			return false

		}

		end_mark := parser.mark

		// Create a VERSION-DIRECTIVE token.

		*token = yaml_token_t{

			typ: yaml_VERSION_DIRECTIVE_TOKEN,

			start_mark: start_mark,

			end_mark: end_mark,

			major: major,

			minor: minor,
		}

		// Is it a TAG directive?

	} else if bytes.Equal(name, []byte("TAG")) {

		// Scan the TAG directive value.

		var handle, prefix []byte

		if !yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix) {

			return false

		}

		end_mark := parser.mark

		// Create a TAG-DIRECTIVE token.

		*token = yaml_token_t{

			typ: yaml_TAG_DIRECTIVE_TOKEN,

			start_mark: start_mark,

			end_mark: end_mark,

			value: handle,

			prefix: prefix,
		}

		// Unknown directive.

	} else {

		yaml_parser_set_scanner_error(parser, "while scanning a directive",

			start_mark, "found unknown directive name")

		return false

	}

	// Eat the rest of the line including any comments.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	for is_blank(parser.buffer, parser.buffer_pos) {

		skip(parser)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	if parser.buffer[parser.buffer_pos] == '#' {

		// [Go] Discard this inline comment for the time being.

		//if !yaml_parser_scan_line_comment(parser, start_mark) {

		//	return false

		//}

		for !is_breakz(parser.buffer, parser.buffer_pos) {

			skip(parser)

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

		}

	}

	// Check if we are at the end of the line.

	if !is_breakz(parser.buffer, parser.buffer_pos) {

		yaml_parser_set_scanner_error(parser, "while scanning a directive",

			start_mark, "did not find expected comment or line break")

		return false

	}

	// Eat a line break.

	if is_break(parser.buffer, parser.buffer_pos) {

		if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

			return false

		}

		skip_line(parser)

	}

	return true

}

// Scan the directive name.

//

// Scope:

//

//	%YAML   1.1     # a comment \n

//	 ^^^^

//	%TAG    !yaml!  tag:yaml.org,2002:  \n

//	 ^^^

func yaml_parser_scan_directive_name(parser *yaml_parser_t, start_mark yaml_mark_t, name *[]byte) bool {

	// Consume the directive name.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	var s []byte

	for is_alpha(parser.buffer, parser.buffer_pos) {

		s = read(parser, s)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	// Check if the name is empty.

	if len(s) == 0 {

		yaml_parser_set_scanner_error(parser, "while scanning a directive",

			start_mark, "could not find expected directive name")

		return false

	}

	// Check for an blank character after the name.

	if !is_blankz(parser.buffer, parser.buffer_pos) {

		yaml_parser_set_scanner_error(parser, "while scanning a directive",

			start_mark, "found unexpected non-alphabetical character")

		return false

	}

	*name = s

	return true

}

// Scan the value of VERSION-DIRECTIVE.

//

// Scope:

//

//	%YAML   1.1     # a comment \n

//	     ^^^^^^

func yaml_parser_scan_version_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, major, minor *int8) bool {

	// Eat whitespaces.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	for is_blank(parser.buffer, parser.buffer_pos) {

		skip(parser)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	// Consume the major version number.

	if !yaml_parser_scan_version_directive_number(parser, start_mark, major) {

		return false

	}

	// Eat '.'.

	if parser.buffer[parser.buffer_pos] != '.' {

		return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",

			start_mark, "did not find expected digit or '.' character")

	}

	skip(parser)

	// Consume the minor version number.

	if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) {

		return false

	}

	return true

}

const max_number_length = 2

// Scan the version number of VERSION-DIRECTIVE.

//

// Scope:

//

//	%YAML   1.1     # a comment \n

//	        ^

//	%YAML   1.1     # a comment \n

//	          ^

func yaml_parser_scan_version_directive_number(parser *yaml_parser_t, start_mark yaml_mark_t, number *int8) bool {

	// Repeat while the next character is digit.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	var value, length int8

	for is_digit(parser.buffer, parser.buffer_pos) {

		// Check if the number is too long.

		length++

		if length > max_number_length {

			return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",

				start_mark, "found extremely long version number")

		}

		value = value*10 + int8(as_digit(parser.buffer, parser.buffer_pos))

		skip(parser)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	// Check if the number was present.

	if length == 0 {

		return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",

			start_mark, "did not find expected version number")

	}

	*number = value

	return true

}

// Scan the value of a TAG-DIRECTIVE token.

//

// Scope:

//

//	%TAG    !yaml!  tag:yaml.org,2002:  \n

//	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

func yaml_parser_scan_tag_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, handle, prefix *[]byte) bool {

	var handle_value, prefix_value []byte

	// Eat whitespaces.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	for is_blank(parser.buffer, parser.buffer_pos) {

		skip(parser)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	// Scan a handle.

	if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) {

		return false

	}

	// Expect a whitespace.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	if !is_blank(parser.buffer, parser.buffer_pos) {

		yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",

			start_mark, "did not find expected whitespace")

		return false

	}

	// Eat whitespaces.

	for is_blank(parser.buffer, parser.buffer_pos) {

		skip(parser)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	// Scan a prefix.

	if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) {

		return false

	}

	// Expect a whitespace or line break.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	if !is_blankz(parser.buffer, parser.buffer_pos) {

		yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",

			start_mark, "did not find expected whitespace or line break")

		return false

	}

	*handle = handle_value

	*prefix = prefix_value

	return true

}

func yaml_parser_scan_anchor(parser *yaml_parser_t, token *yaml_token_t, typ yaml_token_type_t) bool {

	var s []byte

	// Eat the indicator character.

	start_mark := parser.mark

	skip(parser)

	// Consume the value.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	for is_alpha(parser.buffer, parser.buffer_pos) {

		s = read(parser, s)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	end_mark := parser.mark

	/*

	 * Check if length of the anchor is greater than 0 and it is followed by

	 * a whitespace character or one of the indicators:

	 *

	 *      '?', ':', ',', ']', '}', '%', '@', '`'.

	 */

	if len(s) == 0 ||

		!(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '?' ||

			parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == ',' ||

			parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '}' ||

			parser.buffer[parser.buffer_pos] == '%' || parser.buffer[parser.buffer_pos] == '@' ||

			parser.buffer[parser.buffer_pos] == '`') {

		context := "while scanning an alias"

		if typ == yaml_ANCHOR_TOKEN {

			context = "while scanning an anchor"

		}

		yaml_parser_set_scanner_error(parser, context, start_mark,

			"did not find expected alphabetic or numeric character")

		return false

	}

	// Create a token.

	*token = yaml_token_t{

		typ: typ,

		start_mark: start_mark,

		end_mark: end_mark,

		value: s,
	}

	return true

}

/*

 * Scan a TAG token.

 */

func yaml_parser_scan_tag(parser *yaml_parser_t, token *yaml_token_t) bool {

	var handle, suffix []byte

	start_mark := parser.mark

	// Check if the tag is in the canonical form.

	if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

		return false

	}

	if parser.buffer[parser.buffer_pos+1] == '<' {

		// Keep the handle as ''

		// Eat '!<'

		skip(parser)

		skip(parser)

		// Consume the tag value.

		if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {

			return false

		}

		// Check for '>' and eat it.

		if parser.buffer[parser.buffer_pos] != '>' {

			yaml_parser_set_scanner_error(parser, "while scanning a tag",

				start_mark, "did not find the expected '>'")

			return false

		}

		skip(parser)

	} else {

		// The tag has either the '!suffix' or the '!handle!suffix' form.

		// First, try to scan a handle.

		if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) {

			return false

		}

		// Check if it is, indeed, handle.

		if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' {

			// Scan the suffix now.

			if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {

				return false

			}

		} else {

			// It wasn't a handle after all.  Scan the rest of the tag.

			if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) {

				return false

			}

			// Set the handle to '!'.

			handle = []byte{'!'}

			// A special case: the '!' tag.  Set the handle to '' and the

			// suffix to '!'.

			if len(suffix) == 0 {

				handle, suffix = suffix, handle

			}

		}

	}

	// Check the character which ends the tag.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	if !is_blankz(parser.buffer, parser.buffer_pos) {

		yaml_parser_set_scanner_error(parser, "while scanning a tag",

			start_mark, "did not find expected whitespace or line break")

		return false

	}

	end_mark := parser.mark

	// Create a token.

	*token = yaml_token_t{

		typ: yaml_TAG_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,

		value: handle,

		suffix: suffix,
	}

	return true

}

// Scan a tag handle.

func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool {

	// Check the initial '!' character.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	if parser.buffer[parser.buffer_pos] != '!' {

		yaml_parser_set_scanner_tag_error(parser, directive,

			start_mark, "did not find expected '!'")

		return false

	}

	var s []byte

	// Copy the '!' character.

	s = read(parser, s)

	// Copy all subsequent alphabetical and numerical characters.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	for is_alpha(parser.buffer, parser.buffer_pos) {

		s = read(parser, s)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	// Check if the trailing character is '!' and copy it.

	if parser.buffer[parser.buffer_pos] == '!' {

		s = read(parser, s)

	} 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 directive && string(s) != "!" {

			yaml_parser_set_scanner_tag_error(parser, directive,

				start_mark, "did not find expected '!'")

			return false

		}

	}

	*handle = s

	return true

}

// Scan a tag.

func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool {

	//size_t length = head ? strlen((char *)head) : 0

	var s []byte

	hasTag := len(head) > 0

	// Copy the head if needed.

	//

	// Note that we don't copy the leading '!' character.

	if len(head) > 1 {

		s = append(s, head[1:]...)

	}

	// Scan the tag.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	// The set of characters that may appear in URI is as follows:

	//

	//      '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',

	//      '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',

	//      '%'.

	// [Go] TODO Convert this into more reasonable logic.

	for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||

		parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||

		parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||

		parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' ||

		parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' ||

		parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' ||

		parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' ||

		parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' ||

		parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' ||

		parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' ||

		parser.buffer[parser.buffer_pos] == '%' {

		// Check if it is a URI-escape sequence.

		if parser.buffer[parser.buffer_pos] == '%' {

			if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) {

				return false

			}

		} else {

			s = read(parser, s)

		}

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		hasTag = true

	}

	if !hasTag {

		yaml_parser_set_scanner_tag_error(parser, directive,

			start_mark, "did not find expected tag URI")

		return false

	}

	*uri = s

	return true

}

// Decode an URI-escape sequence corresponding to a single UTF-8 character.

func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool {

	// Decode the required number of characters.

	w := 1024

	for w > 0 {

		// Check for a URI-escaped octet.

		if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {

			return false

		}

		if !(parser.buffer[parser.buffer_pos] == '%' &&

			is_hex(parser.buffer, parser.buffer_pos+1) &&

			is_hex(parser.buffer, parser.buffer_pos+2)) {

			return yaml_parser_set_scanner_tag_error(parser, directive,

				start_mark, "did not find URI escaped octet")

		}

		// Get the octet.

		octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2))

		// If it is the leading octet, determine the length of the UTF-8 sequence.

		if w == 1024 {

			w = width(octet)

			if w == 0 {

				return yaml_parser_set_scanner_tag_error(parser, directive,

					start_mark, "found an incorrect leading UTF-8 octet")

			}

		} else {

			// Check if the trailing octet is correct.

			if octet&0xC0 != 0x80 {

				return yaml_parser_set_scanner_tag_error(parser, directive,

					start_mark, "found an incorrect trailing UTF-8 octet")

			}

		}

		// Copy the octet and move the pointers.

		*s = append(*s, octet)

		skip(parser)

		skip(parser)

		skip(parser)

		w--

	}

	return true

}

// Scan a block scalar.

func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, literal bool) bool {

	// Eat the indicator '|' or '>'.

	start_mark := parser.mark

	skip(parser)

	// Scan the additional block scalar indicators.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	// Check for a chomping indicator.

	var chomping, increment int

	if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {

		// Set the chomping method and eat the indicator.

		if parser.buffer[parser.buffer_pos] == '+' {

			chomping = +1

		} else {

			chomping = -1

		}

		skip(parser)

		// Check for an indentation indicator.

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		if is_digit(parser.buffer, parser.buffer_pos) {

			// Check that the indentation is greater than 0.

			if parser.buffer[parser.buffer_pos] == '0' {

				yaml_parser_set_scanner_error(parser, "while scanning a block scalar",

					start_mark, "found an indentation indicator equal to 0")

				return false

			}

			// Get the indentation level and eat the indicator.

			increment = as_digit(parser.buffer, parser.buffer_pos)

			skip(parser)

		}

	} else if is_digit(parser.buffer, parser.buffer_pos) {

		// Do the same as above, but in the opposite order.

		if parser.buffer[parser.buffer_pos] == '0' {

			yaml_parser_set_scanner_error(parser, "while scanning a block scalar",

				start_mark, "found an indentation indicator equal to 0")

			return false

		}

		increment = as_digit(parser.buffer, parser.buffer_pos)

		skip(parser)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {

			if parser.buffer[parser.buffer_pos] == '+' {

				chomping = +1

			} else {

				chomping = -1

			}

			skip(parser)

		}

	}

	// Eat whitespaces and comments to the end of the line.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	for is_blank(parser.buffer, parser.buffer_pos) {

		skip(parser)

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

	}

	if parser.buffer[parser.buffer_pos] == '#' {

		if !yaml_parser_scan_line_comment(parser, start_mark) {

			return false

		}

		for !is_breakz(parser.buffer, parser.buffer_pos) {

			skip(parser)

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

		}

	}

	// Check if we are at the end of the line.

	if !is_breakz(parser.buffer, parser.buffer_pos) {

		yaml_parser_set_scanner_error(parser, "while scanning a block scalar",

			start_mark, "did not find expected comment or line break")

		return false

	}

	// Eat a line break.

	if is_break(parser.buffer, parser.buffer_pos) {

		if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

			return false

		}

		skip_line(parser)

	}

	end_mark := parser.mark

	// Set the indentation level if it was specified.

	var indent int

	if increment > 0 {

		if parser.indent >= 0 {

			indent = parser.indent + increment

		} else {

			indent = increment

		}

	}

	// Scan the leading line breaks and determine the indentation level if needed.

	var s, leading_break, trailing_breaks []byte

	if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {

		return false

	}

	// Scan the block scalar content.

	if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

		return false

	}

	var leading_blank, trailing_blank bool

	for parser.mark.column == indent && !is_z(parser.buffer, parser.buffer_pos) {

		// We are at the beginning of a non-empty line.

		// Is it a trailing whitespace?

		trailing_blank = is_blank(parser.buffer, parser.buffer_pos)

		// Check if we need to fold the leading line break.

		if !literal && !leading_blank && !trailing_blank && len(leading_break) > 0 && leading_break[0] == '\n' {

			// Do we need to join the lines by space?

			if len(trailing_breaks) == 0 {

				s = append(s, ' ')

			}

		} else {

			s = append(s, leading_break...)

		}

		leading_break = leading_break[:0]

		// Append the remaining line breaks.

		s = append(s, trailing_breaks...)

		trailing_breaks = trailing_breaks[:0]

		// Is it a leading whitespace?

		leading_blank = is_blank(parser.buffer, parser.buffer_pos)

		// Consume the current line.

		for !is_breakz(parser.buffer, parser.buffer_pos) {

			s = read(parser, s)

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

		}

		// Consume the line break.

		if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

			return false

		}

		leading_break = read_line(parser, leading_break)

		// Eat the following indentation spaces and line breaks.

		if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {

			return false

		}

	}

	// Chomp the tail.

	if chomping != -1 {

		s = append(s, leading_break...)

	}

	if chomping == 1 {

		s = append(s, trailing_breaks...)

	}

	// Create a token.

	*token = yaml_token_t{

		typ: yaml_SCALAR_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,

		value: s,

		style: yaml_LITERAL_SCALAR_STYLE,
	}

	if !literal {

		token.style = yaml_FOLDED_SCALAR_STYLE

	}

	return true

}

// Scan indentation spaces and line breaks for a block scalar.  Determine the

// indentation level if needed.

func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool {

	*end_mark = parser.mark

	// Eat the indentation spaces and line breaks.

	max_indent := 0

	for {

		// Eat the indentation spaces.

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) {

			skip(parser)

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

		}

		if parser.mark.column > max_indent {

			max_indent = parser.mark.column

		}

		// Check for a tab character messing the indentation.

		if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) {

			return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",

				start_mark, "found a tab character where an indentation space is expected")

		}

		// Have we found a non-empty line?

		if !is_break(parser.buffer, parser.buffer_pos) {

			break

		}

		// Consume the line break.

		if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

			return false

		}

		// [Go] Should really be returning breaks instead.

		*breaks = read_line(parser, *breaks)

		*end_mark = parser.mark

	}

	// Determine the indentation level if needed.

	if *indent == 0 {

		*indent = max_indent

		if *indent < parser.indent+1 {

			*indent = parser.indent + 1

		}

		if *indent < 1 {

			*indent = 1

		}

	}

	return true

}

// Scan a quoted scalar.

func yaml_parser_scan_flow_scalar(parser *yaml_parser_t, token *yaml_token_t, single bool) bool {

	// Eat the left quote.

	start_mark := parser.mark

	skip(parser)

	// Consume the content of the quoted scalar.

	var s, leading_break, trailing_breaks, whitespaces []byte

	for {

		// Check that there are no document indicators at the beginning of the line.

		if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {

			return false

		}

		if parser.mark.column == 0 &&

			((parser.buffer[parser.buffer_pos+0] == '-' &&

				parser.buffer[parser.buffer_pos+1] == '-' &&

				parser.buffer[parser.buffer_pos+2] == '-') ||

				(parser.buffer[parser.buffer_pos+0] == '.' &&

					parser.buffer[parser.buffer_pos+1] == '.' &&

					parser.buffer[parser.buffer_pos+2] == '.')) &&

			is_blankz(parser.buffer, parser.buffer_pos+3) {

			yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",

				start_mark, "found unexpected document indicator")

			return false

		}

		// Check for EOF.

		if is_z(parser.buffer, parser.buffer_pos) {

			yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",

				start_mark, "found unexpected end of stream")

			return false

		}

		// Consume non-blank characters.

		leading_blanks := false

		for !is_blankz(parser.buffer, parser.buffer_pos) {

			if single && parser.buffer[parser.buffer_pos] == '\'' && parser.buffer[parser.buffer_pos+1] == '\'' {

				// Is is an escaped single quote.

				s = append(s, '\'')

				skip(parser)

				skip(parser)

			} else if single && parser.buffer[parser.buffer_pos] == '\'' {

				// It is a right single quote.

				break

			} else if !single && parser.buffer[parser.buffer_pos] == '"' {

				// It is a right double quote.

				break

			} else if !single && parser.buffer[parser.buffer_pos] == '\\' && is_break(parser.buffer, parser.buffer_pos+1) {

				// It is an escaped line break.

				if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {

					return false

				}

				skip(parser)

				skip_line(parser)

				leading_blanks = true

				break

			} else if !single && parser.buffer[parser.buffer_pos] == '\\' {

				// It is an escape sequence.

				code_length := 0

				// Check the escape character.

				switch parser.buffer[parser.buffer_pos+1] {

				case '0':

					s = append(s, 0)

				case 'a':

					s = append(s, '\x07')

				case 'b':

					s = append(s, '\x08')

				case 't', '\t':

					s = append(s, '\x09')

				case 'n':

					s = append(s, '\x0A')

				case 'v':

					s = append(s, '\x0B')

				case 'f':

					s = append(s, '\x0C')

				case 'r':

					s = append(s, '\x0D')

				case 'e':

					s = append(s, '\x1B')

				case ' ':

					s = append(s, '\x20')

				case '"':

					s = append(s, '"')

				case '\'':

					s = append(s, '\'')

				case '\\':

					s = append(s, '\\')

				case 'N': // NEL (#x85)

					s = append(s, '\xC2')

					s = append(s, '\x85')

				case '_': // #xA0

					s = append(s, '\xC2')

					s = append(s, '\xA0')

				case 'L': // LS (#x2028)

					s = append(s, '\xE2')

					s = append(s, '\x80')

					s = append(s, '\xA8')

				case 'P': // PS (#x2029)

					s = append(s, '\xE2')

					s = append(s, '\x80')

					s = append(s, '\xA9')

				case 'x':

					code_length = 2

				case 'u':

					code_length = 4

				case 'U':

					code_length = 8

				default:

					yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",

						start_mark, "found unknown escape character")

					return false

				}

				skip(parser)

				skip(parser)

				// Consume an arbitrary escape code.

				if code_length > 0 {

					var value int

					// Scan the character value.

					if parser.unread < code_length && !yaml_parser_update_buffer(parser, code_length) {

						return false

					}

					for k := 0; k < code_length; k++ {

						if !is_hex(parser.buffer, parser.buffer_pos+k) {

							yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",

								start_mark, "did not find expected hexdecimal number")

							return false

						}

						value = (value << 4) + as_hex(parser.buffer, parser.buffer_pos+k)

					}

					// Check the value and write the character.

					if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF {

						yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",

							start_mark, "found invalid Unicode character escape code")

						return false

					}

					if value <= 0x7F {

						s = append(s, byte(value))

					} else if value <= 0x7FF {

						s = append(s, byte(0xC0+(value>>6)))

						s = append(s, byte(0x80+(value&0x3F)))

					} else if value <= 0xFFFF {

						s = append(s, byte(0xE0+(value>>12)))

						s = append(s, byte(0x80+((value>>6)&0x3F)))

						s = append(s, byte(0x80+(value&0x3F)))

					} else {

						s = append(s, byte(0xF0+(value>>18)))

						s = append(s, byte(0x80+((value>>12)&0x3F)))

						s = append(s, byte(0x80+((value>>6)&0x3F)))

						s = append(s, byte(0x80+(value&0x3F)))

					}

					// Advance the pointer.

					for k := 0; k < code_length; k++ {

						skip(parser)

					}

				}

			} else {

				// It is a non-escaped non-blank character.

				s = read(parser, s)

			}

			if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

				return false

			}

		}

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		// Check if we are at the end of the scalar.

		if single {

			if parser.buffer[parser.buffer_pos] == '\'' {

				break

			}

		} else {

			if parser.buffer[parser.buffer_pos] == '"' {

				break

			}

		}

		// Consume blank characters.

		for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {

			if is_blank(parser.buffer, parser.buffer_pos) {

				// Consume a space or a tab character.

				if !leading_blanks {

					whitespaces = read(parser, whitespaces)

				} else {

					skip(parser)

				}

			} else {

				if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

					return false

				}

				// Check if it is a first line break.

				if !leading_blanks {

					whitespaces = whitespaces[:0]

					leading_break = read_line(parser, leading_break)

					leading_blanks = true

				} else {

					trailing_breaks = read_line(parser, trailing_breaks)

				}

			}

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

		}

		// Join the whitespaces or fold line breaks.

		if leading_blanks {

			// Do we need to fold line breaks?

			if len(leading_break) > 0 && leading_break[0] == '\n' {

				if len(trailing_breaks) == 0 {

					s = append(s, ' ')

				} else {

					s = append(s, trailing_breaks...)

				}

			} else {

				s = append(s, leading_break...)

				s = append(s, trailing_breaks...)

			}

			trailing_breaks = trailing_breaks[:0]

			leading_break = leading_break[:0]

		} else {

			s = append(s, whitespaces...)

			whitespaces = whitespaces[:0]

		}

	}

	// Eat the right quote.

	skip(parser)

	end_mark := parser.mark

	// Create a token.

	*token = yaml_token_t{

		typ: yaml_SCALAR_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,

		value: s,

		style: yaml_SINGLE_QUOTED_SCALAR_STYLE,
	}

	if !single {

		token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE

	}

	return true

}

// Scan a plain scalar.

func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) bool {

	var s, leading_break, trailing_breaks, whitespaces []byte

	var leading_blanks bool

	var indent = parser.indent + 1

	start_mark := parser.mark

	end_mark := parser.mark

	// Consume the content of the plain scalar.

	for {

		// Check for a document indicator.

		if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {

			return false

		}

		if parser.mark.column == 0 &&

			((parser.buffer[parser.buffer_pos+0] == '-' &&

				parser.buffer[parser.buffer_pos+1] == '-' &&

				parser.buffer[parser.buffer_pos+2] == '-') ||

				(parser.buffer[parser.buffer_pos+0] == '.' &&

					parser.buffer[parser.buffer_pos+1] == '.' &&

					parser.buffer[parser.buffer_pos+2] == '.')) &&

			is_blankz(parser.buffer, parser.buffer_pos+3) {

			break

		}

		// Check for a comment.

		if parser.buffer[parser.buffer_pos] == '#' {

			break

		}

		// Consume non-blank characters.

		for !is_blankz(parser.buffer, parser.buffer_pos) {

			// Check for indicators that may end a plain scalar.

			if (parser.buffer[parser.buffer_pos] == ':' && is_blankz(parser.buffer, parser.buffer_pos+1)) ||

				(parser.flow_level > 0 &&

					(parser.buffer[parser.buffer_pos] == ',' ||

						parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == '[' ||

						parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||

						parser.buffer[parser.buffer_pos] == '}')) {

				break

			}

			// Check if we need to join whitespaces and breaks.

			if leading_blanks || len(whitespaces) > 0 {

				if leading_blanks {

					// Do we need to fold line breaks?

					if leading_break[0] == '\n' {

						if len(trailing_breaks) == 0 {

							s = append(s, ' ')

						} else {

							s = append(s, trailing_breaks...)

						}

					} else {

						s = append(s, leading_break...)

						s = append(s, trailing_breaks...)

					}

					trailing_breaks = trailing_breaks[:0]

					leading_break = leading_break[:0]

					leading_blanks = false

				} else {

					s = append(s, whitespaces...)

					whitespaces = whitespaces[:0]

				}

			}

			// Copy the character.

			s = read(parser, s)

			end_mark = parser.mark

			if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

				return false

			}

		}

		// Is it the end?

		if !(is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos)) {

			break

		}

		// Consume blank characters.

		if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

			return false

		}

		for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {

			if is_blank(parser.buffer, parser.buffer_pos) {

				// Check for tab characters that abuse indentation.

				if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) {

					yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",

						start_mark, "found a tab character that violates indentation")

					return false

				}

				// Consume a space or a tab character.

				if !leading_blanks {

					whitespaces = read(parser, whitespaces)

				} else {

					skip(parser)

				}

			} else {

				if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

					return false

				}

				// Check if it is a first line break.

				if !leading_blanks {

					whitespaces = whitespaces[:0]

					leading_break = read_line(parser, leading_break)

					leading_blanks = true

				} else {

					trailing_breaks = read_line(parser, trailing_breaks)

				}

			}

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

		}

		// Check indentation level.

		if parser.flow_level == 0 && parser.mark.column < indent {

			break

		}

	}

	// Create a token.

	*token = yaml_token_t{

		typ: yaml_SCALAR_TOKEN,

		start_mark: start_mark,

		end_mark: end_mark,

		value: s,

		style: yaml_PLAIN_SCALAR_STYLE,
	}

	// Note that we change the 'simple_key_allowed' flag.

	if leading_blanks {

		parser.simple_key_allowed = true

	}

	return true

}

func yaml_parser_scan_line_comment(parser *yaml_parser_t, token_mark yaml_mark_t) bool {

	if parser.newlines > 0 {

		return true

	}

	var start_mark yaml_mark_t

	var text []byte

	for peek := 0; peek < 512; peek++ {

		if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {

			break

		}

		if is_blank(parser.buffer, parser.buffer_pos+peek) {

			continue

		}

		if parser.buffer[parser.buffer_pos+peek] == '#' {

			seen := parser.mark.index + peek

			for {

				if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

					return false

				}

				if is_breakz(parser.buffer, parser.buffer_pos) {

					if parser.mark.index >= seen {

						break

					}

					if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

						return false

					}

					skip_line(parser)

				} else if parser.mark.index >= seen {

					if len(text) == 0 {

						start_mark = parser.mark

					}

					text = read(parser, text)

				} else {

					skip(parser)

				}

			}

		}

		break

	}

	if len(text) > 0 {

		parser.comments = append(parser.comments, yaml_comment_t{

			token_mark: token_mark,

			start_mark: start_mark,

			line: text,
		})

	}

	return true

}

func yaml_parser_scan_comments(parser *yaml_parser_t, scan_mark yaml_mark_t) bool {

	token := parser.tokens[len(parser.tokens)-1]

	if token.typ == yaml_FLOW_ENTRY_TOKEN && len(parser.tokens) > 1 {

		token = parser.tokens[len(parser.tokens)-2]

	}

	var token_mark = token.start_mark

	var start_mark yaml_mark_t

	var next_indent = parser.indent

	if next_indent < 0 {

		next_indent = 0

	}

	var recent_empty = false

	var first_empty = parser.newlines <= 1

	var line = parser.mark.line

	var column = parser.mark.column

	var text []byte

	// The foot line is the place where a comment must start to

	// still be considered as a foot of the prior content.

	// If there's some content in the currently parsed line, then

	// the foot is the line below it.

	var foot_line = -1

	if scan_mark.line > 0 {

		foot_line = parser.mark.line - parser.newlines + 1

		if parser.newlines == 0 && parser.mark.column > 1 {

			foot_line++

		}

	}

	var peek = 0

	for ; peek < 512; peek++ {

		if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {

			break

		}

		column++

		if is_blank(parser.buffer, parser.buffer_pos+peek) {

			continue

		}

		c := parser.buffer[parser.buffer_pos+peek]

		var close_flow = parser.flow_level > 0 && (c == ']' || c == '}')

		if close_flow || is_breakz(parser.buffer, parser.buffer_pos+peek) {

			// Got line break or terminator.

			if close_flow || !recent_empty {

				if close_flow || first_empty && (start_mark.line == foot_line && token.typ != yaml_VALUE_TOKEN || start_mark.column-1 < next_indent) {

					// This is the first empty line and there were no empty lines before,

					// so this initial part of the comment is a foot of the prior token

					// instead of being a head for the following one. Split it up.

					// Alternatively, this might also be the last comment inside a flow

					// scope, so it must be a footer.

					if len(text) > 0 {

						if start_mark.column-1 < next_indent {

							// If dedented it's unrelated to the prior token.

							token_mark = start_mark

						}

						parser.comments = append(parser.comments, yaml_comment_t{

							scan_mark: scan_mark,

							token_mark: token_mark,

							start_mark: start_mark,

							end_mark: yaml_mark_t{parser.mark.index + peek, line, column},

							foot: text,
						})

						scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}

						token_mark = scan_mark

						text = nil

					}

				} else {

					if len(text) > 0 && parser.buffer[parser.buffer_pos+peek] != 0 {

						text = append(text, '\n')

					}

				}

			}

			if !is_break(parser.buffer, parser.buffer_pos+peek) {

				break

			}

			first_empty = false

			recent_empty = true

			column = 0

			line++

			continue

		}

		if len(text) > 0 && (close_flow || column-1 < next_indent && column != start_mark.column) {

			// The comment at the different indentation is a foot of the

			// preceding data rather than a head of the upcoming one.

			parser.comments = append(parser.comments, yaml_comment_t{

				scan_mark: scan_mark,

				token_mark: token_mark,

				start_mark: start_mark,

				end_mark: yaml_mark_t{parser.mark.index + peek, line, column},

				foot: text,
			})

			scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}

			token_mark = scan_mark

			text = nil

		}

		if parser.buffer[parser.buffer_pos+peek] != '#' {

			break

		}

		if len(text) == 0 {

			start_mark = yaml_mark_t{parser.mark.index + peek, line, column}

		} else {

			text = append(text, '\n')

		}

		recent_empty = false

		// Consume until after the consumed comment line.

		seen := parser.mark.index + peek

		for {

			if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {

				return false

			}

			if is_breakz(parser.buffer, parser.buffer_pos) {

				if parser.mark.index >= seen {

					break

				}

				if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {

					return false

				}

				skip_line(parser)

			} else if parser.mark.index >= seen {

				text = read(parser, text)

			} else {

				skip(parser)

			}

		}

		peek = 0

		column = 0

		line = parser.mark.line

		next_indent = parser.indent

		if next_indent < 0 {

			next_indent = 0

		}

	}

	if len(text) > 0 {

		parser.comments = append(parser.comments, yaml_comment_t{

			scan_mark: scan_mark,

			token_mark: start_mark,

			start_mark: start_mark,

			end_mark: yaml_mark_t{parser.mark.index + peek - 1, line, column},

			head: text,
		})

	}

	return true

}