...
Run Format

Source file src/go/parser/interface.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// This file contains the exported entry points for invoking the parser.
     6	
     7	package parser
     8	
     9	import (
    10		"bytes"
    11		"errors"
    12		"go/ast"
    13		"go/token"
    14		"io"
    15		"io/ioutil"
    16		"os"
    17		"path/filepath"
    18		"strings"
    19	)
    20	
    21	// If src != nil, readSource converts src to a []byte if possible;
    22	// otherwise it returns an error. If src == nil, readSource returns
    23	// the result of reading the file specified by filename.
    24	//
    25	func readSource(filename string, src interface{}) ([]byte, error) {
    26		if src != nil {
    27			switch s := src.(type) {
    28			case string:
    29				return []byte(s), nil
    30			case []byte:
    31				return s, nil
    32			case *bytes.Buffer:
    33				// is io.Reader, but src is already available in []byte form
    34				if s != nil {
    35					return s.Bytes(), nil
    36				}
    37			case io.Reader:
    38				var buf bytes.Buffer
    39				if _, err := io.Copy(&buf, s); err != nil {
    40					return nil, err
    41				}
    42				return buf.Bytes(), nil
    43			}
    44			return nil, errors.New("invalid source")
    45		}
    46		return ioutil.ReadFile(filename)
    47	}
    48	
    49	// A Mode value is a set of flags (or 0).
    50	// They control the amount of source code parsed and other optional
    51	// parser functionality.
    52	//
    53	type Mode uint
    54	
    55	const (
    56		PackageClauseOnly Mode             = 1 << iota // stop parsing after package clause
    57		ImportsOnly                                    // stop parsing after import declarations
    58		ParseComments                                  // parse comments and add them to AST
    59		Trace                                          // print a trace of parsed productions
    60		DeclarationErrors                              // report declaration errors
    61		SpuriousErrors                                 // same as AllErrors, for backward-compatibility
    62		AllErrors         = SpuriousErrors             // report all errors (not just the first 10 on different lines)
    63	)
    64	
    65	// ParseFile parses the source code of a single Go source file and returns
    66	// the corresponding ast.File node. The source code may be provided via
    67	// the filename of the source file, or via the src parameter.
    68	//
    69	// If src != nil, ParseFile parses the source from src and the filename is
    70	// only used when recording position information. The type of the argument
    71	// for the src parameter must be string, []byte, or io.Reader.
    72	// If src == nil, ParseFile parses the file specified by filename.
    73	//
    74	// The mode parameter controls the amount of source text parsed and other
    75	// optional parser functionality. Position information is recorded in the
    76	// file set fset.
    77	//
    78	// If the source couldn't be read, the returned AST is nil and the error
    79	// indicates the specific failure. If the source was read but syntax
    80	// errors were found, the result is a partial AST (with ast.Bad* nodes
    81	// representing the fragments of erroneous source code). Multiple errors
    82	// are returned via a scanner.ErrorList which is sorted by file position.
    83	//
    84	func ParseFile(fset *token.FileSet, filename string, src interface{}, mode Mode) (f *ast.File, err error) {
    85		// get source
    86		text, err := readSource(filename, src)
    87		if err != nil {
    88			return nil, err
    89		}
    90	
    91		var p parser
    92		defer func() {
    93			if e := recover(); e != nil {
    94				// resume same panic if it's not a bailout
    95				if _, ok := e.(bailout); !ok {
    96					panic(e)
    97				}
    98			}
    99	
   100			// set result values
   101			if f == nil {
   102				// source is not a valid Go source file - satisfy
   103				// ParseFile API and return a valid (but) empty
   104				// *ast.File
   105				f = &ast.File{
   106					Name:  new(ast.Ident),
   107					Scope: ast.NewScope(nil),
   108				}
   109			}
   110	
   111			p.errors.Sort()
   112			err = p.errors.Err()
   113		}()
   114	
   115		// parse source
   116		p.init(fset, filename, text, mode)
   117		f = p.parseFile()
   118	
   119		return
   120	}
   121	
   122	// ParseDir calls ParseFile for all files with names ending in ".go" in the
   123	// directory specified by path and returns a map of package name -> package
   124	// AST with all the packages found.
   125	//
   126	// If filter != nil, only the files with os.FileInfo entries passing through
   127	// the filter (and ending in ".go") are considered. The mode bits are passed
   128	// to ParseFile unchanged. Position information is recorded in fset.
   129	//
   130	// If the directory couldn't be read, a nil map and the respective error are
   131	// returned. If a parse error occurred, a non-nil but incomplete map and the
   132	// first error encountered are returned.
   133	//
   134	func ParseDir(fset *token.FileSet, path string, filter func(os.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error) {
   135		fd, err := os.Open(path)
   136		if err != nil {
   137			return nil, err
   138		}
   139		defer fd.Close()
   140	
   141		list, err := fd.Readdir(-1)
   142		if err != nil {
   143			return nil, err
   144		}
   145	
   146		pkgs = make(map[string]*ast.Package)
   147		for _, d := range list {
   148			if strings.HasSuffix(d.Name(), ".go") && (filter == nil || filter(d)) {
   149				filename := filepath.Join(path, d.Name())
   150				if src, err := ParseFile(fset, filename, nil, mode); err == nil {
   151					name := src.Name.Name
   152					pkg, found := pkgs[name]
   153					if !found {
   154						pkg = &ast.Package{
   155							Name:  name,
   156							Files: make(map[string]*ast.File),
   157						}
   158						pkgs[name] = pkg
   159					}
   160					pkg.Files[filename] = src
   161				} else if first == nil {
   162					first = err
   163				}
   164			}
   165		}
   166	
   167		return
   168	}
   169	
   170	// ParseExprFrom is a convenience function for parsing an expression.
   171	// The arguments have the same meaning as for Parse, but the source must
   172	// be a valid Go (type or value) expression.
   173	//
   174	func ParseExprFrom(fset *token.FileSet, filename string, src interface{}, mode Mode) (ast.Expr, error) {
   175		// get source
   176		text, err := readSource(filename, src)
   177		if err != nil {
   178			return nil, err
   179		}
   180	
   181		var p parser
   182		defer func() {
   183			if e := recover(); e != nil {
   184				// resume same panic if it's not a bailout
   185				if _, ok := e.(bailout); !ok {
   186					panic(e)
   187				}
   188			}
   189			p.errors.Sort()
   190			err = p.errors.Err()
   191		}()
   192	
   193		// parse expr
   194		p.init(fset, filename, text, mode)
   195		// Set up pkg-level scopes to avoid nil-pointer errors.
   196		// This is not needed for a correct expression x as the
   197		// parser will be ok with a nil topScope, but be cautious
   198		// in case of an erroneous x.
   199		p.openScope()
   200		p.pkgScope = p.topScope
   201		e := p.parseRhsOrType()
   202		p.closeScope()
   203		assert(p.topScope == nil, "unbalanced scopes")
   204	
   205		// If a semicolon was inserted, consume it;
   206		// report an error if there's more tokens.
   207		if p.tok == token.SEMICOLON && p.lit == "\n" {
   208			p.next()
   209		}
   210		p.expect(token.EOF)
   211	
   212		if p.errors.Len() > 0 {
   213			p.errors.Sort()
   214			return nil, p.errors.Err()
   215		}
   216	
   217		return e, nil
   218	}
   219	
   220	// ParseExpr is a convenience function for obtaining the AST of an expression x.
   221	// The position information recorded in the AST is undefined. The filename used
   222	// in error messages is the empty string.
   223	//
   224	func ParseExpr(x string) (ast.Expr, error) {
   225		return ParseExprFrom(token.NewFileSet(), "", []byte(x), 0)
   226	}
   227	

View as plain text