func (parser *Parser) parseSequence(block bool) (node *Sequence, err error) { var tok scanner.Token var sep, sentinel token.Token // Discard opening token if tok, err = parser.scan(); err != nil { return } if block { sep, sentinel = token.BLOCK_ENTRY, token.BLOCK_END } else { sep, sentinel = token.FLOW_ENTRY, token.FLOW_SEQUENCE_END } node = new(Sequence) node.basicNode = new(basicNode) node.pos = tok.GetStart() node.Nodes = make([]Node, 0, 2) childCount := 0 // Block sequences have a leading separator if block { tok, err = parser.scan() if tok.GetKind() != sep { err = errors.New("Expected leading block entry token") return } } for err == nil && tok.GetKind() != sentinel { var child Node // Scan child if child, err = parser.parseNode(); err != nil { return } // Add child to node if cap(node.Nodes) < childCount+1 { newNodes := make([]Node, childCount, cap(node.Nodes)*2) copy(newNodes, node.Nodes) node.Nodes = newNodes } node.Nodes = node.Nodes[0 : childCount+1] node.Nodes[childCount] = child childCount++ // Check for separator tok, err = parser.scan() if err != nil { return } else if tok.GetKind() != sep && tok.GetKind() != sentinel { err = errors.New("Unexpected token in sequence: " + tok.String()) return } } return }
func (parser *Parser) parseMapping(block bool) (node *Mapping, err error) { var tok scanner.Token var sentinel token.Token // Discard opening token if tok, err = parser.scan(); err != nil { return } if block { sentinel = token.BLOCK_END } else { sentinel = token.FLOW_MAPPING_END } node = new(Mapping) node.basicNode = new(basicNode) node.pos = tok.GetStart() node.Pairs = make([]KeyValuePair, 0, 2) pairCount := 0 for err == nil && tok.GetKind() != sentinel { var pair KeyValuePair // Scan key tok, err = parser.scan() if err != nil { return } else if tok.GetKind() != token.KEY { err = errors.New("Expected key") return } pair.Key, err = parser.parseNode() if err != nil { return } // Scan value tok, err = parser.scan() if err != nil { return } else if tok.GetKind() != token.VALUE { err = errors.New("Expected value") return } pair.Value, err = parser.parseNode() if err != nil { return } // Add pair to node if cap(node.Pairs) < pairCount+1 { newPairs := make([]KeyValuePair, pairCount, cap(node.Pairs)*2) copy(newPairs, node.Pairs) node.Pairs = newPairs } node.Pairs = node.Pairs[0 : pairCount+1] node.Pairs[pairCount] = pair pairCount++ // Find closure // Wouldn't it be great if it were always this easy? tok, err = parser.scan() if err != nil { return } else if !(tok.GetKind() == sentinel || (!block && tok.GetKind() == token.FLOW_ENTRY) || (block && tok.GetKind() == token.KEY)) { err = errors.New("Unexpected token in mapping: " + tok.GetKind().String() + " " + tok.String()) return } if tok.GetKind() == token.KEY { parser.unscan(tok) } } return }