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

   1 package yaml
   2
   3 import (
   4         "bytes"
   5 )
   6
   7 // The parser implements the following grammar:
   8 //
   9 // stream               ::= STREAM-START implicit_document? explicit_document* STREAM-END
  10 // implicit_document    ::= block_node DOCUMENT-END*
  11 // explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
  12 // block_node_or_indentless_sequence    ::=
  13 //                          ALIAS
  14 //                          | properties (block_content | indentless_block_sequence)?
  15 //                          | block_content
  16 //                          | indentless_block_sequence
  17 // block_node           ::= ALIAS
  18 //                          | properties block_content?
  19 //                          | block_content
  20 // flow_node            ::= ALIAS
  21 //                          | properties flow_content?
  22 //                          | flow_content
  23 // properties           ::= TAG ANCHOR? | ANCHOR TAG?
  24 // block_content        ::= block_collection | flow_collection | SCALAR
  25 // flow_content         ::= flow_collection | SCALAR
  26 // block_collection     ::= block_sequence | block_mapping
  27 // flow_collection      ::= flow_sequence | flow_mapping
  28 // block_sequence       ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
  29 // indentless_sequence  ::= (BLOCK-ENTRY block_node?)+
  30 // block_mapping        ::= BLOCK-MAPPING_START
  31 //                          ((KEY block_node_or_indentless_sequence?)?
  32 //                          (VALUE block_node_or_indentless_sequence?)?)*
  33 //                          BLOCK-END
  34 // flow_sequence        ::= FLOW-SEQUENCE-START
  35 //                          (flow_sequence_entry FLOW-ENTRY)*
  36 //                          flow_sequence_entry?
  37 //                          FLOW-SEQUENCE-END
  38 // flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
  39 // flow_mapping         ::= FLOW-MAPPING-START
  40 //                          (flow_mapping_entry FLOW-ENTRY)*
  41 //                          flow_mapping_entry?
  42 //                          FLOW-MAPPING-END
  43 // flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
  44
  45 // Peek the next token in the token queue.
  46 func peek_token(parser *yaml_parser_t) *yaml_token_t {
  47         if parser.token_available || yaml_parser_fetch_more_tokens(parser) {
  48                 return &parser.tokens[parser.tokens_head]
  49         }
  50         return nil
  51 }
  52
  53 // Remove the next token from the queue (must be called after peek_token).
  54 func skip_token(parser *yaml_parser_t) {
  55         parser.token_available = false
  56         parser.tokens_parsed++
  57         parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN
  58         parser.tokens_head++
  59 }
  60
  61 // Get the next event.
  62 func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool {
  63         // Erase the event object.
  64         *event = yaml_event_t{}
  65
  66         // No events after the end of the stream or error.
  67         if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE {
  68                 return true
  69         }
  70
  71         // Generate the next event.
  72         return yaml_parser_state_machine(parser, event)
  73 }
  74
  75 // Set parser error.
  76 func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool {
  77         parser.error = yaml_PARSER_ERROR
  78         parser.problem = problem
  79         parser.problem_mark = problem_mark
  80         return false
  81 }
  82
  83 func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool {
  84         parser.error = yaml_PARSER_ERROR
  85         parser.context = context
  86         parser.context_mark = context_mark
  87         parser.problem = problem
  88         parser.problem_mark = problem_mark
  89         return false
  90 }
  91
  92 // State dispatcher.
  93 func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool {
  94         //trace("yaml_parser_state_machine", "state:", parser.state.String())
  95
  96         switch parser.state {
  97         case yaml_PARSE_STREAM_START_STATE:
  98                 return yaml_parser_parse_stream_start(parser, event)
  99
 100         case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
 101                 return yaml_parser_parse_document_start(parser, event, true)
 102
 103         case yaml_PARSE_DOCUMENT_START_STATE:
 104                 return yaml_parser_parse_document_start(parser, event, false)
 105
 106         case yaml_PARSE_DOCUMENT_CONTENT_STATE:
 107                 return yaml_parser_parse_document_content(parser, event)
 108
 109         case yaml_PARSE_DOCUMENT_END_STATE:
 110                 return yaml_parser_parse_document_end(parser, event)
 111
 112         case yaml_PARSE_BLOCK_NODE_STATE:
 113                 return yaml_parser_parse_node(parser, event, true, false)
 114
 115         case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
 116                 return yaml_parser_parse_node(parser, event, true, true)
 117
 118         case yaml_PARSE_FLOW_NODE_STATE:
 119                 return yaml_parser_parse_node(parser, event, false, false)
 120
 121         case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
 122                 return yaml_parser_parse_block_sequence_entry(parser, event, true)
 123
 124         case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
 125                 return yaml_parser_parse_block_sequence_entry(parser, event, false)
 126
 127         case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
 128                 return yaml_parser_parse_indentless_sequence_entry(parser, event)
 129
 130         case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
 131                 return yaml_parser_parse_block_mapping_key(parser, event, true)
 132
 133         case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
 134                 return yaml_parser_parse_block_mapping_key(parser, event, false)
 135
 136         case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
 137                 return yaml_parser_parse_block_mapping_value(parser, event)
 138
 139         case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
 140                 return yaml_parser_parse_flow_sequence_entry(parser, event, true)
 141
 142         case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
 143                 return yaml_parser_parse_flow_sequence_entry(parser, event, false)
 144
 145         case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
 146                 return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
 147
 148         case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
 149                 return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)
 150
 151         case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
 152                 return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)
 153
 154         case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
 155                 return yaml_parser_parse_flow_mapping_key(parser, event, true)
 156
 157         case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
 158                 return yaml_parser_parse_flow_mapping_key(parser, event, false)
 159
 160         case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
 161                 return yaml_parser_parse_flow_mapping_value(parser, event, false)
 162
 163         case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
 164                 return yaml_parser_parse_flow_mapping_value(parser, event, true)
 165
 166         default:
 167                 panic("invalid parser state")
 168         }
 169 }
 170
 171 // Parse the production:
 172 // stream   ::= STREAM-START implicit_document? explicit_document* STREAM-END
 173 //              ************
 174 func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool {
 175         token := peek_token(parser)
 176         if token == nil {
 177                 return false
 178         }
 179         if token.typ != yaml_STREAM_START_TOKEN {
 180                 return yaml_parser_set_parser_error(parser, "did not find expected <stream-start>", token.start_mark)
 181         }
 182         parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE
 183         *event = yaml_event_t{
 184                 typ:        yaml_STREAM_START_EVENT,
 185                 start_mark: token.start_mark,
 186                 end_mark:   token.end_mark,
 187                 encoding:   token.encoding,
 188         }
 189         skip_token(parser)
 190         return true
 191 }
 192
 193 // Parse the productions:
 194 // implicit_document    ::= block_node DOCUMENT-END*
 195 //                          *
 196 // explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 197 //                          *************************
 198 func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool {
 199
 200         token := peek_token(parser)
 201         if token == nil {
 202                 return false
 203         }
 204
 205         // Parse extra document end indicators.
 206         if !implicit {
 207                 for token.typ == yaml_DOCUMENT_END_TOKEN {
 208                         skip_token(parser)
 209                         token = peek_token(parser)
 210                         if token == nil {
 211                                 return false
 212                         }
 213                 }
 214         }
 215
 216         if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN &&
 217                 token.typ != yaml_TAG_DIRECTIVE_TOKEN &&
 218                 token.typ != yaml_DOCUMENT_START_TOKEN &&
 219                 token.typ != yaml_STREAM_END_TOKEN {
 220                 // Parse an implicit document.
 221                 if !yaml_parser_process_directives(parser, nil, nil) {
 222                         return false
 223                 }
 224                 parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
 225                 parser.state = yaml_PARSE_BLOCK_NODE_STATE
 226
 227                 *event = yaml_event_t{
 228                         typ:        yaml_DOCUMENT_START_EVENT,
 229                         start_mark: token.start_mark,
 230                         end_mark:   token.end_mark,
 231                 }
 232
 233         } else if token.typ != yaml_STREAM_END_TOKEN {
 234                 // Parse an explicit document.
 235                 var version_directive *yaml_version_directive_t
 236                 var tag_directives []yaml_tag_directive_t
 237                 start_mark := token.start_mark
 238                 if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) {
 239                         return false
 240                 }
 241                 token = peek_token(parser)
 242                 if token == nil {
 243                         return false
 244                 }
 245                 if token.typ != yaml_DOCUMENT_START_TOKEN {
 246                         yaml_parser_set_parser_error(parser,
 247                                 "did not find expected <document start>", token.start_mark)
 248                         return false
 249                 }
 250                 parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
 251                 parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE
 252                 end_mark := token.end_mark
 253
 254                 *event = yaml_event_t{
 255                         typ:               yaml_DOCUMENT_START_EVENT,
 256                         start_mark:        start_mark,
 257                         end_mark:          end_mark,
 258                         version_directive: version_directive,
 259                         tag_directives:    tag_directives,
 260                         implicit:          false,
 261                 }
 262                 skip_token(parser)
 263
 264         } else {
 265                 // Parse the stream end.
 266                 parser.state = yaml_PARSE_END_STATE
 267                 *event = yaml_event_t{
 268                         typ:        yaml_STREAM_END_EVENT,
 269                         start_mark: token.start_mark,
 270                         end_mark:   token.end_mark,
 271                 }
 272                 skip_token(parser)
 273         }
 274
 275         return true
 276 }
 277
 278 // Parse the productions:
 279 // explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 280 //                                                    ***********
 281 //
 282 func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool {
 283         token := peek_token(parser)
 284         if token == nil {
 285                 return false
 286         }
 287         if token.typ == yaml_VERSION_DIRECTIVE_TOKEN ||
 288                 token.typ == yaml_TAG_DIRECTIVE_TOKEN ||
 289                 token.typ == yaml_DOCUMENT_START_TOKEN ||
 290                 token.typ == yaml_DOCUMENT_END_TOKEN ||
 291                 token.typ == yaml_STREAM_END_TOKEN {
 292                 parser.state = parser.states[len(parser.states)-1]
 293                 parser.states = parser.states[:len(parser.states)-1]
 294                 return yaml_parser_process_empty_scalar(parser, event,
 295                         token.start_mark)
 296         }
 297         return yaml_parser_parse_node(parser, event, true, false)
 298 }
 299
 300 // Parse the productions:
 301 // implicit_document    ::= block_node DOCUMENT-END*
 302 //                                     *************
 303 // explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 304 //
 305 func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
 306         token := peek_token(parser)
 307         if token == nil {
 308                 return false
 309         }
 310
 311         start_mark := token.start_mark
 312         end_mark := token.start_mark
 313
 314         implicit := true
 315         if token.typ == yaml_DOCUMENT_END_TOKEN {
 316                 end_mark = token.end_mark
 317                 skip_token(parser)
 318                 implicit = false
 319         }
 320
 321         parser.tag_directives = parser.tag_directives[:0]
 322
 323         parser.state = yaml_PARSE_DOCUMENT_START_STATE
 324         *event = yaml_event_t{
 325                 typ:        yaml_DOCUMENT_END_EVENT,
 326                 start_mark: start_mark,
 327                 end_mark:   end_mark,
 328                 implicit:   implicit,
 329         }
 330         return true
 331 }
 332
 333 // Parse the productions:
 334 // block_node_or_indentless_sequence    ::=
 335 //                          ALIAS
 336 //                          *****
 337 //                          | properties (block_content | indentless_block_sequence)?
 338 //                            **********  *
 339 //                          | block_content | indentless_block_sequence
 340 //                            *
 341 // block_node           ::= ALIAS
 342 //                          *****
 343 //                          | properties block_content?
 344 //                            ********** *
 345 //                          | block_content
 346 //                            *
 347 // flow_node            ::= ALIAS
 348 //                          *****
 349 //                          | properties flow_content?
 350 //                            ********** *
 351 //                          | flow_content
 352 //                            *
 353 // properties           ::= TAG ANCHOR? | ANCHOR TAG?
 354 //                          *************************
 355 // block_content        ::= block_collection | flow_collection | SCALAR
 356 //                                                               ******
 357 // flow_content         ::= flow_collection | SCALAR
 358 //                                            ******
 359 func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool {
 360         //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
 361
 362         token := peek_token(parser)
 363         if token == nil {
 364                 return false
 365         }
 366
 367         if token.typ == yaml_ALIAS_TOKEN {
 368                 parser.state = parser.states[len(parser.states)-1]
 369                 parser.states = parser.states[:len(parser.states)-1]
 370                 *event = yaml_event_t{
 371                         typ:        yaml_ALIAS_EVENT,
 372                         start_mark: token.start_mark,
 373                         end_mark:   token.end_mark,
 374                         anchor:     token.value,
 375                 }
 376                 skip_token(parser)
 377                 return true
 378         }
 379
 380         start_mark := token.start_mark
 381         end_mark := token.start_mark
 382
 383         var tag_token bool
 384         var tag_handle, tag_suffix, anchor []byte
 385         var tag_mark yaml_mark_t
 386         if token.typ == yaml_ANCHOR_TOKEN {
 387                 anchor = token.value
 388                 start_mark = token.start_mark
 389                 end_mark = token.end_mark
 390                 skip_token(parser)
 391                 token = peek_token(parser)
 392                 if token == nil {
 393                         return false
 394                 }
 395                 if token.typ == yaml_TAG_TOKEN {
 396                         tag_token = true
 397                         tag_handle = token.value
 398                         tag_suffix = token.suffix
 399                         tag_mark = token.start_mark
 400                         end_mark = token.end_mark
 401                         skip_token(parser)
 402                         token = peek_token(parser)
 403                         if token == nil {
 404                                 return false
 405                         }
 406                 }
 407         } else if token.typ == yaml_TAG_TOKEN {
 408                 tag_token = true
 409                 tag_handle = token.value
 410                 tag_suffix = token.suffix
 411                 start_mark = token.start_mark
 412                 tag_mark = token.start_mark
 413                 end_mark = token.end_mark
 414                 skip_token(parser)
 415                 token = peek_token(parser)
 416                 if token == nil {
 417                         return false
 418                 }
 419                 if token.typ == yaml_ANCHOR_TOKEN {
 420                         anchor = token.value
 421                         end_mark = token.end_mark
 422                         skip_token(parser)
 423                         token = peek_token(parser)
 424                         if token == nil {
 425                                 return false
 426                         }
 427                 }
 428         }
 429
 430         var tag []byte
 431         if tag_token {
 432                 if len(tag_handle) == 0 {
 433                         tag = tag_suffix
 434                         tag_suffix = nil
 435                 } else {
 436                         for i := range parser.tag_directives {
 437                                 if bytes.Equal(parser.tag_directives[i].handle, tag_handle) {
 438                                         tag = append([]byte(nil), parser.tag_directives[i].prefix...)
 439                                         tag = append(tag, tag_suffix...)
 440                                         break
 441                                 }
 442                         }
 443                         if len(tag) == 0 {
 444                                 yaml_parser_set_parser_error_context(parser,
 445                                         "while parsing a node", start_mark,
 446                                         "found undefined tag handle", tag_mark)
 447                                 return false
 448                         }
 449                 }
 450         }
 451
 452         implicit := len(tag) == 0
 453         if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN {
 454                 end_mark = token.end_mark
 455                 parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
 456                 *event = yaml_event_t{
 457                         typ:        yaml_SEQUENCE_START_EVENT,
 458                         start_mark: start_mark,
 459                         end_mark:   end_mark,
 460                         anchor:     anchor,
 461                         tag:        tag,
 462                         implicit:   implicit,
 463                         style:      yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
 464                 }
 465                 return true
 466         }
 467         if token.typ == yaml_SCALAR_TOKEN {
 468                 var plain_implicit, quoted_implicit bool
 469                 end_mark = token.end_mark
 470                 if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') {
 471                         plain_implicit = true
 472                 } else if len(tag) == 0 {
 473                         quoted_implicit = true
 474                 }
 475                 parser.state = parser.states[len(parser.states)-1]
 476                 parser.states = parser.states[:len(parser.states)-1]
 477
 478                 *event = yaml_event_t{
 479                         typ:             yaml_SCALAR_EVENT,
 480                         start_mark:      start_mark,
 481                         end_mark:        end_mark,
 482                         anchor:          anchor,
 483                         tag:             tag,
 484                         value:           token.value,
 485                         implicit:        plain_implicit,
 486                         quoted_implicit: quoted_implicit,
 487                         style:           yaml_style_t(token.style),
 488                 }
 489                 skip_token(parser)
 490                 return true
 491         }
 492         if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN {
 493                 // [Go] Some of the events below can be merged as they differ only on style.
 494                 end_mark = token.end_mark
 495                 parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE
 496                 *event = yaml_event_t{
 497                         typ:        yaml_SEQUENCE_START_EVENT,
 498                         start_mark: start_mark,
 499                         end_mark:   end_mark,
 500                         anchor:     anchor,
 501                         tag:        tag,
 502                         implicit:   implicit,
 503                         style:      yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
 504                 }
 505                 return true
 506         }
 507         if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
 508                 end_mark = token.end_mark
 509                 parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE
 510                 *event = yaml_event_t{
 511                         typ:        yaml_MAPPING_START_EVENT,
 512                         start_mark: start_mark,
 513                         end_mark:   end_mark,
 514                         anchor:     anchor,
 515                         tag:        tag,
 516                         implicit:   implicit,
 517                         style:      yaml_style_t(yaml_FLOW_MAPPING_STYLE),
 518                 }
 519                 return true
 520         }
 521         if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
 522                 end_mark = token.end_mark
 523                 parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE
 524                 *event = yaml_event_t{
 525                         typ:        yaml_SEQUENCE_START_EVENT,
 526                         start_mark: start_mark,
 527                         end_mark:   end_mark,
 528                         anchor:     anchor,
 529                         tag:        tag,
 530                         implicit:   implicit,
 531                         style:      yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
 532                 }
 533                 return true
 534         }
 535         if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
 536                 end_mark = token.end_mark
 537                 parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE
 538                 *event = yaml_event_t{
 539                         typ:        yaml_MAPPING_START_EVENT,
 540                         start_mark: start_mark,
 541                         end_mark:   end_mark,
 542                         anchor:     anchor,
 543                         tag:        tag,
 544                         implicit:   implicit,
 545                         style:      yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
 546                 }
 547                 return true
 548         }
 549         if len(anchor) > 0 || len(tag) > 0 {
 550                 parser.state = parser.states[len(parser.states)-1]
 551                 parser.states = parser.states[:len(parser.states)-1]
 552
 553                 *event = yaml_event_t{
 554                         typ:             yaml_SCALAR_EVENT,
 555                         start_mark:      start_mark,
 556                         end_mark:        end_mark,
 557                         anchor:          anchor,
 558                         tag:             tag,
 559                         implicit:        implicit,
 560                         quoted_implicit: false,
 561                         style:           yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
 562                 }
 563                 return true
 564         }
 565
 566         context := "while parsing a flow node"
 567         if block {
 568                 context = "while parsing a block node"
 569         }
 570         yaml_parser_set_parser_error_context(parser, context, start_mark,
 571                 "did not find expected node content", token.start_mark)
 572         return false
 573 }
 574
 575 // Parse the productions:
 576 // block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
 577 //                    ********************  *********** *             *********
 578 //
 579 func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 580         if first {
 581                 token := peek_token(parser)
 582                 parser.marks = append(parser.marks, token.start_mark)
 583                 skip_token(parser)
 584         }
 585
 586         token := peek_token(parser)
 587         if token == nil {
 588                 return false
 589         }
 590
 591         if token.typ == yaml_BLOCK_ENTRY_TOKEN {
 592                 mark := token.end_mark
 593                 skip_token(parser)
 594                 token = peek_token(parser)
 595                 if token == nil {
 596                         return false
 597                 }
 598                 if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN {
 599                         parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)
 600                         return yaml_parser_parse_node(parser, event, true, false)
 601                 } else {
 602                         parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
 603                         return yaml_parser_process_empty_scalar(parser, event, mark)
 604                 }
 605         }
 606         if token.typ == yaml_BLOCK_END_TOKEN {
 607                 parser.state = parser.states[len(parser.states)-1]
 608                 parser.states = parser.states[:len(parser.states)-1]
 609                 parser.marks = parser.marks[:len(parser.marks)-1]
 610
 611                 *event = yaml_event_t{
 612                         typ:        yaml_SEQUENCE_END_EVENT,
 613                         start_mark: token.start_mark,
 614                         end_mark:   token.end_mark,
 615                 }
 616
 617                 skip_token(parser)
 618                 return true
 619         }
 620
 621         context_mark := parser.marks[len(parser.marks)-1]
 622         parser.marks = parser.marks[:len(parser.marks)-1]
 623         return yaml_parser_set_parser_error_context(parser,
 624                 "while parsing a block collection", context_mark,
 625                 "did not find expected '-' indicator", token.start_mark)
 626 }
 627
 628 // Parse the productions:
 629 // indentless_sequence  ::= (BLOCK-ENTRY block_node?)+
 630 //                           *********** *
 631 func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool {
 632         token := peek_token(parser)
 633         if token == nil {
 634                 return false
 635         }
 636
 637         if token.typ == yaml_BLOCK_ENTRY_TOKEN {
 638                 mark := token.end_mark
 639                 skip_token(parser)
 640                 token = peek_token(parser)
 641                 if token == nil {
 642                         return false
 643                 }
 644                 if token.typ != yaml_BLOCK_ENTRY_TOKEN &&
 645                         token.typ != yaml_KEY_TOKEN &&
 646                         token.typ != yaml_VALUE_TOKEN &&
 647                         token.typ != yaml_BLOCK_END_TOKEN {
 648                         parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)
 649                         return yaml_parser_parse_node(parser, event, true, false)
 650                 }
 651                 parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
 652                 return yaml_parser_process_empty_scalar(parser, event, mark)
 653         }
 654         parser.state = parser.states[len(parser.states)-1]
 655         parser.states = parser.states[:len(parser.states)-1]
 656
 657         *event = yaml_event_t{
 658                 typ:        yaml_SEQUENCE_END_EVENT,
 659                 start_mark: token.start_mark,
 660                 end_mark:   token.start_mark, // [Go] Shouldn't this be token.end_mark?
 661         }
 662         return true
 663 }
 664
 665 // Parse the productions:
 666 // block_mapping        ::= BLOCK-MAPPING_START
 667 //                          *******************
 668 //                          ((KEY block_node_or_indentless_sequence?)?
 669 //                            *** *
 670 //                          (VALUE block_node_or_indentless_sequence?)?)*
 671 //
 672 //                          BLOCK-END
 673 //                          *********
 674 //
 675 func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 676         if first {
 677                 token := peek_token(parser)
 678                 parser.marks = append(parser.marks, token.start_mark)
 679                 skip_token(parser)
 680         }
 681
 682         token := peek_token(parser)
 683         if token == nil {
 684                 return false
 685         }
 686
 687         if token.typ == yaml_KEY_TOKEN {
 688                 mark := token.end_mark
 689                 skip_token(parser)
 690                 token = peek_token(parser)
 691                 if token == nil {
 692                         return false
 693                 }
 694                 if token.typ != yaml_KEY_TOKEN &&
 695                         token.typ != yaml_VALUE_TOKEN &&
 696                         token.typ != yaml_BLOCK_END_TOKEN {
 697                         parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE)
 698                         return yaml_parser_parse_node(parser, event, true, true)
 699                 } else {
 700                         parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE
 701                         return yaml_parser_process_empty_scalar(parser, event, mark)
 702                 }
 703         } else if token.typ == yaml_BLOCK_END_TOKEN {
 704                 parser.state = parser.states[len(parser.states)-1]
 705                 parser.states = parser.states[:len(parser.states)-1]
 706                 parser.marks = parser.marks[:len(parser.marks)-1]
 707                 *event = yaml_event_t{
 708                         typ:        yaml_MAPPING_END_EVENT,
 709                         start_mark: token.start_mark,
 710                         end_mark:   token.end_mark,
 711                 }
 712                 skip_token(parser)
 713                 return true
 714         }
 715
 716         context_mark := parser.marks[len(parser.marks)-1]
 717         parser.marks = parser.marks[:len(parser.marks)-1]
 718         return yaml_parser_set_parser_error_context(parser,
 719                 "while parsing a block mapping", context_mark,
 720                 "did not find expected key", token.start_mark)
 721 }
 722
 723 // Parse the productions:
 724 // block_mapping        ::= BLOCK-MAPPING_START
 725 //
 726 //                          ((KEY block_node_or_indentless_sequence?)?
 727 //
 728 //                          (VALUE block_node_or_indentless_sequence?)?)*
 729 //                           ***** *
 730 //                          BLOCK-END
 731 //
 732 //
 733 func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
 734         token := peek_token(parser)
 735         if token == nil {
 736                 return false
 737         }
 738         if token.typ == yaml_VALUE_TOKEN {
 739                 mark := token.end_mark
 740                 skip_token(parser)
 741                 token = peek_token(parser)
 742                 if token == nil {
 743                         return false
 744                 }
 745                 if token.typ != yaml_KEY_TOKEN &&
 746                         token.typ != yaml_VALUE_TOKEN &&
 747                         token.typ != yaml_BLOCK_END_TOKEN {
 748                         parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE)
 749                         return yaml_parser_parse_node(parser, event, true, true)
 750                 }
 751                 parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
 752                 return yaml_parser_process_empty_scalar(parser, event, mark)
 753         }
 754         parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
 755         return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
 756 }
 757
 758 // Parse the productions:
 759 // flow_sequence        ::= FLOW-SEQUENCE-START
 760 //                          *******************
 761 //                          (flow_sequence_entry FLOW-ENTRY)*
 762 //                           *                   **********
 763 //                          flow_sequence_entry?
 764 //                          *
 765 //                          FLOW-SEQUENCE-END
 766 //                          *****************
 767 // flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 768 //                          *
 769 //
 770 func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 771         if first {
 772                 token := peek_token(parser)
 773                 parser.marks = append(parser.marks, token.start_mark)
 774                 skip_token(parser)
 775         }
 776         token := peek_token(parser)
 777         if token == nil {
 778                 return false
 779         }
 780         if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
 781                 if !first {
 782                         if token.typ == yaml_FLOW_ENTRY_TOKEN {
 783                                 skip_token(parser)
 784                                 token = peek_token(parser)
 785                                 if token == nil {
 786                                         return false
 787                                 }
 788                         } else {
 789                                 context_mark := parser.marks[len(parser.marks)-1]
 790                                 parser.marks = parser.marks[:len(parser.marks)-1]
 791                                 return yaml_parser_set_parser_error_context(parser,
 792                                         "while parsing a flow sequence", context_mark,
 793                                         "did not find expected ',' or ']'", token.start_mark)
 794                         }
 795                 }
 796
 797                 if token.typ == yaml_KEY_TOKEN {
 798                         parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE
 799                         *event = yaml_event_t{
 800                                 typ:        yaml_MAPPING_START_EVENT,
 801                                 start_mark: token.start_mark,
 802                                 end_mark:   token.end_mark,
 803                                 implicit:   true,
 804                                 style:      yaml_style_t(yaml_FLOW_MAPPING_STYLE),
 805                         }
 806                         skip_token(parser)
 807                         return true
 808                 } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
 809                         parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE)
 810                         return yaml_parser_parse_node(parser, event, false, false)
 811                 }
 812         }
 813
 814         parser.state = parser.states[len(parser.states)-1]
 815         parser.states = parser.states[:len(parser.states)-1]
 816         parser.marks = parser.marks[:len(parser.marks)-1]
 817
 818         *event = yaml_event_t{
 819                 typ:        yaml_SEQUENCE_END_EVENT,
 820                 start_mark: token.start_mark,
 821                 end_mark:   token.end_mark,
 822         }
 823
 824         skip_token(parser)
 825         return true
 826 }
 827
 828 //
 829 // Parse the productions:
 830 // flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 831 //                                      *** *
 832 //
 833 func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool {
 834         token := peek_token(parser)
 835         if token == nil {
 836                 return false
 837         }
 838         if token.typ != yaml_VALUE_TOKEN &&
 839                 token.typ != yaml_FLOW_ENTRY_TOKEN &&
 840                 token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
 841                 parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)
 842                 return yaml_parser_parse_node(parser, event, false, false)
 843         }
 844         mark := token.end_mark
 845         skip_token(parser)
 846         parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
 847         return yaml_parser_process_empty_scalar(parser, event, mark)
 848 }
 849
 850 // Parse the productions:
 851 // flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 852 //                                                      ***** *
 853 //
 854 func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
 855         token := peek_token(parser)
 856         if token == nil {
 857                 return false
 858         }
 859         if token.typ == yaml_VALUE_TOKEN {
 860                 skip_token(parser)
 861                 token := peek_token(parser)
 862                 if token == nil {
 863                         return false
 864                 }
 865                 if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
 866                         parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)
 867                         return yaml_parser_parse_node(parser, event, false, false)
 868                 }
 869         }
 870         parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
 871         return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
 872 }
 873
 874 // Parse the productions:
 875 // flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 876 //                                                                      *
 877 //
 878 func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool {
 879         token := peek_token(parser)
 880         if token == nil {
 881                 return false
 882         }
 883         parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE
 884         *event = yaml_event_t{
 885                 typ:        yaml_MAPPING_END_EVENT,
 886                 start_mark: token.start_mark,
 887                 end_mark:   token.start_mark, // [Go] Shouldn't this be end_mark?
 888         }
 889         return true
 890 }
 891
 892 // Parse the productions:
 893 // flow_mapping         ::= FLOW-MAPPING-START
 894 //                          ******************
 895 //                          (flow_mapping_entry FLOW-ENTRY)*
 896 //                           *                  **********
 897 //                          flow_mapping_entry?
 898 //                          ******************
 899 //                          FLOW-MAPPING-END
 900 //                          ****************
 901 // flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 902 //                          *           *** *
 903 //
 904 func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 905         if first {
 906                 token := peek_token(parser)
 907                 parser.marks = append(parser.marks, token.start_mark)
 908                 skip_token(parser)
 909         }
 910
 911         token := peek_token(parser)
 912         if token == nil {
 913                 return false
 914         }
 915
 916         if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
 917                 if !first {
 918                         if token.typ == yaml_FLOW_ENTRY_TOKEN {
 919                                 skip_token(parser)
 920                                 token = peek_token(parser)
 921                                 if token == nil {
 922                                         return false
 923                                 }
 924                         } else {
 925                                 context_mark := parser.marks[len(parser.marks)-1]
 926                                 parser.marks = parser.marks[:len(parser.marks)-1]
 927                                 return yaml_parser_set_parser_error_context(parser,
 928                                         "while parsing a flow mapping", context_mark,
 929                                         "did not find expected ',' or '}'", token.start_mark)
 930                         }
 931                 }
 932
 933                 if token.typ == yaml_KEY_TOKEN {
 934                         skip_token(parser)
 935                         token = peek_token(parser)
 936                         if token == nil {
 937                                 return false
 938                         }
 939                         if token.typ != yaml_VALUE_TOKEN &&
 940                                 token.typ != yaml_FLOW_ENTRY_TOKEN &&
 941                                 token.typ != yaml_FLOW_MAPPING_END_TOKEN {
 942                                 parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE)
 943                                 return yaml_parser_parse_node(parser, event, false, false)
 944                         } else {
 945                                 parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE
 946                                 return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
 947                         }
 948                 } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
 949                         parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)
 950                         return yaml_parser_parse_node(parser, event, false, false)
 951                 }
 952         }
 953
 954         parser.state = parser.states[len(parser.states)-1]
 955         parser.states = parser.states[:len(parser.states)-1]
 956         parser.marks = parser.marks[:len(parser.marks)-1]
 957         *event = yaml_event_t{
 958                 typ:        yaml_MAPPING_END_EVENT,
 959                 start_mark: token.start_mark,
 960                 end_mark:   token.end_mark,
 961         }
 962         skip_token(parser)
 963         return true
 964 }
 965
 966 // Parse the productions:
 967 // flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 968 //                                   *                  ***** *
 969 //
 970 func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool {
 971         token := peek_token(parser)
 972         if token == nil {
 973                 return false
 974         }
 975         if empty {
 976                 parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
 977                 return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
 978         }
 979         if token.typ == yaml_VALUE_TOKEN {
 980                 skip_token(parser)
 981                 token = peek_token(parser)
 982                 if token == nil {
 983                         return false
 984                 }
 985                 if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN {
 986                         parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE)
 987                         return yaml_parser_parse_node(parser, event, false, false)
 988                 }
 989         }
 990         parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
 991         return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
 992 }
 993
 994 // Generate an empty scalar event.
 995 func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool {
 996         *event = yaml_event_t{
 997                 typ:        yaml_SCALAR_EVENT,
 998                 start_mark: mark,
 999                 end_mark:   mark,
1000                 value:      nil, // Empty
1001                 implicit:   true,
1002                 style:      yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
1003         }
1004         return true
1005 }
1006
1007 var default_tag_directives = []yaml_tag_directive_t{
1008         {[]byte("!"), []byte("!")},
1009         {[]byte("!!"), []byte("tag:yaml.org,2002:")},
1010 }
1011
1012 // Parse directives.
1013 func yaml_parser_process_directives(parser *yaml_parser_t,
1014         version_directive_ref **yaml_version_directive_t,
1015         tag_directives_ref *[]yaml_tag_directive_t) bool {
1016
1017         var version_directive *yaml_version_directive_t
1018         var tag_directives []yaml_tag_directive_t
1019
1020         token := peek_token(parser)
1021         if token == nil {
1022                 return false
1023         }
1024
1025         for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN {
1026                 if token.typ == yaml_VERSION_DIRECTIVE_TOKEN {
1027                         if version_directive != nil {
1028                                 yaml_parser_set_parser_error(parser,
1029                                         "found duplicate %YAML directive", token.start_mark)
1030                                 return false
1031                         }
1032                         if token.major != 1 || token.minor != 1 {
1033                                 yaml_parser_set_parser_error(parser,
1034                                         "found incompatible YAML document", token.start_mark)
1035                                 return false
1036                         }
1037                         version_directive = &yaml_version_directive_t{
1038                                 major: token.major,
1039                                 minor: token.minor,
1040                         }
1041                 } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN {
1042                         value := yaml_tag_directive_t{
1043                                 handle: token.value,
1044                                 prefix: token.prefix,
1045                         }
1046                         if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) {
1047                                 return false
1048                         }
1049                         tag_directives = append(tag_directives, value)
1050                 }
1051
1052                 skip_token(parser)
1053                 token = peek_token(parser)
1054                 if token == nil {
1055                         return false
1056                 }
1057         }
1058
1059         for i := range default_tag_directives {
1060                 if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) {
1061                         return false
1062                 }
1063         }
1064
1065         if version_directive_ref != nil {
1066                 *version_directive_ref = version_directive
1067         }
1068         if tag_directives_ref != nil {
1069                 *tag_directives_ref = tag_directives
1070         }
1071         return true
1072 }
1073
1074 // Append a tag directive to the directives stack.
1075 func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool {
1076         for i := range parser.tag_directives {
1077                 if bytes.Equal(value.handle, parser.tag_directives[i].handle) {
1078                         if allow_duplicates {
1079                                 return true
1080                         }
1081                         return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark)
1082                 }
1083         }
1084
1085         // [Go] I suspect the copy is unnecessary. This was likely done
1086         // because there was no way to track ownership of the data.
1087         value_copy := yaml_tag_directive_t{
1088                 handle: make([]byte, len(value.handle)),
1089                 prefix: make([]byte, len(value.prefix)),
1090         }
1091         copy(value_copy.handle, value.handle)
1092         copy(value_copy.prefix, value.prefix)
1093         parser.tag_directives = append(parser.tag_directives, value_copy)
1094         return true
1095 }