mirror of https://github.com/cheat/cheat.git
Use yaml.v3 rather than .v2 and .v1
This commit is contained in:
parent
2edc0ee299
commit
402a58c140
3
go.mod
3
go.mod
|
@ -9,8 +9,7 @@ require (
|
||||||
github.com/go-git/go-git/v5 v5.4.2
|
github.com/go-git/go-git/v5 v5.4.2
|
||||||
github.com/mattn/go-isatty v0.0.16
|
github.com/mattn/go-isatty v0.0.16
|
||||||
github.com/mitchellh/go-homedir v1.1.0
|
github.com/mitchellh/go-homedir v1.1.0
|
||||||
gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0
|
gopkg.in/yaml.v3 v3.0.0
|
||||||
gopkg.in/yaml.v2 v2.4.0
|
|
||||||
)
|
)
|
||||||
|
|
||||||
require (
|
require (
|
||||||
|
|
4
go.sum
4
go.sum
|
@ -131,13 +131,9 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntN
|
||||||
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
|
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
|
||||||
gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
|
gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
|
||||||
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
|
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
|
||||||
gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0 h1:POO/ycCATvegFmVuPpQzZFJ+pGZeX22Ufu6fibxDVjU=
|
|
||||||
gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
|
|
||||||
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||||
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||||
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||||
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
|
|
||||||
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
|
|
||||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||||
gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA=
|
gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA=
|
||||||
gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||||
|
|
|
@ -9,7 +9,7 @@ import (
|
||||||
cp "github.com/cheat/cheat/internal/cheatpath"
|
cp "github.com/cheat/cheat/internal/cheatpath"
|
||||||
|
|
||||||
"github.com/mitchellh/go-homedir"
|
"github.com/mitchellh/go-homedir"
|
||||||
"gopkg.in/yaml.v2"
|
"gopkg.in/yaml.v3"
|
||||||
)
|
)
|
||||||
|
|
||||||
// Config encapsulates configuration parameters
|
// Config encapsulates configuration parameters
|
||||||
|
@ -39,7 +39,7 @@ func New(opts map[string]interface{}, confPath string, resolve bool) (Config, er
|
||||||
conf.Path = confPath
|
conf.Path = confPath
|
||||||
|
|
||||||
// unmarshal the yaml
|
// unmarshal the yaml
|
||||||
err = yaml.UnmarshalStrict(buf, &conf)
|
err = yaml.Unmarshal(buf, &conf)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return Config{}, fmt.Errorf("could not unmarshal yaml: %v", err)
|
return Config{}, fmt.Errorf("could not unmarshal yaml: %v", err)
|
||||||
}
|
}
|
||||||
|
|
|
@ -5,7 +5,7 @@ import (
|
||||||
"runtime"
|
"runtime"
|
||||||
"strings"
|
"strings"
|
||||||
|
|
||||||
"gopkg.in/yaml.v1"
|
"gopkg.in/yaml.v3"
|
||||||
)
|
)
|
||||||
|
|
||||||
// Parse parses cheatsheet frontmatter
|
// Parse parses cheatsheet frontmatter
|
||||||
|
|
|
@ -1,188 +0,0 @@
|
||||||
|
|
||||||
Copyright (c) 2011-2014 - Canonical Inc.
|
|
||||||
|
|
||||||
This software is licensed under the LGPLv3, included below.
|
|
||||||
|
|
||||||
As a special exception to the GNU Lesser General Public License version 3
|
|
||||||
("LGPL3"), the copyright holders of this Library give you permission to
|
|
||||||
convey to a third party a Combined Work that links statically or dynamically
|
|
||||||
to this Library without providing any Minimal Corresponding Source or
|
|
||||||
Minimal Application Code as set out in 4d or providing the installation
|
|
||||||
information set out in section 4e, provided that you comply with the other
|
|
||||||
provisions of LGPL3 and provided that you meet, for the Application the
|
|
||||||
terms and conditions of the license(s) which apply to the Application.
|
|
||||||
|
|
||||||
Except as stated in this special exception, the provisions of LGPL3 will
|
|
||||||
continue to comply in full to this Library. If you modify this Library, you
|
|
||||||
may apply this exception to your version of this Library, but you are not
|
|
||||||
obliged to do so. If you do not wish to do so, delete this exception
|
|
||||||
statement from your version. This exception does not (and cannot) modify any
|
|
||||||
license terms which apply to the Application, with which you must still
|
|
||||||
comply.
|
|
||||||
|
|
||||||
|
|
||||||
GNU LESSER GENERAL PUBLIC LICENSE
|
|
||||||
Version 3, 29 June 2007
|
|
||||||
|
|
||||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
|
|
||||||
Everyone is permitted to copy and distribute verbatim copies
|
|
||||||
of this license document, but changing it is not allowed.
|
|
||||||
|
|
||||||
|
|
||||||
This version of the GNU Lesser General Public License incorporates
|
|
||||||
the terms and conditions of version 3 of the GNU General Public
|
|
||||||
License, supplemented by the additional permissions listed below.
|
|
||||||
|
|
||||||
0. Additional Definitions.
|
|
||||||
|
|
||||||
As used herein, "this License" refers to version 3 of the GNU Lesser
|
|
||||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU
|
|
||||||
General Public License.
|
|
||||||
|
|
||||||
"The Library" refers to a covered work governed by this License,
|
|
||||||
other than an Application or a Combined Work as defined below.
|
|
||||||
|
|
||||||
An "Application" is any work that makes use of an interface provided
|
|
||||||
by the Library, but which is not otherwise based on the Library.
|
|
||||||
Defining a subclass of a class defined by the Library is deemed a mode
|
|
||||||
of using an interface provided by the Library.
|
|
||||||
|
|
||||||
A "Combined Work" is a work produced by combining or linking an
|
|
||||||
Application with the Library. The particular version of the Library
|
|
||||||
with which the Combined Work was made is also called the "Linked
|
|
||||||
Version".
|
|
||||||
|
|
||||||
The "Minimal Corresponding Source" for a Combined Work means the
|
|
||||||
Corresponding Source for the Combined Work, excluding any source code
|
|
||||||
for portions of the Combined Work that, considered in isolation, are
|
|
||||||
based on the Application, and not on the Linked Version.
|
|
||||||
|
|
||||||
The "Corresponding Application Code" for a Combined Work means the
|
|
||||||
object code and/or source code for the Application, including any data
|
|
||||||
and utility programs needed for reproducing the Combined Work from the
|
|
||||||
Application, but excluding the System Libraries of the Combined Work.
|
|
||||||
|
|
||||||
1. Exception to Section 3 of the GNU GPL.
|
|
||||||
|
|
||||||
You may convey a covered work under sections 3 and 4 of this License
|
|
||||||
without being bound by section 3 of the GNU GPL.
|
|
||||||
|
|
||||||
2. Conveying Modified Versions.
|
|
||||||
|
|
||||||
If you modify a copy of the Library, and, in your modifications, a
|
|
||||||
facility refers to a function or data to be supplied by an Application
|
|
||||||
that uses the facility (other than as an argument passed when the
|
|
||||||
facility is invoked), then you may convey a copy of the modified
|
|
||||||
version:
|
|
||||||
|
|
||||||
a) under this License, provided that you make a good faith effort to
|
|
||||||
ensure that, in the event an Application does not supply the
|
|
||||||
function or data, the facility still operates, and performs
|
|
||||||
whatever part of its purpose remains meaningful, or
|
|
||||||
|
|
||||||
b) under the GNU GPL, with none of the additional permissions of
|
|
||||||
this License applicable to that copy.
|
|
||||||
|
|
||||||
3. Object Code Incorporating Material from Library Header Files.
|
|
||||||
|
|
||||||
The object code form of an Application may incorporate material from
|
|
||||||
a header file that is part of the Library. You may convey such object
|
|
||||||
code under terms of your choice, provided that, if the incorporated
|
|
||||||
material is not limited to numerical parameters, data structure
|
|
||||||
layouts and accessors, or small macros, inline functions and templates
|
|
||||||
(ten or fewer lines in length), you do both of the following:
|
|
||||||
|
|
||||||
a) Give prominent notice with each copy of the object code that the
|
|
||||||
Library is used in it and that the Library and its use are
|
|
||||||
covered by this License.
|
|
||||||
|
|
||||||
b) Accompany the object code with a copy of the GNU GPL and this license
|
|
||||||
document.
|
|
||||||
|
|
||||||
4. Combined Works.
|
|
||||||
|
|
||||||
You may convey a Combined Work under terms of your choice that,
|
|
||||||
taken together, effectively do not restrict modification of the
|
|
||||||
portions of the Library contained in the Combined Work and reverse
|
|
||||||
engineering for debugging such modifications, if you also do each of
|
|
||||||
the following:
|
|
||||||
|
|
||||||
a) Give prominent notice with each copy of the Combined Work that
|
|
||||||
the Library is used in it and that the Library and its use are
|
|
||||||
covered by this License.
|
|
||||||
|
|
||||||
b) Accompany the Combined Work with a copy of the GNU GPL and this license
|
|
||||||
document.
|
|
||||||
|
|
||||||
c) For a Combined Work that displays copyright notices during
|
|
||||||
execution, include the copyright notice for the Library among
|
|
||||||
these notices, as well as a reference directing the user to the
|
|
||||||
copies of the GNU GPL and this license document.
|
|
||||||
|
|
||||||
d) Do one of the following:
|
|
||||||
|
|
||||||
0) Convey the Minimal Corresponding Source under the terms of this
|
|
||||||
License, and the Corresponding Application Code in a form
|
|
||||||
suitable for, and under terms that permit, the user to
|
|
||||||
recombine or relink the Application with a modified version of
|
|
||||||
the Linked Version to produce a modified Combined Work, in the
|
|
||||||
manner specified by section 6 of the GNU GPL for conveying
|
|
||||||
Corresponding Source.
|
|
||||||
|
|
||||||
1) Use a suitable shared library mechanism for linking with the
|
|
||||||
Library. A suitable mechanism is one that (a) uses at run time
|
|
||||||
a copy of the Library already present on the user's computer
|
|
||||||
system, and (b) will operate properly with a modified version
|
|
||||||
of the Library that is interface-compatible with the Linked
|
|
||||||
Version.
|
|
||||||
|
|
||||||
e) Provide Installation Information, but only if you would otherwise
|
|
||||||
be required to provide such information under section 6 of the
|
|
||||||
GNU GPL, and only to the extent that such information is
|
|
||||||
necessary to install and execute a modified version of the
|
|
||||||
Combined Work produced by recombining or relinking the
|
|
||||||
Application with a modified version of the Linked Version. (If
|
|
||||||
you use option 4d0, the Installation Information must accompany
|
|
||||||
the Minimal Corresponding Source and Corresponding Application
|
|
||||||
Code. If you use option 4d1, you must provide the Installation
|
|
||||||
Information in the manner specified by section 6 of the GNU GPL
|
|
||||||
for conveying Corresponding Source.)
|
|
||||||
|
|
||||||
5. Combined Libraries.
|
|
||||||
|
|
||||||
You may place library facilities that are a work based on the
|
|
||||||
Library side by side in a single library together with other library
|
|
||||||
facilities that are not Applications and are not covered by this
|
|
||||||
License, and convey such a combined library under terms of your
|
|
||||||
choice, if you do both of the following:
|
|
||||||
|
|
||||||
a) Accompany the combined library with a copy of the same work based
|
|
||||||
on the Library, uncombined with any other library facilities,
|
|
||||||
conveyed under the terms of this License.
|
|
||||||
|
|
||||||
b) Give prominent notice with the combined library that part of it
|
|
||||||
is a work based on the Library, and explaining where to find the
|
|
||||||
accompanying uncombined form of the same work.
|
|
||||||
|
|
||||||
6. Revised Versions of the GNU Lesser General Public License.
|
|
||||||
|
|
||||||
The Free Software Foundation may publish revised and/or new versions
|
|
||||||
of the GNU Lesser General Public License from time to time. Such new
|
|
||||||
versions will be similar in spirit to the present version, but may
|
|
||||||
differ in detail to address new problems or concerns.
|
|
||||||
|
|
||||||
Each version is given a distinguishing version number. If the
|
|
||||||
Library as you received it specifies that a certain numbered version
|
|
||||||
of the GNU Lesser General Public License "or any later version"
|
|
||||||
applies to it, you have the option of following the terms and
|
|
||||||
conditions either of that published version or of any later version
|
|
||||||
published by the Free Software Foundation. If the Library as you
|
|
||||||
received it does not specify a version number of the GNU Lesser
|
|
||||||
General Public License, you may choose any version of the GNU Lesser
|
|
||||||
General Public License ever published by the Free Software Foundation.
|
|
||||||
|
|
||||||
If the Library as you received it specifies that a proxy can decide
|
|
||||||
whether future versions of the GNU Lesser General Public License shall
|
|
||||||
apply, that proxy's public statement of acceptance of any version is
|
|
||||||
permanent authorization for you to choose that version for the
|
|
||||||
Library.
|
|
|
@ -1,128 +0,0 @@
|
||||||
# YAML support for the Go language
|
|
||||||
|
|
||||||
Introduction
|
|
||||||
------------
|
|
||||||
|
|
||||||
The yaml package enables Go programs to comfortably encode and decode YAML
|
|
||||||
values. It was developed within [Canonical](https://www.canonical.com) as
|
|
||||||
part of the [juju](https://juju.ubuntu.com) project, and is based on a
|
|
||||||
pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML)
|
|
||||||
C library to parse and generate YAML data quickly and reliably.
|
|
||||||
|
|
||||||
Compatibility
|
|
||||||
-------------
|
|
||||||
|
|
||||||
The yaml package supports most of YAML 1.1 and 1.2, including support for
|
|
||||||
anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
|
|
||||||
implemented, and base-60 floats from YAML 1.1 are purposefully not
|
|
||||||
supported since they're a poor design and are gone in YAML 1.2.
|
|
||||||
|
|
||||||
Installation and usage
|
|
||||||
----------------------
|
|
||||||
|
|
||||||
The import path for the package is *gopkg.in/yaml.v1*.
|
|
||||||
|
|
||||||
To install it, run:
|
|
||||||
|
|
||||||
go get gopkg.in/yaml.v1
|
|
||||||
|
|
||||||
API documentation
|
|
||||||
-----------------
|
|
||||||
|
|
||||||
If opened in a browser, the import path itself leads to the API documentation:
|
|
||||||
|
|
||||||
* [https://gopkg.in/yaml.v1](https://gopkg.in/yaml.v1)
|
|
||||||
|
|
||||||
API stability
|
|
||||||
-------------
|
|
||||||
|
|
||||||
The package API for yaml v1 will remain stable as described in [gopkg.in](https://gopkg.in).
|
|
||||||
|
|
||||||
|
|
||||||
License
|
|
||||||
-------
|
|
||||||
|
|
||||||
The yaml package is licensed under the LGPL with an exception that allows it to be linked statically. Please see the LICENSE file for details.
|
|
||||||
|
|
||||||
|
|
||||||
Example
|
|
||||||
-------
|
|
||||||
|
|
||||||
```Go
|
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"log"
|
|
||||||
|
|
||||||
"gopkg.in/yaml.v1"
|
|
||||||
)
|
|
||||||
|
|
||||||
var data = `
|
|
||||||
a: Easy!
|
|
||||||
b:
|
|
||||||
c: 2
|
|
||||||
d: [3, 4]
|
|
||||||
`
|
|
||||||
|
|
||||||
type T struct {
|
|
||||||
A string
|
|
||||||
B struct{C int; D []int ",flow"}
|
|
||||||
}
|
|
||||||
|
|
||||||
func main() {
|
|
||||||
t := T{}
|
|
||||||
|
|
||||||
err := yaml.Unmarshal([]byte(data), &t)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- t:\n%v\n\n", t)
|
|
||||||
|
|
||||||
d, err := yaml.Marshal(&t)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- t dump:\n%s\n\n", string(d))
|
|
||||||
|
|
||||||
m := make(map[interface{}]interface{})
|
|
||||||
|
|
||||||
err = yaml.Unmarshal([]byte(data), &m)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- m:\n%v\n\n", m)
|
|
||||||
|
|
||||||
d, err = yaml.Marshal(&m)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("error: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Printf("--- m dump:\n%s\n\n", string(d))
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
This example will generate the following output:
|
|
||||||
|
|
||||||
```
|
|
||||||
--- t:
|
|
||||||
{Easy! {2 [3 4]}}
|
|
||||||
|
|
||||||
--- t dump:
|
|
||||||
a: Easy!
|
|
||||||
b:
|
|
||||||
c: 2
|
|
||||||
d: [3, 4]
|
|
||||||
|
|
||||||
|
|
||||||
--- m:
|
|
||||||
map[a:Easy! b:map[c:2 d:[3 4]]]
|
|
||||||
|
|
||||||
--- m dump:
|
|
||||||
a: Easy!
|
|
||||||
b:
|
|
||||||
c: 2
|
|
||||||
d:
|
|
||||||
- 3
|
|
||||||
- 4
|
|
||||||
```
|
|
||||||
|
|
|
@ -1,742 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"io"
|
|
||||||
"os"
|
|
||||||
)
|
|
||||||
|
|
||||||
func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
|
|
||||||
//fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
|
|
||||||
|
|
||||||
// Check if we can move the queue at the beginning of the buffer.
|
|
||||||
if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
|
|
||||||
if parser.tokens_head != len(parser.tokens) {
|
|
||||||
copy(parser.tokens, parser.tokens[parser.tokens_head:])
|
|
||||||
}
|
|
||||||
parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
|
|
||||||
parser.tokens_head = 0
|
|
||||||
}
|
|
||||||
parser.tokens = append(parser.tokens, *token)
|
|
||||||
if pos < 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
|
|
||||||
parser.tokens[parser.tokens_head+pos] = *token
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a new parser object.
|
|
||||||
func yaml_parser_initialize(parser *yaml_parser_t) bool {
|
|
||||||
*parser = yaml_parser_t{
|
|
||||||
raw_buffer: make([]byte, 0, input_raw_buffer_size),
|
|
||||||
buffer: make([]byte, 0, input_buffer_size),
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy a parser object.
|
|
||||||
func yaml_parser_delete(parser *yaml_parser_t) {
|
|
||||||
*parser = yaml_parser_t{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// String read handler.
|
|
||||||
func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
|
|
||||||
if parser.input_pos == len(parser.input) {
|
|
||||||
return 0, io.EOF
|
|
||||||
}
|
|
||||||
n = copy(buffer, parser.input[parser.input_pos:])
|
|
||||||
parser.input_pos += n
|
|
||||||
return n, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// File read handler.
|
|
||||||
func yaml_file_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
|
|
||||||
return parser.input_file.Read(buffer)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set a string input.
|
|
||||||
func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
|
|
||||||
if parser.read_handler != nil {
|
|
||||||
panic("must set the input source only once")
|
|
||||||
}
|
|
||||||
parser.read_handler = yaml_string_read_handler
|
|
||||||
parser.input = input
|
|
||||||
parser.input_pos = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set a file input.
|
|
||||||
func yaml_parser_set_input_file(parser *yaml_parser_t, file *os.File) {
|
|
||||||
if parser.read_handler != nil {
|
|
||||||
panic("must set the input source only once")
|
|
||||||
}
|
|
||||||
parser.read_handler = yaml_file_read_handler
|
|
||||||
parser.input_file = file
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set the source encoding.
|
|
||||||
func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
|
|
||||||
if parser.encoding != yaml_ANY_ENCODING {
|
|
||||||
panic("must set the encoding only once")
|
|
||||||
}
|
|
||||||
parser.encoding = encoding
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a new emitter object.
|
|
||||||
func yaml_emitter_initialize(emitter *yaml_emitter_t) bool {
|
|
||||||
*emitter = yaml_emitter_t{
|
|
||||||
buffer: make([]byte, output_buffer_size),
|
|
||||||
raw_buffer: make([]byte, 0, output_raw_buffer_size),
|
|
||||||
states: make([]yaml_emitter_state_t, 0, initial_stack_size),
|
|
||||||
events: make([]yaml_event_t, 0, initial_queue_size),
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy an emitter object.
|
|
||||||
func yaml_emitter_delete(emitter *yaml_emitter_t) {
|
|
||||||
*emitter = yaml_emitter_t{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// String write handler.
|
|
||||||
func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
|
|
||||||
*emitter.output_buffer = append(*emitter.output_buffer, buffer...)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// File write handler.
|
|
||||||
func yaml_file_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
|
|
||||||
_, err := emitter.output_file.Write(buffer)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set a string output.
|
|
||||||
func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
|
|
||||||
if emitter.write_handler != nil {
|
|
||||||
panic("must set the output target only once")
|
|
||||||
}
|
|
||||||
emitter.write_handler = yaml_string_write_handler
|
|
||||||
emitter.output_buffer = output_buffer
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set a file output.
|
|
||||||
func yaml_emitter_set_output_file(emitter *yaml_emitter_t, file io.Writer) {
|
|
||||||
if emitter.write_handler != nil {
|
|
||||||
panic("must set the output target only once")
|
|
||||||
}
|
|
||||||
emitter.write_handler = yaml_file_write_handler
|
|
||||||
emitter.output_file = file
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set the output encoding.
|
|
||||||
func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
|
|
||||||
if emitter.encoding != yaml_ANY_ENCODING {
|
|
||||||
panic("must set the output encoding only once")
|
|
||||||
}
|
|
||||||
emitter.encoding = encoding
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set the canonical output style.
|
|
||||||
func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
|
|
||||||
emitter.canonical = canonical
|
|
||||||
}
|
|
||||||
|
|
||||||
//// Set the indentation increment.
|
|
||||||
func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
|
|
||||||
if indent < 2 || indent > 9 {
|
|
||||||
indent = 2
|
|
||||||
}
|
|
||||||
emitter.best_indent = indent
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set the preferred line width.
|
|
||||||
func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
|
|
||||||
if width < 0 {
|
|
||||||
width = -1
|
|
||||||
}
|
|
||||||
emitter.best_width = width
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set if unescaped non-ASCII characters are allowed.
|
|
||||||
func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
|
|
||||||
emitter.unicode = unicode
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set the preferred line break character.
|
|
||||||
func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
|
|
||||||
emitter.line_break = line_break
|
|
||||||
}
|
|
||||||
|
|
||||||
///*
|
|
||||||
// * Destroy a token object.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(void)
|
|
||||||
//yaml_token_delete(yaml_token_t *token)
|
|
||||||
//{
|
|
||||||
// assert(token); // Non-NULL token object expected.
|
|
||||||
//
|
|
||||||
// switch (token.type)
|
|
||||||
// {
|
|
||||||
// case YAML_TAG_DIRECTIVE_TOKEN:
|
|
||||||
// yaml_free(token.data.tag_directive.handle);
|
|
||||||
// yaml_free(token.data.tag_directive.prefix);
|
|
||||||
// break;
|
|
||||||
//
|
|
||||||
// case YAML_ALIAS_TOKEN:
|
|
||||||
// yaml_free(token.data.alias.value);
|
|
||||||
// break;
|
|
||||||
//
|
|
||||||
// case YAML_ANCHOR_TOKEN:
|
|
||||||
// yaml_free(token.data.anchor.value);
|
|
||||||
// break;
|
|
||||||
//
|
|
||||||
// case YAML_TAG_TOKEN:
|
|
||||||
// yaml_free(token.data.tag.handle);
|
|
||||||
// yaml_free(token.data.tag.suffix);
|
|
||||||
// break;
|
|
||||||
//
|
|
||||||
// case YAML_SCALAR_TOKEN:
|
|
||||||
// yaml_free(token.data.scalar.value);
|
|
||||||
// break;
|
|
||||||
//
|
|
||||||
// default:
|
|
||||||
// break;
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// memset(token, 0, sizeof(yaml_token_t));
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///*
|
|
||||||
// * Check if a string is a valid UTF-8 sequence.
|
|
||||||
// *
|
|
||||||
// * Check 'reader.c' for more details on UTF-8 encoding.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//static int
|
|
||||||
//yaml_check_utf8(yaml_char_t *start, size_t length)
|
|
||||||
//{
|
|
||||||
// yaml_char_t *end = start+length;
|
|
||||||
// yaml_char_t *pointer = start;
|
|
||||||
//
|
|
||||||
// while (pointer < end) {
|
|
||||||
// unsigned char octet;
|
|
||||||
// unsigned int width;
|
|
||||||
// unsigned int value;
|
|
||||||
// size_t k;
|
|
||||||
//
|
|
||||||
// octet = pointer[0];
|
|
||||||
// width = (octet & 0x80) == 0x00 ? 1 :
|
|
||||||
// (octet & 0xE0) == 0xC0 ? 2 :
|
|
||||||
// (octet & 0xF0) == 0xE0 ? 3 :
|
|
||||||
// (octet & 0xF8) == 0xF0 ? 4 : 0;
|
|
||||||
// value = (octet & 0x80) == 0x00 ? octet & 0x7F :
|
|
||||||
// (octet & 0xE0) == 0xC0 ? octet & 0x1F :
|
|
||||||
// (octet & 0xF0) == 0xE0 ? octet & 0x0F :
|
|
||||||
// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
|
|
||||||
// if (!width) return 0;
|
|
||||||
// if (pointer+width > end) return 0;
|
|
||||||
// for (k = 1; k < width; k ++) {
|
|
||||||
// octet = pointer[k];
|
|
||||||
// if ((octet & 0xC0) != 0x80) return 0;
|
|
||||||
// value = (value << 6) + (octet & 0x3F);
|
|
||||||
// }
|
|
||||||
// if (!((width == 1) ||
|
|
||||||
// (width == 2 && value >= 0x80) ||
|
|
||||||
// (width == 3 && value >= 0x800) ||
|
|
||||||
// (width == 4 && value >= 0x10000))) return 0;
|
|
||||||
//
|
|
||||||
// pointer += width;
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// return 1;
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
|
|
||||||
// Create STREAM-START.
|
|
||||||
func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_STREAM_START_EVENT,
|
|
||||||
encoding: encoding,
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create STREAM-END.
|
|
||||||
func yaml_stream_end_event_initialize(event *yaml_event_t) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_STREAM_END_EVENT,
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create DOCUMENT-START.
|
|
||||||
func yaml_document_start_event_initialize(event *yaml_event_t, version_directive *yaml_version_directive_t,
|
|
||||||
tag_directives []yaml_tag_directive_t, implicit bool) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_DOCUMENT_START_EVENT,
|
|
||||||
version_directive: version_directive,
|
|
||||||
tag_directives: tag_directives,
|
|
||||||
implicit: implicit,
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create DOCUMENT-END.
|
|
||||||
func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_DOCUMENT_END_EVENT,
|
|
||||||
implicit: implicit,
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
///*
|
|
||||||
// * Create ALIAS.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(int)
|
|
||||||
//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
|
|
||||||
//{
|
|
||||||
// mark yaml_mark_t = { 0, 0, 0 }
|
|
||||||
// anchor_copy *yaml_char_t = NULL
|
|
||||||
//
|
|
||||||
// assert(event) // Non-NULL event object is expected.
|
|
||||||
// assert(anchor) // Non-NULL anchor is expected.
|
|
||||||
//
|
|
||||||
// if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
|
|
||||||
//
|
|
||||||
// anchor_copy = yaml_strdup(anchor)
|
|
||||||
// if (!anchor_copy)
|
|
||||||
// return 0
|
|
||||||
//
|
|
||||||
// ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
|
|
||||||
//
|
|
||||||
// return 1
|
|
||||||
//}
|
|
||||||
|
|
||||||
// Create SCALAR.
|
|
||||||
func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_SCALAR_EVENT,
|
|
||||||
anchor: anchor,
|
|
||||||
tag: tag,
|
|
||||||
value: value,
|
|
||||||
implicit: plain_implicit,
|
|
||||||
quoted_implicit: quoted_implicit,
|
|
||||||
style: yaml_style_t(style),
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create SEQUENCE-START.
|
|
||||||
func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_SEQUENCE_START_EVENT,
|
|
||||||
anchor: anchor,
|
|
||||||
tag: tag,
|
|
||||||
implicit: implicit,
|
|
||||||
style: yaml_style_t(style),
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create SEQUENCE-END.
|
|
||||||
func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_SEQUENCE_END_EVENT,
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create MAPPING-START.
|
|
||||||
func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_MAPPING_START_EVENT,
|
|
||||||
anchor: anchor,
|
|
||||||
tag: tag,
|
|
||||||
implicit: implicit,
|
|
||||||
style: yaml_style_t(style),
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create MAPPING-END.
|
|
||||||
func yaml_mapping_end_event_initialize(event *yaml_event_t) bool {
|
|
||||||
*event = yaml_event_t{
|
|
||||||
typ: yaml_MAPPING_END_EVENT,
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy an event object.
|
|
||||||
func yaml_event_delete(event *yaml_event_t) {
|
|
||||||
*event = yaml_event_t{}
|
|
||||||
}
|
|
||||||
|
|
||||||
///*
|
|
||||||
// * Create a document object.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(int)
|
|
||||||
//yaml_document_initialize(document *yaml_document_t,
|
|
||||||
// version_directive *yaml_version_directive_t,
|
|
||||||
// tag_directives_start *yaml_tag_directive_t,
|
|
||||||
// tag_directives_end *yaml_tag_directive_t,
|
|
||||||
// start_implicit int, end_implicit int)
|
|
||||||
//{
|
|
||||||
// struct {
|
|
||||||
// error yaml_error_type_t
|
|
||||||
// } context
|
|
||||||
// struct {
|
|
||||||
// start *yaml_node_t
|
|
||||||
// end *yaml_node_t
|
|
||||||
// top *yaml_node_t
|
|
||||||
// } nodes = { NULL, NULL, NULL }
|
|
||||||
// version_directive_copy *yaml_version_directive_t = NULL
|
|
||||||
// struct {
|
|
||||||
// start *yaml_tag_directive_t
|
|
||||||
// end *yaml_tag_directive_t
|
|
||||||
// top *yaml_tag_directive_t
|
|
||||||
// } tag_directives_copy = { NULL, NULL, NULL }
|
|
||||||
// value yaml_tag_directive_t = { NULL, NULL }
|
|
||||||
// mark yaml_mark_t = { 0, 0, 0 }
|
|
||||||
//
|
|
||||||
// assert(document) // Non-NULL document object is expected.
|
|
||||||
// assert((tag_directives_start && tag_directives_end) ||
|
|
||||||
// (tag_directives_start == tag_directives_end))
|
|
||||||
// // Valid tag directives are expected.
|
|
||||||
//
|
|
||||||
// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
|
|
||||||
//
|
|
||||||
// if (version_directive) {
|
|
||||||
// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
|
|
||||||
// if (!version_directive_copy) goto error
|
|
||||||
// version_directive_copy.major = version_directive.major
|
|
||||||
// version_directive_copy.minor = version_directive.minor
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// if (tag_directives_start != tag_directives_end) {
|
|
||||||
// tag_directive *yaml_tag_directive_t
|
|
||||||
// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
|
|
||||||
// goto error
|
|
||||||
// for (tag_directive = tag_directives_start
|
|
||||||
// tag_directive != tag_directives_end; tag_directive ++) {
|
|
||||||
// assert(tag_directive.handle)
|
|
||||||
// assert(tag_directive.prefix)
|
|
||||||
// if (!yaml_check_utf8(tag_directive.handle,
|
|
||||||
// strlen((char *)tag_directive.handle)))
|
|
||||||
// goto error
|
|
||||||
// if (!yaml_check_utf8(tag_directive.prefix,
|
|
||||||
// strlen((char *)tag_directive.prefix)))
|
|
||||||
// goto error
|
|
||||||
// value.handle = yaml_strdup(tag_directive.handle)
|
|
||||||
// value.prefix = yaml_strdup(tag_directive.prefix)
|
|
||||||
// if (!value.handle || !value.prefix) goto error
|
|
||||||
// if (!PUSH(&context, tag_directives_copy, value))
|
|
||||||
// goto error
|
|
||||||
// value.handle = NULL
|
|
||||||
// value.prefix = NULL
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
|
|
||||||
// tag_directives_copy.start, tag_directives_copy.top,
|
|
||||||
// start_implicit, end_implicit, mark, mark)
|
|
||||||
//
|
|
||||||
// return 1
|
|
||||||
//
|
|
||||||
//error:
|
|
||||||
// STACK_DEL(&context, nodes)
|
|
||||||
// yaml_free(version_directive_copy)
|
|
||||||
// while (!STACK_EMPTY(&context, tag_directives_copy)) {
|
|
||||||
// value yaml_tag_directive_t = POP(&context, tag_directives_copy)
|
|
||||||
// yaml_free(value.handle)
|
|
||||||
// yaml_free(value.prefix)
|
|
||||||
// }
|
|
||||||
// STACK_DEL(&context, tag_directives_copy)
|
|
||||||
// yaml_free(value.handle)
|
|
||||||
// yaml_free(value.prefix)
|
|
||||||
//
|
|
||||||
// return 0
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///*
|
|
||||||
// * Destroy a document object.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(void)
|
|
||||||
//yaml_document_delete(document *yaml_document_t)
|
|
||||||
//{
|
|
||||||
// struct {
|
|
||||||
// error yaml_error_type_t
|
|
||||||
// } context
|
|
||||||
// tag_directive *yaml_tag_directive_t
|
|
||||||
//
|
|
||||||
// context.error = YAML_NO_ERROR // Eliminate a compliler warning.
|
|
||||||
//
|
|
||||||
// assert(document) // Non-NULL document object is expected.
|
|
||||||
//
|
|
||||||
// while (!STACK_EMPTY(&context, document.nodes)) {
|
|
||||||
// node yaml_node_t = POP(&context, document.nodes)
|
|
||||||
// yaml_free(node.tag)
|
|
||||||
// switch (node.type) {
|
|
||||||
// case YAML_SCALAR_NODE:
|
|
||||||
// yaml_free(node.data.scalar.value)
|
|
||||||
// break
|
|
||||||
// case YAML_SEQUENCE_NODE:
|
|
||||||
// STACK_DEL(&context, node.data.sequence.items)
|
|
||||||
// break
|
|
||||||
// case YAML_MAPPING_NODE:
|
|
||||||
// STACK_DEL(&context, node.data.mapping.pairs)
|
|
||||||
// break
|
|
||||||
// default:
|
|
||||||
// assert(0) // Should not happen.
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// STACK_DEL(&context, document.nodes)
|
|
||||||
//
|
|
||||||
// yaml_free(document.version_directive)
|
|
||||||
// for (tag_directive = document.tag_directives.start
|
|
||||||
// tag_directive != document.tag_directives.end
|
|
||||||
// tag_directive++) {
|
|
||||||
// yaml_free(tag_directive.handle)
|
|
||||||
// yaml_free(tag_directive.prefix)
|
|
||||||
// }
|
|
||||||
// yaml_free(document.tag_directives.start)
|
|
||||||
//
|
|
||||||
// memset(document, 0, sizeof(yaml_document_t))
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///**
|
|
||||||
// * Get a document node.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(yaml_node_t *)
|
|
||||||
//yaml_document_get_node(document *yaml_document_t, index int)
|
|
||||||
//{
|
|
||||||
// assert(document) // Non-NULL document object is expected.
|
|
||||||
//
|
|
||||||
// if (index > 0 && document.nodes.start + index <= document.nodes.top) {
|
|
||||||
// return document.nodes.start + index - 1
|
|
||||||
// }
|
|
||||||
// return NULL
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///**
|
|
||||||
// * Get the root object.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(yaml_node_t *)
|
|
||||||
//yaml_document_get_root_node(document *yaml_document_t)
|
|
||||||
//{
|
|
||||||
// assert(document) // Non-NULL document object is expected.
|
|
||||||
//
|
|
||||||
// if (document.nodes.top != document.nodes.start) {
|
|
||||||
// return document.nodes.start
|
|
||||||
// }
|
|
||||||
// return NULL
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///*
|
|
||||||
// * Add a scalar node to a document.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(int)
|
|
||||||
//yaml_document_add_scalar(document *yaml_document_t,
|
|
||||||
// tag *yaml_char_t, value *yaml_char_t, length int,
|
|
||||||
// style yaml_scalar_style_t)
|
|
||||||
//{
|
|
||||||
// struct {
|
|
||||||
// error yaml_error_type_t
|
|
||||||
// } context
|
|
||||||
// mark yaml_mark_t = { 0, 0, 0 }
|
|
||||||
// tag_copy *yaml_char_t = NULL
|
|
||||||
// value_copy *yaml_char_t = NULL
|
|
||||||
// node yaml_node_t
|
|
||||||
//
|
|
||||||
// assert(document) // Non-NULL document object is expected.
|
|
||||||
// assert(value) // Non-NULL value is expected.
|
|
||||||
//
|
|
||||||
// if (!tag) {
|
|
||||||
// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
|
|
||||||
// tag_copy = yaml_strdup(tag)
|
|
||||||
// if (!tag_copy) goto error
|
|
||||||
//
|
|
||||||
// if (length < 0) {
|
|
||||||
// length = strlen((char *)value)
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// if (!yaml_check_utf8(value, length)) goto error
|
|
||||||
// value_copy = yaml_malloc(length+1)
|
|
||||||
// if (!value_copy) goto error
|
|
||||||
// memcpy(value_copy, value, length)
|
|
||||||
// value_copy[length] = '\0'
|
|
||||||
//
|
|
||||||
// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
|
|
||||||
// if (!PUSH(&context, document.nodes, node)) goto error
|
|
||||||
//
|
|
||||||
// return document.nodes.top - document.nodes.start
|
|
||||||
//
|
|
||||||
//error:
|
|
||||||
// yaml_free(tag_copy)
|
|
||||||
// yaml_free(value_copy)
|
|
||||||
//
|
|
||||||
// return 0
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///*
|
|
||||||
// * Add a sequence node to a document.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(int)
|
|
||||||
//yaml_document_add_sequence(document *yaml_document_t,
|
|
||||||
// tag *yaml_char_t, style yaml_sequence_style_t)
|
|
||||||
//{
|
|
||||||
// struct {
|
|
||||||
// error yaml_error_type_t
|
|
||||||
// } context
|
|
||||||
// mark yaml_mark_t = { 0, 0, 0 }
|
|
||||||
// tag_copy *yaml_char_t = NULL
|
|
||||||
// struct {
|
|
||||||
// start *yaml_node_item_t
|
|
||||||
// end *yaml_node_item_t
|
|
||||||
// top *yaml_node_item_t
|
|
||||||
// } items = { NULL, NULL, NULL }
|
|
||||||
// node yaml_node_t
|
|
||||||
//
|
|
||||||
// assert(document) // Non-NULL document object is expected.
|
|
||||||
//
|
|
||||||
// if (!tag) {
|
|
||||||
// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
|
|
||||||
// tag_copy = yaml_strdup(tag)
|
|
||||||
// if (!tag_copy) goto error
|
|
||||||
//
|
|
||||||
// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
|
|
||||||
//
|
|
||||||
// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
|
|
||||||
// style, mark, mark)
|
|
||||||
// if (!PUSH(&context, document.nodes, node)) goto error
|
|
||||||
//
|
|
||||||
// return document.nodes.top - document.nodes.start
|
|
||||||
//
|
|
||||||
//error:
|
|
||||||
// STACK_DEL(&context, items)
|
|
||||||
// yaml_free(tag_copy)
|
|
||||||
//
|
|
||||||
// return 0
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///*
|
|
||||||
// * Add a mapping node to a document.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(int)
|
|
||||||
//yaml_document_add_mapping(document *yaml_document_t,
|
|
||||||
// tag *yaml_char_t, style yaml_mapping_style_t)
|
|
||||||
//{
|
|
||||||
// struct {
|
|
||||||
// error yaml_error_type_t
|
|
||||||
// } context
|
|
||||||
// mark yaml_mark_t = { 0, 0, 0 }
|
|
||||||
// tag_copy *yaml_char_t = NULL
|
|
||||||
// struct {
|
|
||||||
// start *yaml_node_pair_t
|
|
||||||
// end *yaml_node_pair_t
|
|
||||||
// top *yaml_node_pair_t
|
|
||||||
// } pairs = { NULL, NULL, NULL }
|
|
||||||
// node yaml_node_t
|
|
||||||
//
|
|
||||||
// assert(document) // Non-NULL document object is expected.
|
|
||||||
//
|
|
||||||
// if (!tag) {
|
|
||||||
// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
|
|
||||||
// tag_copy = yaml_strdup(tag)
|
|
||||||
// if (!tag_copy) goto error
|
|
||||||
//
|
|
||||||
// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
|
|
||||||
//
|
|
||||||
// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
|
|
||||||
// style, mark, mark)
|
|
||||||
// if (!PUSH(&context, document.nodes, node)) goto error
|
|
||||||
//
|
|
||||||
// return document.nodes.top - document.nodes.start
|
|
||||||
//
|
|
||||||
//error:
|
|
||||||
// STACK_DEL(&context, pairs)
|
|
||||||
// yaml_free(tag_copy)
|
|
||||||
//
|
|
||||||
// return 0
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///*
|
|
||||||
// * Append an item to a sequence node.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(int)
|
|
||||||
//yaml_document_append_sequence_item(document *yaml_document_t,
|
|
||||||
// sequence int, item int)
|
|
||||||
//{
|
|
||||||
// struct {
|
|
||||||
// error yaml_error_type_t
|
|
||||||
// } context
|
|
||||||
//
|
|
||||||
// assert(document) // Non-NULL document is required.
|
|
||||||
// assert(sequence > 0
|
|
||||||
// && document.nodes.start + sequence <= document.nodes.top)
|
|
||||||
// // Valid sequence id is required.
|
|
||||||
// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
|
|
||||||
// // A sequence node is required.
|
|
||||||
// assert(item > 0 && document.nodes.start + item <= document.nodes.top)
|
|
||||||
// // Valid item id is required.
|
|
||||||
//
|
|
||||||
// if (!PUSH(&context,
|
|
||||||
// document.nodes.start[sequence-1].data.sequence.items, item))
|
|
||||||
// return 0
|
|
||||||
//
|
|
||||||
// return 1
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
///*
|
|
||||||
// * Append a pair of a key and a value to a mapping node.
|
|
||||||
// */
|
|
||||||
//
|
|
||||||
//YAML_DECLARE(int)
|
|
||||||
//yaml_document_append_mapping_pair(document *yaml_document_t,
|
|
||||||
// mapping int, key int, value int)
|
|
||||||
//{
|
|
||||||
// struct {
|
|
||||||
// error yaml_error_type_t
|
|
||||||
// } context
|
|
||||||
//
|
|
||||||
// pair yaml_node_pair_t
|
|
||||||
//
|
|
||||||
// assert(document) // Non-NULL document is required.
|
|
||||||
// assert(mapping > 0
|
|
||||||
// && document.nodes.start + mapping <= document.nodes.top)
|
|
||||||
// // Valid mapping id is required.
|
|
||||||
// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
|
|
||||||
// // A mapping node is required.
|
|
||||||
// assert(key > 0 && document.nodes.start + key <= document.nodes.top)
|
|
||||||
// // Valid key id is required.
|
|
||||||
// assert(value > 0 && document.nodes.start + value <= document.nodes.top)
|
|
||||||
// // Valid value id is required.
|
|
||||||
//
|
|
||||||
// pair.key = key
|
|
||||||
// pair.value = value
|
|
||||||
//
|
|
||||||
// if (!PUSH(&context,
|
|
||||||
// document.nodes.start[mapping-1].data.mapping.pairs, pair))
|
|
||||||
// return 0
|
|
||||||
//
|
|
||||||
// return 1
|
|
||||||
//}
|
|
||||||
//
|
|
||||||
//
|
|
|
@ -1,566 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/base64"
|
|
||||||
"fmt"
|
|
||||||
"reflect"
|
|
||||||
"strconv"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
documentNode = 1 << iota
|
|
||||||
mappingNode
|
|
||||||
sequenceNode
|
|
||||||
scalarNode
|
|
||||||
aliasNode
|
|
||||||
)
|
|
||||||
|
|
||||||
type node struct {
|
|
||||||
kind int
|
|
||||||
line, column int
|
|
||||||
tag string
|
|
||||||
value string
|
|
||||||
implicit bool
|
|
||||||
children []*node
|
|
||||||
anchors map[string]*node
|
|
||||||
}
|
|
||||||
|
|
||||||
// ----------------------------------------------------------------------------
|
|
||||||
// Parser, produces a node tree out of a libyaml event stream.
|
|
||||||
|
|
||||||
type parser struct {
|
|
||||||
parser yaml_parser_t
|
|
||||||
event yaml_event_t
|
|
||||||
doc *node
|
|
||||||
}
|
|
||||||
|
|
||||||
func newParser(b []byte) *parser {
|
|
||||||
p := parser{}
|
|
||||||
if !yaml_parser_initialize(&p.parser) {
|
|
||||||
panic("Failed to initialize YAML emitter")
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(b) == 0 {
|
|
||||||
b = []byte{'\n'}
|
|
||||||
}
|
|
||||||
|
|
||||||
yaml_parser_set_input_string(&p.parser, b)
|
|
||||||
|
|
||||||
p.skip()
|
|
||||||
if p.event.typ != yaml_STREAM_START_EVENT {
|
|
||||||
panic("Expected stream start event, got " + strconv.Itoa(int(p.event.typ)))
|
|
||||||
}
|
|
||||||
p.skip()
|
|
||||||
return &p
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) destroy() {
|
|
||||||
if p.event.typ != yaml_NO_EVENT {
|
|
||||||
yaml_event_delete(&p.event)
|
|
||||||
}
|
|
||||||
yaml_parser_delete(&p.parser)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) skip() {
|
|
||||||
if p.event.typ != yaml_NO_EVENT {
|
|
||||||
if p.event.typ == yaml_STREAM_END_EVENT {
|
|
||||||
fail("Attempted to go past the end of stream. Corrupted value?")
|
|
||||||
}
|
|
||||||
yaml_event_delete(&p.event)
|
|
||||||
}
|
|
||||||
if !yaml_parser_parse(&p.parser, &p.event) {
|
|
||||||
p.fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) fail() {
|
|
||||||
var where string
|
|
||||||
var line int
|
|
||||||
if p.parser.problem_mark.line != 0 {
|
|
||||||
line = p.parser.problem_mark.line
|
|
||||||
} else if p.parser.context_mark.line != 0 {
|
|
||||||
line = p.parser.context_mark.line
|
|
||||||
}
|
|
||||||
if line != 0 {
|
|
||||||
where = "line " + strconv.Itoa(line) + ": "
|
|
||||||
}
|
|
||||||
var msg string
|
|
||||||
if len(p.parser.problem) > 0 {
|
|
||||||
msg = p.parser.problem
|
|
||||||
} else {
|
|
||||||
msg = "Unknown problem parsing YAML content"
|
|
||||||
}
|
|
||||||
fail(where + msg)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) anchor(n *node, anchor []byte) {
|
|
||||||
if anchor != nil {
|
|
||||||
p.doc.anchors[string(anchor)] = n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) parse() *node {
|
|
||||||
switch p.event.typ {
|
|
||||||
case yaml_SCALAR_EVENT:
|
|
||||||
return p.scalar()
|
|
||||||
case yaml_ALIAS_EVENT:
|
|
||||||
return p.alias()
|
|
||||||
case yaml_MAPPING_START_EVENT:
|
|
||||||
return p.mapping()
|
|
||||||
case yaml_SEQUENCE_START_EVENT:
|
|
||||||
return p.sequence()
|
|
||||||
case yaml_DOCUMENT_START_EVENT:
|
|
||||||
return p.document()
|
|
||||||
case yaml_STREAM_END_EVENT:
|
|
||||||
// Happens when attempting to decode an empty buffer.
|
|
||||||
return nil
|
|
||||||
default:
|
|
||||||
panic("Attempted to parse unknown event: " + strconv.Itoa(int(p.event.typ)))
|
|
||||||
}
|
|
||||||
panic("unreachable")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) node(kind int) *node {
|
|
||||||
return &node{
|
|
||||||
kind: kind,
|
|
||||||
line: p.event.start_mark.line,
|
|
||||||
column: p.event.start_mark.column,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) document() *node {
|
|
||||||
n := p.node(documentNode)
|
|
||||||
n.anchors = make(map[string]*node)
|
|
||||||
p.doc = n
|
|
||||||
p.skip()
|
|
||||||
n.children = append(n.children, p.parse())
|
|
||||||
if p.event.typ != yaml_DOCUMENT_END_EVENT {
|
|
||||||
panic("Expected end of document event but got " + strconv.Itoa(int(p.event.typ)))
|
|
||||||
}
|
|
||||||
p.skip()
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) alias() *node {
|
|
||||||
n := p.node(aliasNode)
|
|
||||||
n.value = string(p.event.anchor)
|
|
||||||
p.skip()
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) scalar() *node {
|
|
||||||
n := p.node(scalarNode)
|
|
||||||
n.value = string(p.event.value)
|
|
||||||
n.tag = string(p.event.tag)
|
|
||||||
n.implicit = p.event.implicit
|
|
||||||
p.anchor(n, p.event.anchor)
|
|
||||||
p.skip()
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) sequence() *node {
|
|
||||||
n := p.node(sequenceNode)
|
|
||||||
p.anchor(n, p.event.anchor)
|
|
||||||
p.skip()
|
|
||||||
for p.event.typ != yaml_SEQUENCE_END_EVENT {
|
|
||||||
n.children = append(n.children, p.parse())
|
|
||||||
}
|
|
||||||
p.skip()
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *parser) mapping() *node {
|
|
||||||
n := p.node(mappingNode)
|
|
||||||
p.anchor(n, p.event.anchor)
|
|
||||||
p.skip()
|
|
||||||
for p.event.typ != yaml_MAPPING_END_EVENT {
|
|
||||||
n.children = append(n.children, p.parse(), p.parse())
|
|
||||||
}
|
|
||||||
p.skip()
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
|
|
||||||
// ----------------------------------------------------------------------------
|
|
||||||
// Decoder, unmarshals a node into a provided value.
|
|
||||||
|
|
||||||
type decoder struct {
|
|
||||||
doc *node
|
|
||||||
aliases map[string]bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func newDecoder() *decoder {
|
|
||||||
d := &decoder{}
|
|
||||||
d.aliases = make(map[string]bool)
|
|
||||||
return d
|
|
||||||
}
|
|
||||||
|
|
||||||
// d.setter deals with setters and pointer dereferencing and initialization.
|
|
||||||
//
|
|
||||||
// It's a slightly convoluted case to handle properly:
|
|
||||||
//
|
|
||||||
// - nil pointers should be initialized, unless being set to nil
|
|
||||||
// - we don't know at this point yet what's the value to SetYAML() with.
|
|
||||||
// - we can't separate pointer deref/init and setter checking, because
|
|
||||||
// a setter may be found while going down a pointer chain.
|
|
||||||
//
|
|
||||||
// Thus, here is how it takes care of it:
|
|
||||||
//
|
|
||||||
// - out is provided as a pointer, so that it can be replaced.
|
|
||||||
// - when looking at a non-setter ptr, *out=ptr.Elem(), unless tag=!!null
|
|
||||||
// - when a setter is found, *out=interface{}, and a set() function is
|
|
||||||
// returned to call SetYAML() with the value of *out once it's defined.
|
|
||||||
//
|
|
||||||
func (d *decoder) setter(tag string, out *reflect.Value, good *bool) (set func()) {
|
|
||||||
if (*out).Kind() != reflect.Ptr && (*out).CanAddr() {
|
|
||||||
setter, _ := (*out).Addr().Interface().(Setter)
|
|
||||||
if setter != nil {
|
|
||||||
var arg interface{}
|
|
||||||
*out = reflect.ValueOf(&arg).Elem()
|
|
||||||
return func() {
|
|
||||||
*good = setter.SetYAML(shortTag(tag), arg)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
again := true
|
|
||||||
for again {
|
|
||||||
again = false
|
|
||||||
setter, _ := (*out).Interface().(Setter)
|
|
||||||
if tag != yaml_NULL_TAG || setter != nil {
|
|
||||||
if pv := (*out); pv.Kind() == reflect.Ptr {
|
|
||||||
if pv.IsNil() {
|
|
||||||
*out = reflect.New(pv.Type().Elem()).Elem()
|
|
||||||
pv.Set((*out).Addr())
|
|
||||||
} else {
|
|
||||||
*out = pv.Elem()
|
|
||||||
}
|
|
||||||
setter, _ = pv.Interface().(Setter)
|
|
||||||
again = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if setter != nil {
|
|
||||||
var arg interface{}
|
|
||||||
*out = reflect.ValueOf(&arg).Elem()
|
|
||||||
return func() {
|
|
||||||
*good = setter.SetYAML(shortTag(tag), arg)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
|
|
||||||
switch n.kind {
|
|
||||||
case documentNode:
|
|
||||||
good = d.document(n, out)
|
|
||||||
case scalarNode:
|
|
||||||
good = d.scalar(n, out)
|
|
||||||
case aliasNode:
|
|
||||||
good = d.alias(n, out)
|
|
||||||
case mappingNode:
|
|
||||||
good = d.mapping(n, out)
|
|
||||||
case sequenceNode:
|
|
||||||
good = d.sequence(n, out)
|
|
||||||
default:
|
|
||||||
panic("Internal error: unknown node kind: " + strconv.Itoa(n.kind))
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) document(n *node, out reflect.Value) (good bool) {
|
|
||||||
if len(n.children) == 1 {
|
|
||||||
d.doc = n
|
|
||||||
d.unmarshal(n.children[0], out)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
|
|
||||||
an, ok := d.doc.anchors[n.value]
|
|
||||||
if !ok {
|
|
||||||
fail("Unknown anchor '" + n.value + "' referenced")
|
|
||||||
}
|
|
||||||
if d.aliases[n.value] {
|
|
||||||
fail("Anchor '" + n.value + "' value contains itself")
|
|
||||||
}
|
|
||||||
d.aliases[n.value] = true
|
|
||||||
good = d.unmarshal(an, out)
|
|
||||||
delete(d.aliases, n.value)
|
|
||||||
return good
|
|
||||||
}
|
|
||||||
|
|
||||||
var zeroValue reflect.Value
|
|
||||||
|
|
||||||
func resetMap(out reflect.Value) {
|
|
||||||
for _, k := range out.MapKeys() {
|
|
||||||
out.SetMapIndex(k, zeroValue)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var durationType = reflect.TypeOf(time.Duration(0))
|
|
||||||
|
|
||||||
func (d *decoder) scalar(n *node, out reflect.Value) (good bool) {
|
|
||||||
var tag string
|
|
||||||
var resolved interface{}
|
|
||||||
if n.tag == "" && !n.implicit {
|
|
||||||
tag = yaml_STR_TAG
|
|
||||||
resolved = n.value
|
|
||||||
} else {
|
|
||||||
tag, resolved = resolve(n.tag, n.value)
|
|
||||||
if tag == yaml_BINARY_TAG {
|
|
||||||
data, err := base64.StdEncoding.DecodeString(resolved.(string))
|
|
||||||
if err != nil {
|
|
||||||
fail("!!binary value contains invalid base64 data")
|
|
||||||
}
|
|
||||||
resolved = string(data)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if set := d.setter(tag, &out, &good); set != nil {
|
|
||||||
defer set()
|
|
||||||
}
|
|
||||||
if resolved == nil {
|
|
||||||
if out.Kind() == reflect.Map && !out.CanAddr() {
|
|
||||||
resetMap(out)
|
|
||||||
} else {
|
|
||||||
out.Set(reflect.Zero(out.Type()))
|
|
||||||
}
|
|
||||||
good = true
|
|
||||||
return
|
|
||||||
}
|
|
||||||
switch out.Kind() {
|
|
||||||
case reflect.String:
|
|
||||||
if tag == yaml_BINARY_TAG {
|
|
||||||
out.SetString(resolved.(string))
|
|
||||||
good = true
|
|
||||||
} else if resolved != nil {
|
|
||||||
out.SetString(n.value)
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case reflect.Interface:
|
|
||||||
if resolved == nil {
|
|
||||||
out.Set(reflect.Zero(out.Type()))
|
|
||||||
} else {
|
|
||||||
out.Set(reflect.ValueOf(resolved))
|
|
||||||
}
|
|
||||||
good = true
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
switch resolved := resolved.(type) {
|
|
||||||
case int:
|
|
||||||
if !out.OverflowInt(int64(resolved)) {
|
|
||||||
out.SetInt(int64(resolved))
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case int64:
|
|
||||||
if !out.OverflowInt(resolved) {
|
|
||||||
out.SetInt(resolved)
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case float64:
|
|
||||||
if resolved < 1<<63-1 && !out.OverflowInt(int64(resolved)) {
|
|
||||||
out.SetInt(int64(resolved))
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case string:
|
|
||||||
if out.Type() == durationType {
|
|
||||||
d, err := time.ParseDuration(resolved)
|
|
||||||
if err == nil {
|
|
||||||
out.SetInt(int64(d))
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
switch resolved := resolved.(type) {
|
|
||||||
case int:
|
|
||||||
if resolved >= 0 {
|
|
||||||
out.SetUint(uint64(resolved))
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case int64:
|
|
||||||
if resolved >= 0 {
|
|
||||||
out.SetUint(uint64(resolved))
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case float64:
|
|
||||||
if resolved < 1<<64-1 && !out.OverflowUint(uint64(resolved)) {
|
|
||||||
out.SetUint(uint64(resolved))
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case reflect.Bool:
|
|
||||||
switch resolved := resolved.(type) {
|
|
||||||
case bool:
|
|
||||||
out.SetBool(resolved)
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
switch resolved := resolved.(type) {
|
|
||||||
case int:
|
|
||||||
out.SetFloat(float64(resolved))
|
|
||||||
good = true
|
|
||||||
case int64:
|
|
||||||
out.SetFloat(float64(resolved))
|
|
||||||
good = true
|
|
||||||
case float64:
|
|
||||||
out.SetFloat(resolved)
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
case reflect.Ptr:
|
|
||||||
if out.Type().Elem() == reflect.TypeOf(resolved) {
|
|
||||||
elem := reflect.New(out.Type().Elem())
|
|
||||||
elem.Elem().Set(reflect.ValueOf(resolved))
|
|
||||||
out.Set(elem)
|
|
||||||
good = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return good
|
|
||||||
}
|
|
||||||
|
|
||||||
func settableValueOf(i interface{}) reflect.Value {
|
|
||||||
v := reflect.ValueOf(i)
|
|
||||||
sv := reflect.New(v.Type()).Elem()
|
|
||||||
sv.Set(v)
|
|
||||||
return sv
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
|
|
||||||
if set := d.setter(yaml_SEQ_TAG, &out, &good); set != nil {
|
|
||||||
defer set()
|
|
||||||
}
|
|
||||||
var iface reflect.Value
|
|
||||||
if out.Kind() == reflect.Interface {
|
|
||||||
// No type hints. Will have to use a generic sequence.
|
|
||||||
iface = out
|
|
||||||
out = settableValueOf(make([]interface{}, 0))
|
|
||||||
}
|
|
||||||
|
|
||||||
if out.Kind() != reflect.Slice {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
et := out.Type().Elem()
|
|
||||||
|
|
||||||
l := len(n.children)
|
|
||||||
for i := 0; i < l; i++ {
|
|
||||||
e := reflect.New(et).Elem()
|
|
||||||
if ok := d.unmarshal(n.children[i], e); ok {
|
|
||||||
out.Set(reflect.Append(out, e))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if iface.IsValid() {
|
|
||||||
iface.Set(out)
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
|
|
||||||
if set := d.setter(yaml_MAP_TAG, &out, &good); set != nil {
|
|
||||||
defer set()
|
|
||||||
}
|
|
||||||
if out.Kind() == reflect.Struct {
|
|
||||||
return d.mappingStruct(n, out)
|
|
||||||
}
|
|
||||||
|
|
||||||
if out.Kind() == reflect.Interface {
|
|
||||||
// No type hints. Will have to use a generic map.
|
|
||||||
iface := out
|
|
||||||
out = settableValueOf(make(map[interface{}]interface{}))
|
|
||||||
iface.Set(out)
|
|
||||||
}
|
|
||||||
|
|
||||||
if out.Kind() != reflect.Map {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
outt := out.Type()
|
|
||||||
kt := outt.Key()
|
|
||||||
et := outt.Elem()
|
|
||||||
|
|
||||||
if out.IsNil() {
|
|
||||||
out.Set(reflect.MakeMap(outt))
|
|
||||||
}
|
|
||||||
l := len(n.children)
|
|
||||||
for i := 0; i < l; i += 2 {
|
|
||||||
if isMerge(n.children[i]) {
|
|
||||||
d.merge(n.children[i+1], out)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
k := reflect.New(kt).Elem()
|
|
||||||
if d.unmarshal(n.children[i], k) {
|
|
||||||
kkind := k.Kind()
|
|
||||||
if kkind == reflect.Interface {
|
|
||||||
kkind = k.Elem().Kind()
|
|
||||||
}
|
|
||||||
if kkind == reflect.Map || kkind == reflect.Slice {
|
|
||||||
fail(fmt.Sprintf("invalid map key: %#v", k.Interface()))
|
|
||||||
}
|
|
||||||
e := reflect.New(et).Elem()
|
|
||||||
if d.unmarshal(n.children[i+1], e) {
|
|
||||||
out.SetMapIndex(k, e)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
|
|
||||||
sinfo, err := getStructInfo(out.Type())
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
name := settableValueOf("")
|
|
||||||
l := len(n.children)
|
|
||||||
for i := 0; i < l; i += 2 {
|
|
||||||
ni := n.children[i]
|
|
||||||
if isMerge(ni) {
|
|
||||||
d.merge(n.children[i+1], out)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if !d.unmarshal(ni, name) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if info, ok := sinfo.FieldsMap[name.String()]; ok {
|
|
||||||
var field reflect.Value
|
|
||||||
if info.Inline == nil {
|
|
||||||
field = out.Field(info.Num)
|
|
||||||
} else {
|
|
||||||
field = out.FieldByIndex(info.Inline)
|
|
||||||
}
|
|
||||||
d.unmarshal(n.children[i+1], field)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) merge(n *node, out reflect.Value) {
|
|
||||||
const wantMap = "map merge requires map or sequence of maps as the value"
|
|
||||||
switch n.kind {
|
|
||||||
case mappingNode:
|
|
||||||
d.unmarshal(n, out)
|
|
||||||
case aliasNode:
|
|
||||||
an, ok := d.doc.anchors[n.value]
|
|
||||||
if ok && an.kind != mappingNode {
|
|
||||||
fail(wantMap)
|
|
||||||
}
|
|
||||||
d.unmarshal(n, out)
|
|
||||||
case sequenceNode:
|
|
||||||
// Step backwards as earlier nodes take precedence.
|
|
||||||
for i := len(n.children) - 1; i >= 0; i-- {
|
|
||||||
ni := n.children[i]
|
|
||||||
if ni.kind == aliasNode {
|
|
||||||
an, ok := d.doc.anchors[ni.value]
|
|
||||||
if ok && an.kind != mappingNode {
|
|
||||||
fail(wantMap)
|
|
||||||
}
|
|
||||||
} else if ni.kind != mappingNode {
|
|
||||||
fail(wantMap)
|
|
||||||
}
|
|
||||||
d.unmarshal(ni, out)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
fail(wantMap)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func isMerge(n *node) bool {
|
|
||||||
return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
|
|
||||||
}
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,265 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"reflect"
|
|
||||||
"regexp"
|
|
||||||
"sort"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
type encoder struct {
|
|
||||||
emitter yaml_emitter_t
|
|
||||||
event yaml_event_t
|
|
||||||
out []byte
|
|
||||||
flow bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func newEncoder() (e *encoder) {
|
|
||||||
e = &encoder{}
|
|
||||||
e.must(yaml_emitter_initialize(&e.emitter))
|
|
||||||
yaml_emitter_set_output_string(&e.emitter, &e.out)
|
|
||||||
e.must(yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING))
|
|
||||||
e.emit()
|
|
||||||
e.must(yaml_document_start_event_initialize(&e.event, nil, nil, true))
|
|
||||||
e.emit()
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) finish() {
|
|
||||||
e.must(yaml_document_end_event_initialize(&e.event, true))
|
|
||||||
e.emit()
|
|
||||||
e.emitter.open_ended = false
|
|
||||||
e.must(yaml_stream_end_event_initialize(&e.event))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) destroy() {
|
|
||||||
yaml_emitter_delete(&e.emitter)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) emit() {
|
|
||||||
// This will internally delete the e.event value.
|
|
||||||
if !yaml_emitter_emit(&e.emitter, &e.event) && e.event.typ != yaml_DOCUMENT_END_EVENT && e.event.typ != yaml_STREAM_END_EVENT {
|
|
||||||
e.must(false)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) must(ok bool) {
|
|
||||||
if !ok {
|
|
||||||
msg := e.emitter.problem
|
|
||||||
if msg == "" {
|
|
||||||
msg = "Unknown problem generating YAML content"
|
|
||||||
}
|
|
||||||
fail(msg)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) marshal(tag string, in reflect.Value) {
|
|
||||||
if !in.IsValid() {
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
var value interface{}
|
|
||||||
if getter, ok := in.Interface().(Getter); ok {
|
|
||||||
tag, value = getter.GetYAML()
|
|
||||||
tag = longTag(tag)
|
|
||||||
if value == nil {
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
in = reflect.ValueOf(value)
|
|
||||||
}
|
|
||||||
switch in.Kind() {
|
|
||||||
case reflect.Interface:
|
|
||||||
if in.IsNil() {
|
|
||||||
e.nilv()
|
|
||||||
} else {
|
|
||||||
e.marshal(tag, in.Elem())
|
|
||||||
}
|
|
||||||
case reflect.Map:
|
|
||||||
e.mapv(tag, in)
|
|
||||||
case reflect.Ptr:
|
|
||||||
if in.IsNil() {
|
|
||||||
e.nilv()
|
|
||||||
} else {
|
|
||||||
e.marshal(tag, in.Elem())
|
|
||||||
}
|
|
||||||
case reflect.Struct:
|
|
||||||
e.structv(tag, in)
|
|
||||||
case reflect.Slice:
|
|
||||||
e.slicev(tag, in)
|
|
||||||
case reflect.String:
|
|
||||||
e.stringv(tag, in)
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
if in.Type() == durationType {
|
|
||||||
e.stringv(tag, reflect.ValueOf(in.Interface().(time.Duration).String()))
|
|
||||||
} else {
|
|
||||||
e.intv(tag, in)
|
|
||||||
}
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
e.uintv(tag, in)
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
e.floatv(tag, in)
|
|
||||||
case reflect.Bool:
|
|
||||||
e.boolv(tag, in)
|
|
||||||
default:
|
|
||||||
panic("Can't marshal type: " + in.Type().String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) mapv(tag string, in reflect.Value) {
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
keys := keyList(in.MapKeys())
|
|
||||||
sort.Sort(keys)
|
|
||||||
for _, k := range keys {
|
|
||||||
e.marshal("", k)
|
|
||||||
e.marshal("", in.MapIndex(k))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) structv(tag string, in reflect.Value) {
|
|
||||||
sinfo, err := getStructInfo(in.Type())
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
for _, info := range sinfo.FieldsList {
|
|
||||||
var value reflect.Value
|
|
||||||
if info.Inline == nil {
|
|
||||||
value = in.Field(info.Num)
|
|
||||||
} else {
|
|
||||||
value = in.FieldByIndex(info.Inline)
|
|
||||||
}
|
|
||||||
if info.OmitEmpty && isZero(value) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
e.marshal("", reflect.ValueOf(info.Key))
|
|
||||||
e.flow = info.Flow
|
|
||||||
e.marshal("", value)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) mappingv(tag string, f func()) {
|
|
||||||
implicit := tag == ""
|
|
||||||
style := yaml_BLOCK_MAPPING_STYLE
|
|
||||||
if e.flow {
|
|
||||||
e.flow = false
|
|
||||||
style = yaml_FLOW_MAPPING_STYLE
|
|
||||||
}
|
|
||||||
e.must(yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
|
|
||||||
e.emit()
|
|
||||||
f()
|
|
||||||
e.must(yaml_mapping_end_event_initialize(&e.event))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) slicev(tag string, in reflect.Value) {
|
|
||||||
implicit := tag == ""
|
|
||||||
style := yaml_BLOCK_SEQUENCE_STYLE
|
|
||||||
if e.flow {
|
|
||||||
e.flow = false
|
|
||||||
style = yaml_FLOW_SEQUENCE_STYLE
|
|
||||||
}
|
|
||||||
e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
|
|
||||||
e.emit()
|
|
||||||
n := in.Len()
|
|
||||||
for i := 0; i < n; i++ {
|
|
||||||
e.marshal("", in.Index(i))
|
|
||||||
}
|
|
||||||
e.must(yaml_sequence_end_event_initialize(&e.event))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
|
|
||||||
//
|
|
||||||
// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
|
|
||||||
// in YAML 1.2 and by this package, but these should be marshalled quoted for
|
|
||||||
// the time being for compatibility with other parsers.
|
|
||||||
func isBase60Float(s string) (result bool) {
|
|
||||||
// Fast path.
|
|
||||||
if s == "" {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
c := s[0]
|
|
||||||
if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
// Do the full match.
|
|
||||||
return base60float.MatchString(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
// From http://yaml.org/type/float.html, except the regular expression there
|
|
||||||
// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
|
|
||||||
var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
|
|
||||||
|
|
||||||
func (e *encoder) stringv(tag string, in reflect.Value) {
|
|
||||||
var style yaml_scalar_style_t
|
|
||||||
s := in.String()
|
|
||||||
rtag, rs := resolve("", s)
|
|
||||||
if rtag == yaml_BINARY_TAG {
|
|
||||||
if tag == "" || tag == yaml_STR_TAG {
|
|
||||||
tag = rtag
|
|
||||||
s = rs.(string)
|
|
||||||
} else if tag == yaml_BINARY_TAG {
|
|
||||||
fail("explicitly tagged !!binary data must be base64-encoded")
|
|
||||||
} else {
|
|
||||||
fail("cannot marshal invalid UTF-8 data as " + shortTag(tag))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if tag == "" && (rtag != yaml_STR_TAG || isBase60Float(s)) {
|
|
||||||
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
||||||
} else if strings.Contains(s, "\n") {
|
|
||||||
style = yaml_LITERAL_SCALAR_STYLE
|
|
||||||
} else {
|
|
||||||
style = yaml_PLAIN_SCALAR_STYLE
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, style)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) boolv(tag string, in reflect.Value) {
|
|
||||||
var s string
|
|
||||||
if in.Bool() {
|
|
||||||
s = "true"
|
|
||||||
} else {
|
|
||||||
s = "false"
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) intv(tag string, in reflect.Value) {
|
|
||||||
s := strconv.FormatInt(in.Int(), 10)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) uintv(tag string, in reflect.Value) {
|
|
||||||
s := strconv.FormatUint(in.Uint(), 10)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) floatv(tag string, in reflect.Value) {
|
|
||||||
// FIXME: Handle 64 bits here.
|
|
||||||
s := strconv.FormatFloat(float64(in.Float()), 'g', -1, 32)
|
|
||||||
switch s {
|
|
||||||
case "+Inf":
|
|
||||||
s = ".inf"
|
|
||||||
case "-Inf":
|
|
||||||
s = "-.inf"
|
|
||||||
case "NaN":
|
|
||||||
s = ".nan"
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) nilv() {
|
|
||||||
e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
|
|
||||||
implicit := tag == ""
|
|
||||||
e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
|
@ -1,391 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"io"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Set the reader error and return 0.
|
|
||||||
func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool {
|
|
||||||
parser.error = yaml_READER_ERROR
|
|
||||||
parser.problem = problem
|
|
||||||
parser.problem_offset = offset
|
|
||||||
parser.problem_value = value
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Byte order marks.
|
|
||||||
const (
|
|
||||||
bom_UTF8 = "\xef\xbb\xbf"
|
|
||||||
bom_UTF16LE = "\xff\xfe"
|
|
||||||
bom_UTF16BE = "\xfe\xff"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Determine the input stream encoding by checking the BOM symbol. If no BOM is
|
|
||||||
// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
|
|
||||||
func yaml_parser_determine_encoding(parser *yaml_parser_t) bool {
|
|
||||||
// Ensure that we had enough bytes in the raw buffer.
|
|
||||||
for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 {
|
|
||||||
if !yaml_parser_update_raw_buffer(parser) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determine the encoding.
|
|
||||||
buf := parser.raw_buffer
|
|
||||||
pos := parser.raw_buffer_pos
|
|
||||||
avail := len(buf) - pos
|
|
||||||
if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] {
|
|
||||||
parser.encoding = yaml_UTF16LE_ENCODING
|
|
||||||
parser.raw_buffer_pos += 2
|
|
||||||
parser.offset += 2
|
|
||||||
} else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] {
|
|
||||||
parser.encoding = yaml_UTF16BE_ENCODING
|
|
||||||
parser.raw_buffer_pos += 2
|
|
||||||
parser.offset += 2
|
|
||||||
} else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] {
|
|
||||||
parser.encoding = yaml_UTF8_ENCODING
|
|
||||||
parser.raw_buffer_pos += 3
|
|
||||||
parser.offset += 3
|
|
||||||
} else {
|
|
||||||
parser.encoding = yaml_UTF8_ENCODING
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Update the raw buffer.
|
|
||||||
func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool {
|
|
||||||
size_read := 0
|
|
||||||
|
|
||||||
// Return if the raw buffer is full.
|
|
||||||
if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return on EOF.
|
|
||||||
if parser.eof {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Move the remaining bytes in the raw buffer to the beginning.
|
|
||||||
if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) {
|
|
||||||
copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:])
|
|
||||||
}
|
|
||||||
parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos]
|
|
||||||
parser.raw_buffer_pos = 0
|
|
||||||
|
|
||||||
// Call the read handler to fill the buffer.
|
|
||||||
size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)])
|
|
||||||
parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read]
|
|
||||||
if err == io.EOF {
|
|
||||||
parser.eof = true
|
|
||||||
} else if err != nil {
|
|
||||||
return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1)
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ensure that the buffer contains at least `length` characters.
|
|
||||||
// Return true on success, false on failure.
|
|
||||||
//
|
|
||||||
// The length is supposed to be significantly less that the buffer size.
|
|
||||||
func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
|
|
||||||
if parser.read_handler == nil {
|
|
||||||
panic("read handler must be set")
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the EOF flag is set and the raw buffer is empty, do nothing.
|
|
||||||
if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return if the buffer contains enough characters.
|
|
||||||
if parser.unread >= length {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determine the input encoding if it is not known yet.
|
|
||||||
if parser.encoding == yaml_ANY_ENCODING {
|
|
||||||
if !yaml_parser_determine_encoding(parser) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Move the unread characters to the beginning of the buffer.
|
|
||||||
buffer_len := len(parser.buffer)
|
|
||||||
if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len {
|
|
||||||
copy(parser.buffer, parser.buffer[parser.buffer_pos:])
|
|
||||||
buffer_len -= parser.buffer_pos
|
|
||||||
parser.buffer_pos = 0
|
|
||||||
} else if parser.buffer_pos == buffer_len {
|
|
||||||
buffer_len = 0
|
|
||||||
parser.buffer_pos = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Open the whole buffer for writing, and cut it before returning.
|
|
||||||
parser.buffer = parser.buffer[:cap(parser.buffer)]
|
|
||||||
|
|
||||||
// Fill the buffer until it has enough characters.
|
|
||||||
first := true
|
|
||||||
for parser.unread < length {
|
|
||||||
|
|
||||||
// Fill the raw buffer if necessary.
|
|
||||||
if !first || parser.raw_buffer_pos == len(parser.raw_buffer) {
|
|
||||||
if !yaml_parser_update_raw_buffer(parser) {
|
|
||||||
parser.buffer = parser.buffer[:buffer_len]
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
first = false
|
|
||||||
|
|
||||||
// Decode the raw buffer.
|
|
||||||
inner:
|
|
||||||
for parser.raw_buffer_pos != len(parser.raw_buffer) {
|
|
||||||
var value rune
|
|
||||||
var width int
|
|
||||||
|
|
||||||
raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos
|
|
||||||
|
|
||||||
// Decode the next character.
|
|
||||||
switch parser.encoding {
|
|
||||||
case yaml_UTF8_ENCODING:
|
|
||||||
// Decode a UTF-8 character. Check RFC 3629
|
|
||||||
// (http://www.ietf.org/rfc/rfc3629.txt) for more details.
|
|
||||||
//
|
|
||||||
// The following table (taken from the RFC) is used for
|
|
||||||
// decoding.
|
|
||||||
//
|
|
||||||
// Char. number range | UTF-8 octet sequence
|
|
||||||
// (hexadecimal) | (binary)
|
|
||||||
// --------------------+------------------------------------
|
|
||||||
// 0000 0000-0000 007F | 0xxxxxxx
|
|
||||||
// 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
|
|
||||||
// 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
|
|
||||||
// 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
||||||
//
|
|
||||||
// Additionally, the characters in the range 0xD800-0xDFFF
|
|
||||||
// are prohibited as they are reserved for use with UTF-16
|
|
||||||
// surrogate pairs.
|
|
||||||
|
|
||||||
// Determine the length of the UTF-8 sequence.
|
|
||||||
octet := parser.raw_buffer[parser.raw_buffer_pos]
|
|
||||||
switch {
|
|
||||||
case octet&0x80 == 0x00:
|
|
||||||
width = 1
|
|
||||||
case octet&0xE0 == 0xC0:
|
|
||||||
width = 2
|
|
||||||
case octet&0xF0 == 0xE0:
|
|
||||||
width = 3
|
|
||||||
case octet&0xF8 == 0xF0:
|
|
||||||
width = 4
|
|
||||||
default:
|
|
||||||
// The leading octet is invalid.
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid leading UTF-8 octet",
|
|
||||||
parser.offset, int(octet))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the raw buffer contains an incomplete character.
|
|
||||||
if width > raw_unread {
|
|
||||||
if parser.eof {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"incomplete UTF-8 octet sequence",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
break inner
|
|
||||||
}
|
|
||||||
|
|
||||||
// Decode the leading octet.
|
|
||||||
switch {
|
|
||||||
case octet&0x80 == 0x00:
|
|
||||||
value = rune(octet & 0x7F)
|
|
||||||
case octet&0xE0 == 0xC0:
|
|
||||||
value = rune(octet & 0x1F)
|
|
||||||
case octet&0xF0 == 0xE0:
|
|
||||||
value = rune(octet & 0x0F)
|
|
||||||
case octet&0xF8 == 0xF0:
|
|
||||||
value = rune(octet & 0x07)
|
|
||||||
default:
|
|
||||||
value = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check and decode the trailing octets.
|
|
||||||
for k := 1; k < width; k++ {
|
|
||||||
octet = parser.raw_buffer[parser.raw_buffer_pos+k]
|
|
||||||
|
|
||||||
// Check if the octet is valid.
|
|
||||||
if (octet & 0xC0) != 0x80 {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid trailing UTF-8 octet",
|
|
||||||
parser.offset+k, int(octet))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Decode the octet.
|
|
||||||
value = (value << 6) + rune(octet&0x3F)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check the length of the sequence against the value.
|
|
||||||
switch {
|
|
||||||
case width == 1:
|
|
||||||
case width == 2 && value >= 0x80:
|
|
||||||
case width == 3 && value >= 0x800:
|
|
||||||
case width == 4 && value >= 0x10000:
|
|
||||||
default:
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid length of a UTF-8 sequence",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check the range of the value.
|
|
||||||
if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"invalid Unicode character",
|
|
||||||
parser.offset, int(value))
|
|
||||||
}
|
|
||||||
|
|
||||||
case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING:
|
|
||||||
var low, high int
|
|
||||||
if parser.encoding == yaml_UTF16LE_ENCODING {
|
|
||||||
low, high = 0, 1
|
|
||||||
} else {
|
|
||||||
high, low = 1, 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// The UTF-16 encoding is not as simple as one might
|
|
||||||
// naively think. Check RFC 2781
|
|
||||||
// (http://www.ietf.org/rfc/rfc2781.txt).
|
|
||||||
//
|
|
||||||
// Normally, two subsequent bytes describe a Unicode
|
|
||||||
// character. However a special technique (called a
|
|
||||||
// surrogate pair) is used for specifying character
|
|
||||||
// values larger than 0xFFFF.
|
|
||||||
//
|
|
||||||
// A surrogate pair consists of two pseudo-characters:
|
|
||||||
// high surrogate area (0xD800-0xDBFF)
|
|
||||||
// low surrogate area (0xDC00-0xDFFF)
|
|
||||||
//
|
|
||||||
// The following formulas are used for decoding
|
|
||||||
// and encoding characters using surrogate pairs:
|
|
||||||
//
|
|
||||||
// U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
|
|
||||||
// U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
|
|
||||||
// W1 = 110110yyyyyyyyyy
|
|
||||||
// W2 = 110111xxxxxxxxxx
|
|
||||||
//
|
|
||||||
// where U is the character value, W1 is the high surrogate
|
|
||||||
// area, W2 is the low surrogate area.
|
|
||||||
|
|
||||||
// Check for incomplete UTF-16 character.
|
|
||||||
if raw_unread < 2 {
|
|
||||||
if parser.eof {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"incomplete UTF-16 character",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
break inner
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the character.
|
|
||||||
value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) +
|
|
||||||
(rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8)
|
|
||||||
|
|
||||||
// Check for unexpected low surrogate area.
|
|
||||||
if value&0xFC00 == 0xDC00 {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"unexpected low surrogate area",
|
|
||||||
parser.offset, int(value))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check for a high surrogate area.
|
|
||||||
if value&0xFC00 == 0xD800 {
|
|
||||||
width = 4
|
|
||||||
|
|
||||||
// Check for incomplete surrogate pair.
|
|
||||||
if raw_unread < 4 {
|
|
||||||
if parser.eof {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"incomplete UTF-16 surrogate pair",
|
|
||||||
parser.offset, -1)
|
|
||||||
}
|
|
||||||
break inner
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the next character.
|
|
||||||
value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) +
|
|
||||||
(rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8)
|
|
||||||
|
|
||||||
// Check for a low surrogate area.
|
|
||||||
if value2&0xFC00 != 0xDC00 {
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"expected low surrogate area",
|
|
||||||
parser.offset+2, int(value2))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Generate the value of the surrogate pair.
|
|
||||||
value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF)
|
|
||||||
} else {
|
|
||||||
width = 2
|
|
||||||
}
|
|
||||||
|
|
||||||
default:
|
|
||||||
panic("impossible")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is in the allowed range:
|
|
||||||
// #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
|
|
||||||
// | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
|
|
||||||
// | [#x10000-#x10FFFF] (32 bit)
|
|
||||||
switch {
|
|
||||||
case value == 0x09:
|
|
||||||
case value == 0x0A:
|
|
||||||
case value == 0x0D:
|
|
||||||
case value >= 0x20 && value <= 0x7E:
|
|
||||||
case value == 0x85:
|
|
||||||
case value >= 0xA0 && value <= 0xD7FF:
|
|
||||||
case value >= 0xE000 && value <= 0xFFFD:
|
|
||||||
case value >= 0x10000 && value <= 0x10FFFF:
|
|
||||||
default:
|
|
||||||
return yaml_parser_set_reader_error(parser,
|
|
||||||
"control characters are not allowed",
|
|
||||||
parser.offset, int(value))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Move the raw pointers.
|
|
||||||
parser.raw_buffer_pos += width
|
|
||||||
parser.offset += width
|
|
||||||
|
|
||||||
// Finally put the character into the buffer.
|
|
||||||
if value <= 0x7F {
|
|
||||||
// 0000 0000-0000 007F . 0xxxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(value)
|
|
||||||
} else if value <= 0x7FF {
|
|
||||||
// 0000 0080-0000 07FF . 110xxxxx 10xxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6))
|
|
||||||
parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F))
|
|
||||||
} else if value <= 0xFFFF {
|
|
||||||
// 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12))
|
|
||||||
parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F))
|
|
||||||
parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F))
|
|
||||||
} else {
|
|
||||||
// 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
||||||
parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18))
|
|
||||||
parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F))
|
|
||||||
parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F))
|
|
||||||
parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F))
|
|
||||||
}
|
|
||||||
buffer_len += width
|
|
||||||
|
|
||||||
parser.unread++
|
|
||||||
}
|
|
||||||
|
|
||||||
// On EOF, put NUL into the buffer and return.
|
|
||||||
if parser.eof {
|
|
||||||
parser.buffer[buffer_len] = 0
|
|
||||||
buffer_len++
|
|
||||||
parser.unread++
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
parser.buffer = parser.buffer[:buffer_len]
|
|
||||||
return true
|
|
||||||
}
|
|
|
@ -1,190 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/base64"
|
|
||||||
"fmt"
|
|
||||||
"math"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"unicode/utf8"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TODO: merge, timestamps, base 60 floats, omap.
|
|
||||||
|
|
||||||
type resolveMapItem struct {
|
|
||||||
value interface{}
|
|
||||||
tag string
|
|
||||||
}
|
|
||||||
|
|
||||||
var resolveTable = make([]byte, 256)
|
|
||||||
var resolveMap = make(map[string]resolveMapItem)
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
t := resolveTable
|
|
||||||
t[int('+')] = 'S' // Sign
|
|
||||||
t[int('-')] = 'S'
|
|
||||||
for _, c := range "0123456789" {
|
|
||||||
t[int(c)] = 'D' // Digit
|
|
||||||
}
|
|
||||||
for _, c := range "yYnNtTfFoO~" {
|
|
||||||
t[int(c)] = 'M' // In map
|
|
||||||
}
|
|
||||||
t[int('.')] = '.' // Float (potentially in map)
|
|
||||||
|
|
||||||
var resolveMapList = []struct {
|
|
||||||
v interface{}
|
|
||||||
tag string
|
|
||||||
l []string
|
|
||||||
}{
|
|
||||||
{true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}},
|
|
||||||
{true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}},
|
|
||||||
{true, yaml_BOOL_TAG, []string{"on", "On", "ON"}},
|
|
||||||
{false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}},
|
|
||||||
{false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}},
|
|
||||||
{false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}},
|
|
||||||
{nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}},
|
|
||||||
{math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}},
|
|
||||||
{math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}},
|
|
||||||
{math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}},
|
|
||||||
{math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}},
|
|
||||||
{"<<", yaml_MERGE_TAG, []string{"<<"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
m := resolveMap
|
|
||||||
for _, item := range resolveMapList {
|
|
||||||
for _, s := range item.l {
|
|
||||||
m[s] = resolveMapItem{item.v, item.tag}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const longTagPrefix = "tag:yaml.org,2002:"
|
|
||||||
|
|
||||||
func shortTag(tag string) string {
|
|
||||||
// TODO This can easily be made faster and produce less garbage.
|
|
||||||
if strings.HasPrefix(tag, longTagPrefix) {
|
|
||||||
return "!!" + tag[len(longTagPrefix):]
|
|
||||||
}
|
|
||||||
return tag
|
|
||||||
}
|
|
||||||
|
|
||||||
func longTag(tag string) string {
|
|
||||||
if strings.HasPrefix(tag, "!!") {
|
|
||||||
return longTagPrefix + tag[2:]
|
|
||||||
}
|
|
||||||
return tag
|
|
||||||
}
|
|
||||||
|
|
||||||
func resolvableTag(tag string) bool {
|
|
||||||
switch tag {
|
|
||||||
case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG:
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func resolve(tag string, in string) (rtag string, out interface{}) {
|
|
||||||
if !resolvableTag(tag) {
|
|
||||||
return tag, in
|
|
||||||
}
|
|
||||||
|
|
||||||
defer func() {
|
|
||||||
switch tag {
|
|
||||||
case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
fail(fmt.Sprintf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag)))
|
|
||||||
}()
|
|
||||||
|
|
||||||
// Any data is accepted as a !!str or !!binary.
|
|
||||||
// Otherwise, the prefix is enough of a hint about what it might be.
|
|
||||||
hint := byte('N')
|
|
||||||
if in != "" {
|
|
||||||
hint = resolveTable[in[0]]
|
|
||||||
}
|
|
||||||
if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG {
|
|
||||||
// Handle things we can lookup in a map.
|
|
||||||
if item, ok := resolveMap[in]; ok {
|
|
||||||
return item.tag, item.value
|
|
||||||
}
|
|
||||||
|
|
||||||
// Base 60 floats are a bad idea, were dropped in YAML 1.2, and
|
|
||||||
// are purposefully unsupported here. They're still quoted on
|
|
||||||
// the way out for compatibility with other parser, though.
|
|
||||||
|
|
||||||
switch hint {
|
|
||||||
case 'M':
|
|
||||||
// We've already checked the map above.
|
|
||||||
|
|
||||||
case '.':
|
|
||||||
// Not in the map, so maybe a normal float.
|
|
||||||
floatv, err := strconv.ParseFloat(in, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_FLOAT_TAG, floatv
|
|
||||||
}
|
|
||||||
|
|
||||||
case 'D', 'S':
|
|
||||||
// Int, float, or timestamp.
|
|
||||||
plain := strings.Replace(in, "_", "", -1)
|
|
||||||
intv, err := strconv.ParseInt(plain, 0, 64)
|
|
||||||
if err == nil {
|
|
||||||
if intv == int64(int(intv)) {
|
|
||||||
return yaml_INT_TAG, int(intv)
|
|
||||||
} else {
|
|
||||||
return yaml_INT_TAG, intv
|
|
||||||
}
|
|
||||||
}
|
|
||||||
floatv, err := strconv.ParseFloat(plain, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_FLOAT_TAG, floatv
|
|
||||||
}
|
|
||||||
if strings.HasPrefix(plain, "0b") {
|
|
||||||
intv, err := strconv.ParseInt(plain[2:], 2, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_INT_TAG, int(intv)
|
|
||||||
}
|
|
||||||
} else if strings.HasPrefix(plain, "-0b") {
|
|
||||||
intv, err := strconv.ParseInt(plain[3:], 2, 64)
|
|
||||||
if err == nil {
|
|
||||||
return yaml_INT_TAG, -int(intv)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// XXX Handle timestamps here.
|
|
||||||
|
|
||||||
default:
|
|
||||||
panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if tag == yaml_BINARY_TAG {
|
|
||||||
return yaml_BINARY_TAG, in
|
|
||||||
}
|
|
||||||
if utf8.ValidString(in) {
|
|
||||||
return yaml_STR_TAG, in
|
|
||||||
}
|
|
||||||
return yaml_BINARY_TAG, encodeBase64(in)
|
|
||||||
}
|
|
||||||
|
|
||||||
// encodeBase64 encodes s as base64 that is broken up into multiple lines
|
|
||||||
// as appropriate for the resulting length.
|
|
||||||
func encodeBase64(s string) string {
|
|
||||||
const lineLen = 70
|
|
||||||
encLen := base64.StdEncoding.EncodedLen(len(s))
|
|
||||||
lines := encLen/lineLen + 1
|
|
||||||
buf := make([]byte, encLen*2+lines)
|
|
||||||
in := buf[0:encLen]
|
|
||||||
out := buf[encLen:]
|
|
||||||
base64.StdEncoding.Encode(in, []byte(s))
|
|
||||||
k := 0
|
|
||||||
for i := 0; i < len(in); i += lineLen {
|
|
||||||
j := i + lineLen
|
|
||||||
if j > len(in) {
|
|
||||||
j = len(in)
|
|
||||||
}
|
|
||||||
k += copy(out[k:], in[i:j])
|
|
||||||
if lines > 1 {
|
|
||||||
out[k] = '\n'
|
|
||||||
k++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return string(out[:k])
|
|
||||||
}
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,104 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"reflect"
|
|
||||||
"unicode"
|
|
||||||
)
|
|
||||||
|
|
||||||
type keyList []reflect.Value
|
|
||||||
|
|
||||||
func (l keyList) Len() int { return len(l) }
|
|
||||||
func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
|
|
||||||
func (l keyList) Less(i, j int) bool {
|
|
||||||
a := l[i]
|
|
||||||
b := l[j]
|
|
||||||
ak := a.Kind()
|
|
||||||
bk := b.Kind()
|
|
||||||
for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() {
|
|
||||||
a = a.Elem()
|
|
||||||
ak = a.Kind()
|
|
||||||
}
|
|
||||||
for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() {
|
|
||||||
b = b.Elem()
|
|
||||||
bk = b.Kind()
|
|
||||||
}
|
|
||||||
af, aok := keyFloat(a)
|
|
||||||
bf, bok := keyFloat(b)
|
|
||||||
if aok && bok {
|
|
||||||
if af != bf {
|
|
||||||
return af < bf
|
|
||||||
}
|
|
||||||
if ak != bk {
|
|
||||||
return ak < bk
|
|
||||||
}
|
|
||||||
return numLess(a, b)
|
|
||||||
}
|
|
||||||
if ak != reflect.String || bk != reflect.String {
|
|
||||||
return ak < bk
|
|
||||||
}
|
|
||||||
ar, br := []rune(a.String()), []rune(b.String())
|
|
||||||
for i := 0; i < len(ar) && i < len(br); i++ {
|
|
||||||
if ar[i] == br[i] {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
al := unicode.IsLetter(ar[i])
|
|
||||||
bl := unicode.IsLetter(br[i])
|
|
||||||
if al && bl {
|
|
||||||
return ar[i] < br[i]
|
|
||||||
}
|
|
||||||
if al || bl {
|
|
||||||
return bl
|
|
||||||
}
|
|
||||||
var ai, bi int
|
|
||||||
var an, bn int64
|
|
||||||
for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ {
|
|
||||||
an = an*10 + int64(ar[ai]-'0')
|
|
||||||
}
|
|
||||||
for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ {
|
|
||||||
bn = bn*10 + int64(br[bi]-'0')
|
|
||||||
}
|
|
||||||
if an != bn {
|
|
||||||
return an < bn
|
|
||||||
}
|
|
||||||
if ai != bi {
|
|
||||||
return ai < bi
|
|
||||||
}
|
|
||||||
return ar[i] < br[i]
|
|
||||||
}
|
|
||||||
return len(ar) < len(br)
|
|
||||||
}
|
|
||||||
|
|
||||||
// keyFloat returns a float value for v if it is a number/bool
|
|
||||||
// and whether it is a number/bool or not.
|
|
||||||
func keyFloat(v reflect.Value) (f float64, ok bool) {
|
|
||||||
switch v.Kind() {
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
return float64(v.Int()), true
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
return v.Float(), true
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
return float64(v.Uint()), true
|
|
||||||
case reflect.Bool:
|
|
||||||
if v.Bool() {
|
|
||||||
return 1, true
|
|
||||||
}
|
|
||||||
return 0, true
|
|
||||||
}
|
|
||||||
return 0, false
|
|
||||||
}
|
|
||||||
|
|
||||||
// numLess returns whether a < b.
|
|
||||||
// a and b must necessarily have the same kind.
|
|
||||||
func numLess(a, b reflect.Value) bool {
|
|
||||||
switch a.Kind() {
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
return a.Int() < b.Int()
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
return a.Float() < b.Float()
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
return a.Uint() < b.Uint()
|
|
||||||
case reflect.Bool:
|
|
||||||
return !a.Bool() && b.Bool()
|
|
||||||
}
|
|
||||||
panic("not a number")
|
|
||||||
}
|
|
|
@ -1,89 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
// Set the writer error and return false.
|
|
||||||
func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
|
|
||||||
emitter.error = yaml_WRITER_ERROR
|
|
||||||
emitter.problem = problem
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Flush the output buffer.
|
|
||||||
func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
|
|
||||||
if emitter.write_handler == nil {
|
|
||||||
panic("write handler not set")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the buffer is empty.
|
|
||||||
if emitter.buffer_pos == 0 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the output encoding is UTF-8, we don't need to recode the buffer.
|
|
||||||
if emitter.encoding == yaml_UTF8_ENCODING {
|
|
||||||
if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
|
|
||||||
return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
|
|
||||||
}
|
|
||||||
emitter.buffer_pos = 0
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Recode the buffer into the raw buffer.
|
|
||||||
var low, high int
|
|
||||||
if emitter.encoding == yaml_UTF16LE_ENCODING {
|
|
||||||
low, high = 0, 1
|
|
||||||
} else {
|
|
||||||
high, low = 1, 0
|
|
||||||
}
|
|
||||||
|
|
||||||
pos := 0
|
|
||||||
for pos < emitter.buffer_pos {
|
|
||||||
// See the "reader.c" code for more details on UTF-8 encoding. Note
|
|
||||||
// that we assume that the buffer contains a valid UTF-8 sequence.
|
|
||||||
|
|
||||||
// Read the next UTF-8 character.
|
|
||||||
octet := emitter.buffer[pos]
|
|
||||||
|
|
||||||
var w int
|
|
||||||
var value rune
|
|
||||||
switch {
|
|
||||||
case octet&0x80 == 0x00:
|
|
||||||
w, value = 1, rune(octet&0x7F)
|
|
||||||
case octet&0xE0 == 0xC0:
|
|
||||||
w, value = 2, rune(octet&0x1F)
|
|
||||||
case octet&0xF0 == 0xE0:
|
|
||||||
w, value = 3, rune(octet&0x0F)
|
|
||||||
case octet&0xF8 == 0xF0:
|
|
||||||
w, value = 4, rune(octet&0x07)
|
|
||||||
}
|
|
||||||
for k := 1; k < w; k++ {
|
|
||||||
octet = emitter.buffer[pos+k]
|
|
||||||
value = (value << 6) + (rune(octet) & 0x3F)
|
|
||||||
}
|
|
||||||
pos += w
|
|
||||||
|
|
||||||
// Write the character.
|
|
||||||
if value < 0x10000 {
|
|
||||||
var b [2]byte
|
|
||||||
b[high] = byte(value >> 8)
|
|
||||||
b[low] = byte(value & 0xFF)
|
|
||||||
emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1])
|
|
||||||
} else {
|
|
||||||
// Write the character using a surrogate pair (check "reader.c").
|
|
||||||
var b [4]byte
|
|
||||||
value -= 0x10000
|
|
||||||
b[high] = byte(0xD8 + (value >> 18))
|
|
||||||
b[low] = byte((value >> 10) & 0xFF)
|
|
||||||
b[high+2] = byte(0xDC + ((value >> 8) & 0xFF))
|
|
||||||
b[low+2] = byte(value & 0xFF)
|
|
||||||
emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1], b[2], b[3])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write the raw buffer.
|
|
||||||
if err := emitter.write_handler(emitter, emitter.raw_buffer); err != nil {
|
|
||||||
return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
|
|
||||||
}
|
|
||||||
emitter.buffer_pos = 0
|
|
||||||
emitter.raw_buffer = emitter.raw_buffer[:0]
|
|
||||||
return true
|
|
||||||
}
|
|
|
@ -1,301 +0,0 @@
|
||||||
// Package yaml implements YAML support for the Go language.
|
|
||||||
//
|
|
||||||
// Source code and other details for the project are available at GitHub:
|
|
||||||
//
|
|
||||||
// https://github.com/go-yaml/yaml
|
|
||||||
//
|
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"reflect"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
type yamlError string
|
|
||||||
|
|
||||||
func fail(msg string) {
|
|
||||||
panic(yamlError(msg))
|
|
||||||
}
|
|
||||||
|
|
||||||
func handleErr(err *error) {
|
|
||||||
if r := recover(); r != nil {
|
|
||||||
if e, ok := r.(yamlError); ok {
|
|
||||||
*err = errors.New("YAML error: " + string(e))
|
|
||||||
} else {
|
|
||||||
panic(r)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Setter interface may be implemented by types to do their own custom
|
|
||||||
// unmarshalling of YAML values, rather than being implicitly assigned by
|
|
||||||
// the yaml package machinery. If setting the value works, the method should
|
|
||||||
// return true. If it returns false, the value is considered unsupported
|
|
||||||
// and is omitted from maps and slices.
|
|
||||||
type Setter interface {
|
|
||||||
SetYAML(tag string, value interface{}) bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Getter interface is implemented by types to do their own custom
|
|
||||||
// marshalling into a YAML tag and value.
|
|
||||||
type Getter interface {
|
|
||||||
GetYAML() (tag string, value interface{})
|
|
||||||
}
|
|
||||||
|
|
||||||
// Unmarshal decodes the first document found within the in byte slice
|
|
||||||
// and assigns decoded values into the out value.
|
|
||||||
//
|
|
||||||
// Maps and pointers (to a struct, string, int, etc) are accepted as out
|
|
||||||
// values. If an internal pointer within a struct is not initialized,
|
|
||||||
// the yaml package will initialize it if necessary for unmarshalling
|
|
||||||
// the provided data. The out parameter must not be nil.
|
|
||||||
//
|
|
||||||
// The type of the decoded values and the type of out will be considered,
|
|
||||||
// and Unmarshal will do the best possible job to unmarshal values
|
|
||||||
// appropriately. It is NOT considered an error, though, to skip values
|
|
||||||
// because they are not available in the decoded YAML, or if they are not
|
|
||||||
// compatible with the out value. To ensure something was properly
|
|
||||||
// unmarshaled use a map or compare against the previous value for the
|
|
||||||
// field (usually the zero value).
|
|
||||||
//
|
|
||||||
// Struct fields are only unmarshalled if they are exported (have an
|
|
||||||
// upper case first letter), and are unmarshalled using the field name
|
|
||||||
// lowercased as the default key. Custom keys may be defined via the
|
|
||||||
// "yaml" name in the field tag: the content preceding the first comma
|
|
||||||
// is used as the key, and the following comma-separated options are
|
|
||||||
// used to tweak the marshalling process (see Marshal).
|
|
||||||
// Conflicting names result in a runtime error.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// type T struct {
|
|
||||||
// F int `yaml:"a,omitempty"`
|
|
||||||
// B int
|
|
||||||
// }
|
|
||||||
// var t T
|
|
||||||
// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
|
|
||||||
//
|
|
||||||
// See the documentation of Marshal for the format of tags and a list of
|
|
||||||
// supported tag options.
|
|
||||||
//
|
|
||||||
func Unmarshal(in []byte, out interface{}) (err error) {
|
|
||||||
defer handleErr(&err)
|
|
||||||
d := newDecoder()
|
|
||||||
p := newParser(in)
|
|
||||||
defer p.destroy()
|
|
||||||
node := p.parse()
|
|
||||||
if node != nil {
|
|
||||||
v := reflect.ValueOf(out)
|
|
||||||
if v.Kind() == reflect.Ptr && !v.IsNil() {
|
|
||||||
v = v.Elem()
|
|
||||||
}
|
|
||||||
d.unmarshal(node, v)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Marshal serializes the value provided into a YAML document. The structure
|
|
||||||
// of the generated document will reflect the structure of the value itself.
|
|
||||||
// Maps and pointers (to struct, string, int, etc) are accepted as the in value.
|
|
||||||
//
|
|
||||||
// Struct fields are only unmarshalled if they are exported (have an upper case
|
|
||||||
// first letter), and are unmarshalled using the field name lowercased as the
|
|
||||||
// default key. Custom keys may be defined via the "yaml" name in the field
|
|
||||||
// tag: the content preceding the first comma is used as the key, and the
|
|
||||||
// following comma-separated options are used to tweak the marshalling process.
|
|
||||||
// Conflicting names result in a runtime error.
|
|
||||||
//
|
|
||||||
// The field tag format accepted is:
|
|
||||||
//
|
|
||||||
// `(...) yaml:"[<key>][,<flag1>[,<flag2>]]" (...)`
|
|
||||||
//
|
|
||||||
// The following flags are currently supported:
|
|
||||||
//
|
|
||||||
// omitempty Only include the field if it's not set to the zero
|
|
||||||
// value for the type or to empty slices or maps.
|
|
||||||
// Does not apply to zero valued structs.
|
|
||||||
//
|
|
||||||
// flow Marshal using a flow style (useful for structs,
|
|
||||||
// sequences and maps.
|
|
||||||
//
|
|
||||||
// inline Inline the struct it's applied to, so its fields
|
|
||||||
// are processed as if they were part of the outer
|
|
||||||
// struct.
|
|
||||||
//
|
|
||||||
// In addition, if the key is "-", the field is ignored.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// type T struct {
|
|
||||||
// F int "a,omitempty"
|
|
||||||
// B int
|
|
||||||
// }
|
|
||||||
// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
|
|
||||||
// yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
|
|
||||||
//
|
|
||||||
func Marshal(in interface{}) (out []byte, err error) {
|
|
||||||
defer handleErr(&err)
|
|
||||||
e := newEncoder()
|
|
||||||
defer e.destroy()
|
|
||||||
e.marshal("", reflect.ValueOf(in))
|
|
||||||
e.finish()
|
|
||||||
out = e.out
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// --------------------------------------------------------------------------
|
|
||||||
// Maintain a mapping of keys to structure field indexes
|
|
||||||
|
|
||||||
// The code in this section was copied from mgo/bson.
|
|
||||||
|
|
||||||
// structInfo holds details for the serialization of fields of
|
|
||||||
// a given struct.
|
|
||||||
type structInfo struct {
|
|
||||||
FieldsMap map[string]fieldInfo
|
|
||||||
FieldsList []fieldInfo
|
|
||||||
|
|
||||||
// InlineMap is the number of the field in the struct that
|
|
||||||
// contains an ,inline map, or -1 if there's none.
|
|
||||||
InlineMap int
|
|
||||||
}
|
|
||||||
|
|
||||||
type fieldInfo struct {
|
|
||||||
Key string
|
|
||||||
Num int
|
|
||||||
OmitEmpty bool
|
|
||||||
Flow bool
|
|
||||||
|
|
||||||
// Inline holds the field index if the field is part of an inlined struct.
|
|
||||||
Inline []int
|
|
||||||
}
|
|
||||||
|
|
||||||
var structMap = make(map[reflect.Type]*structInfo)
|
|
||||||
var fieldMapMutex sync.RWMutex
|
|
||||||
|
|
||||||
func getStructInfo(st reflect.Type) (*structInfo, error) {
|
|
||||||
fieldMapMutex.RLock()
|
|
||||||
sinfo, found := structMap[st]
|
|
||||||
fieldMapMutex.RUnlock()
|
|
||||||
if found {
|
|
||||||
return sinfo, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
n := st.NumField()
|
|
||||||
fieldsMap := make(map[string]fieldInfo)
|
|
||||||
fieldsList := make([]fieldInfo, 0, n)
|
|
||||||
inlineMap := -1
|
|
||||||
for i := 0; i != n; i++ {
|
|
||||||
field := st.Field(i)
|
|
||||||
if field.PkgPath != "" {
|
|
||||||
continue // Private field
|
|
||||||
}
|
|
||||||
|
|
||||||
info := fieldInfo{Num: i}
|
|
||||||
|
|
||||||
tag := field.Tag.Get("yaml")
|
|
||||||
if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
|
|
||||||
tag = string(field.Tag)
|
|
||||||
}
|
|
||||||
if tag == "-" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
inline := false
|
|
||||||
fields := strings.Split(tag, ",")
|
|
||||||
if len(fields) > 1 {
|
|
||||||
for _, flag := range fields[1:] {
|
|
||||||
switch flag {
|
|
||||||
case "omitempty":
|
|
||||||
info.OmitEmpty = true
|
|
||||||
case "flow":
|
|
||||||
info.Flow = true
|
|
||||||
case "inline":
|
|
||||||
inline = true
|
|
||||||
default:
|
|
||||||
return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
tag = fields[0]
|
|
||||||
}
|
|
||||||
|
|
||||||
if inline {
|
|
||||||
switch field.Type.Kind() {
|
|
||||||
// TODO: Implement support for inline maps.
|
|
||||||
//case reflect.Map:
|
|
||||||
// if inlineMap >= 0 {
|
|
||||||
// return nil, errors.New("Multiple ,inline maps in struct " + st.String())
|
|
||||||
// }
|
|
||||||
// if field.Type.Key() != reflect.TypeOf("") {
|
|
||||||
// return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
|
|
||||||
// }
|
|
||||||
// inlineMap = info.Num
|
|
||||||
case reflect.Struct:
|
|
||||||
sinfo, err := getStructInfo(field.Type)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
for _, finfo := range sinfo.FieldsList {
|
|
||||||
if _, found := fieldsMap[finfo.Key]; found {
|
|
||||||
msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String()
|
|
||||||
return nil, errors.New(msg)
|
|
||||||
}
|
|
||||||
if finfo.Inline == nil {
|
|
||||||
finfo.Inline = []int{i, finfo.Num}
|
|
||||||
} else {
|
|
||||||
finfo.Inline = append([]int{i}, finfo.Inline...)
|
|
||||||
}
|
|
||||||
fieldsMap[finfo.Key] = finfo
|
|
||||||
fieldsList = append(fieldsList, finfo)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
//return nil, errors.New("Option ,inline needs a struct value or map field")
|
|
||||||
return nil, errors.New("Option ,inline needs a struct value field")
|
|
||||||
}
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
if tag != "" {
|
|
||||||
info.Key = tag
|
|
||||||
} else {
|
|
||||||
info.Key = strings.ToLower(field.Name)
|
|
||||||
}
|
|
||||||
|
|
||||||
if _, found = fieldsMap[info.Key]; found {
|
|
||||||
msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
|
|
||||||
return nil, errors.New(msg)
|
|
||||||
}
|
|
||||||
|
|
||||||
fieldsList = append(fieldsList, info)
|
|
||||||
fieldsMap[info.Key] = info
|
|
||||||
}
|
|
||||||
|
|
||||||
sinfo = &structInfo{fieldsMap, fieldsList, inlineMap}
|
|
||||||
|
|
||||||
fieldMapMutex.Lock()
|
|
||||||
structMap[st] = sinfo
|
|
||||||
fieldMapMutex.Unlock()
|
|
||||||
return sinfo, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func isZero(v reflect.Value) bool {
|
|
||||||
switch v.Kind() {
|
|
||||||
case reflect.String:
|
|
||||||
return len(v.String()) == 0
|
|
||||||
case reflect.Interface, reflect.Ptr:
|
|
||||||
return v.IsNil()
|
|
||||||
case reflect.Slice:
|
|
||||||
return v.Len() == 0
|
|
||||||
case reflect.Map:
|
|
||||||
return v.Len() == 0
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
return v.Int() == 0
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
return v.Uint() == 0
|
|
||||||
case reflect.Bool:
|
|
||||||
return !v.Bool()
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
|
@ -1,716 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"io"
|
|
||||||
)
|
|
||||||
|
|
||||||
// The version directive data.
|
|
||||||
type yaml_version_directive_t struct {
|
|
||||||
major int8 // The major version number.
|
|
||||||
minor int8 // The minor version number.
|
|
||||||
}
|
|
||||||
|
|
||||||
// The tag directive data.
|
|
||||||
type yaml_tag_directive_t struct {
|
|
||||||
handle []byte // The tag handle.
|
|
||||||
prefix []byte // The tag prefix.
|
|
||||||
}
|
|
||||||
|
|
||||||
type yaml_encoding_t int
|
|
||||||
|
|
||||||
// The stream encoding.
|
|
||||||
const (
|
|
||||||
// Let the parser choose the encoding.
|
|
||||||
yaml_ANY_ENCODING yaml_encoding_t = iota
|
|
||||||
|
|
||||||
yaml_UTF8_ENCODING // The default UTF-8 encoding.
|
|
||||||
yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM.
|
|
||||||
yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM.
|
|
||||||
)
|
|
||||||
|
|
||||||
type yaml_break_t int
|
|
||||||
|
|
||||||
// Line break types.
|
|
||||||
const (
|
|
||||||
// Let the parser choose the break type.
|
|
||||||
yaml_ANY_BREAK yaml_break_t = iota
|
|
||||||
|
|
||||||
yaml_CR_BREAK // Use CR for line breaks (Mac style).
|
|
||||||
yaml_LN_BREAK // Use LN for line breaks (Unix style).
|
|
||||||
yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style).
|
|
||||||
)
|
|
||||||
|
|
||||||
type yaml_error_type_t int
|
|
||||||
|
|
||||||
// Many bad things could happen with the parser and emitter.
|
|
||||||
const (
|
|
||||||
// No error is produced.
|
|
||||||
yaml_NO_ERROR yaml_error_type_t = iota
|
|
||||||
|
|
||||||
yaml_MEMORY_ERROR // Cannot allocate or reallocate a block of memory.
|
|
||||||
yaml_READER_ERROR // Cannot read or decode the input stream.
|
|
||||||
yaml_SCANNER_ERROR // Cannot scan the input stream.
|
|
||||||
yaml_PARSER_ERROR // Cannot parse the input stream.
|
|
||||||
yaml_COMPOSER_ERROR // Cannot compose a YAML document.
|
|
||||||
yaml_WRITER_ERROR // Cannot write to the output stream.
|
|
||||||
yaml_EMITTER_ERROR // Cannot emit a YAML stream.
|
|
||||||
)
|
|
||||||
|
|
||||||
// The pointer position.
|
|
||||||
type yaml_mark_t struct {
|
|
||||||
index int // The position index.
|
|
||||||
line int // The position line.
|
|
||||||
column int // The position column.
|
|
||||||
}
|
|
||||||
|
|
||||||
// Node Styles
|
|
||||||
|
|
||||||
type yaml_style_t int8
|
|
||||||
|
|
||||||
type yaml_scalar_style_t yaml_style_t
|
|
||||||
|
|
||||||
// Scalar styles.
|
|
||||||
const (
|
|
||||||
// Let the emitter choose the style.
|
|
||||||
yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota
|
|
||||||
|
|
||||||
yaml_PLAIN_SCALAR_STYLE // The plain scalar style.
|
|
||||||
yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style.
|
|
||||||
yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style.
|
|
||||||
yaml_LITERAL_SCALAR_STYLE // The literal scalar style.
|
|
||||||
yaml_FOLDED_SCALAR_STYLE // The folded scalar style.
|
|
||||||
)
|
|
||||||
|
|
||||||
type yaml_sequence_style_t yaml_style_t
|
|
||||||
|
|
||||||
// Sequence styles.
|
|
||||||
const (
|
|
||||||
// Let the emitter choose the style.
|
|
||||||
yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota
|
|
||||||
|
|
||||||
yaml_BLOCK_SEQUENCE_STYLE // The block sequence style.
|
|
||||||
yaml_FLOW_SEQUENCE_STYLE // The flow sequence style.
|
|
||||||
)
|
|
||||||
|
|
||||||
type yaml_mapping_style_t yaml_style_t
|
|
||||||
|
|
||||||
// Mapping styles.
|
|
||||||
const (
|
|
||||||
// Let the emitter choose the style.
|
|
||||||
yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota
|
|
||||||
|
|
||||||
yaml_BLOCK_MAPPING_STYLE // The block mapping style.
|
|
||||||
yaml_FLOW_MAPPING_STYLE // The flow mapping style.
|
|
||||||
)
|
|
||||||
|
|
||||||
// Tokens
|
|
||||||
|
|
||||||
type yaml_token_type_t int
|
|
||||||
|
|
||||||
// Token types.
|
|
||||||
const (
|
|
||||||
// An empty token.
|
|
||||||
yaml_NO_TOKEN yaml_token_type_t = iota
|
|
||||||
|
|
||||||
yaml_STREAM_START_TOKEN // A STREAM-START token.
|
|
||||||
yaml_STREAM_END_TOKEN // A STREAM-END token.
|
|
||||||
|
|
||||||
yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token.
|
|
||||||
yaml_TAG_DIRECTIVE_TOKEN // A TAG-DIRECTIVE token.
|
|
||||||
yaml_DOCUMENT_START_TOKEN // A DOCUMENT-START token.
|
|
||||||
yaml_DOCUMENT_END_TOKEN // A DOCUMENT-END token.
|
|
||||||
|
|
||||||
yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token.
|
|
||||||
yaml_BLOCK_MAPPING_START_TOKEN // A BLOCK-SEQUENCE-END token.
|
|
||||||
yaml_BLOCK_END_TOKEN // A BLOCK-END token.
|
|
||||||
|
|
||||||
yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token.
|
|
||||||
yaml_FLOW_SEQUENCE_END_TOKEN // A FLOW-SEQUENCE-END token.
|
|
||||||
yaml_FLOW_MAPPING_START_TOKEN // A FLOW-MAPPING-START token.
|
|
||||||
yaml_FLOW_MAPPING_END_TOKEN // A FLOW-MAPPING-END token.
|
|
||||||
|
|
||||||
yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token.
|
|
||||||
yaml_FLOW_ENTRY_TOKEN // A FLOW-ENTRY token.
|
|
||||||
yaml_KEY_TOKEN // A KEY token.
|
|
||||||
yaml_VALUE_TOKEN // A VALUE token.
|
|
||||||
|
|
||||||
yaml_ALIAS_TOKEN // An ALIAS token.
|
|
||||||
yaml_ANCHOR_TOKEN // An ANCHOR token.
|
|
||||||
yaml_TAG_TOKEN // A TAG token.
|
|
||||||
yaml_SCALAR_TOKEN // A SCALAR token.
|
|
||||||
)
|
|
||||||
|
|
||||||
func (tt yaml_token_type_t) String() string {
|
|
||||||
switch tt {
|
|
||||||
case yaml_NO_TOKEN:
|
|
||||||
return "yaml_NO_TOKEN"
|
|
||||||
case yaml_STREAM_START_TOKEN:
|
|
||||||
return "yaml_STREAM_START_TOKEN"
|
|
||||||
case yaml_STREAM_END_TOKEN:
|
|
||||||
return "yaml_STREAM_END_TOKEN"
|
|
||||||
case yaml_VERSION_DIRECTIVE_TOKEN:
|
|
||||||
return "yaml_VERSION_DIRECTIVE_TOKEN"
|
|
||||||
case yaml_TAG_DIRECTIVE_TOKEN:
|
|
||||||
return "yaml_TAG_DIRECTIVE_TOKEN"
|
|
||||||
case yaml_DOCUMENT_START_TOKEN:
|
|
||||||
return "yaml_DOCUMENT_START_TOKEN"
|
|
||||||
case yaml_DOCUMENT_END_TOKEN:
|
|
||||||
return "yaml_DOCUMENT_END_TOKEN"
|
|
||||||
case yaml_BLOCK_SEQUENCE_START_TOKEN:
|
|
||||||
return "yaml_BLOCK_SEQUENCE_START_TOKEN"
|
|
||||||
case yaml_BLOCK_MAPPING_START_TOKEN:
|
|
||||||
return "yaml_BLOCK_MAPPING_START_TOKEN"
|
|
||||||
case yaml_BLOCK_END_TOKEN:
|
|
||||||
return "yaml_BLOCK_END_TOKEN"
|
|
||||||
case yaml_FLOW_SEQUENCE_START_TOKEN:
|
|
||||||
return "yaml_FLOW_SEQUENCE_START_TOKEN"
|
|
||||||
case yaml_FLOW_SEQUENCE_END_TOKEN:
|
|
||||||
return "yaml_FLOW_SEQUENCE_END_TOKEN"
|
|
||||||
case yaml_FLOW_MAPPING_START_TOKEN:
|
|
||||||
return "yaml_FLOW_MAPPING_START_TOKEN"
|
|
||||||
case yaml_FLOW_MAPPING_END_TOKEN:
|
|
||||||
return "yaml_FLOW_MAPPING_END_TOKEN"
|
|
||||||
case yaml_BLOCK_ENTRY_TOKEN:
|
|
||||||
return "yaml_BLOCK_ENTRY_TOKEN"
|
|
||||||
case yaml_FLOW_ENTRY_TOKEN:
|
|
||||||
return "yaml_FLOW_ENTRY_TOKEN"
|
|
||||||
case yaml_KEY_TOKEN:
|
|
||||||
return "yaml_KEY_TOKEN"
|
|
||||||
case yaml_VALUE_TOKEN:
|
|
||||||
return "yaml_VALUE_TOKEN"
|
|
||||||
case yaml_ALIAS_TOKEN:
|
|
||||||
return "yaml_ALIAS_TOKEN"
|
|
||||||
case yaml_ANCHOR_TOKEN:
|
|
||||||
return "yaml_ANCHOR_TOKEN"
|
|
||||||
case yaml_TAG_TOKEN:
|
|
||||||
return "yaml_TAG_TOKEN"
|
|
||||||
case yaml_SCALAR_TOKEN:
|
|
||||||
return "yaml_SCALAR_TOKEN"
|
|
||||||
}
|
|
||||||
return "<unknown token>"
|
|
||||||
}
|
|
||||||
|
|
||||||
// The token structure.
|
|
||||||
type yaml_token_t struct {
|
|
||||||
// The token type.
|
|
||||||
typ yaml_token_type_t
|
|
||||||
|
|
||||||
// The start/end of the token.
|
|
||||||
start_mark, end_mark yaml_mark_t
|
|
||||||
|
|
||||||
// The stream encoding (for yaml_STREAM_START_TOKEN).
|
|
||||||
encoding yaml_encoding_t
|
|
||||||
|
|
||||||
// The alias/anchor/scalar value or tag/tag directive handle
|
|
||||||
// (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN).
|
|
||||||
value []byte
|
|
||||||
|
|
||||||
// The tag suffix (for yaml_TAG_TOKEN).
|
|
||||||
suffix []byte
|
|
||||||
|
|
||||||
// The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN).
|
|
||||||
prefix []byte
|
|
||||||
|
|
||||||
// The scalar style (for yaml_SCALAR_TOKEN).
|
|
||||||
style yaml_scalar_style_t
|
|
||||||
|
|
||||||
// The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN).
|
|
||||||
major, minor int8
|
|
||||||
}
|
|
||||||
|
|
||||||
// Events
|
|
||||||
|
|
||||||
type yaml_event_type_t int8
|
|
||||||
|
|
||||||
// Event types.
|
|
||||||
const (
|
|
||||||
// An empty event.
|
|
||||||
yaml_NO_EVENT yaml_event_type_t = iota
|
|
||||||
|
|
||||||
yaml_STREAM_START_EVENT // A STREAM-START event.
|
|
||||||
yaml_STREAM_END_EVENT // A STREAM-END event.
|
|
||||||
yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event.
|
|
||||||
yaml_DOCUMENT_END_EVENT // A DOCUMENT-END event.
|
|
||||||
yaml_ALIAS_EVENT // An ALIAS event.
|
|
||||||
yaml_SCALAR_EVENT // A SCALAR event.
|
|
||||||
yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event.
|
|
||||||
yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event.
|
|
||||||
yaml_MAPPING_START_EVENT // A MAPPING-START event.
|
|
||||||
yaml_MAPPING_END_EVENT // A MAPPING-END event.
|
|
||||||
)
|
|
||||||
|
|
||||||
// The event structure.
|
|
||||||
type yaml_event_t struct {
|
|
||||||
|
|
||||||
// The event type.
|
|
||||||
typ yaml_event_type_t
|
|
||||||
|
|
||||||
// The start and end of the event.
|
|
||||||
start_mark, end_mark yaml_mark_t
|
|
||||||
|
|
||||||
// The document encoding (for yaml_STREAM_START_EVENT).
|
|
||||||
encoding yaml_encoding_t
|
|
||||||
|
|
||||||
// The version directive (for yaml_DOCUMENT_START_EVENT).
|
|
||||||
version_directive *yaml_version_directive_t
|
|
||||||
|
|
||||||
// The list of tag directives (for yaml_DOCUMENT_START_EVENT).
|
|
||||||
tag_directives []yaml_tag_directive_t
|
|
||||||
|
|
||||||
// The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT).
|
|
||||||
anchor []byte
|
|
||||||
|
|
||||||
// The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
|
|
||||||
tag []byte
|
|
||||||
|
|
||||||
// The scalar value (for yaml_SCALAR_EVENT).
|
|
||||||
value []byte
|
|
||||||
|
|
||||||
// Is the document start/end indicator implicit, or the tag optional?
|
|
||||||
// (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT).
|
|
||||||
implicit bool
|
|
||||||
|
|
||||||
// Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT).
|
|
||||||
quoted_implicit bool
|
|
||||||
|
|
||||||
// The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
|
|
||||||
style yaml_style_t
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *yaml_event_t) scalar_style() yaml_scalar_style_t { return yaml_scalar_style_t(e.style) }
|
|
||||||
func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) }
|
|
||||||
func (e *yaml_event_t) mapping_style() yaml_mapping_style_t { return yaml_mapping_style_t(e.style) }
|
|
||||||
|
|
||||||
// Nodes
|
|
||||||
|
|
||||||
const (
|
|
||||||
yaml_NULL_TAG = "tag:yaml.org,2002:null" // The tag !!null with the only possible value: null.
|
|
||||||
yaml_BOOL_TAG = "tag:yaml.org,2002:bool" // The tag !!bool with the values: true and false.
|
|
||||||
yaml_STR_TAG = "tag:yaml.org,2002:str" // The tag !!str for string values.
|
|
||||||
yaml_INT_TAG = "tag:yaml.org,2002:int" // The tag !!int for integer values.
|
|
||||||
yaml_FLOAT_TAG = "tag:yaml.org,2002:float" // The tag !!float for float values.
|
|
||||||
yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values.
|
|
||||||
|
|
||||||
yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences.
|
|
||||||
yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping.
|
|
||||||
|
|
||||||
// Not in original libyaml.
|
|
||||||
yaml_BINARY_TAG = "tag:yaml.org,2002:binary"
|
|
||||||
yaml_MERGE_TAG = "tag:yaml.org,2002:merge"
|
|
||||||
|
|
||||||
yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str.
|
|
||||||
yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq.
|
|
||||||
yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map.
|
|
||||||
)
|
|
||||||
|
|
||||||
type yaml_node_type_t int
|
|
||||||
|
|
||||||
// Node types.
|
|
||||||
const (
|
|
||||||
// An empty node.
|
|
||||||
yaml_NO_NODE yaml_node_type_t = iota
|
|
||||||
|
|
||||||
yaml_SCALAR_NODE // A scalar node.
|
|
||||||
yaml_SEQUENCE_NODE // A sequence node.
|
|
||||||
yaml_MAPPING_NODE // A mapping node.
|
|
||||||
)
|
|
||||||
|
|
||||||
// An element of a sequence node.
|
|
||||||
type yaml_node_item_t int
|
|
||||||
|
|
||||||
// An element of a mapping node.
|
|
||||||
type yaml_node_pair_t struct {
|
|
||||||
key int // The key of the element.
|
|
||||||
value int // The value of the element.
|
|
||||||
}
|
|
||||||
|
|
||||||
// The node structure.
|
|
||||||
type yaml_node_t struct {
|
|
||||||
typ yaml_node_type_t // The node type.
|
|
||||||
tag []byte // The node tag.
|
|
||||||
|
|
||||||
// The node data.
|
|
||||||
|
|
||||||
// The scalar parameters (for yaml_SCALAR_NODE).
|
|
||||||
scalar struct {
|
|
||||||
value []byte // The scalar value.
|
|
||||||
length int // The length of the scalar value.
|
|
||||||
style yaml_scalar_style_t // The scalar style.
|
|
||||||
}
|
|
||||||
|
|
||||||
// The sequence parameters (for YAML_SEQUENCE_NODE).
|
|
||||||
sequence struct {
|
|
||||||
items_data []yaml_node_item_t // The stack of sequence items.
|
|
||||||
style yaml_sequence_style_t // The sequence style.
|
|
||||||
}
|
|
||||||
|
|
||||||
// The mapping parameters (for yaml_MAPPING_NODE).
|
|
||||||
mapping struct {
|
|
||||||
pairs_data []yaml_node_pair_t // The stack of mapping pairs (key, value).
|
|
||||||
pairs_start *yaml_node_pair_t // The beginning of the stack.
|
|
||||||
pairs_end *yaml_node_pair_t // The end of the stack.
|
|
||||||
pairs_top *yaml_node_pair_t // The top of the stack.
|
|
||||||
style yaml_mapping_style_t // The mapping style.
|
|
||||||
}
|
|
||||||
|
|
||||||
start_mark yaml_mark_t // The beginning of the node.
|
|
||||||
end_mark yaml_mark_t // The end of the node.
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// The document structure.
|
|
||||||
type yaml_document_t struct {
|
|
||||||
|
|
||||||
// The document nodes.
|
|
||||||
nodes []yaml_node_t
|
|
||||||
|
|
||||||
// The version directive.
|
|
||||||
version_directive *yaml_version_directive_t
|
|
||||||
|
|
||||||
// The list of tag directives.
|
|
||||||
tag_directives_data []yaml_tag_directive_t
|
|
||||||
tag_directives_start int // The beginning of the tag directives list.
|
|
||||||
tag_directives_end int // The end of the tag directives list.
|
|
||||||
|
|
||||||
start_implicit int // Is the document start indicator implicit?
|
|
||||||
end_implicit int // Is the document end indicator implicit?
|
|
||||||
|
|
||||||
// The start/end of the document.
|
|
||||||
start_mark, end_mark yaml_mark_t
|
|
||||||
}
|
|
||||||
|
|
||||||
// The prototype of a read handler.
|
|
||||||
//
|
|
||||||
// The read handler is called when the parser needs to read more bytes from the
|
|
||||||
// source. The handler should write not more than size bytes to the buffer.
|
|
||||||
// The number of written bytes should be set to the size_read variable.
|
|
||||||
//
|
|
||||||
// [in,out] data A pointer to an application data specified by
|
|
||||||
// yaml_parser_set_input().
|
|
||||||
// [out] buffer The buffer to write the data from the source.
|
|
||||||
// [in] size The size of the buffer.
|
|
||||||
// [out] size_read The actual number of bytes read from the source.
|
|
||||||
//
|
|
||||||
// On success, the handler should return 1. If the handler failed,
|
|
||||||
// the returned value should be 0. On EOF, the handler should set the
|
|
||||||
// size_read to 0 and return 1.
|
|
||||||
type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error)
|
|
||||||
|
|
||||||
// This structure holds information about a potential simple key.
|
|
||||||
type yaml_simple_key_t struct {
|
|
||||||
possible bool // Is a simple key possible?
|
|
||||||
required bool // Is a simple key required?
|
|
||||||
token_number int // The number of the token.
|
|
||||||
mark yaml_mark_t // The position mark.
|
|
||||||
}
|
|
||||||
|
|
||||||
// The states of the parser.
|
|
||||||
type yaml_parser_state_t int
|
|
||||||
|
|
||||||
const (
|
|
||||||
yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota
|
|
||||||
|
|
||||||
yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE // Expect the beginning of an implicit document.
|
|
||||||
yaml_PARSE_DOCUMENT_START_STATE // Expect DOCUMENT-START.
|
|
||||||
yaml_PARSE_DOCUMENT_CONTENT_STATE // Expect the content of a document.
|
|
||||||
yaml_PARSE_DOCUMENT_END_STATE // Expect DOCUMENT-END.
|
|
||||||
yaml_PARSE_BLOCK_NODE_STATE // Expect a block node.
|
|
||||||
yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence.
|
|
||||||
yaml_PARSE_FLOW_NODE_STATE // Expect a flow node.
|
|
||||||
yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a block sequence.
|
|
||||||
yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE // Expect an entry of a block sequence.
|
|
||||||
yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE // Expect an entry of an indentless sequence.
|
|
||||||
yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
|
|
||||||
yaml_PARSE_BLOCK_MAPPING_KEY_STATE // Expect a block mapping key.
|
|
||||||
yaml_PARSE_BLOCK_MAPPING_VALUE_STATE // Expect a block mapping value.
|
|
||||||
yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a flow sequence.
|
|
||||||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE // Expect an entry of a flow sequence.
|
|
||||||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE // Expect a key of an ordered mapping.
|
|
||||||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping.
|
|
||||||
yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE // Expect the and of an ordered mapping entry.
|
|
||||||
yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
|
|
||||||
yaml_PARSE_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
|
|
||||||
yaml_PARSE_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
|
|
||||||
yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE // Expect an empty value of a flow mapping.
|
|
||||||
yaml_PARSE_END_STATE // Expect nothing.
|
|
||||||
)
|
|
||||||
|
|
||||||
func (ps yaml_parser_state_t) String() string {
|
|
||||||
switch ps {
|
|
||||||
case yaml_PARSE_STREAM_START_STATE:
|
|
||||||
return "yaml_PARSE_STREAM_START_STATE"
|
|
||||||
case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
|
|
||||||
return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE"
|
|
||||||
case yaml_PARSE_DOCUMENT_START_STATE:
|
|
||||||
return "yaml_PARSE_DOCUMENT_START_STATE"
|
|
||||||
case yaml_PARSE_DOCUMENT_CONTENT_STATE:
|
|
||||||
return "yaml_PARSE_DOCUMENT_CONTENT_STATE"
|
|
||||||
case yaml_PARSE_DOCUMENT_END_STATE:
|
|
||||||
return "yaml_PARSE_DOCUMENT_END_STATE"
|
|
||||||
case yaml_PARSE_BLOCK_NODE_STATE:
|
|
||||||
return "yaml_PARSE_BLOCK_NODE_STATE"
|
|
||||||
case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
|
|
||||||
return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE"
|
|
||||||
case yaml_PARSE_FLOW_NODE_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_NODE_STATE"
|
|
||||||
case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
|
|
||||||
return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE"
|
|
||||||
case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
|
|
||||||
return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE"
|
|
||||||
case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
|
|
||||||
return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE"
|
|
||||||
case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
|
|
||||||
return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE"
|
|
||||||
case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
|
|
||||||
return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE"
|
|
||||||
case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
|
|
||||||
return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE"
|
|
||||||
case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE"
|
|
||||||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE"
|
|
||||||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE"
|
|
||||||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE"
|
|
||||||
case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE"
|
|
||||||
case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE"
|
|
||||||
case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_MAPPING_KEY_STATE"
|
|
||||||
case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE"
|
|
||||||
case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
|
|
||||||
return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE"
|
|
||||||
case yaml_PARSE_END_STATE:
|
|
||||||
return "yaml_PARSE_END_STATE"
|
|
||||||
}
|
|
||||||
return "<unknown parser state>"
|
|
||||||
}
|
|
||||||
|
|
||||||
// This structure holds aliases data.
|
|
||||||
type yaml_alias_data_t struct {
|
|
||||||
anchor []byte // The anchor.
|
|
||||||
index int // The node id.
|
|
||||||
mark yaml_mark_t // The anchor mark.
|
|
||||||
}
|
|
||||||
|
|
||||||
// The parser structure.
|
|
||||||
//
|
|
||||||
// All members are internal. Manage the structure using the
|
|
||||||
// yaml_parser_ family of functions.
|
|
||||||
type yaml_parser_t struct {
|
|
||||||
|
|
||||||
// Error handling
|
|
||||||
|
|
||||||
error yaml_error_type_t // Error type.
|
|
||||||
|
|
||||||
problem string // Error description.
|
|
||||||
|
|
||||||
// The byte about which the problem occured.
|
|
||||||
problem_offset int
|
|
||||||
problem_value int
|
|
||||||
problem_mark yaml_mark_t
|
|
||||||
|
|
||||||
// The error context.
|
|
||||||
context string
|
|
||||||
context_mark yaml_mark_t
|
|
||||||
|
|
||||||
// Reader stuff
|
|
||||||
|
|
||||||
read_handler yaml_read_handler_t // Read handler.
|
|
||||||
|
|
||||||
input_file io.Reader // File input data.
|
|
||||||
input []byte // String input data.
|
|
||||||
input_pos int
|
|
||||||
|
|
||||||
eof bool // EOF flag
|
|
||||||
|
|
||||||
buffer []byte // The working buffer.
|
|
||||||
buffer_pos int // The current position of the buffer.
|
|
||||||
|
|
||||||
unread int // The number of unread characters in the buffer.
|
|
||||||
|
|
||||||
raw_buffer []byte // The raw buffer.
|
|
||||||
raw_buffer_pos int // The current position of the buffer.
|
|
||||||
|
|
||||||
encoding yaml_encoding_t // The input encoding.
|
|
||||||
|
|
||||||
offset int // The offset of the current position (in bytes).
|
|
||||||
mark yaml_mark_t // The mark of the current position.
|
|
||||||
|
|
||||||
// Scanner stuff
|
|
||||||
|
|
||||||
stream_start_produced bool // Have we started to scan the input stream?
|
|
||||||
stream_end_produced bool // Have we reached the end of the input stream?
|
|
||||||
|
|
||||||
flow_level int // The number of unclosed '[' and '{' indicators.
|
|
||||||
|
|
||||||
tokens []yaml_token_t // The tokens queue.
|
|
||||||
tokens_head int // The head of the tokens queue.
|
|
||||||
tokens_parsed int // The number of tokens fetched from the queue.
|
|
||||||
token_available bool // Does the tokens queue contain a token ready for dequeueing.
|
|
||||||
|
|
||||||
indent int // The current indentation level.
|
|
||||||
indents []int // The indentation levels stack.
|
|
||||||
|
|
||||||
simple_key_allowed bool // May a simple key occur at the current position?
|
|
||||||
simple_keys []yaml_simple_key_t // The stack of simple keys.
|
|
||||||
|
|
||||||
// Parser stuff
|
|
||||||
|
|
||||||
state yaml_parser_state_t // The current parser state.
|
|
||||||
states []yaml_parser_state_t // The parser states stack.
|
|
||||||
marks []yaml_mark_t // The stack of marks.
|
|
||||||
tag_directives []yaml_tag_directive_t // The list of TAG directives.
|
|
||||||
|
|
||||||
// Dumper stuff
|
|
||||||
|
|
||||||
aliases []yaml_alias_data_t // The alias data.
|
|
||||||
|
|
||||||
document *yaml_document_t // The currently parsed document.
|
|
||||||
}
|
|
||||||
|
|
||||||
// Emitter Definitions
|
|
||||||
|
|
||||||
// The prototype of a write handler.
|
|
||||||
//
|
|
||||||
// The write handler is called when the emitter needs to flush the accumulated
|
|
||||||
// characters to the output. The handler should write @a size bytes of the
|
|
||||||
// @a buffer to the output.
|
|
||||||
//
|
|
||||||
// @param[in,out] data A pointer to an application data specified by
|
|
||||||
// yaml_emitter_set_output().
|
|
||||||
// @param[in] buffer The buffer with bytes to be written.
|
|
||||||
// @param[in] size The size of the buffer.
|
|
||||||
//
|
|
||||||
// @returns On success, the handler should return @c 1. If the handler failed,
|
|
||||||
// the returned value should be @c 0.
|
|
||||||
//
|
|
||||||
type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error
|
|
||||||
|
|
||||||
type yaml_emitter_state_t int
|
|
||||||
|
|
||||||
// The emitter states.
|
|
||||||
const (
|
|
||||||
// Expect STREAM-START.
|
|
||||||
yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota
|
|
||||||
|
|
||||||
yaml_EMIT_FIRST_DOCUMENT_START_STATE // Expect the first DOCUMENT-START or STREAM-END.
|
|
||||||
yaml_EMIT_DOCUMENT_START_STATE // Expect DOCUMENT-START or STREAM-END.
|
|
||||||
yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document.
|
|
||||||
yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END.
|
|
||||||
yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence.
|
|
||||||
yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence.
|
|
||||||
yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
|
|
||||||
yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
|
|
||||||
yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping.
|
|
||||||
yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
|
|
||||||
yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a block sequence.
|
|
||||||
yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE // Expect an item of a block sequence.
|
|
||||||
yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
|
|
||||||
yaml_EMIT_BLOCK_MAPPING_KEY_STATE // Expect the key of a block mapping.
|
|
||||||
yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping.
|
|
||||||
yaml_EMIT_BLOCK_MAPPING_VALUE_STATE // Expect a value of a block mapping.
|
|
||||||
yaml_EMIT_END_STATE // Expect nothing.
|
|
||||||
)
|
|
||||||
|
|
||||||
// The emitter structure.
|
|
||||||
//
|
|
||||||
// All members are internal. Manage the structure using the @c yaml_emitter_
|
|
||||||
// family of functions.
|
|
||||||
type yaml_emitter_t struct {
|
|
||||||
|
|
||||||
// Error handling
|
|
||||||
|
|
||||||
error yaml_error_type_t // Error type.
|
|
||||||
problem string // Error description.
|
|
||||||
|
|
||||||
// Writer stuff
|
|
||||||
|
|
||||||
write_handler yaml_write_handler_t // Write handler.
|
|
||||||
|
|
||||||
output_buffer *[]byte // String output data.
|
|
||||||
output_file io.Writer // File output data.
|
|
||||||
|
|
||||||
buffer []byte // The working buffer.
|
|
||||||
buffer_pos int // The current position of the buffer.
|
|
||||||
|
|
||||||
raw_buffer []byte // The raw buffer.
|
|
||||||
raw_buffer_pos int // The current position of the buffer.
|
|
||||||
|
|
||||||
encoding yaml_encoding_t // The stream encoding.
|
|
||||||
|
|
||||||
// Emitter stuff
|
|
||||||
|
|
||||||
canonical bool // If the output is in the canonical style?
|
|
||||||
best_indent int // The number of indentation spaces.
|
|
||||||
best_width int // The preferred width of the output lines.
|
|
||||||
unicode bool // Allow unescaped non-ASCII characters?
|
|
||||||
line_break yaml_break_t // The preferred line break.
|
|
||||||
|
|
||||||
state yaml_emitter_state_t // The current emitter state.
|
|
||||||
states []yaml_emitter_state_t // The stack of states.
|
|
||||||
|
|
||||||
events []yaml_event_t // The event queue.
|
|
||||||
events_head int // The head of the event queue.
|
|
||||||
|
|
||||||
indents []int // The stack of indentation levels.
|
|
||||||
|
|
||||||
tag_directives []yaml_tag_directive_t // The list of tag directives.
|
|
||||||
|
|
||||||
indent int // The current indentation level.
|
|
||||||
|
|
||||||
flow_level int // The current flow level.
|
|
||||||
|
|
||||||
root_context bool // Is it the document root context?
|
|
||||||
sequence_context bool // Is it a sequence context?
|
|
||||||
mapping_context bool // Is it a mapping context?
|
|
||||||
simple_key_context bool // Is it a simple mapping key context?
|
|
||||||
|
|
||||||
line int // The current line.
|
|
||||||
column int // The current column.
|
|
||||||
whitespace bool // If the last character was a whitespace?
|
|
||||||
indention bool // If the last character was an indentation character (' ', '-', '?', ':')?
|
|
||||||
open_ended bool // If an explicit document end is required?
|
|
||||||
|
|
||||||
// Anchor analysis.
|
|
||||||
anchor_data struct {
|
|
||||||
anchor []byte // The anchor value.
|
|
||||||
alias bool // Is it an alias?
|
|
||||||
}
|
|
||||||
|
|
||||||
// Tag analysis.
|
|
||||||
tag_data struct {
|
|
||||||
handle []byte // The tag handle.
|
|
||||||
suffix []byte // The tag suffix.
|
|
||||||
}
|
|
||||||
|
|
||||||
// Scalar analysis.
|
|
||||||
scalar_data struct {
|
|
||||||
value []byte // The scalar value.
|
|
||||||
multiline bool // Does the scalar contain line breaks?
|
|
||||||
flow_plain_allowed bool // Can the scalar be expessed in the flow plain style?
|
|
||||||
block_plain_allowed bool // Can the scalar be expressed in the block plain style?
|
|
||||||
single_quoted_allowed bool // Can the scalar be expressed in the single quoted style?
|
|
||||||
block_allowed bool // Can the scalar be expressed in the literal or folded styles?
|
|
||||||
style yaml_scalar_style_t // The output style.
|
|
||||||
}
|
|
||||||
|
|
||||||
// Dumper stuff
|
|
||||||
|
|
||||||
opened bool // If the stream was already opened?
|
|
||||||
closed bool // If the stream was already closed?
|
|
||||||
|
|
||||||
// The information associated with the document nodes.
|
|
||||||
anchors *struct {
|
|
||||||
references int // The number of references.
|
|
||||||
anchor int // The anchor id.
|
|
||||||
serialized bool // If the node has been emitted?
|
|
||||||
}
|
|
||||||
|
|
||||||
last_anchor_id int // The last assigned anchor id.
|
|
||||||
|
|
||||||
document *yaml_document_t // The currently emitted document.
|
|
||||||
}
|
|
|
@ -1,173 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
const (
|
|
||||||
// The size of the input raw buffer.
|
|
||||||
input_raw_buffer_size = 512
|
|
||||||
|
|
||||||
// The size of the input buffer.
|
|
||||||
// It should be possible to decode the whole raw buffer.
|
|
||||||
input_buffer_size = input_raw_buffer_size * 3
|
|
||||||
|
|
||||||
// The size of the output buffer.
|
|
||||||
output_buffer_size = 128
|
|
||||||
|
|
||||||
// The size of the output raw buffer.
|
|
||||||
// It should be possible to encode the whole output buffer.
|
|
||||||
output_raw_buffer_size = (output_buffer_size*2 + 2)
|
|
||||||
|
|
||||||
// The size of other stacks and queues.
|
|
||||||
initial_stack_size = 16
|
|
||||||
initial_queue_size = 16
|
|
||||||
initial_string_size = 16
|
|
||||||
)
|
|
||||||
|
|
||||||
// Check if the character at the specified position is an alphabetical
|
|
||||||
// character, a digit, '_', or '-'.
|
|
||||||
func is_alpha(b []byte, i int) bool {
|
|
||||||
return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is a digit.
|
|
||||||
func is_digit(b []byte, i int) bool {
|
|
||||||
return b[i] >= '0' && b[i] <= '9'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the value of a digit.
|
|
||||||
func as_digit(b []byte, i int) int {
|
|
||||||
return int(b[i]) - '0'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is a hex-digit.
|
|
||||||
func is_hex(b []byte, i int) bool {
|
|
||||||
return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the value of a hex-digit.
|
|
||||||
func as_hex(b []byte, i int) int {
|
|
||||||
bi := b[i]
|
|
||||||
if bi >= 'A' && bi <= 'F' {
|
|
||||||
return int(bi) - 'A' + 10
|
|
||||||
}
|
|
||||||
if bi >= 'a' && bi <= 'f' {
|
|
||||||
return int(bi) - 'a' + 10
|
|
||||||
}
|
|
||||||
return int(bi) - '0'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is ASCII.
|
|
||||||
func is_ascii(b []byte, i int) bool {
|
|
||||||
return b[i] <= 0x7F
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the start of the buffer can be printed unescaped.
|
|
||||||
func is_printable(b []byte, i int) bool {
|
|
||||||
return ((b[i] == 0x0A) || // . == #x0A
|
|
||||||
(b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
|
|
||||||
(b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
|
|
||||||
(b[i] > 0xC2 && b[i] < 0xED) ||
|
|
||||||
(b[i] == 0xED && b[i+1] < 0xA0) ||
|
|
||||||
(b[i] == 0xEE) ||
|
|
||||||
(b[i] == 0xEF && // #xE000 <= . <= #xFFFD
|
|
||||||
!(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
|
|
||||||
!(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is NUL.
|
|
||||||
func is_z(b []byte, i int) bool {
|
|
||||||
return b[i] == 0x00
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the beginning of the buffer is a BOM.
|
|
||||||
func is_bom(b []byte, i int) bool {
|
|
||||||
return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is space.
|
|
||||||
func is_space(b []byte, i int) bool {
|
|
||||||
return b[i] == ' '
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is tab.
|
|
||||||
func is_tab(b []byte, i int) bool {
|
|
||||||
return b[i] == '\t'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is blank (space or tab).
|
|
||||||
func is_blank(b []byte, i int) bool {
|
|
||||||
//return is_space(b, i) || is_tab(b, i)
|
|
||||||
return b[i] == ' ' || b[i] == '\t'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character at the specified position is a line break.
|
|
||||||
func is_break(b []byte, i int) bool {
|
|
||||||
return (b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
|
|
||||||
}
|
|
||||||
|
|
||||||
func is_crlf(b []byte, i int) bool {
|
|
||||||
return b[i] == '\r' && b[i+1] == '\n'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is a line break or NUL.
|
|
||||||
func is_breakz(b []byte, i int) bool {
|
|
||||||
//return is_break(b, i) || is_z(b, i)
|
|
||||||
return ( // is_break:
|
|
||||||
b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
|
|
||||||
// is_z:
|
|
||||||
b[i] == 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is a line break, space, or NUL.
|
|
||||||
func is_spacez(b []byte, i int) bool {
|
|
||||||
//return is_space(b, i) || is_breakz(b, i)
|
|
||||||
return ( // is_space:
|
|
||||||
b[i] == ' ' ||
|
|
||||||
// is_breakz:
|
|
||||||
b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
|
|
||||||
b[i] == 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the character is a line break, space, tab, or NUL.
|
|
||||||
func is_blankz(b []byte, i int) bool {
|
|
||||||
//return is_blank(b, i) || is_breakz(b, i)
|
|
||||||
return ( // is_blank:
|
|
||||||
b[i] == ' ' || b[i] == '\t' ||
|
|
||||||
// is_breakz:
|
|
||||||
b[i] == '\r' || // CR (#xD)
|
|
||||||
b[i] == '\n' || // LF (#xA)
|
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
|
|
||||||
b[i] == 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determine the width of the character.
|
|
||||||
func width(b byte) int {
|
|
||||||
// Don't replace these by a switch without first
|
|
||||||
// confirming that it is being inlined.
|
|
||||||
if b&0x80 == 0x00 {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
if b&0xE0 == 0xC0 {
|
|
||||||
return 2
|
|
||||||
}
|
|
||||||
if b&0xF0 == 0xE0 {
|
|
||||||
return 3
|
|
||||||
}
|
|
||||||
if b&0xF8 == 0xF0 {
|
|
||||||
return 4
|
|
||||||
}
|
|
||||||
return 0
|
|
||||||
|
|
||||||
}
|
|
|
@ -1,17 +0,0 @@
|
||||||
language: go
|
|
||||||
|
|
||||||
go:
|
|
||||||
- "1.4.x"
|
|
||||||
- "1.5.x"
|
|
||||||
- "1.6.x"
|
|
||||||
- "1.7.x"
|
|
||||||
- "1.8.x"
|
|
||||||
- "1.9.x"
|
|
||||||
- "1.10.x"
|
|
||||||
- "1.11.x"
|
|
||||||
- "1.12.x"
|
|
||||||
- "1.13.x"
|
|
||||||
- "1.14.x"
|
|
||||||
- "tip"
|
|
||||||
|
|
||||||
go_import_path: gopkg.in/yaml.v2
|
|
|
@ -1,201 +0,0 @@
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
http://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
APPENDIX: How to apply the Apache License to your work.
|
|
||||||
|
|
||||||
To apply the Apache License to your work, attach the following
|
|
||||||
boilerplate notice, with the fields enclosed by brackets "{}"
|
|
||||||
replaced with your own identifying information. (Don't include
|
|
||||||
the brackets!) The text should be enclosed in the appropriate
|
|
||||||
comment syntax for the file format. We also recommend that a
|
|
||||||
file or class name and description of purpose be included on the
|
|
||||||
same "printed page" as the copyright notice for easier
|
|
||||||
identification within third-party archives.
|
|
||||||
|
|
||||||
Copyright {yyyy} {name of copyright owner}
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
|
@ -1,31 +0,0 @@
|
||||||
The following files were ported to Go from C files of libyaml, and thus
|
|
||||||
are still covered by their original copyright and license:
|
|
||||||
|
|
||||||
apic.go
|
|
||||||
emitterc.go
|
|
||||||
parserc.go
|
|
||||||
readerc.go
|
|
||||||
scannerc.go
|
|
||||||
writerc.go
|
|
||||||
yamlh.go
|
|
||||||
yamlprivateh.go
|
|
||||||
|
|
||||||
Copyright (c) 2006 Kirill Simonov
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
||||||
this software and associated documentation files (the "Software"), to deal in
|
|
||||||
the Software without restriction, including without limitation the rights to
|
|
||||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
||||||
of the Software, and to permit persons to whom the Software is furnished to do
|
|
||||||
so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in all
|
|
||||||
copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
SOFTWARE.
|
|
|
@ -1,390 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"reflect"
|
|
||||||
"regexp"
|
|
||||||
"sort"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
"unicode/utf8"
|
|
||||||
)
|
|
||||||
|
|
||||||
// jsonNumber is the interface of the encoding/json.Number datatype.
|
|
||||||
// Repeating the interface here avoids a dependency on encoding/json, and also
|
|
||||||
// supports other libraries like jsoniter, which use a similar datatype with
|
|
||||||
// the same interface. Detecting this interface is useful when dealing with
|
|
||||||
// structures containing json.Number, which is a string under the hood. The
|
|
||||||
// encoder should prefer the use of Int64(), Float64() and string(), in that
|
|
||||||
// order, when encoding this type.
|
|
||||||
type jsonNumber interface {
|
|
||||||
Float64() (float64, error)
|
|
||||||
Int64() (int64, error)
|
|
||||||
String() string
|
|
||||||
}
|
|
||||||
|
|
||||||
type encoder struct {
|
|
||||||
emitter yaml_emitter_t
|
|
||||||
event yaml_event_t
|
|
||||||
out []byte
|
|
||||||
flow bool
|
|
||||||
// doneInit holds whether the initial stream_start_event has been
|
|
||||||
// emitted.
|
|
||||||
doneInit bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func newEncoder() *encoder {
|
|
||||||
e := &encoder{}
|
|
||||||
yaml_emitter_initialize(&e.emitter)
|
|
||||||
yaml_emitter_set_output_string(&e.emitter, &e.out)
|
|
||||||
yaml_emitter_set_unicode(&e.emitter, true)
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
func newEncoderWithWriter(w io.Writer) *encoder {
|
|
||||||
e := &encoder{}
|
|
||||||
yaml_emitter_initialize(&e.emitter)
|
|
||||||
yaml_emitter_set_output_writer(&e.emitter, w)
|
|
||||||
yaml_emitter_set_unicode(&e.emitter, true)
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) init() {
|
|
||||||
if e.doneInit {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
|
|
||||||
e.emit()
|
|
||||||
e.doneInit = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) finish() {
|
|
||||||
e.emitter.open_ended = false
|
|
||||||
yaml_stream_end_event_initialize(&e.event)
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) destroy() {
|
|
||||||
yaml_emitter_delete(&e.emitter)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) emit() {
|
|
||||||
// This will internally delete the e.event value.
|
|
||||||
e.must(yaml_emitter_emit(&e.emitter, &e.event))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) must(ok bool) {
|
|
||||||
if !ok {
|
|
||||||
msg := e.emitter.problem
|
|
||||||
if msg == "" {
|
|
||||||
msg = "unknown problem generating YAML content"
|
|
||||||
}
|
|
||||||
failf("%s", msg)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) marshalDoc(tag string, in reflect.Value) {
|
|
||||||
e.init()
|
|
||||||
yaml_document_start_event_initialize(&e.event, nil, nil, true)
|
|
||||||
e.emit()
|
|
||||||
e.marshal(tag, in)
|
|
||||||
yaml_document_end_event_initialize(&e.event, true)
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) marshal(tag string, in reflect.Value) {
|
|
||||||
if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
iface := in.Interface()
|
|
||||||
switch m := iface.(type) {
|
|
||||||
case jsonNumber:
|
|
||||||
integer, err := m.Int64()
|
|
||||||
if err == nil {
|
|
||||||
// In this case the json.Number is a valid int64
|
|
||||||
in = reflect.ValueOf(integer)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
float, err := m.Float64()
|
|
||||||
if err == nil {
|
|
||||||
// In this case the json.Number is a valid float64
|
|
||||||
in = reflect.ValueOf(float)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
// fallback case - no number could be obtained
|
|
||||||
in = reflect.ValueOf(m.String())
|
|
||||||
case time.Time, *time.Time:
|
|
||||||
// Although time.Time implements TextMarshaler,
|
|
||||||
// we don't want to treat it as a string for YAML
|
|
||||||
// purposes because YAML has special support for
|
|
||||||
// timestamps.
|
|
||||||
case Marshaler:
|
|
||||||
v, err := m.MarshalYAML()
|
|
||||||
if err != nil {
|
|
||||||
fail(err)
|
|
||||||
}
|
|
||||||
if v == nil {
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
in = reflect.ValueOf(v)
|
|
||||||
case encoding.TextMarshaler:
|
|
||||||
text, err := m.MarshalText()
|
|
||||||
if err != nil {
|
|
||||||
fail(err)
|
|
||||||
}
|
|
||||||
in = reflect.ValueOf(string(text))
|
|
||||||
case nil:
|
|
||||||
e.nilv()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
switch in.Kind() {
|
|
||||||
case reflect.Interface:
|
|
||||||
e.marshal(tag, in.Elem())
|
|
||||||
case reflect.Map:
|
|
||||||
e.mapv(tag, in)
|
|
||||||
case reflect.Ptr:
|
|
||||||
if in.Type() == ptrTimeType {
|
|
||||||
e.timev(tag, in.Elem())
|
|
||||||
} else {
|
|
||||||
e.marshal(tag, in.Elem())
|
|
||||||
}
|
|
||||||
case reflect.Struct:
|
|
||||||
if in.Type() == timeType {
|
|
||||||
e.timev(tag, in)
|
|
||||||
} else {
|
|
||||||
e.structv(tag, in)
|
|
||||||
}
|
|
||||||
case reflect.Slice, reflect.Array:
|
|
||||||
if in.Type().Elem() == mapItemType {
|
|
||||||
e.itemsv(tag, in)
|
|
||||||
} else {
|
|
||||||
e.slicev(tag, in)
|
|
||||||
}
|
|
||||||
case reflect.String:
|
|
||||||
e.stringv(tag, in)
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
if in.Type() == durationType {
|
|
||||||
e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
|
|
||||||
} else {
|
|
||||||
e.intv(tag, in)
|
|
||||||
}
|
|
||||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
||||||
e.uintv(tag, in)
|
|
||||||
case reflect.Float32, reflect.Float64:
|
|
||||||
e.floatv(tag, in)
|
|
||||||
case reflect.Bool:
|
|
||||||
e.boolv(tag, in)
|
|
||||||
default:
|
|
||||||
panic("cannot marshal type: " + in.Type().String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) mapv(tag string, in reflect.Value) {
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
keys := keyList(in.MapKeys())
|
|
||||||
sort.Sort(keys)
|
|
||||||
for _, k := range keys {
|
|
||||||
e.marshal("", k)
|
|
||||||
e.marshal("", in.MapIndex(k))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) itemsv(tag string, in reflect.Value) {
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
|
|
||||||
for _, item := range slice {
|
|
||||||
e.marshal("", reflect.ValueOf(item.Key))
|
|
||||||
e.marshal("", reflect.ValueOf(item.Value))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) structv(tag string, in reflect.Value) {
|
|
||||||
sinfo, err := getStructInfo(in.Type())
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
e.mappingv(tag, func() {
|
|
||||||
for _, info := range sinfo.FieldsList {
|
|
||||||
var value reflect.Value
|
|
||||||
if info.Inline == nil {
|
|
||||||
value = in.Field(info.Num)
|
|
||||||
} else {
|
|
||||||
value = in.FieldByIndex(info.Inline)
|
|
||||||
}
|
|
||||||
if info.OmitEmpty && isZero(value) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
e.marshal("", reflect.ValueOf(info.Key))
|
|
||||||
e.flow = info.Flow
|
|
||||||
e.marshal("", value)
|
|
||||||
}
|
|
||||||
if sinfo.InlineMap >= 0 {
|
|
||||||
m := in.Field(sinfo.InlineMap)
|
|
||||||
if m.Len() > 0 {
|
|
||||||
e.flow = false
|
|
||||||
keys := keyList(m.MapKeys())
|
|
||||||
sort.Sort(keys)
|
|
||||||
for _, k := range keys {
|
|
||||||
if _, found := sinfo.FieldsMap[k.String()]; found {
|
|
||||||
panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String()))
|
|
||||||
}
|
|
||||||
e.marshal("", k)
|
|
||||||
e.flow = false
|
|
||||||
e.marshal("", m.MapIndex(k))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) mappingv(tag string, f func()) {
|
|
||||||
implicit := tag == ""
|
|
||||||
style := yaml_BLOCK_MAPPING_STYLE
|
|
||||||
if e.flow {
|
|
||||||
e.flow = false
|
|
||||||
style = yaml_FLOW_MAPPING_STYLE
|
|
||||||
}
|
|
||||||
yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
|
|
||||||
e.emit()
|
|
||||||
f()
|
|
||||||
yaml_mapping_end_event_initialize(&e.event)
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) slicev(tag string, in reflect.Value) {
|
|
||||||
implicit := tag == ""
|
|
||||||
style := yaml_BLOCK_SEQUENCE_STYLE
|
|
||||||
if e.flow {
|
|
||||||
e.flow = false
|
|
||||||
style = yaml_FLOW_SEQUENCE_STYLE
|
|
||||||
}
|
|
||||||
e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
|
|
||||||
e.emit()
|
|
||||||
n := in.Len()
|
|
||||||
for i := 0; i < n; i++ {
|
|
||||||
e.marshal("", in.Index(i))
|
|
||||||
}
|
|
||||||
e.must(yaml_sequence_end_event_initialize(&e.event))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
||||||
|
|
||||||
// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
|
|
||||||
//
|
|
||||||
// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
|
|
||||||
// in YAML 1.2 and by this package, but these should be marshalled quoted for
|
|
||||||
// the time being for compatibility with other parsers.
|
|
||||||
func isBase60Float(s string) (result bool) {
|
|
||||||
// Fast path.
|
|
||||||
if s == "" {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
c := s[0]
|
|
||||||
if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
// Do the full match.
|
|
||||||
return base60float.MatchString(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
// From http://yaml.org/type/float.html, except the regular expression there
|
|
||||||
// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
|
|
||||||
var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
|
|
||||||
|
|
||||||
func (e *encoder) stringv(tag string, in reflect.Value) {
|
|
||||||
var style yaml_scalar_style_t
|
|
||||||
s := in.String()
|
|
||||||
canUsePlain := true
|
|
||||||
switch {
|
|
||||||
case !utf8.ValidString(s):
|
|
||||||
if tag == yaml_BINARY_TAG {
|
|
||||||
failf("explicitly tagged !!binary data must be base64-encoded")
|
|
||||||
}
|
|
||||||
if tag != "" {
|
|
||||||
failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
|
|
||||||
}
|
|
||||||
// It can't be encoded directly as YAML so use a binary tag
|
|
||||||
// and encode it as base64.
|
|
||||||
tag = yaml_BINARY_TAG
|
|
||||||
s = encodeBase64(s)
|
|
||||||
case tag == "":
|
|
||||||
// Check to see if it would resolve to a specific
|
|
||||||
// tag when encoded unquoted. If it doesn't,
|
|
||||||
// there's no need to quote it.
|
|
||||||
rtag, _ := resolve("", s)
|
|
||||||
canUsePlain = rtag == yaml_STR_TAG && !isBase60Float(s)
|
|
||||||
}
|
|
||||||
// Note: it's possible for user code to emit invalid YAML
|
|
||||||
// if they explicitly specify a tag and a string containing
|
|
||||||
// text that's incompatible with that tag.
|
|
||||||
switch {
|
|
||||||
case strings.Contains(s, "\n"):
|
|
||||||
style = yaml_LITERAL_SCALAR_STYLE
|
|
||||||
case canUsePlain:
|
|
||||||
style = yaml_PLAIN_SCALAR_STYLE
|
|
||||||
default:
|
|
||||||
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, style)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) boolv(tag string, in reflect.Value) {
|
|
||||||
var s string
|
|
||||||
if in.Bool() {
|
|
||||||
s = "true"
|
|
||||||
} else {
|
|
||||||
s = "false"
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) intv(tag string, in reflect.Value) {
|
|
||||||
s := strconv.FormatInt(in.Int(), 10)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) uintv(tag string, in reflect.Value) {
|
|
||||||
s := strconv.FormatUint(in.Uint(), 10)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) timev(tag string, in reflect.Value) {
|
|
||||||
t := in.Interface().(time.Time)
|
|
||||||
s := t.Format(time.RFC3339Nano)
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) floatv(tag string, in reflect.Value) {
|
|
||||||
// Issue #352: When formatting, use the precision of the underlying value
|
|
||||||
precision := 64
|
|
||||||
if in.Kind() == reflect.Float32 {
|
|
||||||
precision = 32
|
|
||||||
}
|
|
||||||
|
|
||||||
s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
|
|
||||||
switch s {
|
|
||||||
case "+Inf":
|
|
||||||
s = ".inf"
|
|
||||||
case "-Inf":
|
|
||||||
s = "-.inf"
|
|
||||||
case "NaN":
|
|
||||||
s = ".nan"
|
|
||||||
}
|
|
||||||
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) nilv() {
|
|
||||||
e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
|
|
||||||
implicit := tag == ""
|
|
||||||
e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
|
|
||||||
e.emit()
|
|
||||||
}
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,26 +0,0 @@
|
||||||
package yaml
|
|
||||||
|
|
||||||
// Set the writer error and return false.
|
|
||||||
func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
|
|
||||||
emitter.error = yaml_WRITER_ERROR
|
|
||||||
emitter.problem = problem
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Flush the output buffer.
|
|
||||||
func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
|
|
||||||
if emitter.write_handler == nil {
|
|
||||||
panic("write handler not set")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if the buffer is empty.
|
|
||||||
if emitter.buffer_pos == 0 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
|
|
||||||
return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
|
|
||||||
}
|
|
||||||
emitter.buffer_pos = 0
|
|
||||||
return true
|
|
||||||
}
|
|
|
@ -1,16 +1,17 @@
|
||||||
|
|
||||||
|
This project is covered by two different licenses: MIT and Apache.
|
||||||
|
|
||||||
|
#### MIT License ####
|
||||||
|
|
||||||
The following files were ported to Go from C files of libyaml, and thus
|
The following files were ported to Go from C files of libyaml, and thus
|
||||||
are still covered by their original copyright and license:
|
are still covered by their original MIT license, with the additional
|
||||||
|
copyright staring in 2011 when the project was ported over:
|
||||||
|
|
||||||
apic.go
|
apic.go emitterc.go parserc.go readerc.go scannerc.go
|
||||||
emitterc.go
|
writerc.go yamlh.go yamlprivateh.go
|
||||||
parserc.go
|
|
||||||
readerc.go
|
|
||||||
scannerc.go
|
|
||||||
writerc.go
|
|
||||||
yamlh.go
|
|
||||||
yamlprivateh.go
|
|
||||||
|
|
||||||
Copyright (c) 2006 Kirill Simonov
|
Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
Copyright (c) 2006-2011 Kirill Simonov
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
this software and associated documentation files (the "Software"), to deal in
|
this software and associated documentation files (the "Software"), to deal in
|
||||||
|
@ -29,3 +30,21 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
SOFTWARE.
|
SOFTWARE.
|
||||||
|
|
||||||
|
### Apache License ###
|
||||||
|
|
||||||
|
All the remaining project files are covered by the Apache license:
|
||||||
|
|
||||||
|
Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
|
||||||
|
Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
you may not use this file except in compliance with the License.
|
||||||
|
You may obtain a copy of the License at
|
||||||
|
|
||||||
|
http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
|
||||||
|
Unless required by applicable law or agreed to in writing, software
|
||||||
|
distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
See the License for the specific language governing permissions and
|
||||||
|
limitations under the License.
|
|
@ -12,7 +12,23 @@ C library to parse and generate YAML data quickly and reliably.
|
||||||
Compatibility
|
Compatibility
|
||||||
-------------
|
-------------
|
||||||
|
|
||||||
The yaml package supports most of YAML 1.1 and 1.2, including support for
|
The yaml package supports most of YAML 1.2, but preserves some behavior
|
||||||
|
from 1.1 for backwards compatibility.
|
||||||
|
|
||||||
|
Specifically, as of v3 of the yaml package:
|
||||||
|
|
||||||
|
- YAML 1.1 bools (_yes/no, on/off_) are supported as long as they are being
|
||||||
|
decoded into a typed bool value. Otherwise they behave as a string. Booleans
|
||||||
|
in YAML 1.2 are _true/false_ only.
|
||||||
|
- Octals encode and decode as _0777_ per YAML 1.1, rather than _0o777_
|
||||||
|
as specified in YAML 1.2, because most parsers still use the old format.
|
||||||
|
Octals in the _0o777_ format are supported though, so new files work.
|
||||||
|
- Does not support base-60 floats. These are gone from YAML 1.2, and were
|
||||||
|
actually never supported by this package as it's clearly a poor choice.
|
||||||
|
|
||||||
|
and offers backwards
|
||||||
|
compatibility with YAML 1.1 in some cases.
|
||||||
|
1.2, including support for
|
||||||
anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
|
anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
|
||||||
implemented, and base-60 floats from YAML 1.1 are purposefully not
|
implemented, and base-60 floats from YAML 1.1 are purposefully not
|
||||||
supported since they're a poor design and are gone in YAML 1.2.
|
supported since they're a poor design and are gone in YAML 1.2.
|
||||||
|
@ -20,29 +36,30 @@ supported since they're a poor design and are gone in YAML 1.2.
|
||||||
Installation and usage
|
Installation and usage
|
||||||
----------------------
|
----------------------
|
||||||
|
|
||||||
The import path for the package is *gopkg.in/yaml.v2*.
|
The import path for the package is *gopkg.in/yaml.v3*.
|
||||||
|
|
||||||
To install it, run:
|
To install it, run:
|
||||||
|
|
||||||
go get gopkg.in/yaml.v2
|
go get gopkg.in/yaml.v3
|
||||||
|
|
||||||
API documentation
|
API documentation
|
||||||
-----------------
|
-----------------
|
||||||
|
|
||||||
If opened in a browser, the import path itself leads to the API documentation:
|
If opened in a browser, the import path itself leads to the API documentation:
|
||||||
|
|
||||||
* [https://gopkg.in/yaml.v2](https://gopkg.in/yaml.v2)
|
- [https://gopkg.in/yaml.v3](https://gopkg.in/yaml.v3)
|
||||||
|
|
||||||
API stability
|
API stability
|
||||||
-------------
|
-------------
|
||||||
|
|
||||||
The package API for yaml v2 will remain stable as described in [gopkg.in](https://gopkg.in).
|
The package API for yaml v3 will remain stable as described in [gopkg.in](https://gopkg.in).
|
||||||
|
|
||||||
|
|
||||||
License
|
License
|
||||||
-------
|
-------
|
||||||
|
|
||||||
The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.
|
The yaml package is licensed under the MIT and Apache License 2.0 licenses.
|
||||||
|
Please see the LICENSE file for details.
|
||||||
|
|
||||||
|
|
||||||
Example
|
Example
|
||||||
|
@ -55,7 +72,7 @@ import (
|
||||||
"fmt"
|
"fmt"
|
||||||
"log"
|
"log"
|
||||||
|
|
||||||
"gopkg.in/yaml.v2"
|
"gopkg.in/yaml.v3"
|
||||||
)
|
)
|
||||||
|
|
||||||
var data = `
|
var data = `
|
|
@ -1,3 +1,25 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -79,8 +101,6 @@ func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
|
||||||
parser.encoding = encoding
|
parser.encoding = encoding
|
||||||
}
|
}
|
||||||
|
|
||||||
var disableLineWrapping = false
|
|
||||||
|
|
||||||
// Create a new emitter object.
|
// Create a new emitter object.
|
||||||
func yaml_emitter_initialize(emitter *yaml_emitter_t) {
|
func yaml_emitter_initialize(emitter *yaml_emitter_t) {
|
||||||
*emitter = yaml_emitter_t{
|
*emitter = yaml_emitter_t{
|
||||||
|
@ -88,9 +108,7 @@ func yaml_emitter_initialize(emitter *yaml_emitter_t) {
|
||||||
raw_buffer: make([]byte, 0, output_raw_buffer_size),
|
raw_buffer: make([]byte, 0, output_raw_buffer_size),
|
||||||
states: make([]yaml_emitter_state_t, 0, initial_stack_size),
|
states: make([]yaml_emitter_state_t, 0, initial_stack_size),
|
||||||
events: make([]yaml_event_t, 0, initial_queue_size),
|
events: make([]yaml_event_t, 0, initial_queue_size),
|
||||||
}
|
best_width: -1,
|
||||||
if disableLineWrapping {
|
|
||||||
emitter.best_width = -1
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -143,7 +161,7 @@ func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
|
||||||
emitter.canonical = canonical
|
emitter.canonical = canonical
|
||||||
}
|
}
|
||||||
|
|
||||||
//// Set the indentation increment.
|
// Set the indentation increment.
|
||||||
func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
|
func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
|
||||||
if indent < 2 || indent > 9 {
|
if indent < 2 || indent > 9 {
|
||||||
indent = 2
|
indent = 2
|
||||||
|
@ -293,29 +311,14 @@ func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
///*
|
// Create ALIAS.
|
||||||
// * Create ALIAS.
|
func yaml_alias_event_initialize(event *yaml_event_t, anchor []byte) bool {
|
||||||
// */
|
*event = yaml_event_t{
|
||||||
//
|
typ: yaml_ALIAS_EVENT,
|
||||||
//YAML_DECLARE(int)
|
anchor: anchor,
|
||||||
//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
|
}
|
||||||
//{
|
return true
|
||||||
// mark yaml_mark_t = { 0, 0, 0 }
|
}
|
||||||
// anchor_copy *yaml_char_t = NULL
|
|
||||||
//
|
|
||||||
// assert(event) // Non-NULL event object is expected.
|
|
||||||
// assert(anchor) // Non-NULL anchor is expected.
|
|
||||||
//
|
|
||||||
// if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
|
|
||||||
//
|
|
||||||
// anchor_copy = yaml_strdup(anchor)
|
|
||||||
// if (!anchor_copy)
|
|
||||||
// return 0
|
|
||||||
//
|
|
||||||
// ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
|
|
||||||
//
|
|
||||||
// return 1
|
|
||||||
//}
|
|
||||||
|
|
||||||
// Create SCALAR.
|
// Create SCALAR.
|
||||||
func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
|
func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
|
|
@ -1,3 +1,18 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -11,34 +26,16 @@ import (
|
||||||
"time"
|
"time"
|
||||||
)
|
)
|
||||||
|
|
||||||
const (
|
|
||||||
documentNode = 1 << iota
|
|
||||||
mappingNode
|
|
||||||
sequenceNode
|
|
||||||
scalarNode
|
|
||||||
aliasNode
|
|
||||||
)
|
|
||||||
|
|
||||||
type node struct {
|
|
||||||
kind int
|
|
||||||
line, column int
|
|
||||||
tag string
|
|
||||||
// For an alias node, alias holds the resolved alias.
|
|
||||||
alias *node
|
|
||||||
value string
|
|
||||||
implicit bool
|
|
||||||
children []*node
|
|
||||||
anchors map[string]*node
|
|
||||||
}
|
|
||||||
|
|
||||||
// ----------------------------------------------------------------------------
|
// ----------------------------------------------------------------------------
|
||||||
// Parser, produces a node tree out of a libyaml event stream.
|
// Parser, produces a node tree out of a libyaml event stream.
|
||||||
|
|
||||||
type parser struct {
|
type parser struct {
|
||||||
parser yaml_parser_t
|
parser yaml_parser_t
|
||||||
event yaml_event_t
|
event yaml_event_t
|
||||||
doc *node
|
doc *Node
|
||||||
|
anchors map[string]*Node
|
||||||
doneInit bool
|
doneInit bool
|
||||||
|
textless bool
|
||||||
}
|
}
|
||||||
|
|
||||||
func newParser(b []byte) *parser {
|
func newParser(b []byte) *parser {
|
||||||
|
@ -66,6 +63,7 @@ func (p *parser) init() {
|
||||||
if p.doneInit {
|
if p.doneInit {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
p.anchors = make(map[string]*Node)
|
||||||
p.expect(yaml_STREAM_START_EVENT)
|
p.expect(yaml_STREAM_START_EVENT)
|
||||||
p.doneInit = true
|
p.doneInit = true
|
||||||
}
|
}
|
||||||
|
@ -102,7 +100,10 @@ func (p *parser) peek() yaml_event_type_t {
|
||||||
if p.event.typ != yaml_NO_EVENT {
|
if p.event.typ != yaml_NO_EVENT {
|
||||||
return p.event.typ
|
return p.event.typ
|
||||||
}
|
}
|
||||||
if !yaml_parser_parse(&p.parser, &p.event) {
|
// It's curious choice from the underlying API to generally return a
|
||||||
|
// positive result on success, but on this case return true in an error
|
||||||
|
// scenario. This was the source of bugs in the past (issue #666).
|
||||||
|
if !yaml_parser_parse(&p.parser, &p.event) || p.parser.error != yaml_NO_ERROR {
|
||||||
p.fail()
|
p.fail()
|
||||||
}
|
}
|
||||||
return p.event.typ
|
return p.event.typ
|
||||||
|
@ -111,14 +112,18 @@ func (p *parser) peek() yaml_event_type_t {
|
||||||
func (p *parser) fail() {
|
func (p *parser) fail() {
|
||||||
var where string
|
var where string
|
||||||
var line int
|
var line int
|
||||||
if p.parser.problem_mark.line != 0 {
|
if p.parser.context_mark.line != 0 {
|
||||||
|
line = p.parser.context_mark.line
|
||||||
|
// Scanner errors don't iterate line before returning error
|
||||||
|
if p.parser.error == yaml_SCANNER_ERROR {
|
||||||
|
line++
|
||||||
|
}
|
||||||
|
} else if p.parser.problem_mark.line != 0 {
|
||||||
line = p.parser.problem_mark.line
|
line = p.parser.problem_mark.line
|
||||||
// Scanner errors don't iterate line before returning error
|
// Scanner errors don't iterate line before returning error
|
||||||
if p.parser.error == yaml_SCANNER_ERROR {
|
if p.parser.error == yaml_SCANNER_ERROR {
|
||||||
line++
|
line++
|
||||||
}
|
}
|
||||||
} else if p.parser.context_mark.line != 0 {
|
|
||||||
line = p.parser.context_mark.line
|
|
||||||
}
|
}
|
||||||
if line != 0 {
|
if line != 0 {
|
||||||
where = "line " + strconv.Itoa(line) + ": "
|
where = "line " + strconv.Itoa(line) + ": "
|
||||||
|
@ -132,13 +137,14 @@ func (p *parser) fail() {
|
||||||
failf("%s%s", where, msg)
|
failf("%s%s", where, msg)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) anchor(n *node, anchor []byte) {
|
func (p *parser) anchor(n *Node, anchor []byte) {
|
||||||
if anchor != nil {
|
if anchor != nil {
|
||||||
p.doc.anchors[string(anchor)] = n
|
n.Anchor = string(anchor)
|
||||||
|
p.anchors[n.Anchor] = n
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) parse() *node {
|
func (p *parser) parse() *Node {
|
||||||
p.init()
|
p.init()
|
||||||
switch p.peek() {
|
switch p.peek() {
|
||||||
case yaml_SCALAR_EVENT:
|
case yaml_SCALAR_EVENT:
|
||||||
|
@ -154,67 +160,148 @@ func (p *parser) parse() *node {
|
||||||
case yaml_STREAM_END_EVENT:
|
case yaml_STREAM_END_EVENT:
|
||||||
// Happens when attempting to decode an empty buffer.
|
// Happens when attempting to decode an empty buffer.
|
||||||
return nil
|
return nil
|
||||||
|
case yaml_TAIL_COMMENT_EVENT:
|
||||||
|
panic("internal error: unexpected tail comment event (please report)")
|
||||||
default:
|
default:
|
||||||
panic("attempted to parse unknown event: " + p.event.typ.String())
|
panic("internal error: attempted to parse unknown event (please report): " + p.event.typ.String())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) node(kind int) *node {
|
func (p *parser) node(kind Kind, defaultTag, tag, value string) *Node {
|
||||||
return &node{
|
var style Style
|
||||||
kind: kind,
|
if tag != "" && tag != "!" {
|
||||||
line: p.event.start_mark.line,
|
tag = shortTag(tag)
|
||||||
column: p.event.start_mark.column,
|
style = TaggedStyle
|
||||||
|
} else if defaultTag != "" {
|
||||||
|
tag = defaultTag
|
||||||
|
} else if kind == ScalarNode {
|
||||||
|
tag, _ = resolve("", value)
|
||||||
}
|
}
|
||||||
|
n := &Node{
|
||||||
|
Kind: kind,
|
||||||
|
Tag: tag,
|
||||||
|
Value: value,
|
||||||
|
Style: style,
|
||||||
|
}
|
||||||
|
if !p.textless {
|
||||||
|
n.Line = p.event.start_mark.line + 1
|
||||||
|
n.Column = p.event.start_mark.column + 1
|
||||||
|
n.HeadComment = string(p.event.head_comment)
|
||||||
|
n.LineComment = string(p.event.line_comment)
|
||||||
|
n.FootComment = string(p.event.foot_comment)
|
||||||
|
}
|
||||||
|
return n
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) document() *node {
|
func (p *parser) parseChild(parent *Node) *Node {
|
||||||
n := p.node(documentNode)
|
child := p.parse()
|
||||||
n.anchors = make(map[string]*node)
|
parent.Content = append(parent.Content, child)
|
||||||
|
return child
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *parser) document() *Node {
|
||||||
|
n := p.node(DocumentNode, "", "", "")
|
||||||
p.doc = n
|
p.doc = n
|
||||||
p.expect(yaml_DOCUMENT_START_EVENT)
|
p.expect(yaml_DOCUMENT_START_EVENT)
|
||||||
n.children = append(n.children, p.parse())
|
p.parseChild(n)
|
||||||
|
if p.peek() == yaml_DOCUMENT_END_EVENT {
|
||||||
|
n.FootComment = string(p.event.foot_comment)
|
||||||
|
}
|
||||||
p.expect(yaml_DOCUMENT_END_EVENT)
|
p.expect(yaml_DOCUMENT_END_EVENT)
|
||||||
return n
|
return n
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) alias() *node {
|
func (p *parser) alias() *Node {
|
||||||
n := p.node(aliasNode)
|
n := p.node(AliasNode, "", "", string(p.event.anchor))
|
||||||
n.value = string(p.event.anchor)
|
n.Alias = p.anchors[n.Value]
|
||||||
n.alias = p.doc.anchors[n.value]
|
if n.Alias == nil {
|
||||||
if n.alias == nil {
|
failf("unknown anchor '%s' referenced", n.Value)
|
||||||
failf("unknown anchor '%s' referenced", n.value)
|
|
||||||
}
|
}
|
||||||
p.expect(yaml_ALIAS_EVENT)
|
p.expect(yaml_ALIAS_EVENT)
|
||||||
return n
|
return n
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) scalar() *node {
|
func (p *parser) scalar() *Node {
|
||||||
n := p.node(scalarNode)
|
var parsedStyle = p.event.scalar_style()
|
||||||
n.value = string(p.event.value)
|
var nodeStyle Style
|
||||||
n.tag = string(p.event.tag)
|
switch {
|
||||||
n.implicit = p.event.implicit
|
case parsedStyle&yaml_DOUBLE_QUOTED_SCALAR_STYLE != 0:
|
||||||
|
nodeStyle = DoubleQuotedStyle
|
||||||
|
case parsedStyle&yaml_SINGLE_QUOTED_SCALAR_STYLE != 0:
|
||||||
|
nodeStyle = SingleQuotedStyle
|
||||||
|
case parsedStyle&yaml_LITERAL_SCALAR_STYLE != 0:
|
||||||
|
nodeStyle = LiteralStyle
|
||||||
|
case parsedStyle&yaml_FOLDED_SCALAR_STYLE != 0:
|
||||||
|
nodeStyle = FoldedStyle
|
||||||
|
}
|
||||||
|
var nodeValue = string(p.event.value)
|
||||||
|
var nodeTag = string(p.event.tag)
|
||||||
|
var defaultTag string
|
||||||
|
if nodeStyle == 0 {
|
||||||
|
if nodeValue == "<<" {
|
||||||
|
defaultTag = mergeTag
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
defaultTag = strTag
|
||||||
|
}
|
||||||
|
n := p.node(ScalarNode, defaultTag, nodeTag, nodeValue)
|
||||||
|
n.Style |= nodeStyle
|
||||||
p.anchor(n, p.event.anchor)
|
p.anchor(n, p.event.anchor)
|
||||||
p.expect(yaml_SCALAR_EVENT)
|
p.expect(yaml_SCALAR_EVENT)
|
||||||
return n
|
return n
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) sequence() *node {
|
func (p *parser) sequence() *Node {
|
||||||
n := p.node(sequenceNode)
|
n := p.node(SequenceNode, seqTag, string(p.event.tag), "")
|
||||||
|
if p.event.sequence_style()&yaml_FLOW_SEQUENCE_STYLE != 0 {
|
||||||
|
n.Style |= FlowStyle
|
||||||
|
}
|
||||||
p.anchor(n, p.event.anchor)
|
p.anchor(n, p.event.anchor)
|
||||||
p.expect(yaml_SEQUENCE_START_EVENT)
|
p.expect(yaml_SEQUENCE_START_EVENT)
|
||||||
for p.peek() != yaml_SEQUENCE_END_EVENT {
|
for p.peek() != yaml_SEQUENCE_END_EVENT {
|
||||||
n.children = append(n.children, p.parse())
|
p.parseChild(n)
|
||||||
}
|
}
|
||||||
|
n.LineComment = string(p.event.line_comment)
|
||||||
|
n.FootComment = string(p.event.foot_comment)
|
||||||
p.expect(yaml_SEQUENCE_END_EVENT)
|
p.expect(yaml_SEQUENCE_END_EVENT)
|
||||||
return n
|
return n
|
||||||
}
|
}
|
||||||
|
|
||||||
func (p *parser) mapping() *node {
|
func (p *parser) mapping() *Node {
|
||||||
n := p.node(mappingNode)
|
n := p.node(MappingNode, mapTag, string(p.event.tag), "")
|
||||||
|
block := true
|
||||||
|
if p.event.mapping_style()&yaml_FLOW_MAPPING_STYLE != 0 {
|
||||||
|
block = false
|
||||||
|
n.Style |= FlowStyle
|
||||||
|
}
|
||||||
p.anchor(n, p.event.anchor)
|
p.anchor(n, p.event.anchor)
|
||||||
p.expect(yaml_MAPPING_START_EVENT)
|
p.expect(yaml_MAPPING_START_EVENT)
|
||||||
for p.peek() != yaml_MAPPING_END_EVENT {
|
for p.peek() != yaml_MAPPING_END_EVENT {
|
||||||
n.children = append(n.children, p.parse(), p.parse())
|
k := p.parseChild(n)
|
||||||
|
if block && k.FootComment != "" {
|
||||||
|
// Must be a foot comment for the prior value when being dedented.
|
||||||
|
if len(n.Content) > 2 {
|
||||||
|
n.Content[len(n.Content)-3].FootComment = k.FootComment
|
||||||
|
k.FootComment = ""
|
||||||
|
}
|
||||||
|
}
|
||||||
|
v := p.parseChild(n)
|
||||||
|
if k.FootComment == "" && v.FootComment != "" {
|
||||||
|
k.FootComment = v.FootComment
|
||||||
|
v.FootComment = ""
|
||||||
|
}
|
||||||
|
if p.peek() == yaml_TAIL_COMMENT_EVENT {
|
||||||
|
if k.FootComment == "" {
|
||||||
|
k.FootComment = string(p.event.foot_comment)
|
||||||
|
}
|
||||||
|
p.expect(yaml_TAIL_COMMENT_EVENT)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
n.LineComment = string(p.event.line_comment)
|
||||||
|
n.FootComment = string(p.event.foot_comment)
|
||||||
|
if n.Style&FlowStyle == 0 && n.FootComment != "" && len(n.Content) > 1 {
|
||||||
|
n.Content[len(n.Content)-2].FootComment = n.FootComment
|
||||||
|
n.FootComment = ""
|
||||||
}
|
}
|
||||||
p.expect(yaml_MAPPING_END_EVENT)
|
p.expect(yaml_MAPPING_END_EVENT)
|
||||||
return n
|
return n
|
||||||
|
@ -224,48 +311,70 @@ func (p *parser) mapping() *node {
|
||||||
// Decoder, unmarshals a node into a provided value.
|
// Decoder, unmarshals a node into a provided value.
|
||||||
|
|
||||||
type decoder struct {
|
type decoder struct {
|
||||||
doc *node
|
doc *Node
|
||||||
aliases map[*node]bool
|
aliases map[*Node]bool
|
||||||
mapType reflect.Type
|
|
||||||
terrors []string
|
terrors []string
|
||||||
strict bool
|
|
||||||
|
|
||||||
|
stringMapType reflect.Type
|
||||||
|
generalMapType reflect.Type
|
||||||
|
|
||||||
|
knownFields bool
|
||||||
|
uniqueKeys bool
|
||||||
decodeCount int
|
decodeCount int
|
||||||
aliasCount int
|
aliasCount int
|
||||||
aliasDepth int
|
aliasDepth int
|
||||||
|
|
||||||
|
mergedFields map[interface{}]bool
|
||||||
}
|
}
|
||||||
|
|
||||||
var (
|
var (
|
||||||
mapItemType = reflect.TypeOf(MapItem{})
|
nodeType = reflect.TypeOf(Node{})
|
||||||
durationType = reflect.TypeOf(time.Duration(0))
|
durationType = reflect.TypeOf(time.Duration(0))
|
||||||
defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
|
stringMapType = reflect.TypeOf(map[string]interface{}{})
|
||||||
ifaceType = defaultMapType.Elem()
|
generalMapType = reflect.TypeOf(map[interface{}]interface{}{})
|
||||||
|
ifaceType = generalMapType.Elem()
|
||||||
timeType = reflect.TypeOf(time.Time{})
|
timeType = reflect.TypeOf(time.Time{})
|
||||||
ptrTimeType = reflect.TypeOf(&time.Time{})
|
ptrTimeType = reflect.TypeOf(&time.Time{})
|
||||||
)
|
)
|
||||||
|
|
||||||
func newDecoder(strict bool) *decoder {
|
func newDecoder() *decoder {
|
||||||
d := &decoder{mapType: defaultMapType, strict: strict}
|
d := &decoder{
|
||||||
d.aliases = make(map[*node]bool)
|
stringMapType: stringMapType,
|
||||||
|
generalMapType: generalMapType,
|
||||||
|
uniqueKeys: true,
|
||||||
|
}
|
||||||
|
d.aliases = make(map[*Node]bool)
|
||||||
return d
|
return d
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) terror(n *node, tag string, out reflect.Value) {
|
func (d *decoder) terror(n *Node, tag string, out reflect.Value) {
|
||||||
if n.tag != "" {
|
if n.Tag != "" {
|
||||||
tag = n.tag
|
tag = n.Tag
|
||||||
}
|
}
|
||||||
value := n.value
|
value := n.Value
|
||||||
if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG {
|
if tag != seqTag && tag != mapTag {
|
||||||
if len(value) > 10 {
|
if len(value) > 10 {
|
||||||
value = " `" + value[:7] + "...`"
|
value = " `" + value[:7] + "...`"
|
||||||
} else {
|
} else {
|
||||||
value = " `" + value + "`"
|
value = " `" + value + "`"
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))
|
d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.Line, shortTag(tag), value, out.Type()))
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {
|
func (d *decoder) callUnmarshaler(n *Node, u Unmarshaler) (good bool) {
|
||||||
|
err := u.UnmarshalYAML(n)
|
||||||
|
if e, ok := err.(*TypeError); ok {
|
||||||
|
d.terrors = append(d.terrors, e.Errors...)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
fail(err)
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *decoder) callObsoleteUnmarshaler(n *Node, u obsoleteUnmarshaler) (good bool) {
|
||||||
terrlen := len(d.terrors)
|
terrlen := len(d.terrors)
|
||||||
err := u.UnmarshalYAML(func(v interface{}) (err error) {
|
err := u.UnmarshalYAML(func(v interface{}) (err error) {
|
||||||
defer handleErr(&err)
|
defer handleErr(&err)
|
||||||
|
@ -294,8 +403,8 @@ func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {
|
||||||
// its types unmarshalled appropriately.
|
// its types unmarshalled appropriately.
|
||||||
//
|
//
|
||||||
// If n holds a null value, prepare returns before doing anything.
|
// If n holds a null value, prepare returns before doing anything.
|
||||||
func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
|
func (d *decoder) prepare(n *Node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
|
||||||
if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "~" || n.value == "" && n.implicit) {
|
if n.ShortTag() == nullTag {
|
||||||
return out, false, false
|
return out, false, false
|
||||||
}
|
}
|
||||||
again := true
|
again := true
|
||||||
|
@ -309,15 +418,40 @@ func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unm
|
||||||
again = true
|
again = true
|
||||||
}
|
}
|
||||||
if out.CanAddr() {
|
if out.CanAddr() {
|
||||||
if u, ok := out.Addr().Interface().(Unmarshaler); ok {
|
outi := out.Addr().Interface()
|
||||||
|
if u, ok := outi.(Unmarshaler); ok {
|
||||||
good = d.callUnmarshaler(n, u)
|
good = d.callUnmarshaler(n, u)
|
||||||
return out, true, good
|
return out, true, good
|
||||||
}
|
}
|
||||||
|
if u, ok := outi.(obsoleteUnmarshaler); ok {
|
||||||
|
good = d.callObsoleteUnmarshaler(n, u)
|
||||||
|
return out, true, good
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return out, false, false
|
return out, false, false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (d *decoder) fieldByIndex(n *Node, v reflect.Value, index []int) (field reflect.Value) {
|
||||||
|
if n.ShortTag() == nullTag {
|
||||||
|
return reflect.Value{}
|
||||||
|
}
|
||||||
|
for _, num := range index {
|
||||||
|
for {
|
||||||
|
if v.Kind() == reflect.Ptr {
|
||||||
|
if v.IsNil() {
|
||||||
|
v.Set(reflect.New(v.Type().Elem()))
|
||||||
|
}
|
||||||
|
v = v.Elem()
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
v = v.Field(num)
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
const (
|
const (
|
||||||
// 400,000 decode operations is ~500kb of dense object declarations, or
|
// 400,000 decode operations is ~500kb of dense object declarations, or
|
||||||
// ~5kb of dense object declarations with 10000% alias expansion
|
// ~5kb of dense object declarations with 10000% alias expansion
|
||||||
|
@ -347,7 +481,7 @@ func allowedAliasRatio(decodeCount int) float64 {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
|
func (d *decoder) unmarshal(n *Node, out reflect.Value) (good bool) {
|
||||||
d.decodeCount++
|
d.decodeCount++
|
||||||
if d.aliasDepth > 0 {
|
if d.aliasDepth > 0 {
|
||||||
d.aliasCount++
|
d.aliasCount++
|
||||||
|
@ -355,46 +489,55 @@ func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
|
||||||
if d.aliasCount > 100 && d.decodeCount > 1000 && float64(d.aliasCount)/float64(d.decodeCount) > allowedAliasRatio(d.decodeCount) {
|
if d.aliasCount > 100 && d.decodeCount > 1000 && float64(d.aliasCount)/float64(d.decodeCount) > allowedAliasRatio(d.decodeCount) {
|
||||||
failf("document contains excessive aliasing")
|
failf("document contains excessive aliasing")
|
||||||
}
|
}
|
||||||
switch n.kind {
|
if out.Type() == nodeType {
|
||||||
case documentNode:
|
out.Set(reflect.ValueOf(n).Elem())
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
switch n.Kind {
|
||||||
|
case DocumentNode:
|
||||||
return d.document(n, out)
|
return d.document(n, out)
|
||||||
case aliasNode:
|
case AliasNode:
|
||||||
return d.alias(n, out)
|
return d.alias(n, out)
|
||||||
}
|
}
|
||||||
out, unmarshaled, good := d.prepare(n, out)
|
out, unmarshaled, good := d.prepare(n, out)
|
||||||
if unmarshaled {
|
if unmarshaled {
|
||||||
return good
|
return good
|
||||||
}
|
}
|
||||||
switch n.kind {
|
switch n.Kind {
|
||||||
case scalarNode:
|
case ScalarNode:
|
||||||
good = d.scalar(n, out)
|
good = d.scalar(n, out)
|
||||||
case mappingNode:
|
case MappingNode:
|
||||||
good = d.mapping(n, out)
|
good = d.mapping(n, out)
|
||||||
case sequenceNode:
|
case SequenceNode:
|
||||||
good = d.sequence(n, out)
|
good = d.sequence(n, out)
|
||||||
|
case 0:
|
||||||
|
if n.IsZero() {
|
||||||
|
return d.null(out)
|
||||||
|
}
|
||||||
|
fallthrough
|
||||||
default:
|
default:
|
||||||
panic("internal error: unknown node kind: " + strconv.Itoa(n.kind))
|
failf("cannot decode node with unknown kind %d", n.Kind)
|
||||||
}
|
}
|
||||||
return good
|
return good
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) document(n *node, out reflect.Value) (good bool) {
|
func (d *decoder) document(n *Node, out reflect.Value) (good bool) {
|
||||||
if len(n.children) == 1 {
|
if len(n.Content) == 1 {
|
||||||
d.doc = n
|
d.doc = n
|
||||||
d.unmarshal(n.children[0], out)
|
d.unmarshal(n.Content[0], out)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
|
func (d *decoder) alias(n *Node, out reflect.Value) (good bool) {
|
||||||
if d.aliases[n] {
|
if d.aliases[n] {
|
||||||
// TODO this could actually be allowed in some circumstances.
|
// TODO this could actually be allowed in some circumstances.
|
||||||
failf("anchor '%s' value contains itself", n.value)
|
failf("anchor '%s' value contains itself", n.Value)
|
||||||
}
|
}
|
||||||
d.aliases[n] = true
|
d.aliases[n] = true
|
||||||
d.aliasDepth++
|
d.aliasDepth++
|
||||||
good = d.unmarshal(n.alias, out)
|
good = d.unmarshal(n.Alias, out)
|
||||||
d.aliasDepth--
|
d.aliasDepth--
|
||||||
delete(d.aliases, n)
|
delete(d.aliases, n)
|
||||||
return good
|
return good
|
||||||
|
@ -408,15 +551,26 @@ func resetMap(out reflect.Value) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) scalar(n *node, out reflect.Value) bool {
|
func (d *decoder) null(out reflect.Value) bool {
|
||||||
|
if out.CanAddr() {
|
||||||
|
switch out.Kind() {
|
||||||
|
case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
|
||||||
|
out.Set(reflect.Zero(out.Type()))
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *decoder) scalar(n *Node, out reflect.Value) bool {
|
||||||
var tag string
|
var tag string
|
||||||
var resolved interface{}
|
var resolved interface{}
|
||||||
if n.tag == "" && !n.implicit {
|
if n.indicatedString() {
|
||||||
tag = yaml_STR_TAG
|
tag = strTag
|
||||||
resolved = n.value
|
resolved = n.Value
|
||||||
} else {
|
} else {
|
||||||
tag, resolved = resolve(n.tag, n.value)
|
tag, resolved = resolve(n.Tag, n.Value)
|
||||||
if tag == yaml_BINARY_TAG {
|
if tag == binaryTag {
|
||||||
data, err := base64.StdEncoding.DecodeString(resolved.(string))
|
data, err := base64.StdEncoding.DecodeString(resolved.(string))
|
||||||
if err != nil {
|
if err != nil {
|
||||||
failf("!!binary value contains invalid base64 data")
|
failf("!!binary value contains invalid base64 data")
|
||||||
|
@ -425,12 +579,7 @@ func (d *decoder) scalar(n *node, out reflect.Value) bool {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if resolved == nil {
|
if resolved == nil {
|
||||||
if out.Kind() == reflect.Map && !out.CanAddr() {
|
return d.null(out)
|
||||||
resetMap(out)
|
|
||||||
} else {
|
|
||||||
out.Set(reflect.Zero(out.Type()))
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
}
|
||||||
if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
|
if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
|
||||||
// We've resolved to exactly the type we want, so use that.
|
// We've resolved to exactly the type we want, so use that.
|
||||||
|
@ -443,13 +592,13 @@ func (d *decoder) scalar(n *node, out reflect.Value) bool {
|
||||||
u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)
|
u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)
|
||||||
if ok {
|
if ok {
|
||||||
var text []byte
|
var text []byte
|
||||||
if tag == yaml_BINARY_TAG {
|
if tag == binaryTag {
|
||||||
text = []byte(resolved.(string))
|
text = []byte(resolved.(string))
|
||||||
} else {
|
} else {
|
||||||
// We let any value be unmarshaled into TextUnmarshaler.
|
// We let any value be unmarshaled into TextUnmarshaler.
|
||||||
// That might be more lax than we'd like, but the
|
// That might be more lax than we'd like, but the
|
||||||
// TextUnmarshaler itself should bowl out any dubious values.
|
// TextUnmarshaler itself should bowl out any dubious values.
|
||||||
text = []byte(n.value)
|
text = []byte(n.Value)
|
||||||
}
|
}
|
||||||
err := u.UnmarshalText(text)
|
err := u.UnmarshalText(text)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
|
@ -460,47 +609,37 @@ func (d *decoder) scalar(n *node, out reflect.Value) bool {
|
||||||
}
|
}
|
||||||
switch out.Kind() {
|
switch out.Kind() {
|
||||||
case reflect.String:
|
case reflect.String:
|
||||||
if tag == yaml_BINARY_TAG {
|
if tag == binaryTag {
|
||||||
out.SetString(resolved.(string))
|
out.SetString(resolved.(string))
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
if resolved != nil {
|
out.SetString(n.Value)
|
||||||
out.SetString(n.value)
|
return true
|
||||||
return true
|
|
||||||
}
|
|
||||||
case reflect.Interface:
|
case reflect.Interface:
|
||||||
if resolved == nil {
|
out.Set(reflect.ValueOf(resolved))
|
||||||
out.Set(reflect.Zero(out.Type()))
|
|
||||||
} else if tag == yaml_TIMESTAMP_TAG {
|
|
||||||
// It looks like a timestamp but for backward compatibility
|
|
||||||
// reasons we set it as a string, so that code that unmarshals
|
|
||||||
// timestamp-like values into interface{} will continue to
|
|
||||||
// see a string and not a time.Time.
|
|
||||||
// TODO(v3) Drop this.
|
|
||||||
out.Set(reflect.ValueOf(n.value))
|
|
||||||
} else {
|
|
||||||
out.Set(reflect.ValueOf(resolved))
|
|
||||||
}
|
|
||||||
return true
|
return true
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||||
|
// This used to work in v2, but it's very unfriendly.
|
||||||
|
isDuration := out.Type() == durationType
|
||||||
|
|
||||||
switch resolved := resolved.(type) {
|
switch resolved := resolved.(type) {
|
||||||
case int:
|
case int:
|
||||||
if !out.OverflowInt(int64(resolved)) {
|
if !isDuration && !out.OverflowInt(int64(resolved)) {
|
||||||
out.SetInt(int64(resolved))
|
out.SetInt(int64(resolved))
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case int64:
|
case int64:
|
||||||
if !out.OverflowInt(resolved) {
|
if !isDuration && !out.OverflowInt(resolved) {
|
||||||
out.SetInt(resolved)
|
out.SetInt(resolved)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case uint64:
|
case uint64:
|
||||||
if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
|
if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
|
||||||
out.SetInt(int64(resolved))
|
out.SetInt(int64(resolved))
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case float64:
|
case float64:
|
||||||
if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
|
if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
|
||||||
out.SetInt(int64(resolved))
|
out.SetInt(int64(resolved))
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -541,6 +680,17 @@ func (d *decoder) scalar(n *node, out reflect.Value) bool {
|
||||||
case bool:
|
case bool:
|
||||||
out.SetBool(resolved)
|
out.SetBool(resolved)
|
||||||
return true
|
return true
|
||||||
|
case string:
|
||||||
|
// This offers some compatibility with the 1.1 spec (https://yaml.org/type/bool.html).
|
||||||
|
// It only works if explicitly attempting to unmarshal into a typed bool value.
|
||||||
|
switch resolved {
|
||||||
|
case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON":
|
||||||
|
out.SetBool(true)
|
||||||
|
return true
|
||||||
|
case "n", "N", "no", "No", "NO", "off", "Off", "OFF":
|
||||||
|
out.SetBool(false)
|
||||||
|
return true
|
||||||
|
}
|
||||||
}
|
}
|
||||||
case reflect.Float32, reflect.Float64:
|
case reflect.Float32, reflect.Float64:
|
||||||
switch resolved := resolved.(type) {
|
switch resolved := resolved.(type) {
|
||||||
|
@ -563,13 +713,7 @@ func (d *decoder) scalar(n *node, out reflect.Value) bool {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case reflect.Ptr:
|
case reflect.Ptr:
|
||||||
if out.Type().Elem() == reflect.TypeOf(resolved) {
|
panic("yaml internal error: please report the issue")
|
||||||
// TODO DOes this make sense? When is out a Ptr except when decoding a nil value?
|
|
||||||
elem := reflect.New(out.Type().Elem())
|
|
||||||
elem.Elem().Set(reflect.ValueOf(resolved))
|
|
||||||
out.Set(elem)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
d.terror(n, tag, out)
|
d.terror(n, tag, out)
|
||||||
return false
|
return false
|
||||||
|
@ -582,8 +726,8 @@ func settableValueOf(i interface{}) reflect.Value {
|
||||||
return sv
|
return sv
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
|
func (d *decoder) sequence(n *Node, out reflect.Value) (good bool) {
|
||||||
l := len(n.children)
|
l := len(n.Content)
|
||||||
|
|
||||||
var iface reflect.Value
|
var iface reflect.Value
|
||||||
switch out.Kind() {
|
switch out.Kind() {
|
||||||
|
@ -598,7 +742,7 @@ func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
|
||||||
iface = out
|
iface = out
|
||||||
out = settableValueOf(make([]interface{}, l))
|
out = settableValueOf(make([]interface{}, l))
|
||||||
default:
|
default:
|
||||||
d.terror(n, yaml_SEQ_TAG, out)
|
d.terror(n, seqTag, out)
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
et := out.Type().Elem()
|
et := out.Type().Elem()
|
||||||
|
@ -606,7 +750,7 @@ func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
|
||||||
j := 0
|
j := 0
|
||||||
for i := 0; i < l; i++ {
|
for i := 0; i < l; i++ {
|
||||||
e := reflect.New(et).Elem()
|
e := reflect.New(et).Elem()
|
||||||
if ok := d.unmarshal(n.children[i], e); ok {
|
if ok := d.unmarshal(n.Content[i], e); ok {
|
||||||
out.Index(j).Set(e)
|
out.Index(j).Set(e)
|
||||||
j++
|
j++
|
||||||
}
|
}
|
||||||
|
@ -620,51 +764,79 @@ func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
|
func (d *decoder) mapping(n *Node, out reflect.Value) (good bool) {
|
||||||
|
l := len(n.Content)
|
||||||
|
if d.uniqueKeys {
|
||||||
|
nerrs := len(d.terrors)
|
||||||
|
for i := 0; i < l; i += 2 {
|
||||||
|
ni := n.Content[i]
|
||||||
|
for j := i + 2; j < l; j += 2 {
|
||||||
|
nj := n.Content[j]
|
||||||
|
if ni.Kind == nj.Kind && ni.Value == nj.Value {
|
||||||
|
d.terrors = append(d.terrors, fmt.Sprintf("line %d: mapping key %#v already defined at line %d", nj.Line, nj.Value, ni.Line))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if len(d.terrors) > nerrs {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
switch out.Kind() {
|
switch out.Kind() {
|
||||||
case reflect.Struct:
|
case reflect.Struct:
|
||||||
return d.mappingStruct(n, out)
|
return d.mappingStruct(n, out)
|
||||||
case reflect.Slice:
|
|
||||||
return d.mappingSlice(n, out)
|
|
||||||
case reflect.Map:
|
case reflect.Map:
|
||||||
// okay
|
// okay
|
||||||
case reflect.Interface:
|
case reflect.Interface:
|
||||||
if d.mapType.Kind() == reflect.Map {
|
iface := out
|
||||||
iface := out
|
if isStringMap(n) {
|
||||||
out = reflect.MakeMap(d.mapType)
|
out = reflect.MakeMap(d.stringMapType)
|
||||||
iface.Set(out)
|
|
||||||
} else {
|
} else {
|
||||||
slicev := reflect.New(d.mapType).Elem()
|
out = reflect.MakeMap(d.generalMapType)
|
||||||
if !d.mappingSlice(n, slicev) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
out.Set(slicev)
|
|
||||||
return true
|
|
||||||
}
|
}
|
||||||
|
iface.Set(out)
|
||||||
default:
|
default:
|
||||||
d.terror(n, yaml_MAP_TAG, out)
|
d.terror(n, mapTag, out)
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
outt := out.Type()
|
outt := out.Type()
|
||||||
kt := outt.Key()
|
kt := outt.Key()
|
||||||
et := outt.Elem()
|
et := outt.Elem()
|
||||||
|
|
||||||
mapType := d.mapType
|
stringMapType := d.stringMapType
|
||||||
if outt.Key() == ifaceType && outt.Elem() == ifaceType {
|
generalMapType := d.generalMapType
|
||||||
d.mapType = outt
|
if outt.Elem() == ifaceType {
|
||||||
|
if outt.Key().Kind() == reflect.String {
|
||||||
|
d.stringMapType = outt
|
||||||
|
} else if outt.Key() == ifaceType {
|
||||||
|
d.generalMapType = outt
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
mergedFields := d.mergedFields
|
||||||
|
d.mergedFields = nil
|
||||||
|
|
||||||
|
var mergeNode *Node
|
||||||
|
|
||||||
|
mapIsNew := false
|
||||||
if out.IsNil() {
|
if out.IsNil() {
|
||||||
out.Set(reflect.MakeMap(outt))
|
out.Set(reflect.MakeMap(outt))
|
||||||
|
mapIsNew = true
|
||||||
}
|
}
|
||||||
l := len(n.children)
|
|
||||||
for i := 0; i < l; i += 2 {
|
for i := 0; i < l; i += 2 {
|
||||||
if isMerge(n.children[i]) {
|
if isMerge(n.Content[i]) {
|
||||||
d.merge(n.children[i+1], out)
|
mergeNode = n.Content[i+1]
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
k := reflect.New(kt).Elem()
|
k := reflect.New(kt).Elem()
|
||||||
if d.unmarshal(n.children[i], k) {
|
if d.unmarshal(n.Content[i], k) {
|
||||||
|
if mergedFields != nil {
|
||||||
|
ki := k.Interface()
|
||||||
|
if mergedFields[ki] {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
mergedFields[ki] = true
|
||||||
|
}
|
||||||
kkind := k.Kind()
|
kkind := k.Kind()
|
||||||
if kkind == reflect.Interface {
|
if kkind == reflect.Interface {
|
||||||
kkind = k.Elem().Kind()
|
kkind = k.Elem().Kind()
|
||||||
|
@ -673,87 +845,83 @@ func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
|
||||||
failf("invalid map key: %#v", k.Interface())
|
failf("invalid map key: %#v", k.Interface())
|
||||||
}
|
}
|
||||||
e := reflect.New(et).Elem()
|
e := reflect.New(et).Elem()
|
||||||
if d.unmarshal(n.children[i+1], e) {
|
if d.unmarshal(n.Content[i+1], e) || n.Content[i+1].ShortTag() == nullTag && (mapIsNew || !out.MapIndex(k).IsValid()) {
|
||||||
d.setMapIndex(n.children[i+1], out, k, e)
|
out.SetMapIndex(k, e)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
d.mapType = mapType
|
|
||||||
|
d.mergedFields = mergedFields
|
||||||
|
if mergeNode != nil {
|
||||||
|
d.merge(n, mergeNode, out)
|
||||||
|
}
|
||||||
|
|
||||||
|
d.stringMapType = stringMapType
|
||||||
|
d.generalMapType = generalMapType
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) setMapIndex(n *node, out, k, v reflect.Value) {
|
func isStringMap(n *Node) bool {
|
||||||
if d.strict && out.MapIndex(k) != zeroValue {
|
if n.Kind != MappingNode {
|
||||||
d.terrors = append(d.terrors, fmt.Sprintf("line %d: key %#v already set in map", n.line+1, k.Interface()))
|
|
||||||
return
|
|
||||||
}
|
|
||||||
out.SetMapIndex(k, v)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) {
|
|
||||||
outt := out.Type()
|
|
||||||
if outt.Elem() != mapItemType {
|
|
||||||
d.terror(n, yaml_MAP_TAG, out)
|
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
l := len(n.Content)
|
||||||
mapType := d.mapType
|
|
||||||
d.mapType = outt
|
|
||||||
|
|
||||||
var slice []MapItem
|
|
||||||
var l = len(n.children)
|
|
||||||
for i := 0; i < l; i += 2 {
|
for i := 0; i < l; i += 2 {
|
||||||
if isMerge(n.children[i]) {
|
shortTag := n.Content[i].ShortTag()
|
||||||
d.merge(n.children[i+1], out)
|
if shortTag != strTag && shortTag != mergeTag {
|
||||||
continue
|
return false
|
||||||
}
|
|
||||||
item := MapItem{}
|
|
||||||
k := reflect.ValueOf(&item.Key).Elem()
|
|
||||||
if d.unmarshal(n.children[i], k) {
|
|
||||||
v := reflect.ValueOf(&item.Value).Elem()
|
|
||||||
if d.unmarshal(n.children[i+1], v) {
|
|
||||||
slice = append(slice, item)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
out.Set(reflect.ValueOf(slice))
|
|
||||||
d.mapType = mapType
|
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
|
func (d *decoder) mappingStruct(n *Node, out reflect.Value) (good bool) {
|
||||||
sinfo, err := getStructInfo(out.Type())
|
sinfo, err := getStructInfo(out.Type())
|
||||||
if err != nil {
|
if err != nil {
|
||||||
panic(err)
|
panic(err)
|
||||||
}
|
}
|
||||||
name := settableValueOf("")
|
|
||||||
l := len(n.children)
|
|
||||||
|
|
||||||
var inlineMap reflect.Value
|
var inlineMap reflect.Value
|
||||||
var elemType reflect.Type
|
var elemType reflect.Type
|
||||||
if sinfo.InlineMap != -1 {
|
if sinfo.InlineMap != -1 {
|
||||||
inlineMap = out.Field(sinfo.InlineMap)
|
inlineMap = out.Field(sinfo.InlineMap)
|
||||||
inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
|
|
||||||
elemType = inlineMap.Type().Elem()
|
elemType = inlineMap.Type().Elem()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
for _, index := range sinfo.InlineUnmarshalers {
|
||||||
|
field := d.fieldByIndex(n, out, index)
|
||||||
|
d.prepare(n, field)
|
||||||
|
}
|
||||||
|
|
||||||
|
mergedFields := d.mergedFields
|
||||||
|
d.mergedFields = nil
|
||||||
|
var mergeNode *Node
|
||||||
var doneFields []bool
|
var doneFields []bool
|
||||||
if d.strict {
|
if d.uniqueKeys {
|
||||||
doneFields = make([]bool, len(sinfo.FieldsList))
|
doneFields = make([]bool, len(sinfo.FieldsList))
|
||||||
}
|
}
|
||||||
|
name := settableValueOf("")
|
||||||
|
l := len(n.Content)
|
||||||
for i := 0; i < l; i += 2 {
|
for i := 0; i < l; i += 2 {
|
||||||
ni := n.children[i]
|
ni := n.Content[i]
|
||||||
if isMerge(ni) {
|
if isMerge(ni) {
|
||||||
d.merge(n.children[i+1], out)
|
mergeNode = n.Content[i+1]
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
if !d.unmarshal(ni, name) {
|
if !d.unmarshal(ni, name) {
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
if info, ok := sinfo.FieldsMap[name.String()]; ok {
|
sname := name.String()
|
||||||
if d.strict {
|
if mergedFields != nil {
|
||||||
|
if mergedFields[sname] {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
mergedFields[sname] = true
|
||||||
|
}
|
||||||
|
if info, ok := sinfo.FieldsMap[sname]; ok {
|
||||||
|
if d.uniqueKeys {
|
||||||
if doneFields[info.Id] {
|
if doneFields[info.Id] {
|
||||||
d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.line+1, name.String(), out.Type()))
|
d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.Line, name.String(), out.Type()))
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
doneFields[info.Id] = true
|
doneFields[info.Id] = true
|
||||||
|
@ -762,20 +930,25 @@ func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
|
||||||
if info.Inline == nil {
|
if info.Inline == nil {
|
||||||
field = out.Field(info.Num)
|
field = out.Field(info.Num)
|
||||||
} else {
|
} else {
|
||||||
field = out.FieldByIndex(info.Inline)
|
field = d.fieldByIndex(n, out, info.Inline)
|
||||||
}
|
}
|
||||||
d.unmarshal(n.children[i+1], field)
|
d.unmarshal(n.Content[i+1], field)
|
||||||
} else if sinfo.InlineMap != -1 {
|
} else if sinfo.InlineMap != -1 {
|
||||||
if inlineMap.IsNil() {
|
if inlineMap.IsNil() {
|
||||||
inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
|
inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
|
||||||
}
|
}
|
||||||
value := reflect.New(elemType).Elem()
|
value := reflect.New(elemType).Elem()
|
||||||
d.unmarshal(n.children[i+1], value)
|
d.unmarshal(n.Content[i+1], value)
|
||||||
d.setMapIndex(n.children[i+1], inlineMap, name, value)
|
inlineMap.SetMapIndex(name, value)
|
||||||
} else if d.strict {
|
} else if d.knownFields {
|
||||||
d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.line+1, name.String(), out.Type()))
|
d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.Line, name.String(), out.Type()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
d.mergedFields = mergedFields
|
||||||
|
if mergeNode != nil {
|
||||||
|
d.merge(n, mergeNode, out)
|
||||||
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -783,24 +956,34 @@ func failWantMap() {
|
||||||
failf("map merge requires map or sequence of maps as the value")
|
failf("map merge requires map or sequence of maps as the value")
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *decoder) merge(n *node, out reflect.Value) {
|
func (d *decoder) merge(parent *Node, merge *Node, out reflect.Value) {
|
||||||
switch n.kind {
|
mergedFields := d.mergedFields
|
||||||
case mappingNode:
|
if mergedFields == nil {
|
||||||
d.unmarshal(n, out)
|
d.mergedFields = make(map[interface{}]bool)
|
||||||
case aliasNode:
|
for i := 0; i < len(parent.Content); i += 2 {
|
||||||
if n.alias != nil && n.alias.kind != mappingNode {
|
k := reflect.New(ifaceType).Elem()
|
||||||
|
if d.unmarshal(parent.Content[i], k) {
|
||||||
|
d.mergedFields[k.Interface()] = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
switch merge.Kind {
|
||||||
|
case MappingNode:
|
||||||
|
d.unmarshal(merge, out)
|
||||||
|
case AliasNode:
|
||||||
|
if merge.Alias != nil && merge.Alias.Kind != MappingNode {
|
||||||
failWantMap()
|
failWantMap()
|
||||||
}
|
}
|
||||||
d.unmarshal(n, out)
|
d.unmarshal(merge, out)
|
||||||
case sequenceNode:
|
case SequenceNode:
|
||||||
// Step backwards as earlier nodes take precedence.
|
for i := 0; i < len(merge.Content); i++ {
|
||||||
for i := len(n.children) - 1; i >= 0; i-- {
|
ni := merge.Content[i]
|
||||||
ni := n.children[i]
|
if ni.Kind == AliasNode {
|
||||||
if ni.kind == aliasNode {
|
if ni.Alias != nil && ni.Alias.Kind != MappingNode {
|
||||||
if ni.alias != nil && ni.alias.kind != mappingNode {
|
|
||||||
failWantMap()
|
failWantMap()
|
||||||
}
|
}
|
||||||
} else if ni.kind != mappingNode {
|
} else if ni.Kind != MappingNode {
|
||||||
failWantMap()
|
failWantMap()
|
||||||
}
|
}
|
||||||
d.unmarshal(ni, out)
|
d.unmarshal(ni, out)
|
||||||
|
@ -808,8 +991,10 @@ func (d *decoder) merge(n *node, out reflect.Value) {
|
||||||
default:
|
default:
|
||||||
failWantMap()
|
failWantMap()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
d.mergedFields = mergedFields
|
||||||
}
|
}
|
||||||
|
|
||||||
func isMerge(n *node) bool {
|
func isMerge(n *Node) bool {
|
||||||
return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
|
return n.Kind == ScalarNode && n.Value == "<<" && (n.Tag == "" || n.Tag == "!" || shortTag(n.Tag) == mergeTag)
|
||||||
}
|
}
|
|
@ -1,3 +1,25 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -43,8 +65,13 @@ func put_break(emitter *yaml_emitter_t) bool {
|
||||||
default:
|
default:
|
||||||
panic("unknown line break setting")
|
panic("unknown line break setting")
|
||||||
}
|
}
|
||||||
|
if emitter.column == 0 {
|
||||||
|
emitter.space_above = true
|
||||||
|
}
|
||||||
emitter.column = 0
|
emitter.column = 0
|
||||||
emitter.line++
|
emitter.line++
|
||||||
|
// [Go] Do this here and below and drop from everywhere else (see commented lines).
|
||||||
|
emitter.indention = true
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -97,8 +124,13 @@ func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
|
||||||
if !write(emitter, s, i) {
|
if !write(emitter, s, i) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
if emitter.column == 0 {
|
||||||
|
emitter.space_above = true
|
||||||
|
}
|
||||||
emitter.column = 0
|
emitter.column = 0
|
||||||
emitter.line++
|
emitter.line++
|
||||||
|
// [Go] Do this here and above and drop from everywhere else (see commented lines).
|
||||||
|
emitter.indention = true
|
||||||
}
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -203,7 +235,14 @@ func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool
|
||||||
emitter.indent = 0
|
emitter.indent = 0
|
||||||
}
|
}
|
||||||
} else if !indentless {
|
} else if !indentless {
|
||||||
emitter.indent += emitter.best_indent
|
// [Go] This was changed so that indentations are more regular.
|
||||||
|
if emitter.states[len(emitter.states)-1] == yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE {
|
||||||
|
// The first indent inside a sequence will just skip the "- " indicator.
|
||||||
|
emitter.indent += 2
|
||||||
|
} else {
|
||||||
|
// Everything else aligns to the chosen indentation.
|
||||||
|
emitter.indent = emitter.best_indent*((emitter.indent+emitter.best_indent)/emitter.best_indent)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -228,16 +267,22 @@ func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bo
|
||||||
return yaml_emitter_emit_document_end(emitter, event)
|
return yaml_emitter_emit_document_end(emitter, event)
|
||||||
|
|
||||||
case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
|
case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
|
||||||
return yaml_emitter_emit_flow_sequence_item(emitter, event, true)
|
return yaml_emitter_emit_flow_sequence_item(emitter, event, true, false)
|
||||||
|
|
||||||
|
case yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE:
|
||||||
|
return yaml_emitter_emit_flow_sequence_item(emitter, event, false, true)
|
||||||
|
|
||||||
case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
|
case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
|
||||||
return yaml_emitter_emit_flow_sequence_item(emitter, event, false)
|
return yaml_emitter_emit_flow_sequence_item(emitter, event, false, false)
|
||||||
|
|
||||||
case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
|
case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
|
||||||
return yaml_emitter_emit_flow_mapping_key(emitter, event, true)
|
return yaml_emitter_emit_flow_mapping_key(emitter, event, true, false)
|
||||||
|
|
||||||
|
case yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE:
|
||||||
|
return yaml_emitter_emit_flow_mapping_key(emitter, event, false, true)
|
||||||
|
|
||||||
case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
|
case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
|
||||||
return yaml_emitter_emit_flow_mapping_key(emitter, event, false)
|
return yaml_emitter_emit_flow_mapping_key(emitter, event, false, false)
|
||||||
|
|
||||||
case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
|
case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
|
||||||
return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
|
return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
|
||||||
|
@ -298,6 +343,8 @@ func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t
|
||||||
emitter.column = 0
|
emitter.column = 0
|
||||||
emitter.whitespace = true
|
emitter.whitespace = true
|
||||||
emitter.indention = true
|
emitter.indention = true
|
||||||
|
emitter.space_above = true
|
||||||
|
emitter.foot_indent = -1
|
||||||
|
|
||||||
if emitter.encoding != yaml_UTF8_ENCODING {
|
if emitter.encoding != yaml_UTF8_ENCODING {
|
||||||
if !yaml_emitter_write_bom(emitter) {
|
if !yaml_emitter_write_bom(emitter) {
|
||||||
|
@ -392,13 +439,22 @@ func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
if emitter.canonical {
|
if emitter.canonical || true {
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if len(emitter.head_comment) > 0 {
|
||||||
|
if !yaml_emitter_process_head_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !put_break(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
|
emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -425,7 +481,20 @@ func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event
|
||||||
// Expect the root node.
|
// Expect the root node.
|
||||||
func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
|
func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
|
||||||
emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
|
emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
|
||||||
return yaml_emitter_emit_node(emitter, event, true, false, false, false)
|
|
||||||
|
if !yaml_emitter_process_head_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_emit_node(emitter, event, true, false, false, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
// Expect DOCUMENT-END.
|
// Expect DOCUMENT-END.
|
||||||
|
@ -433,6 +502,12 @@ func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t
|
||||||
if event.typ != yaml_DOCUMENT_END_EVENT {
|
if event.typ != yaml_DOCUMENT_END_EVENT {
|
||||||
return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
|
return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
|
||||||
}
|
}
|
||||||
|
// [Go] Force document foot separation.
|
||||||
|
emitter.foot_indent = 0
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
emitter.foot_indent = -1
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
@ -454,7 +529,7 @@ func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t
|
||||||
}
|
}
|
||||||
|
|
||||||
// Expect a flow item node.
|
// Expect a flow item node.
|
||||||
func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
|
func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
|
||||||
if first {
|
if first {
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
|
||||||
return false
|
return false
|
||||||
|
@ -466,13 +541,15 @@ func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_e
|
||||||
}
|
}
|
||||||
|
|
||||||
if event.typ == yaml_SEQUENCE_END_EVENT {
|
if event.typ == yaml_SEQUENCE_END_EVENT {
|
||||||
emitter.flow_level--
|
if emitter.canonical && !first && !trail {
|
||||||
emitter.indent = emitter.indents[len(emitter.indents)-1]
|
|
||||||
emitter.indents = emitter.indents[:len(emitter.indents)-1]
|
|
||||||
if emitter.canonical && !first {
|
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
emitter.flow_level--
|
||||||
|
emitter.indent = emitter.indents[len(emitter.indents)-1]
|
||||||
|
emitter.indents = emitter.indents[:len(emitter.indents)-1]
|
||||||
|
if emitter.column == 0 || emitter.canonical && !first {
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
@ -480,29 +557,62 @@ func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_e
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
emitter.state = emitter.states[len(emitter.states)-1]
|
emitter.state = emitter.states[len(emitter.states)-1]
|
||||||
emitter.states = emitter.states[:len(emitter.states)-1]
|
emitter.states = emitter.states[:len(emitter.states)-1]
|
||||||
|
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
if !first {
|
if !first && !trail {
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if !yaml_emitter_process_head_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if emitter.column == 0 {
|
||||||
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if emitter.canonical || emitter.column > emitter.best_width {
|
if emitter.canonical || emitter.column > emitter.best_width {
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
|
if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
|
||||||
return yaml_emitter_emit_node(emitter, event, false, true, false, false)
|
emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE)
|
||||||
|
} else {
|
||||||
|
emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
|
||||||
|
}
|
||||||
|
if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
|
||||||
|
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
// Expect a flow key node.
|
// Expect a flow key node.
|
||||||
func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
|
func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
|
||||||
if first {
|
if first {
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
|
||||||
return false
|
return false
|
||||||
|
@ -514,13 +624,18 @@ func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_eve
|
||||||
}
|
}
|
||||||
|
|
||||||
if event.typ == yaml_MAPPING_END_EVENT {
|
if event.typ == yaml_MAPPING_END_EVENT {
|
||||||
|
if (emitter.canonical || len(emitter.head_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0) && !first && !trail {
|
||||||
|
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_head_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
emitter.flow_level--
|
emitter.flow_level--
|
||||||
emitter.indent = emitter.indents[len(emitter.indents)-1]
|
emitter.indent = emitter.indents[len(emitter.indents)-1]
|
||||||
emitter.indents = emitter.indents[:len(emitter.indents)-1]
|
emitter.indents = emitter.indents[:len(emitter.indents)-1]
|
||||||
if emitter.canonical && !first {
|
if emitter.canonical && !first {
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
@ -528,16 +643,33 @@ func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_eve
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
emitter.state = emitter.states[len(emitter.states)-1]
|
emitter.state = emitter.states[len(emitter.states)-1]
|
||||||
emitter.states = emitter.states[:len(emitter.states)-1]
|
emitter.states = emitter.states[:len(emitter.states)-1]
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
if !first {
|
if !first && !trail {
|
||||||
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if !yaml_emitter_process_head_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
if emitter.column == 0 {
|
||||||
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if emitter.canonical || emitter.column > emitter.best_width {
|
if emitter.canonical || emitter.column > emitter.best_width {
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
|
@ -571,14 +703,32 @@ func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_e
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
|
if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
|
||||||
return yaml_emitter_emit_node(emitter, event, false, false, true, false)
|
emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE)
|
||||||
|
} else {
|
||||||
|
emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
|
||||||
|
}
|
||||||
|
if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
|
||||||
|
if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
// Expect a block item node.
|
// Expect a block item node.
|
||||||
func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
|
func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
|
||||||
if first {
|
if first {
|
||||||
if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) {
|
if !yaml_emitter_increase_indent(emitter, false, false) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -589,6 +739,9 @@ func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_
|
||||||
emitter.states = emitter.states[:len(emitter.states)-1]
|
emitter.states = emitter.states[:len(emitter.states)-1]
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
if !yaml_emitter_process_head_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
@ -596,7 +749,16 @@ func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
|
emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
|
||||||
return yaml_emitter_emit_node(emitter, event, false, true, false, false)
|
if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
// Expect a block key node.
|
// Expect a block key node.
|
||||||
|
@ -606,6 +768,9 @@ func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_ev
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if !yaml_emitter_process_head_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
if event.typ == yaml_MAPPING_END_EVENT {
|
if event.typ == yaml_MAPPING_END_EVENT {
|
||||||
emitter.indent = emitter.indents[len(emitter.indents)-1]
|
emitter.indent = emitter.indents[len(emitter.indents)-1]
|
||||||
emitter.indents = emitter.indents[:len(emitter.indents)-1]
|
emitter.indents = emitter.indents[:len(emitter.indents)-1]
|
||||||
|
@ -616,6 +781,13 @@ func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_ev
|
||||||
if !yaml_emitter_write_indent(emitter) {
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
if len(emitter.line_comment) > 0 {
|
||||||
|
// [Go] A line comment was provided for the key. That's unusual as the
|
||||||
|
// scanner associates line comments with the value. Either way,
|
||||||
|
// save the line comment and render it appropriately later.
|
||||||
|
emitter.key_line_comment = emitter.line_comment
|
||||||
|
emitter.line_comment = nil
|
||||||
|
}
|
||||||
if yaml_emitter_check_simple_key(emitter) {
|
if yaml_emitter_check_simple_key(emitter) {
|
||||||
emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
|
emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
|
||||||
return yaml_emitter_emit_node(emitter, event, false, false, true, true)
|
return yaml_emitter_emit_node(emitter, event, false, false, true, true)
|
||||||
|
@ -641,8 +813,42 @@ func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if len(emitter.key_line_comment) > 0 {
|
||||||
|
// [Go] Line comments are generally associated with the value, but when there's
|
||||||
|
// no value on the same line as a mapping key they end up attached to the
|
||||||
|
// key itself.
|
||||||
|
if event.typ == yaml_SCALAR_EVENT {
|
||||||
|
if len(emitter.line_comment) == 0 {
|
||||||
|
// A scalar is coming and it has no line comments by itself yet,
|
||||||
|
// so just let it handle the line comment as usual. If it has a
|
||||||
|
// line comment, we can't have both so the one from the key is lost.
|
||||||
|
emitter.line_comment = emitter.key_line_comment
|
||||||
|
emitter.key_line_comment = nil
|
||||||
|
}
|
||||||
|
} else if event.sequence_style() != yaml_FLOW_SEQUENCE_STYLE && (event.typ == yaml_MAPPING_START_EVENT || event.typ == yaml_SEQUENCE_START_EVENT) {
|
||||||
|
// An indented block follows, so write the comment right now.
|
||||||
|
emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
|
||||||
|
}
|
||||||
|
}
|
||||||
emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
|
emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
|
||||||
return yaml_emitter_emit_node(emitter, event, false, false, true, false)
|
if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_process_foot_comment(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func yaml_emitter_silent_nil_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
|
||||||
|
return event.typ == yaml_SCALAR_EVENT && event.implicit && !emitter.canonical && len(emitter.scalar_data.value) == 0
|
||||||
}
|
}
|
||||||
|
|
||||||
// Expect a node.
|
// Expect a node.
|
||||||
|
@ -908,6 +1114,71 @@ func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
|
||||||
panic("unknown scalar style")
|
panic("unknown scalar style")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Write a head comment.
|
||||||
|
func yaml_emitter_process_head_comment(emitter *yaml_emitter_t) bool {
|
||||||
|
if len(emitter.tail_comment) > 0 {
|
||||||
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_write_comment(emitter, emitter.tail_comment) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
emitter.tail_comment = emitter.tail_comment[:0]
|
||||||
|
emitter.foot_indent = emitter.indent
|
||||||
|
if emitter.foot_indent < 0 {
|
||||||
|
emitter.foot_indent = 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(emitter.head_comment) == 0 {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_write_comment(emitter, emitter.head_comment) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
emitter.head_comment = emitter.head_comment[:0]
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
// Write an line comment.
|
||||||
|
func yaml_emitter_process_line_comment(emitter *yaml_emitter_t) bool {
|
||||||
|
if len(emitter.line_comment) == 0 {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
if !emitter.whitespace {
|
||||||
|
if !put(emitter, ' ') {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !yaml_emitter_write_comment(emitter, emitter.line_comment) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
emitter.line_comment = emitter.line_comment[:0]
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
// Write a foot comment.
|
||||||
|
func yaml_emitter_process_foot_comment(emitter *yaml_emitter_t) bool {
|
||||||
|
if len(emitter.foot_comment) == 0 {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
if !yaml_emitter_write_indent(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !yaml_emitter_write_comment(emitter, emitter.foot_comment) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
emitter.foot_comment = emitter.foot_comment[:0]
|
||||||
|
emitter.foot_indent = emitter.indent
|
||||||
|
if emitter.foot_indent < 0 {
|
||||||
|
emitter.foot_indent = 0
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
// Check if a %YAML directive is valid.
|
// Check if a %YAML directive is valid.
|
||||||
func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
|
func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
|
||||||
if version_directive.major != 1 || version_directive.minor != 1 {
|
if version_directive.major != 1 || version_directive.minor != 1 {
|
||||||
|
@ -987,6 +1258,7 @@ func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
|
||||||
flow_indicators = false
|
flow_indicators = false
|
||||||
line_breaks = false
|
line_breaks = false
|
||||||
special_characters = false
|
special_characters = false
|
||||||
|
tab_characters = false
|
||||||
|
|
||||||
leading_space = false
|
leading_space = false
|
||||||
leading_break = false
|
leading_break = false
|
||||||
|
@ -1055,7 +1327,9 @@ func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
|
if value[i] == '\t' {
|
||||||
|
tab_characters = true
|
||||||
|
} else if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
|
||||||
special_characters = true
|
special_characters = true
|
||||||
}
|
}
|
||||||
if is_space(value, i) {
|
if is_space(value, i) {
|
||||||
|
@ -1110,10 +1384,12 @@ func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
|
||||||
emitter.scalar_data.block_plain_allowed = false
|
emitter.scalar_data.block_plain_allowed = false
|
||||||
emitter.scalar_data.single_quoted_allowed = false
|
emitter.scalar_data.single_quoted_allowed = false
|
||||||
}
|
}
|
||||||
if space_break || special_characters {
|
if space_break || tab_characters || special_characters {
|
||||||
emitter.scalar_data.flow_plain_allowed = false
|
emitter.scalar_data.flow_plain_allowed = false
|
||||||
emitter.scalar_data.block_plain_allowed = false
|
emitter.scalar_data.block_plain_allowed = false
|
||||||
emitter.scalar_data.single_quoted_allowed = false
|
emitter.scalar_data.single_quoted_allowed = false
|
||||||
|
}
|
||||||
|
if space_break || special_characters {
|
||||||
emitter.scalar_data.block_allowed = false
|
emitter.scalar_data.block_allowed = false
|
||||||
}
|
}
|
||||||
if line_breaks {
|
if line_breaks {
|
||||||
|
@ -1137,6 +1413,19 @@ func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bo
|
||||||
emitter.tag_data.suffix = nil
|
emitter.tag_data.suffix = nil
|
||||||
emitter.scalar_data.value = nil
|
emitter.scalar_data.value = nil
|
||||||
|
|
||||||
|
if len(event.head_comment) > 0 {
|
||||||
|
emitter.head_comment = event.head_comment
|
||||||
|
}
|
||||||
|
if len(event.line_comment) > 0 {
|
||||||
|
emitter.line_comment = event.line_comment
|
||||||
|
}
|
||||||
|
if len(event.foot_comment) > 0 {
|
||||||
|
emitter.foot_comment = event.foot_comment
|
||||||
|
}
|
||||||
|
if len(event.tail_comment) > 0 {
|
||||||
|
emitter.tail_comment = event.tail_comment
|
||||||
|
}
|
||||||
|
|
||||||
switch event.typ {
|
switch event.typ {
|
||||||
case yaml_ALIAS_EVENT:
|
case yaml_ALIAS_EVENT:
|
||||||
if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
|
if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
|
||||||
|
@ -1208,13 +1497,20 @@ func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if emitter.foot_indent == indent {
|
||||||
|
if !put_break(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
for emitter.column < indent {
|
for emitter.column < indent {
|
||||||
if !put(emitter, ' ') {
|
if !put(emitter, ' ') {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
emitter.whitespace = true
|
emitter.whitespace = true
|
||||||
emitter.indention = true
|
//emitter.indention = true
|
||||||
|
emitter.space_above = false
|
||||||
|
emitter.foot_indent = -1
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1311,7 +1607,7 @@ func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_
|
||||||
}
|
}
|
||||||
|
|
||||||
func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
|
func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
|
||||||
if !emitter.whitespace {
|
if len(value) > 0 && !emitter.whitespace {
|
||||||
if !put(emitter, ' ') {
|
if !put(emitter, ' ') {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
@ -1341,7 +1637,7 @@ func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allo
|
||||||
if !write_break(emitter, value, &i) {
|
if !write_break(emitter, value, &i) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
emitter.indention = true
|
//emitter.indention = true
|
||||||
breaks = true
|
breaks = true
|
||||||
} else {
|
} else {
|
||||||
if breaks {
|
if breaks {
|
||||||
|
@ -1358,7 +1654,9 @@ func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allo
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
emitter.whitespace = false
|
if len(value) > 0 {
|
||||||
|
emitter.whitespace = false
|
||||||
|
}
|
||||||
emitter.indention = false
|
emitter.indention = false
|
||||||
if emitter.root_context {
|
if emitter.root_context {
|
||||||
emitter.open_ended = true
|
emitter.open_ended = true
|
||||||
|
@ -1397,7 +1695,7 @@ func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []by
|
||||||
if !write_break(emitter, value, &i) {
|
if !write_break(emitter, value, &i) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
emitter.indention = true
|
//emitter.indention = true
|
||||||
breaks = true
|
breaks = true
|
||||||
} else {
|
} else {
|
||||||
if breaks {
|
if breaks {
|
||||||
|
@ -1596,10 +1894,10 @@ func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bo
|
||||||
if !yaml_emitter_write_block_scalar_hints(emitter, value) {
|
if !yaml_emitter_write_block_scalar_hints(emitter, value) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
if !put_break(emitter) {
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
emitter.indention = true
|
//emitter.indention = true
|
||||||
emitter.whitespace = true
|
emitter.whitespace = true
|
||||||
breaks := true
|
breaks := true
|
||||||
for i := 0; i < len(value); {
|
for i := 0; i < len(value); {
|
||||||
|
@ -1607,7 +1905,7 @@ func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bo
|
||||||
if !write_break(emitter, value, &i) {
|
if !write_break(emitter, value, &i) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
emitter.indention = true
|
//emitter.indention = true
|
||||||
breaks = true
|
breaks = true
|
||||||
} else {
|
} else {
|
||||||
if breaks {
|
if breaks {
|
||||||
|
@ -1633,11 +1931,11 @@ func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) boo
|
||||||
if !yaml_emitter_write_block_scalar_hints(emitter, value) {
|
if !yaml_emitter_write_block_scalar_hints(emitter, value) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
if !yaml_emitter_process_line_comment(emitter) {
|
||||||
if !put_break(emitter) {
|
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
emitter.indention = true
|
|
||||||
|
//emitter.indention = true
|
||||||
emitter.whitespace = true
|
emitter.whitespace = true
|
||||||
|
|
||||||
breaks := true
|
breaks := true
|
||||||
|
@ -1658,7 +1956,7 @@ func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) boo
|
||||||
if !write_break(emitter, value, &i) {
|
if !write_break(emitter, value, &i) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
emitter.indention = true
|
//emitter.indention = true
|
||||||
breaks = true
|
breaks = true
|
||||||
} else {
|
} else {
|
||||||
if breaks {
|
if breaks {
|
||||||
|
@ -1683,3 +1981,40 @@ func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) boo
|
||||||
}
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func yaml_emitter_write_comment(emitter *yaml_emitter_t, comment []byte) bool {
|
||||||
|
breaks := false
|
||||||
|
pound := false
|
||||||
|
for i := 0; i < len(comment); {
|
||||||
|
if is_break(comment, i) {
|
||||||
|
if !write_break(emitter, comment, &i) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
//emitter.indention = true
|
||||||
|
breaks = true
|
||||||
|
pound = false
|
||||||
|
} else {
|
||||||
|
if breaks && !yaml_emitter_write_indent(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !pound {
|
||||||
|
if comment[i] != '#' && (!put(emitter, '#') || !put(emitter, ' ')) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
pound = true
|
||||||
|
}
|
||||||
|
if !write(emitter, comment, &i) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
emitter.indention = false
|
||||||
|
breaks = false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !breaks && !put_break(emitter) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
emitter.whitespace = true
|
||||||
|
//emitter.indention = true
|
||||||
|
return true
|
||||||
|
}
|
|
@ -0,0 +1,577 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
|
package yaml
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"reflect"
|
||||||
|
"regexp"
|
||||||
|
"sort"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"time"
|
||||||
|
"unicode/utf8"
|
||||||
|
)
|
||||||
|
|
||||||
|
type encoder struct {
|
||||||
|
emitter yaml_emitter_t
|
||||||
|
event yaml_event_t
|
||||||
|
out []byte
|
||||||
|
flow bool
|
||||||
|
indent int
|
||||||
|
doneInit bool
|
||||||
|
}
|
||||||
|
|
||||||
|
func newEncoder() *encoder {
|
||||||
|
e := &encoder{}
|
||||||
|
yaml_emitter_initialize(&e.emitter)
|
||||||
|
yaml_emitter_set_output_string(&e.emitter, &e.out)
|
||||||
|
yaml_emitter_set_unicode(&e.emitter, true)
|
||||||
|
return e
|
||||||
|
}
|
||||||
|
|
||||||
|
func newEncoderWithWriter(w io.Writer) *encoder {
|
||||||
|
e := &encoder{}
|
||||||
|
yaml_emitter_initialize(&e.emitter)
|
||||||
|
yaml_emitter_set_output_writer(&e.emitter, w)
|
||||||
|
yaml_emitter_set_unicode(&e.emitter, true)
|
||||||
|
return e
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) init() {
|
||||||
|
if e.doneInit {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if e.indent == 0 {
|
||||||
|
e.indent = 4
|
||||||
|
}
|
||||||
|
e.emitter.best_indent = e.indent
|
||||||
|
yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
|
||||||
|
e.emit()
|
||||||
|
e.doneInit = true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) finish() {
|
||||||
|
e.emitter.open_ended = false
|
||||||
|
yaml_stream_end_event_initialize(&e.event)
|
||||||
|
e.emit()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) destroy() {
|
||||||
|
yaml_emitter_delete(&e.emitter)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) emit() {
|
||||||
|
// This will internally delete the e.event value.
|
||||||
|
e.must(yaml_emitter_emit(&e.emitter, &e.event))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) must(ok bool) {
|
||||||
|
if !ok {
|
||||||
|
msg := e.emitter.problem
|
||||||
|
if msg == "" {
|
||||||
|
msg = "unknown problem generating YAML content"
|
||||||
|
}
|
||||||
|
failf("%s", msg)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) marshalDoc(tag string, in reflect.Value) {
|
||||||
|
e.init()
|
||||||
|
var node *Node
|
||||||
|
if in.IsValid() {
|
||||||
|
node, _ = in.Interface().(*Node)
|
||||||
|
}
|
||||||
|
if node != nil && node.Kind == DocumentNode {
|
||||||
|
e.nodev(in)
|
||||||
|
} else {
|
||||||
|
yaml_document_start_event_initialize(&e.event, nil, nil, true)
|
||||||
|
e.emit()
|
||||||
|
e.marshal(tag, in)
|
||||||
|
yaml_document_end_event_initialize(&e.event, true)
|
||||||
|
e.emit()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) marshal(tag string, in reflect.Value) {
|
||||||
|
tag = shortTag(tag)
|
||||||
|
if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
|
||||||
|
e.nilv()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
iface := in.Interface()
|
||||||
|
switch value := iface.(type) {
|
||||||
|
case *Node:
|
||||||
|
e.nodev(in)
|
||||||
|
return
|
||||||
|
case Node:
|
||||||
|
if !in.CanAddr() {
|
||||||
|
var n = reflect.New(in.Type()).Elem()
|
||||||
|
n.Set(in)
|
||||||
|
in = n
|
||||||
|
}
|
||||||
|
e.nodev(in.Addr())
|
||||||
|
return
|
||||||
|
case time.Time:
|
||||||
|
e.timev(tag, in)
|
||||||
|
return
|
||||||
|
case *time.Time:
|
||||||
|
e.timev(tag, in.Elem())
|
||||||
|
return
|
||||||
|
case time.Duration:
|
||||||
|
e.stringv(tag, reflect.ValueOf(value.String()))
|
||||||
|
return
|
||||||
|
case Marshaler:
|
||||||
|
v, err := value.MarshalYAML()
|
||||||
|
if err != nil {
|
||||||
|
fail(err)
|
||||||
|
}
|
||||||
|
if v == nil {
|
||||||
|
e.nilv()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
e.marshal(tag, reflect.ValueOf(v))
|
||||||
|
return
|
||||||
|
case encoding.TextMarshaler:
|
||||||
|
text, err := value.MarshalText()
|
||||||
|
if err != nil {
|
||||||
|
fail(err)
|
||||||
|
}
|
||||||
|
in = reflect.ValueOf(string(text))
|
||||||
|
case nil:
|
||||||
|
e.nilv()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
switch in.Kind() {
|
||||||
|
case reflect.Interface:
|
||||||
|
e.marshal(tag, in.Elem())
|
||||||
|
case reflect.Map:
|
||||||
|
e.mapv(tag, in)
|
||||||
|
case reflect.Ptr:
|
||||||
|
e.marshal(tag, in.Elem())
|
||||||
|
case reflect.Struct:
|
||||||
|
e.structv(tag, in)
|
||||||
|
case reflect.Slice, reflect.Array:
|
||||||
|
e.slicev(tag, in)
|
||||||
|
case reflect.String:
|
||||||
|
e.stringv(tag, in)
|
||||||
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||||
|
e.intv(tag, in)
|
||||||
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
||||||
|
e.uintv(tag, in)
|
||||||
|
case reflect.Float32, reflect.Float64:
|
||||||
|
e.floatv(tag, in)
|
||||||
|
case reflect.Bool:
|
||||||
|
e.boolv(tag, in)
|
||||||
|
default:
|
||||||
|
panic("cannot marshal type: " + in.Type().String())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) mapv(tag string, in reflect.Value) {
|
||||||
|
e.mappingv(tag, func() {
|
||||||
|
keys := keyList(in.MapKeys())
|
||||||
|
sort.Sort(keys)
|
||||||
|
for _, k := range keys {
|
||||||
|
e.marshal("", k)
|
||||||
|
e.marshal("", in.MapIndex(k))
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) fieldByIndex(v reflect.Value, index []int) (field reflect.Value) {
|
||||||
|
for _, num := range index {
|
||||||
|
for {
|
||||||
|
if v.Kind() == reflect.Ptr {
|
||||||
|
if v.IsNil() {
|
||||||
|
return reflect.Value{}
|
||||||
|
}
|
||||||
|
v = v.Elem()
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
v = v.Field(num)
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) structv(tag string, in reflect.Value) {
|
||||||
|
sinfo, err := getStructInfo(in.Type())
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
e.mappingv(tag, func() {
|
||||||
|
for _, info := range sinfo.FieldsList {
|
||||||
|
var value reflect.Value
|
||||||
|
if info.Inline == nil {
|
||||||
|
value = in.Field(info.Num)
|
||||||
|
} else {
|
||||||
|
value = e.fieldByIndex(in, info.Inline)
|
||||||
|
if !value.IsValid() {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if info.OmitEmpty && isZero(value) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
e.marshal("", reflect.ValueOf(info.Key))
|
||||||
|
e.flow = info.Flow
|
||||||
|
e.marshal("", value)
|
||||||
|
}
|
||||||
|
if sinfo.InlineMap >= 0 {
|
||||||
|
m := in.Field(sinfo.InlineMap)
|
||||||
|
if m.Len() > 0 {
|
||||||
|
e.flow = false
|
||||||
|
keys := keyList(m.MapKeys())
|
||||||
|
sort.Sort(keys)
|
||||||
|
for _, k := range keys {
|
||||||
|
if _, found := sinfo.FieldsMap[k.String()]; found {
|
||||||
|
panic(fmt.Sprintf("cannot have key %q in inlined map: conflicts with struct field", k.String()))
|
||||||
|
}
|
||||||
|
e.marshal("", k)
|
||||||
|
e.flow = false
|
||||||
|
e.marshal("", m.MapIndex(k))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) mappingv(tag string, f func()) {
|
||||||
|
implicit := tag == ""
|
||||||
|
style := yaml_BLOCK_MAPPING_STYLE
|
||||||
|
if e.flow {
|
||||||
|
e.flow = false
|
||||||
|
style = yaml_FLOW_MAPPING_STYLE
|
||||||
|
}
|
||||||
|
yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
|
||||||
|
e.emit()
|
||||||
|
f()
|
||||||
|
yaml_mapping_end_event_initialize(&e.event)
|
||||||
|
e.emit()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) slicev(tag string, in reflect.Value) {
|
||||||
|
implicit := tag == ""
|
||||||
|
style := yaml_BLOCK_SEQUENCE_STYLE
|
||||||
|
if e.flow {
|
||||||
|
e.flow = false
|
||||||
|
style = yaml_FLOW_SEQUENCE_STYLE
|
||||||
|
}
|
||||||
|
e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
|
||||||
|
e.emit()
|
||||||
|
n := in.Len()
|
||||||
|
for i := 0; i < n; i++ {
|
||||||
|
e.marshal("", in.Index(i))
|
||||||
|
}
|
||||||
|
e.must(yaml_sequence_end_event_initialize(&e.event))
|
||||||
|
e.emit()
|
||||||
|
}
|
||||||
|
|
||||||
|
// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
|
||||||
|
//
|
||||||
|
// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
|
||||||
|
// in YAML 1.2 and by this package, but these should be marshalled quoted for
|
||||||
|
// the time being for compatibility with other parsers.
|
||||||
|
func isBase60Float(s string) (result bool) {
|
||||||
|
// Fast path.
|
||||||
|
if s == "" {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
c := s[0]
|
||||||
|
if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
// Do the full match.
|
||||||
|
return base60float.MatchString(s)
|
||||||
|
}
|
||||||
|
|
||||||
|
// From http://yaml.org/type/float.html, except the regular expression there
|
||||||
|
// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
|
||||||
|
var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
|
||||||
|
|
||||||
|
// isOldBool returns whether s is bool notation as defined in YAML 1.1.
|
||||||
|
//
|
||||||
|
// We continue to force strings that YAML 1.1 would interpret as booleans to be
|
||||||
|
// rendered as quotes strings so that the marshalled output valid for YAML 1.1
|
||||||
|
// parsing.
|
||||||
|
func isOldBool(s string) (result bool) {
|
||||||
|
switch s {
|
||||||
|
case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON",
|
||||||
|
"n", "N", "no", "No", "NO", "off", "Off", "OFF":
|
||||||
|
return true
|
||||||
|
default:
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) stringv(tag string, in reflect.Value) {
|
||||||
|
var style yaml_scalar_style_t
|
||||||
|
s := in.String()
|
||||||
|
canUsePlain := true
|
||||||
|
switch {
|
||||||
|
case !utf8.ValidString(s):
|
||||||
|
if tag == binaryTag {
|
||||||
|
failf("explicitly tagged !!binary data must be base64-encoded")
|
||||||
|
}
|
||||||
|
if tag != "" {
|
||||||
|
failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
|
||||||
|
}
|
||||||
|
// It can't be encoded directly as YAML so use a binary tag
|
||||||
|
// and encode it as base64.
|
||||||
|
tag = binaryTag
|
||||||
|
s = encodeBase64(s)
|
||||||
|
case tag == "":
|
||||||
|
// Check to see if it would resolve to a specific
|
||||||
|
// tag when encoded unquoted. If it doesn't,
|
||||||
|
// there's no need to quote it.
|
||||||
|
rtag, _ := resolve("", s)
|
||||||
|
canUsePlain = rtag == strTag && !(isBase60Float(s) || isOldBool(s))
|
||||||
|
}
|
||||||
|
// Note: it's possible for user code to emit invalid YAML
|
||||||
|
// if they explicitly specify a tag and a string containing
|
||||||
|
// text that's incompatible with that tag.
|
||||||
|
switch {
|
||||||
|
case strings.Contains(s, "\n"):
|
||||||
|
if e.flow {
|
||||||
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
||||||
|
} else {
|
||||||
|
style = yaml_LITERAL_SCALAR_STYLE
|
||||||
|
}
|
||||||
|
case canUsePlain:
|
||||||
|
style = yaml_PLAIN_SCALAR_STYLE
|
||||||
|
default:
|
||||||
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
||||||
|
}
|
||||||
|
e.emitScalar(s, "", tag, style, nil, nil, nil, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) boolv(tag string, in reflect.Value) {
|
||||||
|
var s string
|
||||||
|
if in.Bool() {
|
||||||
|
s = "true"
|
||||||
|
} else {
|
||||||
|
s = "false"
|
||||||
|
}
|
||||||
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) intv(tag string, in reflect.Value) {
|
||||||
|
s := strconv.FormatInt(in.Int(), 10)
|
||||||
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) uintv(tag string, in reflect.Value) {
|
||||||
|
s := strconv.FormatUint(in.Uint(), 10)
|
||||||
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) timev(tag string, in reflect.Value) {
|
||||||
|
t := in.Interface().(time.Time)
|
||||||
|
s := t.Format(time.RFC3339Nano)
|
||||||
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) floatv(tag string, in reflect.Value) {
|
||||||
|
// Issue #352: When formatting, use the precision of the underlying value
|
||||||
|
precision := 64
|
||||||
|
if in.Kind() == reflect.Float32 {
|
||||||
|
precision = 32
|
||||||
|
}
|
||||||
|
|
||||||
|
s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
|
||||||
|
switch s {
|
||||||
|
case "+Inf":
|
||||||
|
s = ".inf"
|
||||||
|
case "-Inf":
|
||||||
|
s = "-.inf"
|
||||||
|
case "NaN":
|
||||||
|
s = ".nan"
|
||||||
|
}
|
||||||
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) nilv() {
|
||||||
|
e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t, head, line, foot, tail []byte) {
|
||||||
|
// TODO Kill this function. Replace all initialize calls by their underlining Go literals.
|
||||||
|
implicit := tag == ""
|
||||||
|
if !implicit {
|
||||||
|
tag = longTag(tag)
|
||||||
|
}
|
||||||
|
e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
|
||||||
|
e.event.head_comment = head
|
||||||
|
e.event.line_comment = line
|
||||||
|
e.event.foot_comment = foot
|
||||||
|
e.event.tail_comment = tail
|
||||||
|
e.emit()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) nodev(in reflect.Value) {
|
||||||
|
e.node(in.Interface().(*Node), "")
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *encoder) node(node *Node, tail string) {
|
||||||
|
// Zero nodes behave as nil.
|
||||||
|
if node.Kind == 0 && node.IsZero() {
|
||||||
|
e.nilv()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the tag was not explicitly requested, and dropping it won't change the
|
||||||
|
// implicit tag of the value, don't include it in the presentation.
|
||||||
|
var tag = node.Tag
|
||||||
|
var stag = shortTag(tag)
|
||||||
|
var forceQuoting bool
|
||||||
|
if tag != "" && node.Style&TaggedStyle == 0 {
|
||||||
|
if node.Kind == ScalarNode {
|
||||||
|
if stag == strTag && node.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0 {
|
||||||
|
tag = ""
|
||||||
|
} else {
|
||||||
|
rtag, _ := resolve("", node.Value)
|
||||||
|
if rtag == stag {
|
||||||
|
tag = ""
|
||||||
|
} else if stag == strTag {
|
||||||
|
tag = ""
|
||||||
|
forceQuoting = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
var rtag string
|
||||||
|
switch node.Kind {
|
||||||
|
case MappingNode:
|
||||||
|
rtag = mapTag
|
||||||
|
case SequenceNode:
|
||||||
|
rtag = seqTag
|
||||||
|
}
|
||||||
|
if rtag == stag {
|
||||||
|
tag = ""
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
switch node.Kind {
|
||||||
|
case DocumentNode:
|
||||||
|
yaml_document_start_event_initialize(&e.event, nil, nil, true)
|
||||||
|
e.event.head_comment = []byte(node.HeadComment)
|
||||||
|
e.emit()
|
||||||
|
for _, node := range node.Content {
|
||||||
|
e.node(node, "")
|
||||||
|
}
|
||||||
|
yaml_document_end_event_initialize(&e.event, true)
|
||||||
|
e.event.foot_comment = []byte(node.FootComment)
|
||||||
|
e.emit()
|
||||||
|
|
||||||
|
case SequenceNode:
|
||||||
|
style := yaml_BLOCK_SEQUENCE_STYLE
|
||||||
|
if node.Style&FlowStyle != 0 {
|
||||||
|
style = yaml_FLOW_SEQUENCE_STYLE
|
||||||
|
}
|
||||||
|
e.must(yaml_sequence_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style))
|
||||||
|
e.event.head_comment = []byte(node.HeadComment)
|
||||||
|
e.emit()
|
||||||
|
for _, node := range node.Content {
|
||||||
|
e.node(node, "")
|
||||||
|
}
|
||||||
|
e.must(yaml_sequence_end_event_initialize(&e.event))
|
||||||
|
e.event.line_comment = []byte(node.LineComment)
|
||||||
|
e.event.foot_comment = []byte(node.FootComment)
|
||||||
|
e.emit()
|
||||||
|
|
||||||
|
case MappingNode:
|
||||||
|
style := yaml_BLOCK_MAPPING_STYLE
|
||||||
|
if node.Style&FlowStyle != 0 {
|
||||||
|
style = yaml_FLOW_MAPPING_STYLE
|
||||||
|
}
|
||||||
|
yaml_mapping_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style)
|
||||||
|
e.event.tail_comment = []byte(tail)
|
||||||
|
e.event.head_comment = []byte(node.HeadComment)
|
||||||
|
e.emit()
|
||||||
|
|
||||||
|
// The tail logic below moves the foot comment of prior keys to the following key,
|
||||||
|
// since the value for each key may be a nested structure and the foot needs to be
|
||||||
|
// processed only the entirety of the value is streamed. The last tail is processed
|
||||||
|
// with the mapping end event.
|
||||||
|
var tail string
|
||||||
|
for i := 0; i+1 < len(node.Content); i += 2 {
|
||||||
|
k := node.Content[i]
|
||||||
|
foot := k.FootComment
|
||||||
|
if foot != "" {
|
||||||
|
kopy := *k
|
||||||
|
kopy.FootComment = ""
|
||||||
|
k = &kopy
|
||||||
|
}
|
||||||
|
e.node(k, tail)
|
||||||
|
tail = foot
|
||||||
|
|
||||||
|
v := node.Content[i+1]
|
||||||
|
e.node(v, "")
|
||||||
|
}
|
||||||
|
|
||||||
|
yaml_mapping_end_event_initialize(&e.event)
|
||||||
|
e.event.tail_comment = []byte(tail)
|
||||||
|
e.event.line_comment = []byte(node.LineComment)
|
||||||
|
e.event.foot_comment = []byte(node.FootComment)
|
||||||
|
e.emit()
|
||||||
|
|
||||||
|
case AliasNode:
|
||||||
|
yaml_alias_event_initialize(&e.event, []byte(node.Value))
|
||||||
|
e.event.head_comment = []byte(node.HeadComment)
|
||||||
|
e.event.line_comment = []byte(node.LineComment)
|
||||||
|
e.event.foot_comment = []byte(node.FootComment)
|
||||||
|
e.emit()
|
||||||
|
|
||||||
|
case ScalarNode:
|
||||||
|
value := node.Value
|
||||||
|
if !utf8.ValidString(value) {
|
||||||
|
if stag == binaryTag {
|
||||||
|
failf("explicitly tagged !!binary data must be base64-encoded")
|
||||||
|
}
|
||||||
|
if stag != "" {
|
||||||
|
failf("cannot marshal invalid UTF-8 data as %s", stag)
|
||||||
|
}
|
||||||
|
// It can't be encoded directly as YAML so use a binary tag
|
||||||
|
// and encode it as base64.
|
||||||
|
tag = binaryTag
|
||||||
|
value = encodeBase64(value)
|
||||||
|
}
|
||||||
|
|
||||||
|
style := yaml_PLAIN_SCALAR_STYLE
|
||||||
|
switch {
|
||||||
|
case node.Style&DoubleQuotedStyle != 0:
|
||||||
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
||||||
|
case node.Style&SingleQuotedStyle != 0:
|
||||||
|
style = yaml_SINGLE_QUOTED_SCALAR_STYLE
|
||||||
|
case node.Style&LiteralStyle != 0:
|
||||||
|
style = yaml_LITERAL_SCALAR_STYLE
|
||||||
|
case node.Style&FoldedStyle != 0:
|
||||||
|
style = yaml_FOLDED_SCALAR_STYLE
|
||||||
|
case strings.Contains(value, "\n"):
|
||||||
|
style = yaml_LITERAL_SCALAR_STYLE
|
||||||
|
case forceQuoting:
|
||||||
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
||||||
|
}
|
||||||
|
|
||||||
|
e.emitScalar(value, node.Anchor, tag, style, []byte(node.HeadComment), []byte(node.LineComment), []byte(node.FootComment), []byte(tail))
|
||||||
|
default:
|
||||||
|
failf("cannot encode node with unknown kind %d", node.Kind)
|
||||||
|
}
|
||||||
|
}
|
|
@ -1,3 +1,25 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -45,11 +67,46 @@ import (
|
||||||
// Peek the next token in the token queue.
|
// Peek the next token in the token queue.
|
||||||
func peek_token(parser *yaml_parser_t) *yaml_token_t {
|
func peek_token(parser *yaml_parser_t) *yaml_token_t {
|
||||||
if parser.token_available || yaml_parser_fetch_more_tokens(parser) {
|
if parser.token_available || yaml_parser_fetch_more_tokens(parser) {
|
||||||
return &parser.tokens[parser.tokens_head]
|
token := &parser.tokens[parser.tokens_head]
|
||||||
|
yaml_parser_unfold_comments(parser, token)
|
||||||
|
return token
|
||||||
}
|
}
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// yaml_parser_unfold_comments walks through the comments queue and joins all
|
||||||
|
// comments behind the position of the provided token into the respective
|
||||||
|
// top-level comment slices in the parser.
|
||||||
|
func yaml_parser_unfold_comments(parser *yaml_parser_t, token *yaml_token_t) {
|
||||||
|
for parser.comments_head < len(parser.comments) && token.start_mark.index >= parser.comments[parser.comments_head].token_mark.index {
|
||||||
|
comment := &parser.comments[parser.comments_head]
|
||||||
|
if len(comment.head) > 0 {
|
||||||
|
if token.typ == yaml_BLOCK_END_TOKEN {
|
||||||
|
// No heads on ends, so keep comment.head for a follow up token.
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if len(parser.head_comment) > 0 {
|
||||||
|
parser.head_comment = append(parser.head_comment, '\n')
|
||||||
|
}
|
||||||
|
parser.head_comment = append(parser.head_comment, comment.head...)
|
||||||
|
}
|
||||||
|
if len(comment.foot) > 0 {
|
||||||
|
if len(parser.foot_comment) > 0 {
|
||||||
|
parser.foot_comment = append(parser.foot_comment, '\n')
|
||||||
|
}
|
||||||
|
parser.foot_comment = append(parser.foot_comment, comment.foot...)
|
||||||
|
}
|
||||||
|
if len(comment.line) > 0 {
|
||||||
|
if len(parser.line_comment) > 0 {
|
||||||
|
parser.line_comment = append(parser.line_comment, '\n')
|
||||||
|
}
|
||||||
|
parser.line_comment = append(parser.line_comment, comment.line...)
|
||||||
|
}
|
||||||
|
*comment = yaml_comment_t{}
|
||||||
|
parser.comments_head++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Remove the next token from the queue (must be called after peek_token).
|
// Remove the next token from the queue (must be called after peek_token).
|
||||||
func skip_token(parser *yaml_parser_t) {
|
func skip_token(parser *yaml_parser_t) {
|
||||||
parser.token_available = false
|
parser.token_available = false
|
||||||
|
@ -166,7 +223,6 @@ func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool
|
||||||
default:
|
default:
|
||||||
panic("invalid parser state")
|
panic("invalid parser state")
|
||||||
}
|
}
|
||||||
return false
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Parse the production:
|
// Parse the production:
|
||||||
|
@ -225,10 +281,32 @@ func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t
|
||||||
parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
|
parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
|
||||||
parser.state = yaml_PARSE_BLOCK_NODE_STATE
|
parser.state = yaml_PARSE_BLOCK_NODE_STATE
|
||||||
|
|
||||||
|
var head_comment []byte
|
||||||
|
if len(parser.head_comment) > 0 {
|
||||||
|
// [Go] Scan the header comment backwards, and if an empty line is found, break
|
||||||
|
// the header so the part before the last empty line goes into the
|
||||||
|
// document header, while the bottom of it goes into a follow up event.
|
||||||
|
for i := len(parser.head_comment) - 1; i > 0; i-- {
|
||||||
|
if parser.head_comment[i] == '\n' {
|
||||||
|
if i == len(parser.head_comment)-1 {
|
||||||
|
head_comment = parser.head_comment[:i]
|
||||||
|
parser.head_comment = parser.head_comment[i+1:]
|
||||||
|
break
|
||||||
|
} else if parser.head_comment[i-1] == '\n' {
|
||||||
|
head_comment = parser.head_comment[:i-1]
|
||||||
|
parser.head_comment = parser.head_comment[i+1:]
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
*event = yaml_event_t{
|
*event = yaml_event_t{
|
||||||
typ: yaml_DOCUMENT_START_EVENT,
|
typ: yaml_DOCUMENT_START_EVENT,
|
||||||
start_mark: token.start_mark,
|
start_mark: token.start_mark,
|
||||||
end_mark: token.end_mark,
|
end_mark: token.end_mark,
|
||||||
|
|
||||||
|
head_comment: head_comment,
|
||||||
}
|
}
|
||||||
|
|
||||||
} else if token.typ != yaml_STREAM_END_TOKEN {
|
} else if token.typ != yaml_STREAM_END_TOKEN {
|
||||||
|
@ -285,6 +363,7 @@ func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event
|
||||||
if token == nil {
|
if token == nil {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
if token.typ == yaml_VERSION_DIRECTIVE_TOKEN ||
|
if token.typ == yaml_VERSION_DIRECTIVE_TOKEN ||
|
||||||
token.typ == yaml_TAG_DIRECTIVE_TOKEN ||
|
token.typ == yaml_TAG_DIRECTIVE_TOKEN ||
|
||||||
token.typ == yaml_DOCUMENT_START_TOKEN ||
|
token.typ == yaml_DOCUMENT_START_TOKEN ||
|
||||||
|
@ -328,9 +407,25 @@ func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t)
|
||||||
end_mark: end_mark,
|
end_mark: end_mark,
|
||||||
implicit: implicit,
|
implicit: implicit,
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
|
if len(event.head_comment) > 0 && len(event.foot_comment) == 0 {
|
||||||
|
event.foot_comment = event.head_comment
|
||||||
|
event.head_comment = nil
|
||||||
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func yaml_parser_set_event_comments(parser *yaml_parser_t, event *yaml_event_t) {
|
||||||
|
event.head_comment = parser.head_comment
|
||||||
|
event.line_comment = parser.line_comment
|
||||||
|
event.foot_comment = parser.foot_comment
|
||||||
|
parser.head_comment = nil
|
||||||
|
parser.line_comment = nil
|
||||||
|
parser.foot_comment = nil
|
||||||
|
parser.tail_comment = nil
|
||||||
|
parser.stem_comment = nil
|
||||||
|
}
|
||||||
|
|
||||||
// Parse the productions:
|
// Parse the productions:
|
||||||
// block_node_or_indentless_sequence ::=
|
// block_node_or_indentless_sequence ::=
|
||||||
// ALIAS
|
// ALIAS
|
||||||
|
@ -374,6 +469,7 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
|
||||||
end_mark: token.end_mark,
|
end_mark: token.end_mark,
|
||||||
anchor: token.value,
|
anchor: token.value,
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -487,6 +583,7 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
|
||||||
quoted_implicit: quoted_implicit,
|
quoted_implicit: quoted_implicit,
|
||||||
style: yaml_style_t(token.style),
|
style: yaml_style_t(token.style),
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -503,6 +600,7 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
|
||||||
implicit: implicit,
|
implicit: implicit,
|
||||||
style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
|
style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
|
if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
|
||||||
|
@ -517,6 +615,7 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
|
||||||
implicit: implicit,
|
implicit: implicit,
|
||||||
style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
|
style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
|
if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
|
||||||
|
@ -531,6 +630,10 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
|
||||||
implicit: implicit,
|
implicit: implicit,
|
||||||
style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
|
style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
|
||||||
}
|
}
|
||||||
|
if parser.stem_comment != nil {
|
||||||
|
event.head_comment = parser.stem_comment
|
||||||
|
parser.stem_comment = nil
|
||||||
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
|
if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
|
||||||
|
@ -545,6 +648,10 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
|
||||||
implicit: implicit,
|
implicit: implicit,
|
||||||
style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
|
style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
|
||||||
}
|
}
|
||||||
|
if parser.stem_comment != nil {
|
||||||
|
event.head_comment = parser.stem_comment
|
||||||
|
parser.stem_comment = nil
|
||||||
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
if len(anchor) > 0 || len(tag) > 0 {
|
if len(anchor) > 0 || len(tag) > 0 {
|
||||||
|
@ -591,7 +698,9 @@ func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_e
|
||||||
|
|
||||||
if token.typ == yaml_BLOCK_ENTRY_TOKEN {
|
if token.typ == yaml_BLOCK_ENTRY_TOKEN {
|
||||||
mark := token.end_mark
|
mark := token.end_mark
|
||||||
|
prior_head_len := len(parser.head_comment)
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
|
yaml_parser_split_stem_comment(parser, prior_head_len)
|
||||||
token = peek_token(parser)
|
token = peek_token(parser)
|
||||||
if token == nil {
|
if token == nil {
|
||||||
return false
|
return false
|
||||||
|
@ -637,7 +746,9 @@ func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *y
|
||||||
|
|
||||||
if token.typ == yaml_BLOCK_ENTRY_TOKEN {
|
if token.typ == yaml_BLOCK_ENTRY_TOKEN {
|
||||||
mark := token.end_mark
|
mark := token.end_mark
|
||||||
|
prior_head_len := len(parser.head_comment)
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
|
yaml_parser_split_stem_comment(parser, prior_head_len)
|
||||||
token = peek_token(parser)
|
token = peek_token(parser)
|
||||||
if token == nil {
|
if token == nil {
|
||||||
return false
|
return false
|
||||||
|
@ -663,6 +774,32 @@ func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *y
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Split stem comment from head comment.
|
||||||
|
//
|
||||||
|
// When a sequence or map is found under a sequence entry, the former head comment
|
||||||
|
// is assigned to the underlying sequence or map as a whole, not the individual
|
||||||
|
// sequence or map entry as would be expected otherwise. To handle this case the
|
||||||
|
// previous head comment is moved aside as the stem comment.
|
||||||
|
func yaml_parser_split_stem_comment(parser *yaml_parser_t, stem_len int) {
|
||||||
|
if stem_len == 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
token := peek_token(parser)
|
||||||
|
if token.typ != yaml_BLOCK_SEQUENCE_START_TOKEN && token.typ != yaml_BLOCK_MAPPING_START_TOKEN {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
parser.stem_comment = parser.head_comment[:stem_len]
|
||||||
|
if len(parser.head_comment) == stem_len {
|
||||||
|
parser.head_comment = nil
|
||||||
|
} else {
|
||||||
|
// Copy suffix to prevent very strange bugs if someone ever appends
|
||||||
|
// further bytes to the prefix in the stem_comment slice above.
|
||||||
|
parser.head_comment = append([]byte(nil), parser.head_comment[stem_len+1:]...)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Parse the productions:
|
// Parse the productions:
|
||||||
// block_mapping ::= BLOCK-MAPPING_START
|
// block_mapping ::= BLOCK-MAPPING_START
|
||||||
// *******************
|
// *******************
|
||||||
|
@ -685,6 +822,19 @@ func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_even
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// [Go] A tail comment was left from the prior mapping value processed. Emit an event
|
||||||
|
// as it needs to be processed with that value and not the following key.
|
||||||
|
if len(parser.tail_comment) > 0 {
|
||||||
|
*event = yaml_event_t{
|
||||||
|
typ: yaml_TAIL_COMMENT_EVENT,
|
||||||
|
start_mark: token.start_mark,
|
||||||
|
end_mark: token.end_mark,
|
||||||
|
foot_comment: parser.tail_comment,
|
||||||
|
}
|
||||||
|
parser.tail_comment = nil
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
if token.typ == yaml_KEY_TOKEN {
|
if token.typ == yaml_KEY_TOKEN {
|
||||||
mark := token.end_mark
|
mark := token.end_mark
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
|
@ -710,6 +860,7 @@ func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_even
|
||||||
start_mark: token.start_mark,
|
start_mark: token.start_mark,
|
||||||
end_mark: token.end_mark,
|
end_mark: token.end_mark,
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -821,6 +972,7 @@ func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_ev
|
||||||
start_mark: token.start_mark,
|
start_mark: token.start_mark,
|
||||||
end_mark: token.end_mark,
|
end_mark: token.end_mark,
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
|
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
return true
|
return true
|
||||||
|
@ -960,6 +1112,7 @@ func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event
|
||||||
start_mark: token.start_mark,
|
start_mark: token.start_mark,
|
||||||
end_mark: token.end_mark,
|
end_mark: token.end_mark,
|
||||||
}
|
}
|
||||||
|
yaml_parser_set_event_comments(parser, event)
|
||||||
skip_token(parser)
|
skip_token(parser)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
|
@ -1,3 +1,25 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -95,7 +117,7 @@ func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
|
||||||
|
|
||||||
// [Go] This function was changed to guarantee the requested length size at EOF.
|
// [Go] This function was changed to guarantee the requested length size at EOF.
|
||||||
// The fact we need to do this is pretty awful, but the description above implies
|
// The fact we need to do this is pretty awful, but the description above implies
|
||||||
// for that to be the case, and there are tests
|
// for that to be the case, and there are tests
|
||||||
|
|
||||||
// If the EOF flag is set and the raw buffer is empty, do nothing.
|
// If the EOF flag is set and the raw buffer is empty, do nothing.
|
||||||
if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
|
if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
|
|
@ -1,3 +1,18 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -34,18 +49,14 @@ func init() {
|
||||||
tag string
|
tag string
|
||||||
l []string
|
l []string
|
||||||
}{
|
}{
|
||||||
{true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}},
|
{true, boolTag, []string{"true", "True", "TRUE"}},
|
||||||
{true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}},
|
{false, boolTag, []string{"false", "False", "FALSE"}},
|
||||||
{true, yaml_BOOL_TAG, []string{"on", "On", "ON"}},
|
{nil, nullTag, []string{"", "~", "null", "Null", "NULL"}},
|
||||||
{false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}},
|
{math.NaN(), floatTag, []string{".nan", ".NaN", ".NAN"}},
|
||||||
{false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}},
|
{math.Inf(+1), floatTag, []string{".inf", ".Inf", ".INF"}},
|
||||||
{false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}},
|
{math.Inf(+1), floatTag, []string{"+.inf", "+.Inf", "+.INF"}},
|
||||||
{nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}},
|
{math.Inf(-1), floatTag, []string{"-.inf", "-.Inf", "-.INF"}},
|
||||||
{math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}},
|
{"<<", mergeTag, []string{"<<"}},
|
||||||
{math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}},
|
|
||||||
{math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}},
|
|
||||||
{math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}},
|
|
||||||
{"<<", yaml_MERGE_TAG, []string{"<<"}},
|
|
||||||
}
|
}
|
||||||
|
|
||||||
m := resolveMap
|
m := resolveMap
|
||||||
|
@ -56,11 +67,37 @@ func init() {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
const (
|
||||||
|
nullTag = "!!null"
|
||||||
|
boolTag = "!!bool"
|
||||||
|
strTag = "!!str"
|
||||||
|
intTag = "!!int"
|
||||||
|
floatTag = "!!float"
|
||||||
|
timestampTag = "!!timestamp"
|
||||||
|
seqTag = "!!seq"
|
||||||
|
mapTag = "!!map"
|
||||||
|
binaryTag = "!!binary"
|
||||||
|
mergeTag = "!!merge"
|
||||||
|
)
|
||||||
|
|
||||||
|
var longTags = make(map[string]string)
|
||||||
|
var shortTags = make(map[string]string)
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
for _, stag := range []string{nullTag, boolTag, strTag, intTag, floatTag, timestampTag, seqTag, mapTag, binaryTag, mergeTag} {
|
||||||
|
ltag := longTag(stag)
|
||||||
|
longTags[stag] = ltag
|
||||||
|
shortTags[ltag] = stag
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
const longTagPrefix = "tag:yaml.org,2002:"
|
const longTagPrefix = "tag:yaml.org,2002:"
|
||||||
|
|
||||||
func shortTag(tag string) string {
|
func shortTag(tag string) string {
|
||||||
// TODO This can easily be made faster and produce less garbage.
|
|
||||||
if strings.HasPrefix(tag, longTagPrefix) {
|
if strings.HasPrefix(tag, longTagPrefix) {
|
||||||
|
if stag, ok := shortTags[tag]; ok {
|
||||||
|
return stag
|
||||||
|
}
|
||||||
return "!!" + tag[len(longTagPrefix):]
|
return "!!" + tag[len(longTagPrefix):]
|
||||||
}
|
}
|
||||||
return tag
|
return tag
|
||||||
|
@ -68,6 +105,9 @@ func shortTag(tag string) string {
|
||||||
|
|
||||||
func longTag(tag string) string {
|
func longTag(tag string) string {
|
||||||
if strings.HasPrefix(tag, "!!") {
|
if strings.HasPrefix(tag, "!!") {
|
||||||
|
if ltag, ok := longTags[tag]; ok {
|
||||||
|
return ltag
|
||||||
|
}
|
||||||
return longTagPrefix + tag[2:]
|
return longTagPrefix + tag[2:]
|
||||||
}
|
}
|
||||||
return tag
|
return tag
|
||||||
|
@ -75,7 +115,7 @@ func longTag(tag string) string {
|
||||||
|
|
||||||
func resolvableTag(tag string) bool {
|
func resolvableTag(tag string) bool {
|
||||||
switch tag {
|
switch tag {
|
||||||
case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG, yaml_TIMESTAMP_TAG:
|
case "", strTag, boolTag, intTag, floatTag, nullTag, timestampTag:
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
return false
|
return false
|
||||||
|
@ -84,23 +124,24 @@ func resolvableTag(tag string) bool {
|
||||||
var yamlStyleFloat = regexp.MustCompile(`^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$`)
|
var yamlStyleFloat = regexp.MustCompile(`^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$`)
|
||||||
|
|
||||||
func resolve(tag string, in string) (rtag string, out interface{}) {
|
func resolve(tag string, in string) (rtag string, out interface{}) {
|
||||||
|
tag = shortTag(tag)
|
||||||
if !resolvableTag(tag) {
|
if !resolvableTag(tag) {
|
||||||
return tag, in
|
return tag, in
|
||||||
}
|
}
|
||||||
|
|
||||||
defer func() {
|
defer func() {
|
||||||
switch tag {
|
switch tag {
|
||||||
case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG:
|
case "", rtag, strTag, binaryTag:
|
||||||
return
|
return
|
||||||
case yaml_FLOAT_TAG:
|
case floatTag:
|
||||||
if rtag == yaml_INT_TAG {
|
if rtag == intTag {
|
||||||
switch v := out.(type) {
|
switch v := out.(type) {
|
||||||
case int64:
|
case int64:
|
||||||
rtag = yaml_FLOAT_TAG
|
rtag = floatTag
|
||||||
out = float64(v)
|
out = float64(v)
|
||||||
return
|
return
|
||||||
case int:
|
case int:
|
||||||
rtag = yaml_FLOAT_TAG
|
rtag = floatTag
|
||||||
out = float64(v)
|
out = float64(v)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
@ -115,7 +156,7 @@ func resolve(tag string, in string) (rtag string, out interface{}) {
|
||||||
if in != "" {
|
if in != "" {
|
||||||
hint = resolveTable[in[0]]
|
hint = resolveTable[in[0]]
|
||||||
}
|
}
|
||||||
if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG {
|
if hint != 0 && tag != strTag && tag != binaryTag {
|
||||||
// Handle things we can lookup in a map.
|
// Handle things we can lookup in a map.
|
||||||
if item, ok := resolveMap[in]; ok {
|
if item, ok := resolveMap[in]; ok {
|
||||||
return item.tag, item.value
|
return item.tag, item.value
|
||||||
|
@ -133,17 +174,17 @@ func resolve(tag string, in string) (rtag string, out interface{}) {
|
||||||
// Not in the map, so maybe a normal float.
|
// Not in the map, so maybe a normal float.
|
||||||
floatv, err := strconv.ParseFloat(in, 64)
|
floatv, err := strconv.ParseFloat(in, 64)
|
||||||
if err == nil {
|
if err == nil {
|
||||||
return yaml_FLOAT_TAG, floatv
|
return floatTag, floatv
|
||||||
}
|
}
|
||||||
|
|
||||||
case 'D', 'S':
|
case 'D', 'S':
|
||||||
// Int, float, or timestamp.
|
// Int, float, or timestamp.
|
||||||
// Only try values as a timestamp if the value is unquoted or there's an explicit
|
// Only try values as a timestamp if the value is unquoted or there's an explicit
|
||||||
// !!timestamp tag.
|
// !!timestamp tag.
|
||||||
if tag == "" || tag == yaml_TIMESTAMP_TAG {
|
if tag == "" || tag == timestampTag {
|
||||||
t, ok := parseTimestamp(in)
|
t, ok := parseTimestamp(in)
|
||||||
if ok {
|
if ok {
|
||||||
return yaml_TIMESTAMP_TAG, t
|
return timestampTag, t
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -151,49 +192,76 @@ func resolve(tag string, in string) (rtag string, out interface{}) {
|
||||||
intv, err := strconv.ParseInt(plain, 0, 64)
|
intv, err := strconv.ParseInt(plain, 0, 64)
|
||||||
if err == nil {
|
if err == nil {
|
||||||
if intv == int64(int(intv)) {
|
if intv == int64(int(intv)) {
|
||||||
return yaml_INT_TAG, int(intv)
|
return intTag, int(intv)
|
||||||
} else {
|
} else {
|
||||||
return yaml_INT_TAG, intv
|
return intTag, intv
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
uintv, err := strconv.ParseUint(plain, 0, 64)
|
uintv, err := strconv.ParseUint(plain, 0, 64)
|
||||||
if err == nil {
|
if err == nil {
|
||||||
return yaml_INT_TAG, uintv
|
return intTag, uintv
|
||||||
}
|
}
|
||||||
if yamlStyleFloat.MatchString(plain) {
|
if yamlStyleFloat.MatchString(plain) {
|
||||||
floatv, err := strconv.ParseFloat(plain, 64)
|
floatv, err := strconv.ParseFloat(plain, 64)
|
||||||
if err == nil {
|
if err == nil {
|
||||||
return yaml_FLOAT_TAG, floatv
|
return floatTag, floatv
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if strings.HasPrefix(plain, "0b") {
|
if strings.HasPrefix(plain, "0b") {
|
||||||
intv, err := strconv.ParseInt(plain[2:], 2, 64)
|
intv, err := strconv.ParseInt(plain[2:], 2, 64)
|
||||||
if err == nil {
|
if err == nil {
|
||||||
if intv == int64(int(intv)) {
|
if intv == int64(int(intv)) {
|
||||||
return yaml_INT_TAG, int(intv)
|
return intTag, int(intv)
|
||||||
} else {
|
} else {
|
||||||
return yaml_INT_TAG, intv
|
return intTag, intv
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
uintv, err := strconv.ParseUint(plain[2:], 2, 64)
|
uintv, err := strconv.ParseUint(plain[2:], 2, 64)
|
||||||
if err == nil {
|
if err == nil {
|
||||||
return yaml_INT_TAG, uintv
|
return intTag, uintv
|
||||||
}
|
}
|
||||||
} else if strings.HasPrefix(plain, "-0b") {
|
} else if strings.HasPrefix(plain, "-0b") {
|
||||||
intv, err := strconv.ParseInt("-" + plain[3:], 2, 64)
|
intv, err := strconv.ParseInt("-"+plain[3:], 2, 64)
|
||||||
if err == nil {
|
if err == nil {
|
||||||
if true || intv == int64(int(intv)) {
|
if true || intv == int64(int(intv)) {
|
||||||
return yaml_INT_TAG, int(intv)
|
return intTag, int(intv)
|
||||||
} else {
|
} else {
|
||||||
return yaml_INT_TAG, intv
|
return intTag, intv
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Octals as introduced in version 1.2 of the spec.
|
||||||
|
// Octals from the 1.1 spec, spelled as 0777, are still
|
||||||
|
// decoded by default in v3 as well for compatibility.
|
||||||
|
// May be dropped in v4 depending on how usage evolves.
|
||||||
|
if strings.HasPrefix(plain, "0o") {
|
||||||
|
intv, err := strconv.ParseInt(plain[2:], 8, 64)
|
||||||
|
if err == nil {
|
||||||
|
if intv == int64(int(intv)) {
|
||||||
|
return intTag, int(intv)
|
||||||
|
} else {
|
||||||
|
return intTag, intv
|
||||||
|
}
|
||||||
|
}
|
||||||
|
uintv, err := strconv.ParseUint(plain[2:], 8, 64)
|
||||||
|
if err == nil {
|
||||||
|
return intTag, uintv
|
||||||
|
}
|
||||||
|
} else if strings.HasPrefix(plain, "-0o") {
|
||||||
|
intv, err := strconv.ParseInt("-"+plain[3:], 8, 64)
|
||||||
|
if err == nil {
|
||||||
|
if true || intv == int64(int(intv)) {
|
||||||
|
return intTag, int(intv)
|
||||||
|
} else {
|
||||||
|
return intTag, intv
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
default:
|
default:
|
||||||
panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")")
|
panic("internal error: missing handler for resolver table: " + string(rune(hint)) + " (with " + in + ")")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return yaml_STR_TAG, in
|
return strTag, in
|
||||||
}
|
}
|
||||||
|
|
||||||
// encodeBase64 encodes s as base64 that is broken up into multiple lines
|
// encodeBase64 encodes s as base64 that is broken up into multiple lines
|
|
@ -1,3 +1,25 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -489,6 +511,9 @@ func cache(parser *yaml_parser_t, length int) bool {
|
||||||
|
|
||||||
// Advance the buffer pointer.
|
// Advance the buffer pointer.
|
||||||
func skip(parser *yaml_parser_t) {
|
func skip(parser *yaml_parser_t) {
|
||||||
|
if !is_blank(parser.buffer, parser.buffer_pos) {
|
||||||
|
parser.newlines = 0
|
||||||
|
}
|
||||||
parser.mark.index++
|
parser.mark.index++
|
||||||
parser.mark.column++
|
parser.mark.column++
|
||||||
parser.unread--
|
parser.unread--
|
||||||
|
@ -502,17 +527,22 @@ func skip_line(parser *yaml_parser_t) {
|
||||||
parser.mark.line++
|
parser.mark.line++
|
||||||
parser.unread -= 2
|
parser.unread -= 2
|
||||||
parser.buffer_pos += 2
|
parser.buffer_pos += 2
|
||||||
|
parser.newlines++
|
||||||
} else if is_break(parser.buffer, parser.buffer_pos) {
|
} else if is_break(parser.buffer, parser.buffer_pos) {
|
||||||
parser.mark.index++
|
parser.mark.index++
|
||||||
parser.mark.column = 0
|
parser.mark.column = 0
|
||||||
parser.mark.line++
|
parser.mark.line++
|
||||||
parser.unread--
|
parser.unread--
|
||||||
parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
|
parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
|
||||||
|
parser.newlines++
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Copy a character to a string buffer and advance pointers.
|
// Copy a character to a string buffer and advance pointers.
|
||||||
func read(parser *yaml_parser_t, s []byte) []byte {
|
func read(parser *yaml_parser_t, s []byte) []byte {
|
||||||
|
if !is_blank(parser.buffer, parser.buffer_pos) {
|
||||||
|
parser.newlines = 0
|
||||||
|
}
|
||||||
w := width(parser.buffer[parser.buffer_pos])
|
w := width(parser.buffer[parser.buffer_pos])
|
||||||
if w == 0 {
|
if w == 0 {
|
||||||
panic("invalid character sequence")
|
panic("invalid character sequence")
|
||||||
|
@ -564,6 +594,7 @@ func read_line(parser *yaml_parser_t, s []byte) []byte {
|
||||||
parser.mark.column = 0
|
parser.mark.column = 0
|
||||||
parser.mark.line++
|
parser.mark.line++
|
||||||
parser.unread--
|
parser.unread--
|
||||||
|
parser.newlines++
|
||||||
return s
|
return s
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -626,9 +657,13 @@ func trace(args ...interface{}) func() {
|
||||||
func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
|
func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
|
||||||
// While we need more tokens to fetch, do it.
|
// While we need more tokens to fetch, do it.
|
||||||
for {
|
for {
|
||||||
if parser.tokens_head != len(parser.tokens) {
|
// [Go] The comment parsing logic requires a lookahead of two tokens
|
||||||
// If queue is non-empty, check if any potential simple key may
|
// so that foot comments may be parsed in time of associating them
|
||||||
// occupy the head position.
|
// with the tokens that are parsed before them, and also for line
|
||||||
|
// comments to be transformed into head comments in some edge cases.
|
||||||
|
if parser.tokens_head < len(parser.tokens)-2 {
|
||||||
|
// If a potential simple key is at the head position, we need to fetch
|
||||||
|
// the next token to disambiguate it.
|
||||||
head_tok_idx, ok := parser.simple_keys_by_tok[parser.tokens_parsed]
|
head_tok_idx, ok := parser.simple_keys_by_tok[parser.tokens_parsed]
|
||||||
if !ok {
|
if !ok {
|
||||||
break
|
break
|
||||||
|
@ -649,7 +684,7 @@ func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
|
||||||
}
|
}
|
||||||
|
|
||||||
// The dispatcher for token fetchers.
|
// The dispatcher for token fetchers.
|
||||||
func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
|
func yaml_parser_fetch_next_token(parser *yaml_parser_t) (ok bool) {
|
||||||
// Ensure that the buffer is initialized.
|
// Ensure that the buffer is initialized.
|
||||||
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
||||||
return false
|
return false
|
||||||
|
@ -660,13 +695,19 @@ func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
|
||||||
return yaml_parser_fetch_stream_start(parser)
|
return yaml_parser_fetch_stream_start(parser)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
scan_mark := parser.mark
|
||||||
|
|
||||||
// Eat whitespaces and comments until we reach the next token.
|
// Eat whitespaces and comments until we reach the next token.
|
||||||
if !yaml_parser_scan_to_next_token(parser) {
|
if !yaml_parser_scan_to_next_token(parser) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// [Go] While unrolling indents, transform the head comments of prior
|
||||||
|
// indentation levels observed after scan_start into foot comments at
|
||||||
|
// the respective indexes.
|
||||||
|
|
||||||
// Check the indentation level against the current column.
|
// Check the indentation level against the current column.
|
||||||
if !yaml_parser_unroll_indent(parser, parser.mark.column) {
|
if !yaml_parser_unroll_indent(parser, parser.mark.column, scan_mark) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -699,6 +740,26 @@ func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
|
||||||
return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN)
|
return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
comment_mark := parser.mark
|
||||||
|
if len(parser.tokens) > 0 && (parser.flow_level == 0 && buf[pos] == ':' || parser.flow_level > 0 && buf[pos] == ',') {
|
||||||
|
// Associate any following comments with the prior token.
|
||||||
|
comment_mark = parser.tokens[len(parser.tokens)-1].start_mark
|
||||||
|
}
|
||||||
|
defer func() {
|
||||||
|
if !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if len(parser.tokens) > 0 && parser.tokens[len(parser.tokens)-1].typ == yaml_BLOCK_ENTRY_TOKEN {
|
||||||
|
// Sequence indicators alone have no line comments. It becomes
|
||||||
|
// a head comment for whatever follows.
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if !yaml_parser_scan_line_comment(parser, comment_mark) {
|
||||||
|
ok = false
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
|
||||||
// Is it the flow sequence start indicator?
|
// Is it the flow sequence start indicator?
|
||||||
if buf[pos] == '[' {
|
if buf[pos] == '[' {
|
||||||
return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN)
|
return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN)
|
||||||
|
@ -792,7 +853,7 @@ func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
|
||||||
// if it is followed by a non-space character.
|
// if it is followed by a non-space character.
|
||||||
//
|
//
|
||||||
// The last rule is more restrictive than the specification requires.
|
// The last rule is more restrictive than the specification requires.
|
||||||
// [Go] Make this logic more reasonable.
|
// [Go] TODO Make this logic more reasonable.
|
||||||
//switch parser.buffer[parser.buffer_pos] {
|
//switch parser.buffer[parser.buffer_pos] {
|
||||||
//case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`':
|
//case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`':
|
||||||
//}
|
//}
|
||||||
|
@ -965,19 +1026,49 @@ func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml
|
||||||
// Pop indentation levels from the indents stack until the current level
|
// Pop indentation levels from the indents stack until the current level
|
||||||
// becomes less or equal to the column. For each indentation level, append
|
// becomes less or equal to the column. For each indentation level, append
|
||||||
// the BLOCK-END token.
|
// the BLOCK-END token.
|
||||||
func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool {
|
func yaml_parser_unroll_indent(parser *yaml_parser_t, column int, scan_mark yaml_mark_t) bool {
|
||||||
// In the flow context, do nothing.
|
// In the flow context, do nothing.
|
||||||
if parser.flow_level > 0 {
|
if parser.flow_level > 0 {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
block_mark := scan_mark
|
||||||
|
block_mark.index--
|
||||||
|
|
||||||
// Loop through the indentation levels in the stack.
|
// Loop through the indentation levels in the stack.
|
||||||
for parser.indent > column {
|
for parser.indent > column {
|
||||||
|
|
||||||
|
// [Go] Reposition the end token before potential following
|
||||||
|
// foot comments of parent blocks. For that, search
|
||||||
|
// backwards for recent comments that were at the same
|
||||||
|
// indent as the block that is ending now.
|
||||||
|
stop_index := block_mark.index
|
||||||
|
for i := len(parser.comments) - 1; i >= 0; i-- {
|
||||||
|
comment := &parser.comments[i]
|
||||||
|
|
||||||
|
if comment.end_mark.index < stop_index {
|
||||||
|
// Don't go back beyond the start of the comment/whitespace scan, unless column < 0.
|
||||||
|
// If requested indent column is < 0, then the document is over and everything else
|
||||||
|
// is a foot anyway.
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if comment.start_mark.column == parser.indent+1 {
|
||||||
|
// This is a good match. But maybe there's a former comment
|
||||||
|
// at that same indent level, so keep searching.
|
||||||
|
block_mark = comment.start_mark
|
||||||
|
}
|
||||||
|
|
||||||
|
// While the end of the former comment matches with
|
||||||
|
// the start of the following one, we know there's
|
||||||
|
// nothing in between and scanning is still safe.
|
||||||
|
stop_index = comment.scan_mark.index
|
||||||
|
}
|
||||||
|
|
||||||
// Create a token and append it to the queue.
|
// Create a token and append it to the queue.
|
||||||
token := yaml_token_t{
|
token := yaml_token_t{
|
||||||
typ: yaml_BLOCK_END_TOKEN,
|
typ: yaml_BLOCK_END_TOKEN,
|
||||||
start_mark: parser.mark,
|
start_mark: block_mark,
|
||||||
end_mark: parser.mark,
|
end_mark: block_mark,
|
||||||
}
|
}
|
||||||
yaml_insert_token(parser, -1, &token)
|
yaml_insert_token(parser, -1, &token)
|
||||||
|
|
||||||
|
@ -1026,7 +1117,7 @@ func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool {
|
||||||
}
|
}
|
||||||
|
|
||||||
// Reset the indentation level.
|
// Reset the indentation level.
|
||||||
if !yaml_parser_unroll_indent(parser, -1) {
|
if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1050,7 +1141,7 @@ func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool {
|
||||||
// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
|
// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
|
||||||
func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {
|
func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {
|
||||||
// Reset the indentation level.
|
// Reset the indentation level.
|
||||||
if !yaml_parser_unroll_indent(parser, -1) {
|
if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1074,7 +1165,7 @@ func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {
|
||||||
// Produce the DOCUMENT-START or DOCUMENT-END token.
|
// Produce the DOCUMENT-START or DOCUMENT-END token.
|
||||||
func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool {
|
func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool {
|
||||||
// Reset the indentation level.
|
// Reset the indentation level.
|
||||||
if !yaml_parser_unroll_indent(parser, -1) {
|
if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1107,6 +1198,7 @@ func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_
|
||||||
|
|
||||||
// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
|
// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
|
||||||
func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool {
|
func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool {
|
||||||
|
|
||||||
// The indicators '[' and '{' may start a simple key.
|
// The indicators '[' and '{' may start a simple key.
|
||||||
if !yaml_parser_save_simple_key(parser) {
|
if !yaml_parser_save_simple_key(parser) {
|
||||||
return false
|
return false
|
||||||
|
@ -1442,6 +1534,8 @@ func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool {
|
||||||
// Eat whitespaces and comments until the next token is found.
|
// Eat whitespaces and comments until the next token is found.
|
||||||
func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
|
func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
|
||||||
|
|
||||||
|
scan_mark := parser.mark
|
||||||
|
|
||||||
// Until the next token is not found.
|
// Until the next token is not found.
|
||||||
for {
|
for {
|
||||||
// Allow the BOM mark to start a line.
|
// Allow the BOM mark to start a line.
|
||||||
|
@ -1468,13 +1562,33 @@ func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Check if we just had a line comment under a sequence entry that
|
||||||
|
// looks more like a header to the following content. Similar to this:
|
||||||
|
//
|
||||||
|
// - # The comment
|
||||||
|
// - Some data
|
||||||
|
//
|
||||||
|
// If so, transform the line comment to a head comment and reposition.
|
||||||
|
if len(parser.comments) > 0 && len(parser.tokens) > 1 {
|
||||||
|
tokenA := parser.tokens[len(parser.tokens)-2]
|
||||||
|
tokenB := parser.tokens[len(parser.tokens)-1]
|
||||||
|
comment := &parser.comments[len(parser.comments)-1]
|
||||||
|
if tokenA.typ == yaml_BLOCK_SEQUENCE_START_TOKEN && tokenB.typ == yaml_BLOCK_ENTRY_TOKEN && len(comment.line) > 0 && !is_break(parser.buffer, parser.buffer_pos) {
|
||||||
|
// If it was in the prior line, reposition so it becomes a
|
||||||
|
// header of the follow up token. Otherwise, keep it in place
|
||||||
|
// so it becomes a header of the former.
|
||||||
|
comment.head = comment.line
|
||||||
|
comment.line = nil
|
||||||
|
if comment.start_mark.line == parser.mark.line-1 {
|
||||||
|
comment.token_mark = parser.mark
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Eat a comment until a line break.
|
// Eat a comment until a line break.
|
||||||
if parser.buffer[parser.buffer_pos] == '#' {
|
if parser.buffer[parser.buffer_pos] == '#' {
|
||||||
for !is_breakz(parser.buffer, parser.buffer_pos) {
|
if !yaml_parser_scan_comments(parser, scan_mark) {
|
||||||
skip(parser)
|
return false
|
||||||
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1572,6 +1686,10 @@ func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool
|
||||||
}
|
}
|
||||||
|
|
||||||
if parser.buffer[parser.buffer_pos] == '#' {
|
if parser.buffer[parser.buffer_pos] == '#' {
|
||||||
|
// [Go] Discard this inline comment for the time being.
|
||||||
|
//if !yaml_parser_scan_line_comment(parser, start_mark) {
|
||||||
|
// return false
|
||||||
|
//}
|
||||||
for !is_breakz(parser.buffer, parser.buffer_pos) {
|
for !is_breakz(parser.buffer, parser.buffer_pos) {
|
||||||
skip(parser)
|
skip(parser)
|
||||||
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
||||||
|
@ -1987,7 +2105,7 @@ func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte
|
||||||
// '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
|
// '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
|
||||||
// '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
|
// '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
|
||||||
// '%'.
|
// '%'.
|
||||||
// [Go] Convert this into more reasonable logic.
|
// [Go] TODO Convert this into more reasonable logic.
|
||||||
for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||
|
for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||
|
||||||
parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||
|
parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||
|
||||||
parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||
|
parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||
|
||||||
|
@ -2142,6 +2260,9 @@ func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, l
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if parser.buffer[parser.buffer_pos] == '#' {
|
if parser.buffer[parser.buffer_pos] == '#' {
|
||||||
|
if !yaml_parser_scan_line_comment(parser, start_mark) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
for !is_breakz(parser.buffer, parser.buffer_pos) {
|
for !is_breakz(parser.buffer, parser.buffer_pos) {
|
||||||
skip(parser)
|
skip(parser)
|
||||||
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
||||||
|
@ -2709,3 +2830,209 @@ func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) b
|
||||||
}
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func yaml_parser_scan_line_comment(parser *yaml_parser_t, token_mark yaml_mark_t) bool {
|
||||||
|
if parser.newlines > 0 {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
var start_mark yaml_mark_t
|
||||||
|
var text []byte
|
||||||
|
|
||||||
|
for peek := 0; peek < 512; peek++ {
|
||||||
|
if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if is_blank(parser.buffer, parser.buffer_pos+peek) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if parser.buffer[parser.buffer_pos+peek] == '#' {
|
||||||
|
seen := parser.mark.index+peek
|
||||||
|
for {
|
||||||
|
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if is_breakz(parser.buffer, parser.buffer_pos) {
|
||||||
|
if parser.mark.index >= seen {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
skip_line(parser)
|
||||||
|
} else if parser.mark.index >= seen {
|
||||||
|
if len(text) == 0 {
|
||||||
|
start_mark = parser.mark
|
||||||
|
}
|
||||||
|
text = read(parser, text)
|
||||||
|
} else {
|
||||||
|
skip(parser)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if len(text) > 0 {
|
||||||
|
parser.comments = append(parser.comments, yaml_comment_t{
|
||||||
|
token_mark: token_mark,
|
||||||
|
start_mark: start_mark,
|
||||||
|
line: text,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func yaml_parser_scan_comments(parser *yaml_parser_t, scan_mark yaml_mark_t) bool {
|
||||||
|
token := parser.tokens[len(parser.tokens)-1]
|
||||||
|
|
||||||
|
if token.typ == yaml_FLOW_ENTRY_TOKEN && len(parser.tokens) > 1 {
|
||||||
|
token = parser.tokens[len(parser.tokens)-2]
|
||||||
|
}
|
||||||
|
|
||||||
|
var token_mark = token.start_mark
|
||||||
|
var start_mark yaml_mark_t
|
||||||
|
var next_indent = parser.indent
|
||||||
|
if next_indent < 0 {
|
||||||
|
next_indent = 0
|
||||||
|
}
|
||||||
|
|
||||||
|
var recent_empty = false
|
||||||
|
var first_empty = parser.newlines <= 1
|
||||||
|
|
||||||
|
var line = parser.mark.line
|
||||||
|
var column = parser.mark.column
|
||||||
|
|
||||||
|
var text []byte
|
||||||
|
|
||||||
|
// The foot line is the place where a comment must start to
|
||||||
|
// still be considered as a foot of the prior content.
|
||||||
|
// If there's some content in the currently parsed line, then
|
||||||
|
// the foot is the line below it.
|
||||||
|
var foot_line = -1
|
||||||
|
if scan_mark.line > 0 {
|
||||||
|
foot_line = parser.mark.line-parser.newlines+1
|
||||||
|
if parser.newlines == 0 && parser.mark.column > 1 {
|
||||||
|
foot_line++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var peek = 0
|
||||||
|
for ; peek < 512; peek++ {
|
||||||
|
if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
column++
|
||||||
|
if is_blank(parser.buffer, parser.buffer_pos+peek) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
c := parser.buffer[parser.buffer_pos+peek]
|
||||||
|
var close_flow = parser.flow_level > 0 && (c == ']' || c == '}')
|
||||||
|
if close_flow || is_breakz(parser.buffer, parser.buffer_pos+peek) {
|
||||||
|
// Got line break or terminator.
|
||||||
|
if close_flow || !recent_empty {
|
||||||
|
if close_flow || first_empty && (start_mark.line == foot_line && token.typ != yaml_VALUE_TOKEN || start_mark.column-1 < next_indent) {
|
||||||
|
// This is the first empty line and there were no empty lines before,
|
||||||
|
// so this initial part of the comment is a foot of the prior token
|
||||||
|
// instead of being a head for the following one. Split it up.
|
||||||
|
// Alternatively, this might also be the last comment inside a flow
|
||||||
|
// scope, so it must be a footer.
|
||||||
|
if len(text) > 0 {
|
||||||
|
if start_mark.column-1 < next_indent {
|
||||||
|
// If dedented it's unrelated to the prior token.
|
||||||
|
token_mark = start_mark
|
||||||
|
}
|
||||||
|
parser.comments = append(parser.comments, yaml_comment_t{
|
||||||
|
scan_mark: scan_mark,
|
||||||
|
token_mark: token_mark,
|
||||||
|
start_mark: start_mark,
|
||||||
|
end_mark: yaml_mark_t{parser.mark.index + peek, line, column},
|
||||||
|
foot: text,
|
||||||
|
})
|
||||||
|
scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}
|
||||||
|
token_mark = scan_mark
|
||||||
|
text = nil
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if len(text) > 0 && parser.buffer[parser.buffer_pos+peek] != 0 {
|
||||||
|
text = append(text, '\n')
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !is_break(parser.buffer, parser.buffer_pos+peek) {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
first_empty = false
|
||||||
|
recent_empty = true
|
||||||
|
column = 0
|
||||||
|
line++
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(text) > 0 && (close_flow || column-1 < next_indent && column != start_mark.column) {
|
||||||
|
// The comment at the different indentation is a foot of the
|
||||||
|
// preceding data rather than a head of the upcoming one.
|
||||||
|
parser.comments = append(parser.comments, yaml_comment_t{
|
||||||
|
scan_mark: scan_mark,
|
||||||
|
token_mark: token_mark,
|
||||||
|
start_mark: start_mark,
|
||||||
|
end_mark: yaml_mark_t{parser.mark.index + peek, line, column},
|
||||||
|
foot: text,
|
||||||
|
})
|
||||||
|
scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}
|
||||||
|
token_mark = scan_mark
|
||||||
|
text = nil
|
||||||
|
}
|
||||||
|
|
||||||
|
if parser.buffer[parser.buffer_pos+peek] != '#' {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(text) == 0 {
|
||||||
|
start_mark = yaml_mark_t{parser.mark.index + peek, line, column}
|
||||||
|
} else {
|
||||||
|
text = append(text, '\n')
|
||||||
|
}
|
||||||
|
|
||||||
|
recent_empty = false
|
||||||
|
|
||||||
|
// Consume until after the consumed comment line.
|
||||||
|
seen := parser.mark.index+peek
|
||||||
|
for {
|
||||||
|
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if is_breakz(parser.buffer, parser.buffer_pos) {
|
||||||
|
if parser.mark.index >= seen {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
skip_line(parser)
|
||||||
|
} else if parser.mark.index >= seen {
|
||||||
|
text = read(parser, text)
|
||||||
|
} else {
|
||||||
|
skip(parser)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
peek = 0
|
||||||
|
column = 0
|
||||||
|
line = parser.mark.line
|
||||||
|
next_indent = parser.indent
|
||||||
|
if next_indent < 0 {
|
||||||
|
next_indent = 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(text) > 0 {
|
||||||
|
parser.comments = append(parser.comments, yaml_comment_t{
|
||||||
|
scan_mark: scan_mark,
|
||||||
|
token_mark: start_mark,
|
||||||
|
start_mark: start_mark,
|
||||||
|
end_mark: yaml_mark_t{parser.mark.index + peek - 1, line, column},
|
||||||
|
head: text,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
|
@ -1,3 +1,18 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -37,8 +52,10 @@ func (l keyList) Less(i, j int) bool {
|
||||||
return ak < bk
|
return ak < bk
|
||||||
}
|
}
|
||||||
ar, br := []rune(a.String()), []rune(b.String())
|
ar, br := []rune(a.String()), []rune(b.String())
|
||||||
|
digits := false
|
||||||
for i := 0; i < len(ar) && i < len(br); i++ {
|
for i := 0; i < len(ar) && i < len(br); i++ {
|
||||||
if ar[i] == br[i] {
|
if ar[i] == br[i] {
|
||||||
|
digits = unicode.IsDigit(ar[i])
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
al := unicode.IsLetter(ar[i])
|
al := unicode.IsLetter(ar[i])
|
||||||
|
@ -47,12 +64,16 @@ func (l keyList) Less(i, j int) bool {
|
||||||
return ar[i] < br[i]
|
return ar[i] < br[i]
|
||||||
}
|
}
|
||||||
if al || bl {
|
if al || bl {
|
||||||
return bl
|
if digits {
|
||||||
|
return al
|
||||||
|
} else {
|
||||||
|
return bl
|
||||||
|
}
|
||||||
}
|
}
|
||||||
var ai, bi int
|
var ai, bi int
|
||||||
var an, bn int64
|
var an, bn int64
|
||||||
if ar[i] == '0' || br[i] == '0' {
|
if ar[i] == '0' || br[i] == '0' {
|
||||||
for j := i-1; j >= 0 && unicode.IsDigit(ar[j]); j-- {
|
for j := i - 1; j >= 0 && unicode.IsDigit(ar[j]); j-- {
|
||||||
if ar[j] != '0' {
|
if ar[j] != '0' {
|
||||||
an = 1
|
an = 1
|
||||||
bn = 1
|
bn = 1
|
|
@ -0,0 +1,48 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
|
package yaml
|
||||||
|
|
||||||
|
// Set the writer error and return false.
|
||||||
|
func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
|
||||||
|
emitter.error = yaml_WRITER_ERROR
|
||||||
|
emitter.problem = problem
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// Flush the output buffer.
|
||||||
|
func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
|
||||||
|
if emitter.write_handler == nil {
|
||||||
|
panic("write handler not set")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if the buffer is empty.
|
||||||
|
if emitter.buffer_pos == 0 {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
|
||||||
|
return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
|
||||||
|
}
|
||||||
|
emitter.buffer_pos = 0
|
||||||
|
return true
|
||||||
|
}
|
|
@ -1,3 +1,18 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
// Package yaml implements YAML support for the Go language.
|
// Package yaml implements YAML support for the Go language.
|
||||||
//
|
//
|
||||||
// Source code and other details for the project are available at GitHub:
|
// Source code and other details for the project are available at GitHub:
|
||||||
|
@ -13,23 +28,16 @@ import (
|
||||||
"reflect"
|
"reflect"
|
||||||
"strings"
|
"strings"
|
||||||
"sync"
|
"sync"
|
||||||
|
"unicode/utf8"
|
||||||
)
|
)
|
||||||
|
|
||||||
// MapSlice encodes and decodes as a YAML map.
|
// The Unmarshaler interface may be implemented by types to customize their
|
||||||
// The order of keys is preserved when encoding and decoding.
|
// behavior when being unmarshaled from a YAML document.
|
||||||
type MapSlice []MapItem
|
type Unmarshaler interface {
|
||||||
|
UnmarshalYAML(value *Node) error
|
||||||
// MapItem is an item in a MapSlice.
|
|
||||||
type MapItem struct {
|
|
||||||
Key, Value interface{}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// The Unmarshaler interface may be implemented by types to customize their
|
type obsoleteUnmarshaler interface {
|
||||||
// behavior when being unmarshaled from a YAML document. The UnmarshalYAML
|
|
||||||
// method receives a function that may be called to unmarshal the original
|
|
||||||
// YAML value into a field or variable. It is safe to call the unmarshal
|
|
||||||
// function parameter more than once if necessary.
|
|
||||||
type Unmarshaler interface {
|
|
||||||
UnmarshalYAML(unmarshal func(interface{}) error) error
|
UnmarshalYAML(unmarshal func(interface{}) error) error
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -81,18 +89,10 @@ func Unmarshal(in []byte, out interface{}) (err error) {
|
||||||
return unmarshal(in, out, false)
|
return unmarshal(in, out, false)
|
||||||
}
|
}
|
||||||
|
|
||||||
// UnmarshalStrict is like Unmarshal except that any fields that are found
|
|
||||||
// in the data that do not have corresponding struct members, or mapping
|
|
||||||
// keys that are duplicates, will result in
|
|
||||||
// an error.
|
|
||||||
func UnmarshalStrict(in []byte, out interface{}) (err error) {
|
|
||||||
return unmarshal(in, out, true)
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Decoder reads and decodes YAML values from an input stream.
|
// A Decoder reads and decodes YAML values from an input stream.
|
||||||
type Decoder struct {
|
type Decoder struct {
|
||||||
strict bool
|
parser *parser
|
||||||
parser *parser
|
knownFields bool
|
||||||
}
|
}
|
||||||
|
|
||||||
// NewDecoder returns a new decoder that reads from r.
|
// NewDecoder returns a new decoder that reads from r.
|
||||||
|
@ -105,10 +105,10 @@ func NewDecoder(r io.Reader) *Decoder {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// SetStrict sets whether strict decoding behaviour is enabled when
|
// KnownFields ensures that the keys in decoded mappings to
|
||||||
// decoding items in the data (see UnmarshalStrict). By default, decoding is not strict.
|
// exist as fields in the struct being decoded into.
|
||||||
func (dec *Decoder) SetStrict(strict bool) {
|
func (dec *Decoder) KnownFields(enable bool) {
|
||||||
dec.strict = strict
|
dec.knownFields = enable
|
||||||
}
|
}
|
||||||
|
|
||||||
// Decode reads the next YAML-encoded value from its input
|
// Decode reads the next YAML-encoded value from its input
|
||||||
|
@ -117,7 +117,8 @@ func (dec *Decoder) SetStrict(strict bool) {
|
||||||
// See the documentation for Unmarshal for details about the
|
// See the documentation for Unmarshal for details about the
|
||||||
// conversion of YAML into a Go value.
|
// conversion of YAML into a Go value.
|
||||||
func (dec *Decoder) Decode(v interface{}) (err error) {
|
func (dec *Decoder) Decode(v interface{}) (err error) {
|
||||||
d := newDecoder(dec.strict)
|
d := newDecoder()
|
||||||
|
d.knownFields = dec.knownFields
|
||||||
defer handleErr(&err)
|
defer handleErr(&err)
|
||||||
node := dec.parser.parse()
|
node := dec.parser.parse()
|
||||||
if node == nil {
|
if node == nil {
|
||||||
|
@ -134,9 +135,27 @@ func (dec *Decoder) Decode(v interface{}) (err error) {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Decode decodes the node and stores its data into the value pointed to by v.
|
||||||
|
//
|
||||||
|
// See the documentation for Unmarshal for details about the
|
||||||
|
// conversion of YAML into a Go value.
|
||||||
|
func (n *Node) Decode(v interface{}) (err error) {
|
||||||
|
d := newDecoder()
|
||||||
|
defer handleErr(&err)
|
||||||
|
out := reflect.ValueOf(v)
|
||||||
|
if out.Kind() == reflect.Ptr && !out.IsNil() {
|
||||||
|
out = out.Elem()
|
||||||
|
}
|
||||||
|
d.unmarshal(n, out)
|
||||||
|
if len(d.terrors) > 0 {
|
||||||
|
return &TypeError{d.terrors}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
func unmarshal(in []byte, out interface{}, strict bool) (err error) {
|
func unmarshal(in []byte, out interface{}, strict bool) (err error) {
|
||||||
defer handleErr(&err)
|
defer handleErr(&err)
|
||||||
d := newDecoder(strict)
|
d := newDecoder()
|
||||||
p := newParser(in)
|
p := newParser(in)
|
||||||
defer p.destroy()
|
defer p.destroy()
|
||||||
node := p.parse()
|
node := p.parse()
|
||||||
|
@ -233,6 +252,32 @@ func (e *Encoder) Encode(v interface{}) (err error) {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Encode encodes value v and stores its representation in n.
|
||||||
|
//
|
||||||
|
// See the documentation for Marshal for details about the
|
||||||
|
// conversion of Go values into YAML.
|
||||||
|
func (n *Node) Encode(v interface{}) (err error) {
|
||||||
|
defer handleErr(&err)
|
||||||
|
e := newEncoder()
|
||||||
|
defer e.destroy()
|
||||||
|
e.marshalDoc("", reflect.ValueOf(v))
|
||||||
|
e.finish()
|
||||||
|
p := newParser(e.out)
|
||||||
|
p.textless = true
|
||||||
|
defer p.destroy()
|
||||||
|
doc := p.parse()
|
||||||
|
*n = *doc.Content[0]
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetIndent changes the used indentation used when encoding.
|
||||||
|
func (e *Encoder) SetIndent(spaces int) {
|
||||||
|
if spaces < 0 {
|
||||||
|
panic("yaml: cannot indent to a negative number of spaces")
|
||||||
|
}
|
||||||
|
e.encoder.indent = spaces
|
||||||
|
}
|
||||||
|
|
||||||
// Close closes the encoder by writing any remaining data.
|
// Close closes the encoder by writing any remaining data.
|
||||||
// It does not write a stream terminating string "...".
|
// It does not write a stream terminating string "...".
|
||||||
func (e *Encoder) Close() (err error) {
|
func (e *Encoder) Close() (err error) {
|
||||||
|
@ -275,6 +320,168 @@ func (e *TypeError) Error() string {
|
||||||
return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n "))
|
return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n "))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
type Kind uint32
|
||||||
|
|
||||||
|
const (
|
||||||
|
DocumentNode Kind = 1 << iota
|
||||||
|
SequenceNode
|
||||||
|
MappingNode
|
||||||
|
ScalarNode
|
||||||
|
AliasNode
|
||||||
|
)
|
||||||
|
|
||||||
|
type Style uint32
|
||||||
|
|
||||||
|
const (
|
||||||
|
TaggedStyle Style = 1 << iota
|
||||||
|
DoubleQuotedStyle
|
||||||
|
SingleQuotedStyle
|
||||||
|
LiteralStyle
|
||||||
|
FoldedStyle
|
||||||
|
FlowStyle
|
||||||
|
)
|
||||||
|
|
||||||
|
// Node represents an element in the YAML document hierarchy. While documents
|
||||||
|
// are typically encoded and decoded into higher level types, such as structs
|
||||||
|
// and maps, Node is an intermediate representation that allows detailed
|
||||||
|
// control over the content being decoded or encoded.
|
||||||
|
//
|
||||||
|
// It's worth noting that although Node offers access into details such as
|
||||||
|
// line numbers, colums, and comments, the content when re-encoded will not
|
||||||
|
// have its original textual representation preserved. An effort is made to
|
||||||
|
// render the data plesantly, and to preserve comments near the data they
|
||||||
|
// describe, though.
|
||||||
|
//
|
||||||
|
// Values that make use of the Node type interact with the yaml package in the
|
||||||
|
// same way any other type would do, by encoding and decoding yaml data
|
||||||
|
// directly or indirectly into them.
|
||||||
|
//
|
||||||
|
// For example:
|
||||||
|
//
|
||||||
|
// var person struct {
|
||||||
|
// Name string
|
||||||
|
// Address yaml.Node
|
||||||
|
// }
|
||||||
|
// err := yaml.Unmarshal(data, &person)
|
||||||
|
//
|
||||||
|
// Or by itself:
|
||||||
|
//
|
||||||
|
// var person Node
|
||||||
|
// err := yaml.Unmarshal(data, &person)
|
||||||
|
//
|
||||||
|
type Node struct {
|
||||||
|
// Kind defines whether the node is a document, a mapping, a sequence,
|
||||||
|
// a scalar value, or an alias to another node. The specific data type of
|
||||||
|
// scalar nodes may be obtained via the ShortTag and LongTag methods.
|
||||||
|
Kind Kind
|
||||||
|
|
||||||
|
// Style allows customizing the apperance of the node in the tree.
|
||||||
|
Style Style
|
||||||
|
|
||||||
|
// Tag holds the YAML tag defining the data type for the value.
|
||||||
|
// When decoding, this field will always be set to the resolved tag,
|
||||||
|
// even when it wasn't explicitly provided in the YAML content.
|
||||||
|
// When encoding, if this field is unset the value type will be
|
||||||
|
// implied from the node properties, and if it is set, it will only
|
||||||
|
// be serialized into the representation if TaggedStyle is used or
|
||||||
|
// the implicit tag diverges from the provided one.
|
||||||
|
Tag string
|
||||||
|
|
||||||
|
// Value holds the unescaped and unquoted represenation of the value.
|
||||||
|
Value string
|
||||||
|
|
||||||
|
// Anchor holds the anchor name for this node, which allows aliases to point to it.
|
||||||
|
Anchor string
|
||||||
|
|
||||||
|
// Alias holds the node that this alias points to. Only valid when Kind is AliasNode.
|
||||||
|
Alias *Node
|
||||||
|
|
||||||
|
// Content holds contained nodes for documents, mappings, and sequences.
|
||||||
|
Content []*Node
|
||||||
|
|
||||||
|
// HeadComment holds any comments in the lines preceding the node and
|
||||||
|
// not separated by an empty line.
|
||||||
|
HeadComment string
|
||||||
|
|
||||||
|
// LineComment holds any comments at the end of the line where the node is in.
|
||||||
|
LineComment string
|
||||||
|
|
||||||
|
// FootComment holds any comments following the node and before empty lines.
|
||||||
|
FootComment string
|
||||||
|
|
||||||
|
// Line and Column hold the node position in the decoded YAML text.
|
||||||
|
// These fields are not respected when encoding the node.
|
||||||
|
Line int
|
||||||
|
Column int
|
||||||
|
}
|
||||||
|
|
||||||
|
// IsZero returns whether the node has all of its fields unset.
|
||||||
|
func (n *Node) IsZero() bool {
|
||||||
|
return n.Kind == 0 && n.Style == 0 && n.Tag == "" && n.Value == "" && n.Anchor == "" && n.Alias == nil && n.Content == nil &&
|
||||||
|
n.HeadComment == "" && n.LineComment == "" && n.FootComment == "" && n.Line == 0 && n.Column == 0
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// LongTag returns the long form of the tag that indicates the data type for
|
||||||
|
// the node. If the Tag field isn't explicitly defined, one will be computed
|
||||||
|
// based on the node properties.
|
||||||
|
func (n *Node) LongTag() string {
|
||||||
|
return longTag(n.ShortTag())
|
||||||
|
}
|
||||||
|
|
||||||
|
// ShortTag returns the short form of the YAML tag that indicates data type for
|
||||||
|
// the node. If the Tag field isn't explicitly defined, one will be computed
|
||||||
|
// based on the node properties.
|
||||||
|
func (n *Node) ShortTag() string {
|
||||||
|
if n.indicatedString() {
|
||||||
|
return strTag
|
||||||
|
}
|
||||||
|
if n.Tag == "" || n.Tag == "!" {
|
||||||
|
switch n.Kind {
|
||||||
|
case MappingNode:
|
||||||
|
return mapTag
|
||||||
|
case SequenceNode:
|
||||||
|
return seqTag
|
||||||
|
case AliasNode:
|
||||||
|
if n.Alias != nil {
|
||||||
|
return n.Alias.ShortTag()
|
||||||
|
}
|
||||||
|
case ScalarNode:
|
||||||
|
tag, _ := resolve("", n.Value)
|
||||||
|
return tag
|
||||||
|
case 0:
|
||||||
|
// Special case to make the zero value convenient.
|
||||||
|
if n.IsZero() {
|
||||||
|
return nullTag
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return ""
|
||||||
|
}
|
||||||
|
return shortTag(n.Tag)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (n *Node) indicatedString() bool {
|
||||||
|
return n.Kind == ScalarNode &&
|
||||||
|
(shortTag(n.Tag) == strTag ||
|
||||||
|
(n.Tag == "" || n.Tag == "!") && n.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetString is a convenience function that sets the node to a string value
|
||||||
|
// and defines its style in a pleasant way depending on its content.
|
||||||
|
func (n *Node) SetString(s string) {
|
||||||
|
n.Kind = ScalarNode
|
||||||
|
if utf8.ValidString(s) {
|
||||||
|
n.Value = s
|
||||||
|
n.Tag = strTag
|
||||||
|
} else {
|
||||||
|
n.Value = encodeBase64(s)
|
||||||
|
n.Tag = binaryTag
|
||||||
|
}
|
||||||
|
if strings.Contains(n.Value, "\n") {
|
||||||
|
n.Style = LiteralStyle
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// --------------------------------------------------------------------------
|
// --------------------------------------------------------------------------
|
||||||
// Maintain a mapping of keys to structure field indexes
|
// Maintain a mapping of keys to structure field indexes
|
||||||
|
|
||||||
|
@ -289,6 +496,10 @@ type structInfo struct {
|
||||||
// InlineMap is the number of the field in the struct that
|
// InlineMap is the number of the field in the struct that
|
||||||
// contains an ,inline map, or -1 if there's none.
|
// contains an ,inline map, or -1 if there's none.
|
||||||
InlineMap int
|
InlineMap int
|
||||||
|
|
||||||
|
// InlineUnmarshalers holds indexes to inlined fields that
|
||||||
|
// contain unmarshaler values.
|
||||||
|
InlineUnmarshalers [][]int
|
||||||
}
|
}
|
||||||
|
|
||||||
type fieldInfo struct {
|
type fieldInfo struct {
|
||||||
|
@ -306,6 +517,12 @@ type fieldInfo struct {
|
||||||
|
|
||||||
var structMap = make(map[reflect.Type]*structInfo)
|
var structMap = make(map[reflect.Type]*structInfo)
|
||||||
var fieldMapMutex sync.RWMutex
|
var fieldMapMutex sync.RWMutex
|
||||||
|
var unmarshalerType reflect.Type
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
var v Unmarshaler
|
||||||
|
unmarshalerType = reflect.ValueOf(&v).Elem().Type()
|
||||||
|
}
|
||||||
|
|
||||||
func getStructInfo(st reflect.Type) (*structInfo, error) {
|
func getStructInfo(st reflect.Type) (*structInfo, error) {
|
||||||
fieldMapMutex.RLock()
|
fieldMapMutex.RLock()
|
||||||
|
@ -319,6 +536,7 @@ func getStructInfo(st reflect.Type) (*structInfo, error) {
|
||||||
fieldsMap := make(map[string]fieldInfo)
|
fieldsMap := make(map[string]fieldInfo)
|
||||||
fieldsList := make([]fieldInfo, 0, n)
|
fieldsList := make([]fieldInfo, 0, n)
|
||||||
inlineMap := -1
|
inlineMap := -1
|
||||||
|
inlineUnmarshalers := [][]int(nil)
|
||||||
for i := 0; i != n; i++ {
|
for i := 0; i != n; i++ {
|
||||||
field := st.Field(i)
|
field := st.Field(i)
|
||||||
if field.PkgPath != "" && !field.Anonymous {
|
if field.PkgPath != "" && !field.Anonymous {
|
||||||
|
@ -347,7 +565,7 @@ func getStructInfo(st reflect.Type) (*structInfo, error) {
|
||||||
case "inline":
|
case "inline":
|
||||||
inline = true
|
inline = true
|
||||||
default:
|
default:
|
||||||
return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st))
|
return nil, errors.New(fmt.Sprintf("unsupported flag %q in tag %q of type %s", flag, tag, st))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
tag = fields[0]
|
tag = fields[0]
|
||||||
|
@ -357,34 +575,47 @@ func getStructInfo(st reflect.Type) (*structInfo, error) {
|
||||||
switch field.Type.Kind() {
|
switch field.Type.Kind() {
|
||||||
case reflect.Map:
|
case reflect.Map:
|
||||||
if inlineMap >= 0 {
|
if inlineMap >= 0 {
|
||||||
return nil, errors.New("Multiple ,inline maps in struct " + st.String())
|
return nil, errors.New("multiple ,inline maps in struct " + st.String())
|
||||||
}
|
}
|
||||||
if field.Type.Key() != reflect.TypeOf("") {
|
if field.Type.Key() != reflect.TypeOf("") {
|
||||||
return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
|
return nil, errors.New("option ,inline needs a map with string keys in struct " + st.String())
|
||||||
}
|
}
|
||||||
inlineMap = info.Num
|
inlineMap = info.Num
|
||||||
case reflect.Struct:
|
case reflect.Struct, reflect.Ptr:
|
||||||
sinfo, err := getStructInfo(field.Type)
|
ftype := field.Type
|
||||||
if err != nil {
|
for ftype.Kind() == reflect.Ptr {
|
||||||
return nil, err
|
ftype = ftype.Elem()
|
||||||
}
|
}
|
||||||
for _, finfo := range sinfo.FieldsList {
|
if ftype.Kind() != reflect.Struct {
|
||||||
if _, found := fieldsMap[finfo.Key]; found {
|
return nil, errors.New("option ,inline may only be used on a struct or map field")
|
||||||
msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String()
|
}
|
||||||
return nil, errors.New(msg)
|
if reflect.PtrTo(ftype).Implements(unmarshalerType) {
|
||||||
|
inlineUnmarshalers = append(inlineUnmarshalers, []int{i})
|
||||||
|
} else {
|
||||||
|
sinfo, err := getStructInfo(ftype)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
}
|
}
|
||||||
if finfo.Inline == nil {
|
for _, index := range sinfo.InlineUnmarshalers {
|
||||||
finfo.Inline = []int{i, finfo.Num}
|
inlineUnmarshalers = append(inlineUnmarshalers, append([]int{i}, index...))
|
||||||
} else {
|
}
|
||||||
finfo.Inline = append([]int{i}, finfo.Inline...)
|
for _, finfo := range sinfo.FieldsList {
|
||||||
|
if _, found := fieldsMap[finfo.Key]; found {
|
||||||
|
msg := "duplicated key '" + finfo.Key + "' in struct " + st.String()
|
||||||
|
return nil, errors.New(msg)
|
||||||
|
}
|
||||||
|
if finfo.Inline == nil {
|
||||||
|
finfo.Inline = []int{i, finfo.Num}
|
||||||
|
} else {
|
||||||
|
finfo.Inline = append([]int{i}, finfo.Inline...)
|
||||||
|
}
|
||||||
|
finfo.Id = len(fieldsList)
|
||||||
|
fieldsMap[finfo.Key] = finfo
|
||||||
|
fieldsList = append(fieldsList, finfo)
|
||||||
}
|
}
|
||||||
finfo.Id = len(fieldsList)
|
|
||||||
fieldsMap[finfo.Key] = finfo
|
|
||||||
fieldsList = append(fieldsList, finfo)
|
|
||||||
}
|
}
|
||||||
default:
|
default:
|
||||||
//return nil, errors.New("Option ,inline needs a struct value or map field")
|
return nil, errors.New("option ,inline may only be used on a struct or map field")
|
||||||
return nil, errors.New("Option ,inline needs a struct value field")
|
|
||||||
}
|
}
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
|
@ -396,7 +627,7 @@ func getStructInfo(st reflect.Type) (*structInfo, error) {
|
||||||
}
|
}
|
||||||
|
|
||||||
if _, found = fieldsMap[info.Key]; found {
|
if _, found = fieldsMap[info.Key]; found {
|
||||||
msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
|
msg := "duplicated key '" + info.Key + "' in struct " + st.String()
|
||||||
return nil, errors.New(msg)
|
return nil, errors.New(msg)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -406,9 +637,10 @@ func getStructInfo(st reflect.Type) (*structInfo, error) {
|
||||||
}
|
}
|
||||||
|
|
||||||
sinfo = &structInfo{
|
sinfo = &structInfo{
|
||||||
FieldsMap: fieldsMap,
|
FieldsMap: fieldsMap,
|
||||||
FieldsList: fieldsList,
|
FieldsList: fieldsList,
|
||||||
InlineMap: inlineMap,
|
InlineMap: inlineMap,
|
||||||
|
InlineUnmarshalers: inlineUnmarshalers,
|
||||||
}
|
}
|
||||||
|
|
||||||
fieldMapMutex.Lock()
|
fieldMapMutex.Lock()
|
||||||
|
@ -464,15 +696,3 @@ func isZero(v reflect.Value) bool {
|
||||||
}
|
}
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
// FutureLineWrap globally disables line wrapping when encoding long strings.
|
|
||||||
// This is a temporary and thus deprecated method introduced to faciliate
|
|
||||||
// migration towards v3, which offers more control of line lengths on
|
|
||||||
// individual encodings, and has a default matching the behavior introduced
|
|
||||||
// by this function.
|
|
||||||
//
|
|
||||||
// The default formatting of v2 was erroneously changed in v2.3.0 and reverted
|
|
||||||
// in v2.4.0, at which point this function was introduced to help migration.
|
|
||||||
func FutureLineWrap() {
|
|
||||||
disableLineWrapping = true
|
|
||||||
}
|
|
|
@ -1,3 +1,25 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
@ -73,13 +95,13 @@ type yaml_scalar_style_t yaml_style_t
|
||||||
// Scalar styles.
|
// Scalar styles.
|
||||||
const (
|
const (
|
||||||
// Let the emitter choose the style.
|
// Let the emitter choose the style.
|
||||||
yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota
|
yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = 0
|
||||||
|
|
||||||
yaml_PLAIN_SCALAR_STYLE // The plain scalar style.
|
yaml_PLAIN_SCALAR_STYLE yaml_scalar_style_t = 1 << iota // The plain scalar style.
|
||||||
yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style.
|
yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style.
|
||||||
yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style.
|
yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style.
|
||||||
yaml_LITERAL_SCALAR_STYLE // The literal scalar style.
|
yaml_LITERAL_SCALAR_STYLE // The literal scalar style.
|
||||||
yaml_FOLDED_SCALAR_STYLE // The folded scalar style.
|
yaml_FOLDED_SCALAR_STYLE // The folded scalar style.
|
||||||
)
|
)
|
||||||
|
|
||||||
type yaml_sequence_style_t yaml_style_t
|
type yaml_sequence_style_t yaml_style_t
|
||||||
|
@ -238,6 +260,7 @@ const (
|
||||||
yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event.
|
yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event.
|
||||||
yaml_MAPPING_START_EVENT // A MAPPING-START event.
|
yaml_MAPPING_START_EVENT // A MAPPING-START event.
|
||||||
yaml_MAPPING_END_EVENT // A MAPPING-END event.
|
yaml_MAPPING_END_EVENT // A MAPPING-END event.
|
||||||
|
yaml_TAIL_COMMENT_EVENT
|
||||||
)
|
)
|
||||||
|
|
||||||
var eventStrings = []string{
|
var eventStrings = []string{
|
||||||
|
@ -252,6 +275,7 @@ var eventStrings = []string{
|
||||||
yaml_SEQUENCE_END_EVENT: "sequence end",
|
yaml_SEQUENCE_END_EVENT: "sequence end",
|
||||||
yaml_MAPPING_START_EVENT: "mapping start",
|
yaml_MAPPING_START_EVENT: "mapping start",
|
||||||
yaml_MAPPING_END_EVENT: "mapping end",
|
yaml_MAPPING_END_EVENT: "mapping end",
|
||||||
|
yaml_TAIL_COMMENT_EVENT: "tail comment",
|
||||||
}
|
}
|
||||||
|
|
||||||
func (e yaml_event_type_t) String() string {
|
func (e yaml_event_type_t) String() string {
|
||||||
|
@ -279,6 +303,12 @@ type yaml_event_t struct {
|
||||||
// The list of tag directives (for yaml_DOCUMENT_START_EVENT).
|
// The list of tag directives (for yaml_DOCUMENT_START_EVENT).
|
||||||
tag_directives []yaml_tag_directive_t
|
tag_directives []yaml_tag_directive_t
|
||||||
|
|
||||||
|
// The comments
|
||||||
|
head_comment []byte
|
||||||
|
line_comment []byte
|
||||||
|
foot_comment []byte
|
||||||
|
tail_comment []byte
|
||||||
|
|
||||||
// The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT).
|
// The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT).
|
||||||
anchor []byte
|
anchor []byte
|
||||||
|
|
||||||
|
@ -554,6 +584,8 @@ type yaml_parser_t struct {
|
||||||
|
|
||||||
unread int // The number of unread characters in the buffer.
|
unread int // The number of unread characters in the buffer.
|
||||||
|
|
||||||
|
newlines int // The number of line breaks since last non-break/non-blank character
|
||||||
|
|
||||||
raw_buffer []byte // The raw buffer.
|
raw_buffer []byte // The raw buffer.
|
||||||
raw_buffer_pos int // The current position of the buffer.
|
raw_buffer_pos int // The current position of the buffer.
|
||||||
|
|
||||||
|
@ -562,6 +594,17 @@ type yaml_parser_t struct {
|
||||||
offset int // The offset of the current position (in bytes).
|
offset int // The offset of the current position (in bytes).
|
||||||
mark yaml_mark_t // The mark of the current position.
|
mark yaml_mark_t // The mark of the current position.
|
||||||
|
|
||||||
|
// Comments
|
||||||
|
|
||||||
|
head_comment []byte // The current head comments
|
||||||
|
line_comment []byte // The current line comments
|
||||||
|
foot_comment []byte // The current foot comments
|
||||||
|
tail_comment []byte // Foot comment that happens at the end of a block.
|
||||||
|
stem_comment []byte // Comment in item preceding a nested structure (list inside list item, etc)
|
||||||
|
|
||||||
|
comments []yaml_comment_t // The folded comments for all parsed tokens
|
||||||
|
comments_head int
|
||||||
|
|
||||||
// Scanner stuff
|
// Scanner stuff
|
||||||
|
|
||||||
stream_start_produced bool // Have we started to scan the input stream?
|
stream_start_produced bool // Have we started to scan the input stream?
|
||||||
|
@ -595,6 +638,18 @@ type yaml_parser_t struct {
|
||||||
document *yaml_document_t // The currently parsed document.
|
document *yaml_document_t // The currently parsed document.
|
||||||
}
|
}
|
||||||
|
|
||||||
|
type yaml_comment_t struct {
|
||||||
|
|
||||||
|
scan_mark yaml_mark_t // Position where scanning for comments started
|
||||||
|
token_mark yaml_mark_t // Position after which tokens will be associated with this comment
|
||||||
|
start_mark yaml_mark_t // Position of '#' comment mark
|
||||||
|
end_mark yaml_mark_t // Position where comment terminated
|
||||||
|
|
||||||
|
head []byte
|
||||||
|
line []byte
|
||||||
|
foot []byte
|
||||||
|
}
|
||||||
|
|
||||||
// Emitter Definitions
|
// Emitter Definitions
|
||||||
|
|
||||||
// The prototype of a write handler.
|
// The prototype of a write handler.
|
||||||
|
@ -625,8 +680,10 @@ const (
|
||||||
yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document.
|
yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document.
|
||||||
yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END.
|
yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END.
|
||||||
yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence.
|
yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence.
|
||||||
|
yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE // Expect the next item of a flow sequence, with the comma already written out
|
||||||
yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence.
|
yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence.
|
||||||
yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
|
yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
|
||||||
|
yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE // Expect the next key of a flow mapping, with the comma already written out
|
||||||
yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
|
yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
|
||||||
yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping.
|
yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping.
|
||||||
yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
|
yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
|
||||||
|
@ -698,6 +755,9 @@ type yaml_emitter_t struct {
|
||||||
indention bool // If the last character was an indentation character (' ', '-', '?', ':')?
|
indention bool // If the last character was an indentation character (' ', '-', '?', ':')?
|
||||||
open_ended bool // If an explicit document end is required?
|
open_ended bool // If an explicit document end is required?
|
||||||
|
|
||||||
|
space_above bool // Is there's an empty line above?
|
||||||
|
foot_indent int // The indent used to write the foot comment above, or -1 if none.
|
||||||
|
|
||||||
// Anchor analysis.
|
// Anchor analysis.
|
||||||
anchor_data struct {
|
anchor_data struct {
|
||||||
anchor []byte // The anchor value.
|
anchor []byte // The anchor value.
|
||||||
|
@ -721,6 +781,14 @@ type yaml_emitter_t struct {
|
||||||
style yaml_scalar_style_t // The output style.
|
style yaml_scalar_style_t // The output style.
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Comments
|
||||||
|
head_comment []byte
|
||||||
|
line_comment []byte
|
||||||
|
foot_comment []byte
|
||||||
|
tail_comment []byte
|
||||||
|
|
||||||
|
key_line_comment []byte
|
||||||
|
|
||||||
// Dumper stuff
|
// Dumper stuff
|
||||||
|
|
||||||
opened bool // If the stream was already opened?
|
opened bool // If the stream was already opened?
|
37
vendor/gopkg.in/yaml.v2/yamlprivateh.go → vendor/gopkg.in/yaml.v3/yamlprivateh.go
generated
vendored
37
vendor/gopkg.in/yaml.v2/yamlprivateh.go → vendor/gopkg.in/yaml.v3/yamlprivateh.go
generated
vendored
|
@ -1,3 +1,25 @@
|
||||||
|
//
|
||||||
|
// Copyright (c) 2011-2019 Canonical Ltd
|
||||||
|
// Copyright (c) 2006-2010 Kirill Simonov
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||||
|
// this software and associated documentation files (the "Software"), to deal in
|
||||||
|
// the Software without restriction, including without limitation the rights to
|
||||||
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||||
|
// so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
package yaml
|
package yaml
|
||||||
|
|
||||||
const (
|
const (
|
||||||
|
@ -114,8 +136,9 @@ func is_crlf(b []byte, i int) bool {
|
||||||
// Check if the character is a line break or NUL.
|
// Check if the character is a line break or NUL.
|
||||||
func is_breakz(b []byte, i int) bool {
|
func is_breakz(b []byte, i int) bool {
|
||||||
//return is_break(b, i) || is_z(b, i)
|
//return is_break(b, i) || is_z(b, i)
|
||||||
return ( // is_break:
|
return (
|
||||||
b[i] == '\r' || // CR (#xD)
|
// is_break:
|
||||||
|
b[i] == '\r' || // CR (#xD)
|
||||||
b[i] == '\n' || // LF (#xA)
|
b[i] == '\n' || // LF (#xA)
|
||||||
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
|
||||||
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
|
||||||
|
@ -127,8 +150,9 @@ func is_breakz(b []byte, i int) bool {
|
||||||
// Check if the character is a line break, space, or NUL.
|
// Check if the character is a line break, space, or NUL.
|
||||||
func is_spacez(b []byte, i int) bool {
|
func is_spacez(b []byte, i int) bool {
|
||||||
//return is_space(b, i) || is_breakz(b, i)
|
//return is_space(b, i) || is_breakz(b, i)
|
||||||
return ( // is_space:
|
return (
|
||||||
b[i] == ' ' ||
|
// is_space:
|
||||||
|
b[i] == ' ' ||
|
||||||
// is_breakz:
|
// is_breakz:
|
||||||
b[i] == '\r' || // CR (#xD)
|
b[i] == '\r' || // CR (#xD)
|
||||||
b[i] == '\n' || // LF (#xA)
|
b[i] == '\n' || // LF (#xA)
|
||||||
|
@ -141,8 +165,9 @@ func is_spacez(b []byte, i int) bool {
|
||||||
// Check if the character is a line break, space, tab, or NUL.
|
// Check if the character is a line break, space, tab, or NUL.
|
||||||
func is_blankz(b []byte, i int) bool {
|
func is_blankz(b []byte, i int) bool {
|
||||||
//return is_blank(b, i) || is_breakz(b, i)
|
//return is_blank(b, i) || is_breakz(b, i)
|
||||||
return ( // is_blank:
|
return (
|
||||||
b[i] == ' ' || b[i] == '\t' ||
|
// is_blank:
|
||||||
|
b[i] == ' ' || b[i] == '\t' ||
|
||||||
// is_breakz:
|
// is_breakz:
|
||||||
b[i] == '\r' || // CR (#xD)
|
b[i] == '\r' || // CR (#xD)
|
||||||
b[i] == '\n' || // LF (#xA)
|
b[i] == '\n' || // LF (#xA)
|
|
@ -201,9 +201,6 @@ golang.org/x/sys/windows
|
||||||
# gopkg.in/warnings.v0 v0.1.2
|
# gopkg.in/warnings.v0 v0.1.2
|
||||||
## explicit
|
## explicit
|
||||||
gopkg.in/warnings.v0
|
gopkg.in/warnings.v0
|
||||||
# gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0
|
# gopkg.in/yaml.v3 v3.0.0
|
||||||
## explicit
|
## explicit
|
||||||
gopkg.in/yaml.v1
|
gopkg.in/yaml.v3
|
||||||
# gopkg.in/yaml.v2 v2.4.0
|
|
||||||
## explicit; go 1.15
|
|
||||||
gopkg.in/yaml.v2
|
|
||||||
|
|
Loading…
Reference in New Issue