Documentation

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.

    Index

    Examples

    Constants

    View Source
    const Latest = latest

      Latest specifies the latest version of the parser, effectively setting the strictest implementation.

      Variables

      This section is empty.

      Functions

      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
          Output:
          
          "math"
          

          Types

          type DeprecationError

          type DeprecationError struct {
          	Version int
          }

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

            func (*DeprecationError) Error

            func (e *DeprecationError) Error() string

            type Option

            type Option func(p *parser)

              Option specifies a parse option.

              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
              
              	// 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.

                func FromVersion

                func FromVersion(version int) Option

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