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) {

	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

	} 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])

	}

}

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

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

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

	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 {

		// Check if we really need to fetch more tokens.

		need_more_tokens := false

		if parser.tokens_head == len(parser.tokens) {

			// Queue is empty.

			need_more_tokens = true

		} else {

			// Check if any potential simple key may occupy the head position.

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

				simple_key := &parser.simple_keys[i]

				if simple_key.token_number < parser.tokens_parsed {

					break

				}

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

					return false

				} else if valid && simple_key.token_number == parser.tokens_parsed {

					need_more_tokens = true

					break

				}

			}

		}

		// We are finished.

		if !need_more_tokens {

			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) 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)

	}

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

	if !yaml_parser_scan_to_next_token(parser) {

		return false

	}

	// Check the indentation level against the current column.

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

		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)

	}

	// 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] 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,