gopkg.in/yaml.v3/emitterc.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"
)

// Flush the buffer if needed.
func flush(emitter *yaml_emitter_t) bool {
        if emitter.buffer_pos+5 >= len(emitter.buffer) {
                return yaml_emitter_flush(emitter)
        }
        return true
}

// Put a character to the output buffer.
func put(emitter *yaml_emitter_t, value byte) bool {
        if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
                return false
        }
        emitter.buffer[emitter.buffer_pos] = value
        emitter.buffer_pos++
        emitter.column++
        return true
}

// Put a line break to the output buffer.
func put_break(emitter *yaml_emitter_t) bool {
        if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
                return false
        }
        switch emitter.line_break {
        case yaml_CR_BREAK:
                emitter.buffer[emitter.buffer_pos] = '\r'
                emitter.buffer_pos += 1
        case yaml_LN_BREAK:
                emitter.buffer[emitter.buffer_pos] = '\n'
                emitter.buffer_pos += 1
        case yaml_CRLN_BREAK:
                emitter.buffer[emitter.buffer_pos+0] = '\r'
                emitter.buffer[emitter.buffer_pos+1] = '\n'
                emitter.buffer_pos += 2
        default:
                panic("unknown line break setting")
        }
        if emitter.column == 0 {
                emitter.space_above = true
        }
        emitter.column = 0
        emitter.line++
        // [Go] Do this here and below and drop from everywhere else (see commented lines).
        emitter.indention = true
        return true
}

// Copy a character from a string into buffer.
func write(emitter *yaml_emitter_t, s []byte, i *int) bool {
        if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
                return false
        }
        p := emitter.buffer_pos
        w := width(s[*i])
        switch w {
        case 4:
                emitter.buffer[p+3] = s[*i+3]
                fallthrough
        case 3:
                emitter.buffer[p+2] = s[*i+2]
                fallthrough
        case 2:
                emitter.buffer[p+1] = s[*i+1]
                fallthrough
        case 1:
                emitter.buffer[p+0] = s[*i+0]
        default:
                panic("unknown character width")
        }
        emitter.column++
        emitter.buffer_pos += w
        *i += w
        return true
}

// Write a whole string into buffer.
func write_all(emitter *yaml_emitter_t, s []byte) bool {
        for i := 0; i < len(s); {
                if !write(emitter, s, &i) {
                        return false
                }
        }
        return true
}

// Copy a line break character from a string into buffer.
func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
        if s[*i] == '\n' {
                if !put_break(emitter) {
                        return false
                }
                *i++
        } else {
                if !write(emitter, s, i) {
                        return false
                }
                if emitter.column == 0 {
                        emitter.space_above = true
                }
                emitter.column = 0
                emitter.line++
                // [Go] Do this here and above and drop from everywhere else (see commented lines).
                emitter.indention = true
        }
        return true
}

// Set an emitter error and return false.
func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
        emitter.error = yaml_EMITTER_ERROR
        emitter.problem = problem
        return false
}

// Emit an event.
func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        emitter.events = append(emitter.events, *event)
        for !yaml_emitter_need_more_events(emitter) {
                event := &emitter.events[emitter.events_head]
                if !yaml_emitter_analyze_event(emitter, event) {
                        return false
                }
                if !yaml_emitter_state_machine(emitter, event) {
                        return false
                }
                yaml_event_delete(event)
                emitter.events_head++
        }
        return true
}

// Check if we need to accumulate more events before emitting.
//
// We accumulate extra
//  - 1 event for DOCUMENT-START
//  - 2 events for SEQUENCE-START
//  - 3 events for MAPPING-START
//
func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
        if emitter.events_head == len(emitter.events) {
                return true
        }
        var accumulate int
        switch emitter.events[emitter.events_head].typ {
        case yaml_DOCUMENT_START_EVENT:
                accumulate = 1
                break
        case yaml_SEQUENCE_START_EVENT:
                accumulate = 2
                break
        case yaml_MAPPING_START_EVENT:
                accumulate = 3
                break
        default:
                return false
        }
        if len(emitter.events)-emitter.events_head > accumulate {
                return false
        }
        var level int
        for i := emitter.events_head; i < len(emitter.events); i++ {
                switch emitter.events[i].typ {
                case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
                        level++
                case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
                        level--
                }
                if level == 0 {
                        return false
                }
        }
        return true
}

// Append a directive to the directives stack.
func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {
        for i := 0; i < len(emitter.tag_directives); i++ {
                if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
                        if allow_duplicates {
                                return true
                        }
                        return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
                }
        }

        // [Go] Do we actually need to copy this given garbage collection
        // and the lack of deallocating destructors?
        tag_copy := yaml_tag_directive_t{
                handle: make([]byte, len(value.handle)),
                prefix: make([]byte, len(value.prefix)),
        }
        copy(tag_copy.handle, value.handle)
        copy(tag_copy.prefix, value.prefix)
        emitter.tag_directives = append(emitter.tag_directives, tag_copy)
        return true
}

// Increase the indentation level.
func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
        emitter.indents = append(emitter.indents, emitter.indent)
        if emitter.indent < 0 {
                if flow {
                        emitter.indent = emitter.best_indent
                } else {
                        emitter.indent = 0
                }
        } else if !indentless {
                // [Go] This was changed so that indentations are more regular.
                if emitter.states[len(emitter.states)-1] == yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE {
                        // The first indent inside a sequence will just skip the "- " indicator.
                        emitter.indent += 2
                } else {
                        // Everything else aligns to the chosen indentation.
                        emitter.indent = emitter.best_indent*((emitter.indent+emitter.best_indent)/emitter.best_indent)
                }
        }
        return true
}

// State dispatcher.
func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        switch emitter.state {
        default:
        case yaml_EMIT_STREAM_START_STATE:
                return yaml_emitter_emit_stream_start(emitter, event)

        case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
                return yaml_emitter_emit_document_start(emitter, event, true)

        case yaml_EMIT_DOCUMENT_START_STATE:
                return yaml_emitter_emit_document_start(emitter, event, false)

        case yaml_EMIT_DOCUMENT_CONTENT_STATE:
                return yaml_emitter_emit_document_content(emitter, event)

        case yaml_EMIT_DOCUMENT_END_STATE:
                return yaml_emitter_emit_document_end(emitter, event)

        case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
                return yaml_emitter_emit_flow_sequence_item(emitter, event, true, false)

        case yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE:
                return yaml_emitter_emit_flow_sequence_item(emitter, event, false, true)

        case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
                return yaml_emitter_emit_flow_sequence_item(emitter, event, false, false)

        case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
                return yaml_emitter_emit_flow_mapping_key(emitter, event, true, false)

        case yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE:
                return yaml_emitter_emit_flow_mapping_key(emitter, event, false, true)

        case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
                return yaml_emitter_emit_flow_mapping_key(emitter, event, false, false)

        case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
                return yaml_emitter_emit_flow_mapping_value(emitter, event, true)

        case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
                return yaml_emitter_emit_flow_mapping_value(emitter, event, false)

        case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
                return yaml_emitter_emit_block_sequence_item(emitter, event, true)

        case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
                return yaml_emitter_emit_block_sequence_item(emitter, event, false)

        case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
                return yaml_emitter_emit_block_mapping_key(emitter, event, true)

        case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
                return yaml_emitter_emit_block_mapping_key(emitter, event, false)

        case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
                return yaml_emitter_emit_block_mapping_value(emitter, event, true)

        case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
                return yaml_emitter_emit_block_mapping_value(emitter, event, false)

        case yaml_EMIT_END_STATE:
                return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
        }
        panic("invalid emitter state")
}

// Expect STREAM-START.
func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        if event.typ != yaml_STREAM_START_EVENT {
                return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
        }
        if emitter.encoding == yaml_ANY_ENCODING {
                emitter.encoding = event.encoding
                if emitter.encoding == yaml_ANY_ENCODING {
                        emitter.encoding = yaml_UTF8_ENCODING
                }
        }
        if emitter.best_indent < 2 || emitter.best_indent > 9 {
                emitter.best_indent = 2
        }
        if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
                emitter.best_width = 80
        }
        if emitter.best_width < 0 {
                emitter.best_width = 1<<31 - 1
        }
        if emitter.line_break == yaml_ANY_BREAK {
                emitter.line_break = yaml_LN_BREAK
        }

        emitter.indent = -1
        emitter.line = 0
        emitter.column = 0
        emitter.whitespace = true
        emitter.indention = true
        emitter.space_above = true
        emitter.foot_indent = -1

        if emitter.encoding != yaml_UTF8_ENCODING {
                if !yaml_emitter_write_bom(emitter) {
                        return false
                }
        }
        emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
        return true
}

// Expect DOCUMENT-START or STREAM-END.
func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {

        if event.typ == yaml_DOCUMENT_START_EVENT {

                if event.version_directive != nil {
                        if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
                                return false
                        }
                }

                for i := 0; i < len(event.tag_directives); i++ {
                        tag_directive := &event.tag_directives[i]
                        if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
                                return false
                        }
                        if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
                                return false
                        }
                }

                for i := 0; i < len(default_tag_directives); i++ {
                        tag_directive := &default_tag_directives[i]
                        if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
                                return false
                        }
                }

                implicit := event.implicit
                if !first || emitter.canonical {
                        implicit = false
                }

                if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {
                        if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
                                return false
                        }
                        if !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                }

                if event.version_directive != nil {
                        implicit = false
                        if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
                                return false
                        }
                        if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
                                return false
                        }
                        if !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                }

                if len(event.tag_directives) > 0 {
                        implicit = false
                        for i := 0; i < len(event.tag_directives); i++ {
                                tag_directive := &event.tag_directives[i]
                                if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
                                        return false
                                }
                                if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
                                        return false
                                }
                                if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
                                        return false
                                }
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                        }
                }

                if yaml_emitter_check_empty_document(emitter) {
                        implicit = false
                }
                if !implicit {
                        if !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                        if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
                                return false
                        }
                        if emitter.canonical || true {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                        }
                }

                if len(emitter.head_comment) > 0 {
                        if !yaml_emitter_process_head_comment(emitter) {
                                return false
                        }
                        if !put_break(emitter) {
                                return false
                        }
                }

                emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
                return true
        }

        if event.typ == yaml_STREAM_END_EVENT {
                if emitter.open_ended {
                        if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
                                return false
                        }
                        if !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                }
                if !yaml_emitter_flush(emitter) {
                        return false
                }
                emitter.state = yaml_EMIT_END_STATE
                return true
        }

        return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
}

// Expect the root node.
func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)

        if !yaml_emitter_process_head_comment(emitter) {
                return false
        }
        if !yaml_emitter_emit_node(emitter, event, true, false, false, false) {
                return false
        }
        if !yaml_emitter_process_line_comment(emitter) {
                return false
        }
        if !yaml_emitter_process_foot_comment(emitter) {
                return false
        }
        return true
}

// Expect DOCUMENT-END.
func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        if event.typ != yaml_DOCUMENT_END_EVENT {
                return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
        }
        // [Go] Force document foot separation.
        emitter.foot_indent = 0
        if !yaml_emitter_process_foot_comment(emitter) {
                return false
        }
        emitter.foot_indent = -1
        if !yaml_emitter_write_indent(emitter) {
                return false
        }
        if !event.implicit {
                // [Go] Allocate the slice elsewhere.
                if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
                        return false
                }
                if !yaml_emitter_write_indent(emitter) {
                        return false
                }
        }
        if !yaml_emitter_flush(emitter) {
                return false
        }
        emitter.state = yaml_EMIT_DOCUMENT_START_STATE
        emitter.tag_directives = emitter.tag_directives[:0]
        return true
}

// Expect a flow item node.
func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
        if first {
                if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
                        return false
                }
                if !yaml_emitter_increase_indent(emitter, true, false) {
                        return false
                }
                emitter.flow_level++
        }

        if event.typ == yaml_SEQUENCE_END_EVENT {
                if emitter.canonical && !first && !trail {
                        if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
                                return false
                        }
                }
                emitter.flow_level--
                emitter.indent = emitter.indents[len(emitter.indents)-1]
                emitter.indents = emitter.indents[:len(emitter.indents)-1]
                if emitter.column == 0 || emitter.canonical && !first {
                        if !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                }
                if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
                        return false
                }
                if !yaml_emitter_process_line_comment(emitter) {
                        return false
                }
                if !yaml_emitter_process_foot_comment(emitter) {
                        return false
                }
                emitter.state = emitter.states[len(emitter.states)-1]
                emitter.states = emitter.states[:len(emitter.states)-1]

                return true
        }

        if !first && !trail {
                if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
                        return false
                }
        }

        if !yaml_emitter_process_head_comment(emitter) {
                return false
        }
        if emitter.column == 0 {
                if !yaml_emitter_write_indent(emitter) {
                        return false
                }
        }

        if emitter.canonical || emitter.column > emitter.best_width {
                if !yaml_emitter_write_indent(emitter) {
                        return false
                }
        }
        if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
                emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE)
        } else {
                emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
        }
        if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
                return false
        }
        if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
                if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
                        return false
                }
        }
        if !yaml_emitter_process_line_comment(emitter) {
                return false
        }
        if !yaml_emitter_process_foot_comment(emitter) {
                return false
        }
        return true
}

// Expect a flow key node.
func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
        if first {
                if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
                        return false
                }
                if !yaml_emitter_increase_indent(emitter, true, false) {
                        return false
                }
                emitter.flow_level++
        }

        if event.typ == yaml_MAPPING_END_EVENT {
                if (emitter.canonical || len(emitter.head_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0) && !first && !trail {
                        if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
                                return false
                        }
                }
                if !yaml_emitter_process_head_comment(emitter) {
                        return false
                }
                emitter.flow_level--
                emitter.indent = emitter.indents[len(emitter.indents)-1]
                emitter.indents = emitter.indents[:len(emitter.indents)-1]
                if emitter.canonical && !first {
                        if !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                }
                if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
                        return false
                }
                if !yaml_emitter_process_line_comment(emitter) {
                        return false
                }
                if !yaml_emitter_process_foot_comment(emitter) {
                        return false
                }
                emitter.state = emitter.states[len(emitter.states)-1]
                emitter.states = emitter.states[:len(emitter.states)-1]
                return true
        }

        if !first && !trail {
                if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
                        return false
                }
        }

        if !yaml_emitter_process_head_comment(emitter) {
                return false
        }

        if emitter.column == 0 {
                if !yaml_emitter_write_indent(emitter) {
                        return false
                }
        }

        if emitter.canonical || emitter.column > emitter.best_width {
                if !yaml_emitter_write_indent(emitter) {
                        return false
                }
        }

        if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
                emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
                return yaml_emitter_emit_node(emitter, event, false, false, true, true)
        }
        if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
                return false
        }
        emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
        return yaml_emitter_emit_node(emitter, event, false, false, true, false)
}

// Expect a flow value node.
func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
        if simple {
                if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
                        return false
                }
        } else {
                if emitter.canonical || emitter.column > emitter.best_width {
                        if !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                }
                if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
                        return false
                }
        }
        if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
                emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE)
        } else {
                emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
        }
        if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
                return false
        }
        if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
                if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
                        return false
                }
        }
        if !yaml_emitter_process_line_comment(emitter) {
                return false
        }
        if !yaml_emitter_process_foot_comment(emitter) {
                return false
        }
        return true
}

// Expect a block item node.
func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
        if first {
                if !yaml_emitter_increase_indent(emitter, false, false) {
                        return false
                }
        }
        if event.typ == yaml_SEQUENCE_END_EVENT {
                emitter.indent = emitter.indents[len(emitter.indents)-1]
                emitter.indents = emitter.indents[:len(emitter.indents)-1]
                emitter.state = emitter.states[len(emitter.states)-1]
                emitter.states = emitter.states[:len(emitter.states)-1]
                return true
        }
        if !yaml_emitter_process_head_comment(emitter) {
                return false
        }
        if !yaml_emitter_write_indent(emitter) {
                return false
        }
        if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
                return false
        }
        emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
        if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
                return false
        }
        if !yaml_emitter_process_line_comment(emitter) {
                return false
        }
        if !yaml_emitter_process_foot_comment(emitter) {
                return false
        }
        return true
}

// Expect a block key node.
func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
        if first {
                if !yaml_emitter_increase_indent(emitter, false, false) {
                        return false
                }
        }
        if !yaml_emitter_process_head_comment(emitter) {
                return false
        }
        if event.typ == yaml_MAPPING_END_EVENT {
                emitter.indent = emitter.indents[len(emitter.indents)-1]
                emitter.indents = emitter.indents[:len(emitter.indents)-1]
                emitter.state = emitter.states[len(emitter.states)-1]
                emitter.states = emitter.states[:len(emitter.states)-1]
                return true
        }
        if !yaml_emitter_write_indent(emitter) {
                return false
        }
        if len(emitter.line_comment) > 0 {
                // [Go] A line comment was provided for the key. That's unusual as the
                //      scanner associates line comments with the value. Either way,
                //      save the line comment and render it appropriately later.
                emitter.key_line_comment = emitter.line_comment
                emitter.line_comment = nil
        }
        if yaml_emitter_check_simple_key(emitter) {
                emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
                return yaml_emitter_emit_node(emitter, event, false, false, true, true)
        }
        if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
                return false
        }
        emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
        return yaml_emitter_emit_node(emitter, event, false, false, true, false)
}

// Expect a block value node.
func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
        if simple {
                if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
                        return false
                }
        } else {
                if !yaml_emitter_write_indent(emitter) {
                        return false
                }
                if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
                        return false
                }
        }
        if len(emitter.key_line_comment) > 0 {
                // [Go] Line comments are generally associated with the value, but when there's
                //      no value on the same line as a mapping key they end up attached to the
                //      key itself.
                if event.typ == yaml_SCALAR_EVENT {
                        if len(emitter.line_comment) == 0 {
                                // A scalar is coming and it has no line comments by itself yet,
                                // so just let it handle the line comment as usual. If it has a
                                // line comment, we can't have both so the one from the key is lost.
                                emitter.line_comment = emitter.key_line_comment
                                emitter.key_line_comment = nil
                        }
                } else if event.sequence_style() != yaml_FLOW_SEQUENCE_STYLE && (event.typ == yaml_MAPPING_START_EVENT || event.typ == yaml_SEQUENCE_START_EVENT) {
                        // An indented block follows, so write the comment right now.
                        emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
                        if !yaml_emitter_process_line_comment(emitter) {
                                return false
                        }
                        emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
                }
        }
        emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
        if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
                return false
        }
        if !yaml_emitter_process_line_comment(emitter) {
                return false
        }
        if !yaml_emitter_process_foot_comment(emitter) {
                return false
        }
        return true
}

func yaml_emitter_silent_nil_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        return event.typ == yaml_SCALAR_EVENT && event.implicit && !emitter.canonical && len(emitter.scalar_data.value) == 0
}

// Expect a node.
func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,
        root bool, sequence bool, mapping bool, simple_key bool) bool {

        emitter.root_context = root
        emitter.sequence_context = sequence
        emitter.mapping_context = mapping
        emitter.simple_key_context = simple_key

        switch event.typ {
        case yaml_ALIAS_EVENT:
                return yaml_emitter_emit_alias(emitter, event)
        case yaml_SCALAR_EVENT:
                return yaml_emitter_emit_scalar(emitter, event)
        case yaml_SEQUENCE_START_EVENT:
                return yaml_emitter_emit_sequence_start(emitter, event)
        case yaml_MAPPING_START_EVENT:
                return yaml_emitter_emit_mapping_start(emitter, event)
        default:
                return yaml_emitter_set_emitter_error(emitter,
                        fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ))
        }
}

// Expect ALIAS.
func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        if !yaml_emitter_process_anchor(emitter) {
                return false
        }
        emitter.state = emitter.states[len(emitter.states)-1]
        emitter.states = emitter.states[:len(emitter.states)-1]
        return true
}

// Expect SCALAR.
func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        if !yaml_emitter_select_scalar_style(emitter, event) {
                return false
        }
        if !yaml_emitter_process_anchor(emitter) {
                return false
        }
        if !yaml_emitter_process_tag(emitter) {
                return false
        }
        if !yaml_emitter_increase_indent(emitter, true, false) {
                return false
        }
        if !yaml_emitter_process_scalar(emitter) {
                return false
        }
        emitter.indent = emitter.indents[len(emitter.indents)-1]
        emitter.indents = emitter.indents[:len(emitter.indents)-1]
        emitter.state = emitter.states[len(emitter.states)-1]
        emitter.states = emitter.states[:len(emitter.states)-1]
        return true
}

// Expect SEQUENCE-START.
func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        if !yaml_emitter_process_anchor(emitter) {
                return false
        }
        if !yaml_emitter_process_tag(emitter) {
                return false
        }
        if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||
                yaml_emitter_check_empty_sequence(emitter) {
                emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
        } else {
                emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
        }
        return true
}

// Expect MAPPING-START.
func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
        if !yaml_emitter_process_anchor(emitter) {
                return false
        }
        if !yaml_emitter_process_tag(emitter) {
                return false
        }
        if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||
                yaml_emitter_check_empty_mapping(emitter) {
                emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
        } else {
                emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
        }
        return true
}

// Check if the document content is an empty scalar.
func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
        return false // [Go] Huh?
}

// Check if the next events represent an empty sequence.
func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
        if len(emitter.events)-emitter.events_head < 2 {
                return false
        }
        return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
                emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
}

// Check if the next events represent an empty mapping.
func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
        if len(emitter.events)-emitter.events_head < 2 {
                return false
        }
        return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
                emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
}

// Check if the next node can be expressed as a simple key.
func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
        length := 0
        switch emitter.events[emitter.events_head].typ {
        case yaml_ALIAS_EVENT:
                length += len(emitter.anchor_data.anchor)
        case yaml_SCALAR_EVENT:
                if emitter.scalar_data.multiline {
                        return false
                }
                length += len(emitter.anchor_data.anchor) +
                        len(emitter.tag_data.handle) +
                        len(emitter.tag_data.suffix) +
                        len(emitter.scalar_data.value)
        case yaml_SEQUENCE_START_EVENT:
                if !yaml_emitter_check_empty_sequence(emitter) {
                        return false
                }
                length += len(emitter.anchor_data.anchor) +
                        len(emitter.tag_data.handle) +
                        len(emitter.tag_data.suffix)
        case yaml_MAPPING_START_EVENT:
                if !yaml_emitter_check_empty_mapping(emitter) {
                        return false
                }
                length += len(emitter.anchor_data.anchor) +
                        len(emitter.tag_data.handle) +
                        len(emitter.tag_data.suffix)
        default:
                return false
        }
        return length <= 128
}

// Determine an acceptable scalar style.
func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {

        no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
        if no_tag && !event.implicit && !event.quoted_implicit {
                return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
        }

        style := event.scalar_style()
        if style == yaml_ANY_SCALAR_STYLE {
                style = yaml_PLAIN_SCALAR_STYLE
        }
        if emitter.canonical {
                style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
        }
        if emitter.simple_key_context && emitter.scalar_data.multiline {
                style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
        }

        if style == yaml_PLAIN_SCALAR_STYLE {
                if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||
                        emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
                        style = yaml_SINGLE_QUOTED_SCALAR_STYLE
                }
                if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {
                        style = yaml_SINGLE_QUOTED_SCALAR_STYLE
                }
                if no_tag && !event.implicit {
                        style = yaml_SINGLE_QUOTED_SCALAR_STYLE
                }
        }
        if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
                if !emitter.scalar_data.single_quoted_allowed {
                        style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
                }
        }
        if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {
                if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {
                        style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
                }
        }

        if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
                emitter.tag_data.handle = []byte{'!'}
        }
        emitter.scalar_data.style = style
        return true
}

// Write an anchor.
func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
        if emitter.anchor_data.anchor == nil {
                return true
        }
        c := []byte{'&'}
        if emitter.anchor_data.alias {
                c[0] = '*'
        }
        if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
                return false
        }
        return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
}

// Write a tag.
func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
        if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
                return true
        }
        if len(emitter.tag_data.handle) > 0 {
                if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
                        return false
                }
                if len(emitter.tag_data.suffix) > 0 {
                        if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
                                return false
                        }
                }
        } else {
                // [Go] Allocate these slices elsewhere.
                if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
                        return false
                }
                if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
                        return false
                }
                if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
                        return false
                }
        }
        return true
}

// Write a scalar.
func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
        switch emitter.scalar_data.style {
        case yaml_PLAIN_SCALAR_STYLE:
                return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)

        case yaml_SINGLE_QUOTED_SCALAR_STYLE:
                return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)

        case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
                return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)

        case yaml_LITERAL_SCALAR_STYLE:
                return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)

        case yaml_FOLDED_SCALAR_STYLE:
                return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
        }
        panic("unknown scalar style")
}

// Write a head comment.
func yaml_emitter_process_head_comment(emitter *yaml_emitter_t) bool {
        if len(emitter.tail_comment) > 0 {
                if !yaml_emitter_write_indent(emitter) {
                        return false
                }
                if !yaml_emitter_write_comment(emitter, emitter.tail_comment) {
                        return false
                }
                emitter.tail_comment = emitter.tail_comment[:0]
                emitter.foot_indent = emitter.indent
                if emitter.foot_indent < 0 {
                        emitter.foot_indent = 0
                }
        }

        if len(emitter.head_comment) == 0 {
                return true
        }
        if !yaml_emitter_write_indent(emitter) {
                return false
        }
        if !yaml_emitter_write_comment(emitter, emitter.head_comment) {
                return false
        }
        emitter.head_comment = emitter.head_comment[:0]
        return true
}

// Write an line comment.
func yaml_emitter_process_line_comment(emitter *yaml_emitter_t) bool {
        if len(emitter.line_comment) == 0 {
                return true
        }
        if !emitter.whitespace {
                if !put(emitter, ' ') {
                        return false
                }
        }
        if !yaml_emitter_write_comment(emitter, emitter.line_comment) {
                return false
        }
        emitter.line_comment = emitter.line_comment[:0]
        return true
}

// Write a foot comment.
func yaml_emitter_process_foot_comment(emitter *yaml_emitter_t) bool {
        if len(emitter.foot_comment) == 0 {
                return true
        }
        if !yaml_emitter_write_indent(emitter) {
                return false
        }
        if !yaml_emitter_write_comment(emitter, emitter.foot_comment) {
                return false
        }
        emitter.foot_comment = emitter.foot_comment[:0]
        emitter.foot_indent = emitter.indent
        if emitter.foot_indent < 0 {
                emitter.foot_indent = 0
        }
        return true
}

// Check if a %YAML directive is valid.
func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
        if version_directive.major != 1 || version_directive.minor != 1 {
                return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
        }
        return true
}

// Check if a %TAG directive is valid.
func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool {
        handle := tag_directive.handle
        prefix := tag_directive.prefix
        if len(handle) == 0 {
                return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
        }
        if handle[0] != '!' {
                return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
        }
        if handle[len(handle)-1] != '!' {
                return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
        }
        for i := 1; i < len(handle)-1; i += width(handle[i]) {
                if !is_alpha(handle, i) {
                        return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
                }
        }
        if len(prefix) == 0 {
                return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
        }
        return true
}

// Check if an anchor is valid.
func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
        if len(anchor) == 0 {
                problem := "anchor value must not be empty"
                if alias {
                        problem = "alias value must not be empty"
                }
                return yaml_emitter_set_emitter_error(emitter, problem)
        }
        for i := 0; i < len(anchor); i += width(anchor[i]) {
                if !is_alpha(anchor, i) {
                        problem := "anchor value must contain alphanumerical characters only"
                        if alias {
                                problem = "alias value must contain alphanumerical characters only"
                        }
                        return yaml_emitter_set_emitter_error(emitter, problem)
                }
        }
        emitter.anchor_data.anchor = anchor
        emitter.anchor_data.alias = alias
        return true
}

// Check if a tag is valid.
func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
        if len(tag) == 0 {
                return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
        }
        for i := 0; i < len(emitter.tag_directives); i++ {
                tag_directive := &emitter.tag_directives[i]
                if bytes.HasPrefix(tag, tag_directive.prefix) {
                        emitter.tag_data.handle = tag_directive.handle
                        emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
                        return true
                }
        }
        emitter.tag_data.suffix = tag
        return true
}

// Check if a scalar is valid.
func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
        var (
                block_indicators   = false
                flow_indicators    = false
                line_breaks        = false
                special_characters = false
                tab_characters     = false

                leading_space  = false
                leading_break  = false
                trailing_space = false
                trailing_break = false
                break_space    = false
                space_break    = false

                preceded_by_whitespace = false
                followed_by_whitespace = false
                previous_space         = false
                previous_break         = false
        )

        emitter.scalar_data.value = value

        if len(value) == 0 {
                emitter.scalar_data.multiline = false
                emitter.scalar_data.flow_plain_allowed = false
                emitter.scalar_data.block_plain_allowed = true
                emitter.scalar_data.single_quoted_allowed = true
                emitter.scalar_data.block_allowed = false
                return true
        }

        if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
                block_indicators = true
                flow_indicators = true
        }

        preceded_by_whitespace = true
        for i, w := 0, 0; i < len(value); i += w {
                w = width(value[i])
                followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)

                if i == 0 {
                        switch value[i] {
                        case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
                                flow_indicators = true
                                block_indicators = true
                        case '?', ':':
                                flow_indicators = true
                                if followed_by_whitespace {
                                        block_indicators = true
                                }
                        case '-':
                                if followed_by_whitespace {
                                        flow_indicators = true
                                        block_indicators = true
                                }
                        }
                } else {
                        switch value[i] {
                        case ',', '?', '[', ']', '{', '}':
                                flow_indicators = true
                        case ':':
                                flow_indicators = true
                                if followed_by_whitespace {
                                        block_indicators = true
                                }
                        case '#':
                                if preceded_by_whitespace {
                                        flow_indicators = true
                                        block_indicators = true
                                }
                        }
                }

                if value[i] == '\t' {
                        tab_characters = true
                } else if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
                        special_characters = true
                }
                if is_space(value, i) {
                        if i == 0 {
                                leading_space = true
                        }
                        if i+width(value[i]) == len(value) {
                                trailing_space = true
                        }
                        if previous_break {
                                break_space = true
                        }
                        previous_space = true
                        previous_break = false
                } else if is_break(value, i) {
                        line_breaks = true
                        if i == 0 {
                                leading_break = true
                        }
                        if i+width(value[i]) == len(value) {
                                trailing_break = true
                        }
                        if previous_space {
                                space_break = true
                        }
                        previous_space = false
                        previous_break = true
                } else {
                        previous_space = false
                        previous_break = false
                }

                // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
                preceded_by_whitespace = is_blankz(value, i)
        }

        emitter.scalar_data.multiline = line_breaks
        emitter.scalar_data.flow_plain_allowed = true
        emitter.scalar_data.block_plain_allowed = true
        emitter.scalar_data.single_quoted_allowed = true
        emitter.scalar_data.block_allowed = true

        if leading_space || leading_break || trailing_space || trailing_break {
                emitter.scalar_data.flow_plain_allowed = false
                emitter.scalar_data.block_plain_allowed = false
        }
        if trailing_space {
                emitter.scalar_data.block_allowed = false
        }
        if break_space {
                emitter.scalar_data.flow_plain_allowed = false
                emitter.scalar_data.block_plain_allowed = false
                emitter.scalar_data.single_quoted_allowed = false
        }
        if space_break || tab_characters || special_characters {
                emitter.scalar_data.flow_plain_allowed = false
                emitter.scalar_data.block_plain_allowed = false
                emitter.scalar_data.single_quoted_allowed = false
        }
        if space_break || special_characters {
                emitter.scalar_data.block_allowed = false
        }
        if line_breaks {
                emitter.scalar_data.flow_plain_allowed = false
                emitter.scalar_data.block_plain_allowed = false
        }
        if flow_indicators {
                emitter.scalar_data.flow_plain_allowed = false
        }
        if block_indicators {
                emitter.scalar_data.block_plain_allowed = false
        }
        return true
}

// Check if the event data is valid.
func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {

        emitter.anchor_data.anchor = nil
        emitter.tag_data.handle = nil
        emitter.tag_data.suffix = nil
        emitter.scalar_data.value = nil

        if len(event.head_comment) > 0 {
                emitter.head_comment = event.head_comment
        }
        if len(event.line_comment) > 0 {
                emitter.line_comment = event.line_comment
        }
        if len(event.foot_comment) > 0 {
                emitter.foot_comment = event.foot_comment
        }
        if len(event.tail_comment) > 0 {
                emitter.tail_comment = event.tail_comment
        }

        switch event.typ {
        case yaml_ALIAS_EVENT:
                if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
                        return false
                }

        case yaml_SCALAR_EVENT:
                if len(event.anchor) > 0 {
                        if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
                                return false
                        }
                }
                if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) {
                        if !yaml_emitter_analyze_tag(emitter, event.tag) {
                                return false
                        }
                }
                if !yaml_emitter_analyze_scalar(emitter, event.value) {
                        return false
                }

        case yaml_SEQUENCE_START_EVENT:
                if len(event.anchor) > 0 {
                        if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
                                return false
                        }
                }
                if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
                        if !yaml_emitter_analyze_tag(emitter, event.tag) {
                                return false
                        }
                }

        case yaml_MAPPING_START_EVENT:
                if len(event.anchor) > 0 {
                        if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
                                return false
                        }
                }
                if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
                        if !yaml_emitter_analyze_tag(emitter, event.tag) {
                                return false
                        }
                }
        }
        return true
}

// Write the BOM character.
func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
        if !flush(emitter) {
                return false
        }
        pos := emitter.buffer_pos
        emitter.buffer[pos+0] = '\xEF'
        emitter.buffer[pos+1] = '\xBB'
        emitter.buffer[pos+2] = '\xBF'
        emitter.buffer_pos += 3
        return true
}

func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
        indent := emitter.indent
        if indent < 0 {
                indent = 0
        }
        if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) {
                if !put_break(emitter) {
                        return false
                }
        }
        if emitter.foot_indent == indent {
                if !put_break(emitter) {
                        return false
                }
        }
        for emitter.column < indent {
                if !put(emitter, ' ') {
                        return false
                }
        }
        emitter.whitespace = true
        //emitter.indention = true
        emitter.space_above = false
        emitter.foot_indent = -1
        return true
}

func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
        if need_whitespace && !emitter.whitespace {
                if !put(emitter, ' ') {
                        return false
                }
        }
        if !write_all(emitter, indicator) {
                return false
        }
        emitter.whitespace = is_whitespace
        emitter.indention = (emitter.indention && is_indention)
        emitter.open_ended = false
        return true
}

func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
        if !write_all(emitter, value) {
                return false
        }
        emitter.whitespace = false
        emitter.indention = false
        return true
}

func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
        if !emitter.whitespace {
                if !put(emitter, ' ') {
                        return false
                }
        }
        if !write_all(emitter, value) {
                return false
        }
        emitter.whitespace = false
        emitter.indention = false
        return true
}

func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
        if need_whitespace && !emitter.whitespace {
                if !put(emitter, ' ') {
                        return false
                }
        }
        for i := 0; i < len(value); {
                var must_write bool
                switch value[i] {
                case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
                        must_write = true
                default:
                        must_write = is_alpha(value, i)
                }
                if must_write {
                        if !write(emitter, value, &i) {
                                return false
                        }
                } else {
                        w := width(value[i])
                        for k := 0; k < w; k++ {
                                octet := value[i]
                                i++
                                if !put(emitter, '%') {
                                        return false
                                }

                                c := octet >> 4
                                if c < 10 {
                                        c += '0'
                                } else {
                                        c += 'A' - 10
                                }
                                if !put(emitter, c) {
                                        return false
                                }

                                c = octet & 0x0f
                                if c < 10 {
                                        c += '0'
                                } else {
                                        c += 'A' - 10
                                }
                                if !put(emitter, c) {
                                        return false
                                }
                        }
                }
        }
        emitter.whitespace = false
        emitter.indention = false
        return true
}

func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
        if len(value) > 0 && !emitter.whitespace {
                if !put(emitter, ' ') {
                        return false
                }
        }

        spaces := false
        breaks := false
        for i := 0; i < len(value); {
                if is_space(value, i) {
                        if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                                i += width(value[i])
                        } else {
                                if !write(emitter, value, &i) {
                                        return false
                                }
                        }
                        spaces = true
                } else if is_break(value, i) {
                        if !breaks && value[i] == '\n' {
                                if !put_break(emitter) {
                                        return false
                                }
                        }
                        if !write_break(emitter, value, &i) {
                                return false
                        }
                        //emitter.indention = true
                        breaks = true
                } else {
                        if breaks {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                        }
                        if !write(emitter, value, &i) {
                                return false
                        }
                        emitter.indention = false
                        spaces = false
                        breaks = false
                }
        }

        if len(value) > 0 {
                emitter.whitespace = false
        }
        emitter.indention = false
        if emitter.root_context {
                emitter.open_ended = true
        }

        return true
}

func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {

        if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
                return false
        }

        spaces := false
        breaks := false
        for i := 0; i < len(value); {
                if is_space(value, i) {
                        if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                                i += width(value[i])
                        } else {
                                if !write(emitter, value, &i) {
                                        return false
                                }
                        }
                        spaces = true
                } else if is_break(value, i) {
                        if !breaks && value[i] == '\n' {
                                if !put_break(emitter) {
                                        return false
                                }
                        }
                        if !write_break(emitter, value, &i) {
                                return false
                        }
                        //emitter.indention = true
                        breaks = true
                } else {
                        if breaks {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                        }
                        if value[i] == '\'' {
                                if !put(emitter, '\'') {
                                        return false
                                }
                        }
                        if !write(emitter, value, &i) {
                                return false
                        }
                        emitter.indention = false
                        spaces = false
                        breaks = false
                }
        }
        if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
                return false
        }
        emitter.whitespace = false
        emitter.indention = false
        return true
}

func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
        spaces := false
        if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
                return false
        }

        for i := 0; i < len(value); {
                if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) ||
                        is_bom(value, i) || is_break(value, i) ||
                        value[i] == '"' || value[i] == '\\' {

                        octet := value[i]

                        var w int
                        var v rune
                        switch {
                        case octet&0x80 == 0x00:
                                w, v = 1, rune(octet&0x7F)
                        case octet&0xE0 == 0xC0:
                                w, v = 2, rune(octet&0x1F)
                        case octet&0xF0 == 0xE0:
                                w, v = 3, rune(octet&0x0F)
                        case octet&0xF8 == 0xF0:
                                w, v = 4, rune(octet&0x07)
                        }
                        for k := 1; k < w; k++ {
                                octet = value[i+k]
                                v = (v << 6) + (rune(octet) & 0x3F)
                        }
                        i += w

                        if !put(emitter, '\\') {
                                return false
                        }

                        var ok bool
                        switch v {
                        case 0x00:
                                ok = put(emitter, '0')
                        case 0x07:
                                ok = put(emitter, 'a')
                        case 0x08:
                                ok = put(emitter, 'b')
                        case 0x09:
                                ok = put(emitter, 't')
                        case 0x0A:
                                ok = put(emitter, 'n')
                        case 0x0b:
                                ok = put(emitter, 'v')
                        case 0x0c:
                                ok = put(emitter, 'f')
                        case 0x0d:
                                ok = put(emitter, 'r')
                        case 0x1b:
                                ok = put(emitter, 'e')
                        case 0x22:
                                ok = put(emitter, '"')
                        case 0x5c:
                                ok = put(emitter, '\\')
                        case 0x85:
                                ok = put(emitter, 'N')
                        case 0xA0:
                                ok = put(emitter, '_')
                        case 0x2028:
                                ok = put(emitter, 'L')
                        case 0x2029:
                                ok = put(emitter, 'P')
                        default:
                                if v <= 0xFF {
                                        ok = put(emitter, 'x')
                                        w = 2
                                } else if v <= 0xFFFF {
                                        ok = put(emitter, 'u')
                                        w = 4
                                } else {
                                        ok = put(emitter, 'U')
                                        w = 8
                                }
                                for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
                                        digit := byte((v >> uint(k)) & 0x0F)
                                        if digit < 10 {
                                                ok = put(emitter, digit+'0')
                                        } else {
                                                ok = put(emitter, digit+'A'-10)
                                        }
                                }
                        }
                        if !ok {
                                return false
                        }
                        spaces = false
                } else if is_space(value, i) {
                        if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                                if is_space(value, i+1) {
                                        if !put(emitter, '\\') {
                                                return false
                                        }
                                }
                                i += width(value[i])
                        } else if !write(emitter, value, &i) {
                                return false
                        }
                        spaces = true
                } else {
                        if !write(emitter, value, &i) {
                                return false
                        }
                        spaces = false
                }
        }
        if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
                return false
        }
        emitter.whitespace = false
        emitter.indention = false
        return true
}

func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
        if is_space(value, 0) || is_break(value, 0) {
                indent_hint := []byte{'0' + byte(emitter.best_indent)}
                if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
                        return false
                }
        }

        emitter.open_ended = false

        var chomp_hint [1]byte
        if len(value) == 0 {
                chomp_hint[0] = '-'
        } else {
                i := len(value) - 1
                for value[i]&0xC0 == 0x80 {
                        i--
                }
                if !is_break(value, i) {
                        chomp_hint[0] = '-'
                } else if i == 0 {
                        chomp_hint[0] = '+'
                        emitter.open_ended = true
                } else {
                        i--
                        for value[i]&0xC0 == 0x80 {
                                i--
                        }
                        if is_break(value, i) {
                                chomp_hint[0] = '+'
                                emitter.open_ended = true
                        }
                }
        }
        if chomp_hint[0] != 0 {
                if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
                        return false
                }
        }
        return true
}

func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
        if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) {
                return false
        }
        if !yaml_emitter_write_block_scalar_hints(emitter, value) {
                return false
        }
        if !yaml_emitter_process_line_comment(emitter) {
                return false
        }
        //emitter.indention = true
        emitter.whitespace = true
        breaks := true
        for i := 0; i < len(value); {
                if is_break(value, i) {
                        if !write_break(emitter, value, &i) {
                                return false
                        }
                        //emitter.indention = true
                        breaks = true
                } else {
                        if breaks {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                        }
                        if !write(emitter, value, &i) {
                                return false
                        }
                        emitter.indention = false
                        breaks = false
                }
        }

        return true
}

func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
        if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
                return false
        }
        if !yaml_emitter_write_block_scalar_hints(emitter, value) {
                return false
        }
        if !yaml_emitter_process_line_comment(emitter) {
                return false
        }

        //emitter.indention = true
        emitter.whitespace = true

        breaks := true
        leading_spaces := true
        for i := 0; i < len(value); {
                if is_break(value, i) {
                        if !breaks && !leading_spaces && value[i] == '\n' {
                                k := 0
                                for is_break(value, k) {
                                        k += width(value[k])
                                }
                                if !is_blankz(value, k) {
                                        if !put_break(emitter) {
                                                return false
                                        }
                                }
                        }
                        if !write_break(emitter, value, &i) {
                                return false
                        }
                        //emitter.indention = true
                        breaks = true
                } else {
                        if breaks {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                                leading_spaces = is_blank(value, i)
                        }
                        if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
                                if !yaml_emitter_write_indent(emitter) {
                                        return false
                                }
                                i += width(value[i])
                        } else {
                                if !write(emitter, value, &i) {
                                        return false
                                }
                        }
                        emitter.indention = false
                        breaks = false
                }
        }
        return true
}

func yaml_emitter_write_comment(emitter *yaml_emitter_t, comment []byte) bool {
        breaks := false
        pound := false
        for i := 0; i < len(comment); {
                if is_break(comment, i) {
                        if !write_break(emitter, comment, &i) {
                                return false
                        }
                        //emitter.indention = true
                        breaks = true
                        pound = false
                } else {
                        if breaks && !yaml_emitter_write_indent(emitter) {
                                return false
                        }
                        if !pound {
                                if comment[i] != '#' && (!put(emitter, '#') || !put(emitter, ' ')) {
                                        return false
                                }
                                pound = true
                        }
                        if !write(emitter, comment, &i) {
                                return false
                        }
                        emitter.indention = false
                        breaks = false
                }
        }
        if !breaks && !put_break(emitter) {
                return false
        }

        emitter.whitespace = true
        //emitter.indention = true
        return true
}
nishi@chaotic.ninja	ViewVC Help
Powered by ViewVC 1.3.0-dev