vendor/gopkg.in/yaml.v2/emitterc.go

   1 package yaml
   2
   3 import (
   4         "bytes"
   5 )
   6
   7 // Flush the buffer if needed.
   8 func flush(emitter *yaml_emitter_t) bool {
   9         if emitter.buffer_pos+5 >= len(emitter.buffer) {
  10                 return yaml_emitter_flush(emitter)
  11         }
  12         return true
  13 }
  14
  15 // Put a character to the output buffer.
  16 func put(emitter *yaml_emitter_t, value byte) bool {
  17         if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
  18                 return false
  19         }
  20         emitter.buffer[emitter.buffer_pos] = value
  21         emitter.buffer_pos++
  22         emitter.column++
  23         return true
  24 }
  25
  26 // Put a line break to the output buffer.
  27 func put_break(emitter *yaml_emitter_t) bool {
  28         if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
  29                 return false
  30         }
  31         switch emitter.line_break {
  32         case yaml_CR_BREAK:
  33                 emitter.buffer[emitter.buffer_pos] = '\r'
  34                 emitter.buffer_pos += 1
  35         case yaml_LN_BREAK:
  36                 emitter.buffer[emitter.buffer_pos] = '\n'
  37                 emitter.buffer_pos += 1
  38         case yaml_CRLN_BREAK:
  39                 emitter.buffer[emitter.buffer_pos+0] = '\r'
  40                 emitter.buffer[emitter.buffer_pos+1] = '\n'
  41                 emitter.buffer_pos += 2
  42         default:
  43                 panic("unknown line break setting")
  44         }
  45         emitter.column = 0
  46         emitter.line++
  47         return true
  48 }
  49
  50 // Copy a character from a string into buffer.
  51 func write(emitter *yaml_emitter_t, s []byte, i *int) bool {
  52         if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
  53                 return false
  54         }
  55         p := emitter.buffer_pos
  56         w := width(s[*i])
  57         switch w {
  58         case 4:
  59                 emitter.buffer[p+3] = s[*i+3]
  60                 fallthrough
  61         case 3:
  62                 emitter.buffer[p+2] = s[*i+2]
  63                 fallthrough
  64         case 2:
  65                 emitter.buffer[p+1] = s[*i+1]
  66                 fallthrough
  67         case 1:
  68                 emitter.buffer[p+0] = s[*i+0]
  69         default:
  70                 panic("unknown character width")
  71         }
  72         emitter.column++
  73         emitter.buffer_pos += w
  74         *i += w
  75         return true
  76 }
  77
  78 // Write a whole string into buffer.
  79 func write_all(emitter *yaml_emitter_t, s []byte) bool {
  80         for i := 0; i < len(s); {
  81                 if !write(emitter, s, &i) {
  82                         return false
  83                 }
  84         }
  85         return true
  86 }
  87
  88 // Copy a line break character from a string into buffer.
  89 func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
  90         if s[*i] == '\n' {
  91                 if !put_break(emitter) {
  92                         return false
  93                 }
  94                 *i++
  95         } else {
  96                 if !write(emitter, s, i) {
  97                         return false
  98                 }
  99                 emitter.column = 0
 100                 emitter.line++
 101         }
 102         return true
 103 }
 104
 105 // Set an emitter error and return false.
 106 func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
 107         emitter.error = yaml_EMITTER_ERROR
 108         emitter.problem = problem
 109         return false
 110 }
 111
 112 // Emit an event.
 113 func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 114         emitter.events = append(emitter.events, *event)
 115         for !yaml_emitter_need_more_events(emitter) {
 116                 event := &emitter.events[emitter.events_head]
 117                 if !yaml_emitter_analyze_event(emitter, event) {
 118                         return false
 119                 }
 120                 if !yaml_emitter_state_machine(emitter, event) {
 121                         return false
 122                 }
 123                 yaml_event_delete(event)
 124                 emitter.events_head++
 125         }
 126         return true
 127 }
 128
 129 // Check if we need to accumulate more events before emitting.
 130 //
 131 // We accumulate extra
 132 //  - 1 event for DOCUMENT-START
 133 //  - 2 events for SEQUENCE-START
 134 //  - 3 events for MAPPING-START
 135 //
 136 func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
 137         if emitter.events_head == len(emitter.events) {
 138                 return true
 139         }
 140         var accumulate int
 141         switch emitter.events[emitter.events_head].typ {
 142         case yaml_DOCUMENT_START_EVENT:
 143                 accumulate = 1
 144                 break
 145         case yaml_SEQUENCE_START_EVENT:
 146                 accumulate = 2
 147                 break
 148         case yaml_MAPPING_START_EVENT:
 149                 accumulate = 3
 150                 break
 151         default:
 152                 return false
 153         }
 154         if len(emitter.events)-emitter.events_head > accumulate {
 155                 return false
 156         }
 157         var level int
 158         for i := emitter.events_head; i < len(emitter.events); i++ {
 159                 switch emitter.events[i].typ {
 160                 case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
 161                         level++
 162                 case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
 163                         level--
 164                 }
 165                 if level == 0 {
 166                         return false
 167                 }
 168         }
 169         return true
 170 }
 171
 172 // Append a directive to the directives stack.
 173 func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {
 174         for i := 0; i < len(emitter.tag_directives); i++ {
 175                 if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
 176                         if allow_duplicates {
 177                                 return true
 178                         }
 179                         return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
 180                 }
 181         }
 182
 183         // [Go] Do we actually need to copy this given garbage collection
 184         // and the lack of deallocating destructors?
 185         tag_copy := yaml_tag_directive_t{
 186                 handle: make([]byte, len(value.handle)),
 187                 prefix: make([]byte, len(value.prefix)),
 188         }
 189         copy(tag_copy.handle, value.handle)
 190         copy(tag_copy.prefix, value.prefix)
 191         emitter.tag_directives = append(emitter.tag_directives, tag_copy)
 192         return true
 193 }
 194
 195 // Increase the indentation level.
 196 func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
 197         emitter.indents = append(emitter.indents, emitter.indent)
 198         if emitter.indent < 0 {
 199                 if flow {
 200                         emitter.indent = emitter.best_indent
 201                 } else {
 202                         emitter.indent = 0
 203                 }
 204         } else if !indentless {
 205                 emitter.indent += emitter.best_indent
 206         }
 207         return true
 208 }
 209
 210 // State dispatcher.
 211 func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 212         switch emitter.state {
 213         default:
 214         case yaml_EMIT_STREAM_START_STATE:
 215                 return yaml_emitter_emit_stream_start(emitter, event)
 216
 217         case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
 218                 return yaml_emitter_emit_document_start(emitter, event, true)
 219
 220         case yaml_EMIT_DOCUMENT_START_STATE:
 221                 return yaml_emitter_emit_document_start(emitter, event, false)
 222
 223         case yaml_EMIT_DOCUMENT_CONTENT_STATE:
 224                 return yaml_emitter_emit_document_content(emitter, event)
 225
 226         case yaml_EMIT_DOCUMENT_END_STATE:
 227                 return yaml_emitter_emit_document_end(emitter, event)
 228
 229         case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
 230                 return yaml_emitter_emit_flow_sequence_item(emitter, event, true)
 231
 232         case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
 233                 return yaml_emitter_emit_flow_sequence_item(emitter, event, false)
 234
 235         case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
 236                 return yaml_emitter_emit_flow_mapping_key(emitter, event, true)
 237
 238         case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
 239                 return yaml_emitter_emit_flow_mapping_key(emitter, event, false)
 240
 241         case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
 242                 return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
 243
 244         case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
 245                 return yaml_emitter_emit_flow_mapping_value(emitter, event, false)
 246
 247         case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
 248                 return yaml_emitter_emit_block_sequence_item(emitter, event, true)
 249
 250         case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
 251                 return yaml_emitter_emit_block_sequence_item(emitter, event, false)
 252
 253         case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
 254                 return yaml_emitter_emit_block_mapping_key(emitter, event, true)
 255
 256         case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
 257                 return yaml_emitter_emit_block_mapping_key(emitter, event, false)
 258
 259         case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
 260                 return yaml_emitter_emit_block_mapping_value(emitter, event, true)
 261
 262         case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
 263                 return yaml_emitter_emit_block_mapping_value(emitter, event, false)
 264
 265         case yaml_EMIT_END_STATE:
 266                 return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
 267         }
 268         panic("invalid emitter state")
 269 }
 270
 271 // Expect STREAM-START.
 272 func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 273         if event.typ != yaml_STREAM_START_EVENT {
 274                 return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
 275         }
 276         if emitter.encoding == yaml_ANY_ENCODING {
 277                 emitter.encoding = event.encoding
 278                 if emitter.encoding == yaml_ANY_ENCODING {
 279                         emitter.encoding = yaml_UTF8_ENCODING
 280                 }
 281         }
 282         if emitter.best_indent < 2 || emitter.best_indent > 9 {
 283                 emitter.best_indent = 2
 284         }
 285         if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
 286                 emitter.best_width = 80
 287         }
 288         if emitter.best_width < 0 {
 289                 emitter.best_width = 1<<31 - 1
 290         }
 291         if emitter.line_break == yaml_ANY_BREAK {
 292                 emitter.line_break = yaml_LN_BREAK
 293         }
 294
 295         emitter.indent = -1
 296         emitter.line = 0
 297         emitter.column = 0
 298         emitter.whitespace = true
 299         emitter.indention = true
 300
 301         if emitter.encoding != yaml_UTF8_ENCODING {
 302                 if !yaml_emitter_write_bom(emitter) {
 303                         return false
 304                 }
 305         }
 306         emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
 307         return true
 308 }
 309
 310 // Expect DOCUMENT-START or STREAM-END.
 311 func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
 312
 313         if event.typ == yaml_DOCUMENT_START_EVENT {
 314
 315                 if event.version_directive != nil {
 316                         if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
 317                                 return false
 318                         }
 319                 }
 320
 321                 for i := 0; i < len(event.tag_directives); i++ {
 322                         tag_directive := &event.tag_directives[i]
 323                         if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
 324                                 return false
 325                         }
 326                         if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
 327                                 return false
 328                         }
 329                 }
 330
 331                 for i := 0; i < len(default_tag_directives); i++ {
 332                         tag_directive := &default_tag_directives[i]
 333                         if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
 334                                 return false
 335                         }
 336                 }
 337
 338                 implicit := event.implicit
 339                 if !first || emitter.canonical {
 340                         implicit = false
 341                 }
 342
 343                 if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {
 344                         if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
 345                                 return false
 346                         }
 347                         if !yaml_emitter_write_indent(emitter) {
 348                                 return false
 349                         }
 350                 }
 351
 352                 if event.version_directive != nil {
 353                         implicit = false
 354                         if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
 355                                 return false
 356                         }
 357                         if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
 358                                 return false
 359                         }
 360                         if !yaml_emitter_write_indent(emitter) {
 361                                 return false
 362                         }
 363                 }
 364
 365                 if len(event.tag_directives) > 0 {
 366                         implicit = false
 367                         for i := 0; i < len(event.tag_directives); i++ {
 368                                 tag_directive := &event.tag_directives[i]
 369                                 if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
 370                                         return false
 371                                 }
 372                                 if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
 373                                         return false
 374                                 }
 375                                 if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
 376                                         return false
 377                                 }
 378                                 if !yaml_emitter_write_indent(emitter) {
 379                                         return false
 380                                 }
 381                         }
 382                 }
 383
 384                 if yaml_emitter_check_empty_document(emitter) {
 385                         implicit = false
 386                 }
 387                 if !implicit {
 388                         if !yaml_emitter_write_indent(emitter) {
 389                                 return false
 390                         }
 391                         if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
 392                                 return false
 393                         }
 394                         if emitter.canonical {
 395                                 if !yaml_emitter_write_indent(emitter) {
 396                                         return false
 397                                 }
 398                         }
 399                 }
 400
 401                 emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
 402                 return true
 403         }
 404
 405         if event.typ == yaml_STREAM_END_EVENT {
 406                 if emitter.open_ended {
 407                         if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
 408                                 return false
 409                         }
 410                         if !yaml_emitter_write_indent(emitter) {
 411                                 return false
 412                         }
 413                 }
 414                 if !yaml_emitter_flush(emitter) {
 415                         return false
 416                 }
 417                 emitter.state = yaml_EMIT_END_STATE
 418                 return true
 419         }
 420
 421         return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
 422 }
 423
 424 // Expect the root node.
 425 func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 426         emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
 427         return yaml_emitter_emit_node(emitter, event, true, false, false, false)
 428 }
 429
 430 // Expect DOCUMENT-END.
 431 func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 432         if event.typ != yaml_DOCUMENT_END_EVENT {
 433                 return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
 434         }
 435         if !yaml_emitter_write_indent(emitter) {
 436                 return false
 437         }
 438         if !event.implicit {
 439                 // [Go] Allocate the slice elsewhere.
 440                 if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
 441                         return false
 442                 }
 443                 if !yaml_emitter_write_indent(emitter) {
 444                         return false
 445                 }
 446         }
 447         if !yaml_emitter_flush(emitter) {
 448                 return false
 449         }
 450         emitter.state = yaml_EMIT_DOCUMENT_START_STATE
 451         emitter.tag_directives = emitter.tag_directives[:0]
 452         return true
 453 }
 454
 455 // Expect a flow item node.
 456 func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
 457         if first {
 458                 if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
 459                         return false
 460                 }
 461                 if !yaml_emitter_increase_indent(emitter, true, false) {
 462                         return false
 463                 }
 464                 emitter.flow_level++
 465         }
 466
 467         if event.typ == yaml_SEQUENCE_END_EVENT {
 468                 emitter.flow_level--
 469                 emitter.indent = emitter.indents[len(emitter.indents)-1]
 470                 emitter.indents = emitter.indents[:len(emitter.indents)-1]
 471                 if emitter.canonical && !first {
 472                         if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
 473                                 return false
 474                         }
 475                         if !yaml_emitter_write_indent(emitter) {
 476                                 return false
 477                         }
 478                 }
 479                 if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
 480                         return false
 481                 }
 482                 emitter.state = emitter.states[len(emitter.states)-1]
 483                 emitter.states = emitter.states[:len(emitter.states)-1]
 484
 485                 return true
 486         }
 487
 488         if !first {
 489                 if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
 490                         return false
 491                 }
 492         }
 493
 494         if emitter.canonical || emitter.column > emitter.best_width {
 495                 if !yaml_emitter_write_indent(emitter) {
 496                         return false
 497                 }
 498         }
 499         emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
 500         return yaml_emitter_emit_node(emitter, event, false, true, false, false)
 501 }
 502
 503 // Expect a flow key node.
 504 func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
 505         if first {
 506                 if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
 507                         return false
 508                 }
 509                 if !yaml_emitter_increase_indent(emitter, true, false) {
 510                         return false
 511                 }
 512                 emitter.flow_level++
 513         }
 514
 515         if event.typ == yaml_MAPPING_END_EVENT {
 516                 emitter.flow_level--
 517                 emitter.indent = emitter.indents[len(emitter.indents)-1]
 518                 emitter.indents = emitter.indents[:len(emitter.indents)-1]
 519                 if emitter.canonical && !first {
 520                         if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
 521                                 return false
 522                         }
 523                         if !yaml_emitter_write_indent(emitter) {
 524                                 return false
 525                         }
 526                 }
 527                 if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
 528                         return false
 529                 }
 530                 emitter.state = emitter.states[len(emitter.states)-1]
 531                 emitter.states = emitter.states[:len(emitter.states)-1]
 532                 return true
 533         }
 534
 535         if !first {
 536                 if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
 537                         return false
 538                 }
 539         }
 540         if emitter.canonical || emitter.column > emitter.best_width {
 541                 if !yaml_emitter_write_indent(emitter) {
 542                         return false
 543                 }
 544         }
 545
 546         if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
 547                 emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
 548                 return yaml_emitter_emit_node(emitter, event, false, false, true, true)
 549         }
 550         if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
 551                 return false
 552         }
 553         emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
 554         return yaml_emitter_emit_node(emitter, event, false, false, true, false)
 555 }
 556
 557 // Expect a flow value node.
 558 func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
 559         if simple {
 560                 if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
 561                         return false
 562                 }
 563         } else {
 564                 if emitter.canonical || emitter.column > emitter.best_width {
 565                         if !yaml_emitter_write_indent(emitter) {
 566                                 return false
 567                         }
 568                 }
 569                 if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
 570                         return false
 571                 }
 572         }
 573         emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
 574         return yaml_emitter_emit_node(emitter, event, false, false, true, false)
 575 }
 576
 577 // Expect a block item node.
 578 func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
 579         if first {
 580                 if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) {
 581                         return false
 582                 }
 583         }
 584         if event.typ == yaml_SEQUENCE_END_EVENT {
 585                 emitter.indent = emitter.indents[len(emitter.indents)-1]
 586                 emitter.indents = emitter.indents[:len(emitter.indents)-1]
 587                 emitter.state = emitter.states[len(emitter.states)-1]
 588                 emitter.states = emitter.states[:len(emitter.states)-1]
 589                 return true
 590         }
 591         if !yaml_emitter_write_indent(emitter) {
 592                 return false
 593         }
 594         if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
 595                 return false
 596         }
 597         emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
 598         return yaml_emitter_emit_node(emitter, event, false, true, false, false)
 599 }
 600
 601 // Expect a block key node.
 602 func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
 603         if first {
 604                 if !yaml_emitter_increase_indent(emitter, false, false) {
 605                         return false
 606                 }
 607         }
 608         if event.typ == yaml_MAPPING_END_EVENT {
 609                 emitter.indent = emitter.indents[len(emitter.indents)-1]
 610                 emitter.indents = emitter.indents[:len(emitter.indents)-1]
 611                 emitter.state = emitter.states[len(emitter.states)-1]
 612                 emitter.states = emitter.states[:len(emitter.states)-1]
 613                 return true
 614         }
 615         if !yaml_emitter_write_indent(emitter) {
 616                 return false
 617         }
 618         if yaml_emitter_check_simple_key(emitter) {
 619                 emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
 620                 return yaml_emitter_emit_node(emitter, event, false, false, true, true)
 621         }
 622         if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
 623                 return false
 624         }
 625         emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
 626         return yaml_emitter_emit_node(emitter, event, false, false, true, false)
 627 }
 628
 629 // Expect a block value node.
 630 func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
 631         if simple {
 632                 if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
 633                         return false
 634                 }
 635         } else {
 636                 if !yaml_emitter_write_indent(emitter) {
 637                         return false
 638                 }
 639                 if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
 640                         return false
 641                 }
 642         }
 643         emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
 644         return yaml_emitter_emit_node(emitter, event, false, false, true, false)
 645 }
 646
 647 // Expect a node.
 648 func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,
 649         root bool, sequence bool, mapping bool, simple_key bool) bool {
 650
 651         emitter.root_context = root
 652         emitter.sequence_context = sequence
 653         emitter.mapping_context = mapping
 654         emitter.simple_key_context = simple_key
 655
 656         switch event.typ {
 657         case yaml_ALIAS_EVENT:
 658                 return yaml_emitter_emit_alias(emitter, event)
 659         case yaml_SCALAR_EVENT:
 660                 return yaml_emitter_emit_scalar(emitter, event)
 661         case yaml_SEQUENCE_START_EVENT:
 662                 return yaml_emitter_emit_sequence_start(emitter, event)
 663         case yaml_MAPPING_START_EVENT:
 664                 return yaml_emitter_emit_mapping_start(emitter, event)
 665         default:
 666                 return yaml_emitter_set_emitter_error(emitter,
 667                         "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS")
 668         }
 669         return false
 670 }
 671
 672 // Expect ALIAS.
 673 func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 674         if !yaml_emitter_process_anchor(emitter) {
 675                 return false
 676         }
 677         emitter.state = emitter.states[len(emitter.states)-1]
 678         emitter.states = emitter.states[:len(emitter.states)-1]
 679         return true
 680 }
 681
 682 // Expect SCALAR.
 683 func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 684         if !yaml_emitter_select_scalar_style(emitter, event) {
 685                 return false
 686         }
 687         if !yaml_emitter_process_anchor(emitter) {
 688                 return false
 689         }
 690         if !yaml_emitter_process_tag(emitter) {
 691                 return false
 692         }
 693         if !yaml_emitter_increase_indent(emitter, true, false) {
 694                 return false
 695         }
 696         if !yaml_emitter_process_scalar(emitter) {
 697                 return false
 698         }
 699         emitter.indent = emitter.indents[len(emitter.indents)-1]
 700         emitter.indents = emitter.indents[:len(emitter.indents)-1]
 701         emitter.state = emitter.states[len(emitter.states)-1]
 702         emitter.states = emitter.states[:len(emitter.states)-1]
 703         return true
 704 }
 705
 706 // Expect SEQUENCE-START.
 707 func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 708         if !yaml_emitter_process_anchor(emitter) {
 709                 return false
 710         }
 711         if !yaml_emitter_process_tag(emitter) {
 712                 return false
 713         }
 714         if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||
 715                 yaml_emitter_check_empty_sequence(emitter) {
 716                 emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
 717         } else {
 718                 emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
 719         }
 720         return true
 721 }
 722
 723 // Expect MAPPING-START.
 724 func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 725         if !yaml_emitter_process_anchor(emitter) {
 726                 return false
 727         }
 728         if !yaml_emitter_process_tag(emitter) {
 729                 return false
 730         }
 731         if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||
 732                 yaml_emitter_check_empty_mapping(emitter) {
 733                 emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
 734         } else {
 735                 emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
 736         }
 737         return true
 738 }
 739
 740 // Check if the document content is an empty scalar.
 741 func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
 742         return false // [Go] Huh?
 743 }
 744
 745 // Check if the next events represent an empty sequence.
 746 func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
 747         if len(emitter.events)-emitter.events_head < 2 {
 748                 return false
 749         }
 750         return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
 751                 emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
 752 }
 753
 754 // Check if the next events represent an empty mapping.
 755 func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
 756         if len(emitter.events)-emitter.events_head < 2 {
 757                 return false
 758         }
 759         return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
 760                 emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
 761 }
 762
 763 // Check if the next node can be expressed as a simple key.
 764 func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
 765         length := 0
 766         switch emitter.events[emitter.events_head].typ {
 767         case yaml_ALIAS_EVENT:
 768                 length += len(emitter.anchor_data.anchor)
 769         case yaml_SCALAR_EVENT:
 770                 if emitter.scalar_data.multiline {
 771                         return false
 772                 }
 773                 length += len(emitter.anchor_data.anchor) +
 774                         len(emitter.tag_data.handle) +
 775                         len(emitter.tag_data.suffix) +
 776                         len(emitter.scalar_data.value)
 777         case yaml_SEQUENCE_START_EVENT:
 778                 if !yaml_emitter_check_empty_sequence(emitter) {
 779                         return false
 780                 }
 781                 length += len(emitter.anchor_data.anchor) +
 782                         len(emitter.tag_data.handle) +
 783                         len(emitter.tag_data.suffix)
 784         case yaml_MAPPING_START_EVENT:
 785                 if !yaml_emitter_check_empty_mapping(emitter) {
 786                         return false
 787                 }
 788                 length += len(emitter.anchor_data.anchor) +
 789                         len(emitter.tag_data.handle) +
 790                         len(emitter.tag_data.suffix)
 791         default:
 792                 return false
 793         }
 794         return length <= 128
 795 }
 796
 797 // Determine an acceptable scalar style.
 798 func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {
 799
 800         no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
 801         if no_tag && !event.implicit && !event.quoted_implicit {
 802                 return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
 803         }
 804
 805         style := event.scalar_style()
 806         if style == yaml_ANY_SCALAR_STYLE {
 807                 style = yaml_PLAIN_SCALAR_STYLE
 808         }
 809         if emitter.canonical {
 810                 style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
 811         }
 812         if emitter.simple_key_context && emitter.scalar_data.multiline {
 813                 style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
 814         }
 815
 816         if style == yaml_PLAIN_SCALAR_STYLE {
 817                 if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||
 818                         emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
 819                         style = yaml_SINGLE_QUOTED_SCALAR_STYLE
 820                 }
 821                 if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {
 822                         style = yaml_SINGLE_QUOTED_SCALAR_STYLE
 823                 }
 824                 if no_tag && !event.implicit {
 825                         style = yaml_SINGLE_QUOTED_SCALAR_STYLE
 826                 }
 827         }
 828         if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
 829                 if !emitter.scalar_data.single_quoted_allowed {
 830                         style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
 831                 }
 832         }
 833         if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {
 834                 if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {
 835                         style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
 836                 }
 837         }
 838
 839         if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
 840                 emitter.tag_data.handle = []byte{'!'}
 841         }
 842         emitter.scalar_data.style = style
 843         return true
 844 }
 845
 846 // Write an achor.
 847 func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
 848         if emitter.anchor_data.anchor == nil {
 849                 return true
 850         }
 851         c := []byte{'&'}
 852         if emitter.anchor_data.alias {
 853                 c[0] = '*'
 854         }
 855         if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
 856                 return false
 857         }
 858         return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
 859 }
 860
 861 // Write a tag.
 862 func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
 863         if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
 864                 return true
 865         }
 866         if len(emitter.tag_data.handle) > 0 {
 867                 if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
 868                         return false
 869                 }
 870                 if len(emitter.tag_data.suffix) > 0 {
 871                         if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
 872                                 return false
 873                         }
 874                 }
 875         } else {
 876                 // [Go] Allocate these slices elsewhere.
 877                 if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
 878                         return false
 879                 }
 880                 if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
 881                         return false
 882                 }
 883                 if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
 884                         return false
 885                 }
 886         }
 887         return true
 888 }
 889
 890 // Write a scalar.
 891 func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
 892         switch emitter.scalar_data.style {
 893         case yaml_PLAIN_SCALAR_STYLE:
 894                 return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
 895
 896         case yaml_SINGLE_QUOTED_SCALAR_STYLE:
 897                 return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
 898
 899         case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
 900                 return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
 901
 902         case yaml_LITERAL_SCALAR_STYLE:
 903                 return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)
 904
 905         case yaml_FOLDED_SCALAR_STYLE:
 906                 return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
 907         }
 908         panic("unknown scalar style")
 909 }
 910
 911 // Check if a %YAML directive is valid.
 912 func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
 913         if version_directive.major != 1 || version_directive.minor != 1 {
 914                 return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
 915         }
 916         return true
 917 }
 918
 919 // Check if a %TAG directive is valid.
 920 func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool {
 921         handle := tag_directive.handle
 922         prefix := tag_directive.prefix
 923         if len(handle) == 0 {
 924                 return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
 925         }
 926         if handle[0] != '!' {
 927                 return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
 928         }
 929         if handle[len(handle)-1] != '!' {
 930                 return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
 931         }
 932         for i := 1; i < len(handle)-1; i += width(handle[i]) {
 933                 if !is_alpha(handle, i) {
 934                         return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
 935                 }
 936         }
 937         if len(prefix) == 0 {
 938                 return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
 939         }
 940         return true
 941 }
 942
 943 // Check if an anchor is valid.
 944 func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
 945         if len(anchor) == 0 {
 946                 problem := "anchor value must not be empty"
 947                 if alias {
 948                         problem = "alias value must not be empty"
 949                 }
 950                 return yaml_emitter_set_emitter_error(emitter, problem)
 951         }
 952         for i := 0; i < len(anchor); i += width(anchor[i]) {
 953                 if !is_alpha(anchor, i) {
 954                         problem := "anchor value must contain alphanumerical characters only"
 955                         if alias {
 956                                 problem = "alias value must contain alphanumerical characters only"
 957                         }
 958                         return yaml_emitter_set_emitter_error(emitter, problem)
 959                 }
 960         }
 961         emitter.anchor_data.anchor = anchor
 962         emitter.anchor_data.alias = alias
 963         return true
 964 }
 965
 966 // Check if a tag is valid.
 967 func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
 968         if len(tag) == 0 {
 969                 return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
 970         }
 971         for i := 0; i < len(emitter.tag_directives); i++ {
 972                 tag_directive := &emitter.tag_directives[i]
 973                 if bytes.HasPrefix(tag, tag_directive.prefix) {
 974                         emitter.tag_data.handle = tag_directive.handle
 975                         emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
 976                         return true
 977                 }
 978         }
 979         emitter.tag_data.suffix = tag
 980         return true
 981 }
 982
 983 // Check if a scalar is valid.
 984 func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
 985         var (
 986                 block_indicators   = false
 987                 flow_indicators    = false
 988                 line_breaks        = false
 989                 special_characters = false
 990
 991                 leading_space  = false
 992                 leading_break  = false
 993                 trailing_space = false
 994                 trailing_break = false
 995                 break_space    = false
 996                 space_break    = false
 997
 998                 preceeded_by_whitespace = false
 999                 followed_by_whitespace  = false
1000                 previous_space          = false
1001                 previous_break          = false
1002         )
1003
1004         emitter.scalar_data.value = value
1005
1006         if len(value) == 0 {
1007                 emitter.scalar_data.multiline = false
1008                 emitter.scalar_data.flow_plain_allowed = false
1009                 emitter.scalar_data.block_plain_allowed = true
1010                 emitter.scalar_data.single_quoted_allowed = true
1011                 emitter.scalar_data.block_allowed = false
1012                 return true
1013         }
1014
1015         if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
1016                 block_indicators = true
1017                 flow_indicators = true
1018         }
1019
1020         preceeded_by_whitespace = true
1021         for i, w := 0, 0; i < len(value); i += w {
1022                 w = width(value[i])
1023                 followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)
1024
1025                 if i == 0 {
1026                         switch value[i] {
1027                         case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
1028                                 flow_indicators = true
1029                                 block_indicators = true
1030                         case '?', ':':
1031                                 flow_indicators = true
1032                                 if followed_by_whitespace {
1033                                         block_indicators = true
1034                                 }
1035                         case '-':
1036                                 if followed_by_whitespace {
1037                                         flow_indicators = true
1038                                         block_indicators = true
1039                                 }
1040                         }
1041                 } else {
1042                         switch value[i] {
1043                         case ',', '?', '[', ']', '{', '}':
1044                                 flow_indicators = true
1045                         case ':':
1046                                 flow_indicators = true
1047                                 if followed_by_whitespace {
1048                                         block_indicators = true
1049                                 }
1050                         case '#':
1051                                 if preceeded_by_whitespace {
1052                                         flow_indicators = true
1053                                         block_indicators = true
1054                                 }
1055                         }
1056                 }
1057
1058                 if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
1059                         special_characters = true
1060                 }
1061                 if is_space(value, i) {
1062                         if i == 0 {
1063                                 leading_space = true
1064                         }
1065                         if i+width(value[i]) == len(value) {
1066                                 trailing_space = true
1067                         }
1068                         if previous_break {
1069                                 break_space = true
1070                         }
1071                         previous_space = true
1072                         previous_break = false
1073                 } else if is_break(value, i) {
1074                         line_breaks = true
1075                         if i == 0 {
1076                                 leading_break = true
1077                         }
1078                         if i+width(value[i]) == len(value) {
1079                                 trailing_break = true
1080                         }
1081                         if previous_space {
1082                                 space_break = true
1083                         }
1084                         previous_space = false
1085                         previous_break = true
1086                 } else {
1087                         previous_space = false
1088                         previous_break = false
1089                 }
1090
1091                 // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
1092                 preceeded_by_whitespace = is_blankz(value, i)
1093         }
1094
1095         emitter.scalar_data.multiline = line_breaks
1096         emitter.scalar_data.flow_plain_allowed = true
1097         emitter.scalar_data.block_plain_allowed = true
1098         emitter.scalar_data.single_quoted_allowed = true
1099         emitter.scalar_data.block_allowed = true
1100
1101         if leading_space || leading_break || trailing_space || trailing_break {
1102                 emitter.scalar_data.flow_plain_allowed = false
1103                 emitter.scalar_data.block_plain_allowed = false
1104         }
1105         if trailing_space {
1106                 emitter.scalar_data.block_allowed = false
1107         }
1108         if break_space {
1109                 emitter.scalar_data.flow_plain_allowed = false
1110                 emitter.scalar_data.block_plain_allowed = false
1111                 emitter.scalar_data.single_quoted_allowed = false
1112         }
1113         if space_break || special_characters {
1114                 emitter.scalar_data.flow_plain_allowed = false
1115                 emitter.scalar_data.block_plain_allowed = false
1116                 emitter.scalar_data.single_quoted_allowed = false
1117                 emitter.scalar_data.block_allowed = false
1118         }
1119         if line_breaks {
1120                 emitter.scalar_data.flow_plain_allowed = false
1121                 emitter.scalar_data.block_plain_allowed = false
1122         }
1123         if flow_indicators {
1124                 emitter.scalar_data.flow_plain_allowed = false
1125         }
1126         if block_indicators {
1127                 emitter.scalar_data.block_plain_allowed = false
1128         }
1129         return true
1130 }
1131
1132 // Check if the event data is valid.
1133 func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
1134
1135         emitter.anchor_data.anchor = nil
1136         emitter.tag_data.handle = nil
1137         emitter.tag_data.suffix = nil
1138         emitter.scalar_data.value = nil
1139
1140         switch event.typ {
1141         case yaml_ALIAS_EVENT:
1142                 if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
1143                         return false
1144                 }
1145
1146         case yaml_SCALAR_EVENT:
1147                 if len(event.anchor) > 0 {
1148                         if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1149                                 return false
1150                         }
1151                 }
1152                 if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) {
1153                         if !yaml_emitter_analyze_tag(emitter, event.tag) {
1154                                 return false
1155                         }
1156                 }
1157                 if !yaml_emitter_analyze_scalar(emitter, event.value) {
1158                         return false
1159                 }
1160
1161         case yaml_SEQUENCE_START_EVENT:
1162                 if len(event.anchor) > 0 {
1163                         if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1164                                 return false
1165                         }
1166                 }
1167                 if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
1168                         if !yaml_emitter_analyze_tag(emitter, event.tag) {
1169                                 return false
1170                         }
1171                 }
1172
1173         case yaml_MAPPING_START_EVENT:
1174                 if len(event.anchor) > 0 {
1175                         if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1176                                 return false
1177                         }
1178                 }
1179                 if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
1180                         if !yaml_emitter_analyze_tag(emitter, event.tag) {
1181                                 return false
1182                         }
1183                 }
1184         }
1185         return true
1186 }
1187
1188 // Write the BOM character.
1189 func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
1190         if !flush(emitter) {
1191                 return false
1192         }
1193         pos := emitter.buffer_pos
1194         emitter.buffer[pos+0] = '\xEF'
1195         emitter.buffer[pos+1] = '\xBB'
1196         emitter.buffer[pos+2] = '\xBF'
1197         emitter.buffer_pos += 3
1198         return true
1199 }
1200
1201 func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
1202         indent := emitter.indent
1203         if indent < 0 {
1204                 indent = 0
1205         }
1206         if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) {
1207                 if !put_break(emitter) {
1208                         return false
1209                 }
1210         }
1211         for emitter.column < indent {
1212                 if !put(emitter, ' ') {
1213                         return false
1214                 }
1215         }
1216         emitter.whitespace = true
1217         emitter.indention = true
1218         return true
1219 }
1220
1221 func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
1222         if need_whitespace && !emitter.whitespace {
1223                 if !put(emitter, ' ') {
1224                         return false
1225                 }
1226         }
1227         if !write_all(emitter, indicator) {
1228                 return false
1229         }
1230         emitter.whitespace = is_whitespace
1231         emitter.indention = (emitter.indention && is_indention)
1232         emitter.open_ended = false
1233         return true
1234 }
1235
1236 func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
1237         if !write_all(emitter, value) {
1238                 return false
1239         }
1240         emitter.whitespace = false
1241         emitter.indention = false
1242         return true
1243 }
1244
1245 func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
1246         if !emitter.whitespace {
1247                 if !put(emitter, ' ') {
1248                         return false
1249                 }
1250         }
1251         if !write_all(emitter, value) {
1252                 return false
1253         }
1254         emitter.whitespace = false
1255         emitter.indention = false
1256         return true
1257 }
1258
1259 func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
1260         if need_whitespace && !emitter.whitespace {
1261                 if !put(emitter, ' ') {
1262                         return false
1263                 }
1264         }
1265         for i := 0; i < len(value); {
1266                 var must_write bool
1267                 switch value[i] {
1268                 case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
1269                         must_write = true
1270                 default:
1271                         must_write = is_alpha(value, i)
1272                 }
1273                 if must_write {
1274                         if !write(emitter, value, &i) {
1275                                 return false
1276                         }
1277                 } else {
1278                         w := width(value[i])
1279                         for k := 0; k < w; k++ {
1280                                 octet := value[i]
1281                                 i++
1282                                 if !put(emitter, '%') {
1283                                         return false
1284                                 }
1285
1286                                 c := octet >> 4
1287                                 if c < 10 {
1288                                         c += '0'
1289                                 } else {
1290                                         c += 'A' - 10
1291                                 }
1292                                 if !put(emitter, c) {
1293                                         return false
1294                                 }
1295
1296                                 c = octet & 0x0f
1297                                 if c < 10 {
1298                                         c += '0'
1299                                 } else {
1300                                         c += 'A' - 10
1301                                 }
1302                                 if !put(emitter, c) {
1303                                         return false
1304                                 }
1305                         }
1306                 }
1307         }
1308         emitter.whitespace = false
1309         emitter.indention = false
1310         return true
1311 }
1312
1313 func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1314         if !emitter.whitespace {
1315                 if !put(emitter, ' ') {
1316                         return false
1317                 }
1318         }
1319
1320         spaces := false
1321         breaks := false
1322         for i := 0; i < len(value); {
1323                 if is_space(value, i) {
1324                         if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
1325                                 if !yaml_emitter_write_indent(emitter) {
1326                                         return false
1327                                 }
1328                                 i += width(value[i])
1329                         } else {
1330                                 if !write(emitter, value, &i) {
1331                                         return false
1332                                 }
1333                         }
1334                         spaces = true
1335                 } else if is_break(value, i) {
1336                         if !breaks && value[i] == '\n' {
1337                                 if !put_break(emitter) {
1338                                         return false
1339                                 }
1340                         }
1341                         if !write_break(emitter, value, &i) {
1342                                 return false
1343                         }
1344                         emitter.indention = true
1345                         breaks = true
1346                 } else {
1347                         if breaks {
1348                                 if !yaml_emitter_write_indent(emitter) {
1349                                         return false
1350                                 }
1351                         }
1352                         if !write(emitter, value, &i) {
1353                                 return false
1354                         }
1355                         emitter.indention = false
1356                         spaces = false
1357                         breaks = false
1358                 }
1359         }
1360
1361         emitter.whitespace = false
1362         emitter.indention = false
1363         if emitter.root_context {
1364                 emitter.open_ended = true
1365         }
1366
1367         return true
1368 }
1369
1370 func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1371
1372         if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
1373                 return false
1374         }
1375
1376         spaces := false
1377         breaks := false
1378         for i := 0; i < len(value); {
1379                 if is_space(value, i) {
1380                         if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
1381                                 if !yaml_emitter_write_indent(emitter) {
1382                                         return false
1383                                 }
1384                                 i += width(value[i])
1385                         } else {
1386                                 if !write(emitter, value, &i) {
1387                                         return false
1388                                 }
1389                         }
1390                         spaces = true
1391                 } else if is_break(value, i) {
1392                         if !breaks && value[i] == '\n' {
1393                                 if !put_break(emitter) {
1394                                         return false
1395                                 }
1396                         }
1397                         if !write_break(emitter, value, &i) {
1398                                 return false
1399                         }
1400                         emitter.indention = true
1401                         breaks = true
1402                 } else {
1403                         if breaks {
1404                                 if !yaml_emitter_write_indent(emitter) {
1405                                         return false
1406                                 }
1407                         }
1408                         if value[i] == '\'' {
1409                                 if !put(emitter, '\'') {
1410                                         return false
1411                                 }
1412                         }
1413                         if !write(emitter, value, &i) {
1414                                 return false
1415                         }
1416                         emitter.indention = false
1417                         spaces = false
1418                         breaks = false
1419                 }
1420         }
1421         if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
1422                 return false
1423         }
1424         emitter.whitespace = false
1425         emitter.indention = false
1426         return true
1427 }
1428
1429 func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1430         spaces := false
1431         if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
1432                 return false
1433         }
1434
1435         for i := 0; i < len(value); {
1436                 if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) ||
1437                         is_bom(value, i) || is_break(value, i) ||
1438                         value[i] == '"' || value[i] == '\\' {
1439
1440                         octet := value[i]
1441
1442                         var w int
1443                         var v rune
1444                         switch {
1445                         case octet&0x80 == 0x00:
1446                                 w, v = 1, rune(octet&0x7F)
1447                         case octet&0xE0 == 0xC0:
1448                                 w, v = 2, rune(octet&0x1F)
1449                         case octet&0xF0 == 0xE0:
1450                                 w, v = 3, rune(octet&0x0F)
1451                         case octet&0xF8 == 0xF0:
1452                                 w, v = 4, rune(octet&0x07)
1453                         }
1454                         for k := 1; k < w; k++ {
1455                                 octet = value[i+k]
1456                                 v = (v << 6) + (rune(octet) & 0x3F)
1457                         }
1458                         i += w
1459
1460                         if !put(emitter, '\\') {
1461                                 return false
1462                         }
1463
1464                         var ok bool
1465                         switch v {
1466                         case 0x00:
1467                                 ok = put(emitter, '0')
1468                         case 0x07:
1469                                 ok = put(emitter, 'a')
1470                         case 0x08:
1471                                 ok = put(emitter, 'b')
1472                         case 0x09:
1473                                 ok = put(emitter, 't')
1474                         case 0x0A:
1475                                 ok = put(emitter, 'n')
1476                         case 0x0b:
1477                                 ok = put(emitter, 'v')
1478                         case 0x0c:
1479                                 ok = put(emitter, 'f')
1480                         case 0x0d:
1481                                 ok = put(emitter, 'r')
1482                         case 0x1b:
1483                                 ok = put(emitter, 'e')
1484                         case 0x22:
1485                                 ok = put(emitter, '"')
1486                         case 0x5c:
1487                                 ok = put(emitter, '\\')
1488                         case 0x85:
1489                                 ok = put(emitter, 'N')
1490                         case 0xA0:
1491                                 ok = put(emitter, '_')
1492                         case 0x2028:
1493                                 ok = put(emitter, 'L')
1494                         case 0x2029:
1495                                 ok = put(emitter, 'P')
1496                         default:
1497                                 if v <= 0xFF {
1498                                         ok = put(emitter, 'x')
1499                                         w = 2
1500                                 } else if v <= 0xFFFF {
1501                                         ok = put(emitter, 'u')
1502                                         w = 4
1503                                 } else {
1504                                         ok = put(emitter, 'U')
1505                                         w = 8
1506                                 }
1507                                 for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
1508                                         digit := byte((v >> uint(k)) & 0x0F)
1509                                         if digit < 10 {
1510                                                 ok = put(emitter, digit+'0')
1511                                         } else {
1512                                                 ok = put(emitter, digit+'A'-10)
1513                                         }
1514                                 }
1515                         }
1516                         if !ok {
1517                                 return false
1518                         }
1519                         spaces = false
1520                 } else if is_space(value, i) {
1521                         if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
1522                                 if !yaml_emitter_write_indent(emitter) {
1523                                         return false
1524                                 }
1525                                 if is_space(value, i+1) {
1526                                         if !put(emitter, '\\') {
1527                                                 return false
1528                                         }
1529                                 }
1530                                 i += width(value[i])
1531                         } else if !write(emitter, value, &i) {
1532                                 return false
1533                         }
1534                         spaces = true
1535                 } else {
1536                         if !write(emitter, value, &i) {
1537                                 return false
1538                         }
1539                         spaces = false
1540                 }
1541         }
1542         if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
1543                 return false
1544         }
1545         emitter.whitespace = false
1546         emitter.indention = false
1547         return true
1548 }
1549
1550 func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
1551         if is_space(value, 0) || is_break(value, 0) {
1552                 indent_hint := []byte{'0' + byte(emitter.best_indent)}
1553                 if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
1554                         return false
1555                 }
1556         }
1557
1558         emitter.open_ended = false
1559
1560         var chomp_hint [1]byte
1561         if len(value) == 0 {
1562                 chomp_hint[0] = '-'
1563         } else {
1564                 i := len(value) - 1
1565                 for value[i]&0xC0 == 0x80 {
1566                         i--
1567                 }
1568                 if !is_break(value, i) {
1569                         chomp_hint[0] = '-'
1570                 } else if i == 0 {
1571                         chomp_hint[0] = '+'
1572                         emitter.open_ended = true
1573                 } else {
1574                         i--
1575                         for value[i]&0xC0 == 0x80 {
1576                                 i--
1577                         }
1578                         if is_break(value, i) {
1579                                 chomp_hint[0] = '+'
1580                                 emitter.open_ended = true
1581                         }
1582                 }
1583         }
1584         if chomp_hint[0] != 0 {
1585                 if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
1586                         return false
1587                 }
1588         }
1589         return true
1590 }
1591
1592 func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
1593         if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) {
1594                 return false
1595         }
1596         if !yaml_emitter_write_block_scalar_hints(emitter, value) {
1597                 return false
1598         }
1599         if !put_break(emitter) {
1600                 return false
1601         }
1602         emitter.indention = true
1603         emitter.whitespace = true
1604         breaks := true
1605         for i := 0; i < len(value); {
1606                 if is_break(value, i) {
1607                         if !write_break(emitter, value, &i) {
1608                                 return false
1609                         }
1610                         emitter.indention = true
1611                         breaks = true
1612                 } else {
1613                         if breaks {
1614                                 if !yaml_emitter_write_indent(emitter) {
1615                                         return false
1616                                 }
1617                         }
1618                         if !write(emitter, value, &i) {
1619                                 return false
1620                         }
1621                         emitter.indention = false
1622                         breaks = false
1623                 }
1624         }
1625
1626         return true
1627 }
1628
1629 func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
1630         if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
1631                 return false
1632         }
1633         if !yaml_emitter_write_block_scalar_hints(emitter, value) {
1634                 return false
1635         }
1636
1637         if !put_break(emitter) {
1638                 return false
1639         }
1640         emitter.indention = true
1641         emitter.whitespace = true
1642
1643         breaks := true
1644         leading_spaces := true
1645         for i := 0; i < len(value); {
1646                 if is_break(value, i) {
1647                         if !breaks && !leading_spaces && value[i] == '\n' {
1648                                 k := 0
1649                                 for is_break(value, k) {
1650                                         k += width(value[k])
1651                                 }
1652                                 if !is_blankz(value, k) {
1653                                         if !put_break(emitter) {
1654                                                 return false
1655                                         }
1656                                 }
1657                         }
1658                         if !write_break(emitter, value, &i) {
1659                                 return false
1660                         }
1661                         emitter.indention = true
1662                         breaks = true
1663                 } else {
1664                         if breaks {
1665                                 if !yaml_emitter_write_indent(emitter) {
1666                                         return false
1667                                 }
1668                                 leading_spaces = is_blank(value, i)
1669                         }
1670                         if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
1671                                 if !yaml_emitter_write_indent(emitter) {
1672                                         return false
1673                                 }
1674                                 i += width(value[i])
1675                         } else {
1676                                 if !write(emitter, value, &i) {
1677                                         return false
1678                                 }
1679                         }
1680                         emitter.indention = false
1681                         breaks = false
1682                 }
1683         }
1684         return true
1685 }