...
▽

Package parser

import "cuelang.org/go/cue/parser"
Overview
Index
Examples

Overview ▾

Package parser implements a parser for CUE source files. Input may be provided in a variety of forms (see the various Parse* functions); the output is an abstract syntax tree (AST) representing the CUE source. The parser is invoked through one of the Parse* functions.

The parser accepts a larger language than is syntactically permitted by the CUE spec, for simplicity, and for improved robustness in the presence of syntax errors.

Constants

const (
    // Latest specifies the latest version of the parser, effectively setting
    // the strictest implementation.
    Latest = latest

    // FullBackwardCompatibility enables all deprecated features that are
    // currently still supported by the parser.
    FullBackwardCompatibility = fullCompatibility
)

func ParseExpr 

func ParseExpr(filename string, src interface{}, mode ...Option) (ast.Expr, error)

ParseExpr is a convenience function for parsing an expression. The arguments have the same meaning as for Parse, but the source must be a valid CUE (type or value) expression. Specifically, fset must not be nil.

func ParseFile 

func ParseFile(filename string, src interface{}, mode ...Option) (f *ast.File, err error)

ParseFile parses the source code of a single CUE source file and returns the corresponding File node. The source code may be provided via the filename of the source file, or via the src parameter.

If src != nil, ParseFile parses the source from src and the filename is only used when recording position information. The type of the argument for the src parameter must be string, []byte, or io.Reader. If src == nil, ParseFile parses the file specified by filename.

The mode parameter controls the amount of source text parsed and other optional parser functionality. Position information is recorded in the file set fset, which must not be nil.

If the source couldn't be read, the returned AST is nil and the error indicates the specific failure. If the source was read but syntax errors were found, the result is a partial AST (with Bad* nodes representing the fragments of erroneous source code). Multiple errors are returned via a ErrorList which is sorted by file position.

▾ Example

Code:

// Parse some CUE source but stop after processing the imports.
f, err := parser.ParseFile("example.cue", `
        import "math"

        foo: 1
        bar: "baz"
    `, parser.ImportsOnly)
if err != nil {
    fmt.Println(err)
    return
}

// Print the imports from the file's AST.
for _, s := range f.Imports {
    fmt.Println(s.Path.Value)
}

Output:

"math"

type DeprecationError

DeprecationError is a sentinel error to indicate that an error is related to an unsupported old CUE syntax. 

type DeprecationError struct {
    Version int
}

func (*DeprecationError) Error 

func (e *DeprecationError) Error() string

type Option

Option specifies a parse option. 

type Option func(p *parser)
var (
    // PackageClauseOnly causes parsing to stop after the package clause.
    PackageClauseOnly Option = packageClauseOnly

    // ImportsOnly causes parsing to stop parsing after the import declarations.
    ImportsOnly Option = importsOnly

    // ParseComments causes comments to be parsed.
    ParseComments Option = parseComments

    // ParseFuncs causes function declarations to be parsed.
    //
    // This is an experimental function and the API is likely to
    // change or dissapear.
    ParseFuncs Option = parseFuncs

    // Trace causes parsing to print a trace of parsed productions.
    Trace Option = traceOpt

    // DeclarationErrors causes parsing to report declaration errors.
    DeclarationErrors Option = declarationErrors

    // AllErrors causes all errors to be reported (not just the first 10 on different lines).
    AllErrors Option = allErrors

    // AllowPartial allows the parser to be used on a prefix buffer.
    AllowPartial Option = allowPartial
)

func FileOffset 

func FileOffset(pos int) Option

FileOffset specifies the File position info to use.

Deprecated: this has no effect.

func FromVersion 

func FromVersion(version int) Option

FromVersion specifies until which legacy version the parser should provide backwards compatibility.