func main() {
	flag.Parse()

	var filename string
	switch flag.NArg() {
	case 0:
		filename = "/dev/stdin"
	case 1:
		filename = flag.Arg(0)
	default:
		usage()
	}

	src, err := ioutil.ReadFile(filename)
	if err != nil {
		scanner.PrintError(os.Stderr, err)
	}

	if path.Ext(filename) == ".html" {
		src = extractEBNF(src)
	}

	grammar, err := ebnf.Parse(filename, src)
	if err != nil {
		scanner.PrintError(os.Stderr, err)
	}

	if err = ebnf.Verify(grammar, *start); err != nil {
		scanner.PrintError(os.Stderr, err)
	}
}

func main() {
	flag.Parse()
	log.SetFlags(0)

	// If no paths are provided then use the present working directory.
	roots := flag.Args()
	if len(roots) == 0 {
		roots = []string{"."}
	}

	// Recursively retrieve all ego templates
	var v visitor
	for _, root := range roots {
		if err := filepath.Walk(root, v.visit); err != nil {
			scanner.PrintError(os.Stderr, err)
			os.Exit(1)
		}
	}

	// Parse every *.ego file.
	for _, path := range v.paths {
		template, err := egon.ParseFile(path)
		if err != nil {
			log.Fatal("parse file: ", err)
		}

		pkg := &egon.Package{Template: template}
		err = pkg.Write()
		if err != nil {
			log.Fatal("write: ", err)
		}
	}
}

// FormatCode runs "goimports -w" on the source file.
func (f *SourceFile) FormatCode() error {
	if NoFormat {
		return nil
	}
	// Parse file into AST
	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, f.Abs(), nil, parser.ParseComments)
	if err != nil {
		content, _ := ioutil.ReadFile(f.Abs())
		var buf bytes.Buffer
		scanner.PrintError(&buf, err)
		return fmt.Errorf("%s\n========\nContent:\n%s", buf.String(), content)
	}
	// Clean unused imports
	imports := astutil.Imports(fset, file)
	for _, group := range imports {
		for _, imp := range group {
			path := strings.Trim(imp.Path.Value, `"`)
			if !astutil.UsesImport(file, path) {
				astutil.DeleteImport(fset, file, path)
			}
		}
	}
	ast.SortImports(fset, file)
	// Open file to be written
	w, err := os.OpenFile(f.Abs(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.ModePerm)
	if err != nil {
		return err
	}
	defer w.Close()
	// Write formatted code without unused imports
	return format.Node(w, fset, file)
}

// ErrPosition reports an error at position.
func (c *Report) ErrPosition(position token.Position, format string, arg ...interface{}) {
	if c.TraceErrors {
		fmt.Fprintf(os.Stderr, "%v: %s\n", position, fmt.Sprintf(format, arg...))
	}

	if c.IgnoreErrors {
		return
	}

	c.errorsMu.Lock()         // X+
	defer c.errorsMu.Unlock() // X-

	if c.PanicOnError {
		panic(fmt.Errorf("%s: %v", position, fmt.Sprintf(format, arg...)))
	}

	c.errors.Add(position, fmt.Sprintf(format, arg...))

	if c.ErrLimit > 0 {
		c.ErrLimit--
		if c.ErrLimit == 0 {
			scanner.PrintError(os.Stderr, c.errors)
			log.Fatalf("too many errors")
		}
	}

}

func main() {
	log.SetFlags(0)
	kingpin.CommandLine.Help = "Generate native Go code from ERB-style Templates"
	kingpin.Parse()

	if len(egon.Config.Folders) == 0 {
		egon.Config.Folders = []string{"."}
	}

	// Recursively retrieve all templates
	var v visitor
	for _, root := range egon.Config.Folders {
		log.Printf("scanning folder [%s]", root)
		if err := filepath.Walk(root, v.visit); err != nil {
			scanner.PrintError(os.Stderr, err)
			os.Exit(1)
		}
	}

	// Parse every *.ego file.
	for _, path := range v.paths {
		template, err := egon.ParseFile(path)
		if err != nil {
			log.Fatal("parse file: ", err)
		}

		pkg := &egon.Package{Template: template}
		err = pkg.Write()
		if err != nil {
			log.Fatal("write: ", err)
		}
	}
}

func main() {
	log.SetFlags(0)
	list := flag.Bool("l", false, "List assembly code and exit.")
	trace := flag.Bool("t", false, "Trace execution.")
	stack := flag.Bool("s", false, "Trace execution and stack.")
	flag.Parse()
	if n := flag.NArg(); n != 1 {
		log.Fatalf("expected 1 argument, got %v", n)
	}

	prog, err := pl0.Parse(flag.Arg(0))
	if err != nil {
		scanner.PrintError(os.Stderr, err)
		os.Stderr.Sync()
		os.Exit(1)
	}

	if *list {
		prog.List(os.Stdout)
		return
	}

	switch {
	case *stack:
		err = prog.Run(pl0.TraceStack())
	case *trace:
		err = prog.Run(pl0.Trace())
	default:
		err = prog.Run()
	}
	if err != nil {
		log.Fatal(err)
	}
}

func Example_undeclared() {
	_, err := ParseString("",
		`
	CONST a = 42;
	
	VAR b;
	
	PROCEDURE c;
	BEGIN
		CALL aa;
		CALL c;
	END;
	
	BEGIN
		b := a;
		b := d;
		e := 10;
		CALL c;
		CALL f;
		? b;
		? g;
	END.
`)

	scanner.PrintError(os.Stdout, err)
	// Output:
	// 8:8: undeclared identifier aa
	// 14:8: undeclared identifier d
	// 15:3: undeclared identifier e
	// 17:8: undeclared identifier f
	// 19:5: undeclared identifier g
}

func Example_redeclaration() {
	_, err := ParseString("",
		`
	CONST a = 42, b = 24, a = 314;
	
	VAR b, c, d;
	
	PROCEDURE c;
	BEGIN
	END;
	
	PROCEDURE d;
	BEGIN
	END;
	
	PROCEDURE e;
	BEGIN
	END;
	
	PROCEDURE e;
	BEGIN
	END;
	
	BEGIN
	END.
`)

	scanner.PrintError(os.Stdout, err)
	// Output:
	// 2:24: redeclaration of a at 2:8
	// 4:6: redeclaration of b at 2:16
	// 6:12: redeclaration of c at 4:9
	// 10:12: redeclaration of d at 4:12
	// 18:12: redeclaration of e at 14:12
}

func report(err error) {
	scanner.PrintError(os.Stderr, err)
	if list, ok := err.(scanner.ErrorList); ok {
		errorCount += len(list)
		return
	}
	errorCount++
}

func TestTypeCheck(t *testing.T) {
	flag.Parse()
	pkgRx, err := regexp.Compile(*pkgPat)
	if err != nil {
		t.Fatalf("illegal flag value %q: %s", *pkgPat, err)
	}

	pkgs, err := parser.ParseDir(fset, testDir, testFilter, 0)
	if err != nil {
		scanner.PrintError(os.Stderr, err)
		t.Fatalf("packages in %s contain syntax errors", testDir)
	}

	for _, pkg := range pkgs {
		if !pkgRx.MatchString(pkg.Name) {
			continue // only test selected packages
		}

		if *trace {
			fmt.Println(pkg.Name)
		}

		xlist := expectedErrors(t, pkg)
		err := CheckPackage(fset, pkg, nil)
		if err != nil {
			if elist, ok := err.(scanner.ErrorList); ok {
				// verify that errors match
				for i := 0; i < len(xlist) && i < len(elist); i++ {
					checkError(t, xlist[i], elist[i])
				}
				// the correct number or errors must have been found
				if len(xlist) != len(elist) {
					fmt.Fprintf(os.Stderr, "%s\n", pkg.Name)
					scanner.PrintError(os.Stderr, elist)
					fmt.Fprintln(os.Stderr)
					t.Errorf("TypeCheck(%s): %d errors expected but %d reported", pkg.Name, len(xlist), len(elist))
				}
			} else {
				t.Errorf("TypeCheck(%s): %v", pkg.Name, err)
			}
		} else if len(xlist) > 0 {
			t.Errorf("TypeCheck(%s): %d errors expected but 0 reported", pkg.Name, len(xlist))
		}
	}
}

func Test(t *testing.T) {
	err := processFile("testdata/data.go", NewPrototype())
	e, ok := err.(scanner.ErrorList)
	if !ok {
		t.Fatal(err)
	}

	if len(e) != NUM_ERRORS {
		t.Errorf("expected %d errors", NUM_ERRORS)
		scanner.PrintError(os.Stderr, err)
	}
}

// MustCompileLexer is like CompileLexer but panics if the definitions cannot be compiled.
// It simplifies safe initialization of global variables holding compiled Lexers.
func MustCompileLexer(starts [][]int, tokdefs map[string]int, grammar, start string) (lexer *Lexer) {
	var err error
	if lexer, err = CompileLexer(starts, tokdefs, grammar, start); err != nil {
		if list, ok := err.(scanner.ErrorList); ok {
			scanner.PrintError(os.Stderr, list)
		} else {
			log.Fatal(err)
		}
		panic(err)
	}
	return
}

func Main() {
	world = eval.NewWorld()
	defineFuncs()
	r := bufio.NewReader(os.Stdin)
	for {
		print("; ")
		line, err := r.ReadSlice('\n')
		if err != nil {
			break
		}

		// Try line as a command
		cmd, rest := getCmd(line)
		if cmd != nil {
			err := cmd.handler(rest)
			if err != nil {
				scanner.PrintError(os.Stderr, err)
			}
			continue
		}

		// Try line as code
		code, err := world.Compile(string(line))
		if err != nil {
			scanner.PrintError(os.Stderr, err)
			continue
		}
		v, err := code.Run()
		if err != nil {
			fmt.Fprintf(os.Stderr, err.String())
			continue
		}
		if v != nil {
			println(v.String())
		}
	}
}

func generate(arch, header, out, test, predefined string) error {
	m, err := ccgo.NewModel(arch)
	if err != nil {
		return err
	}

	var cpplog *os.File
	var s []string
	opts := []cc.Opt{cc.SysIncludePaths([]string{ccgo.LibcIncludePath})}
	if *cpp {
		var err error
		if cpplog, err = os.Create("log-cpp-" + arch); err != nil {
			return err
		}

		defer cpplog.Close()

		opts = append(opts, cc.Cpp(func(a []xc.Token) {
			if len(a) == 0 {
				return
			}

			s = s[:0]
			for _, v := range a {
				s = append(s, cc.TokSrc(v))
			}
			fmt.Fprintf(cpplog, "%s: %s\n", a[0].Position(), strings.Join(s, " "))
		}))
	}

	predefined += fmt.Sprintf("\n#define __MODEL%v\n", ccgo.Archs[arch])
	tu, err := cc.Parse(predefined, paths, m, opts...)
	if err != nil {
		var buf bytes.Buffer
		scanner.PrintError(&buf, err)
		return fmt.Errorf("%s", buf.Bytes())
	}

	return (&ccgo.Job{
		DeclarationComments: *pos,
		Header:              header,
		ImportPath:          importPath,
		In:                  tu,
		Model:               m,
		Out:                 out,
		Root:                root,
		Test:                test,
	}).Run()
}

func checkFiles(t *testing.T, testname string, testfiles []string) {
	// TODO(gri) Eventually all these different phases should be
	//           subsumed into a single function call that takes
	//           a set of files and creates a fully resolved and
	//           type-checked AST.

	files, err := parseFiles(t, testname, testfiles)

	// we are expecting the following errors
	// (collect these after parsing the files so that
	// they are found in the file set)
	errors := expectedErrors(t, testname, files)

	// verify errors returned by the parser
	eliminate(t, errors, err)

	// verify errors returned after resolving identifiers
	pkg, err := ast.NewPackage(fset, files, GcImport, Universe)
	eliminate(t, errors, err)

	// verify errors returned by the typechecker
	var list scanner.ErrorList
	errh := func(pos token.Pos, msg string) {
		list.Add(fset.Position(pos), msg)
	}
	err = Check(fset, pkg, errh, nil)
	eliminate(t, errors, list)

	if *listErrors {
		scanner.PrintError(os.Stdout, err)
		return
	}

	// there should be no expected errors left
	if len(errors) > 0 {
		t.Errorf("%s: %d errors not reported:", testname, len(errors))
		for pos, msg := range errors {
			t.Errorf("%s: %s\n", fset.Position(pos), msg)
		}
	}
}

func Example_illegalFactor() {
	_, err := ParseString("",
		`
	CONST a = 42;
	
	VAR b;
	
	PROCEDURE c;
	BEGIN
	END;
	
	BEGIN
		b := a;
		b := b;
		b := c;
	END.
`)

	scanner.PrintError(os.Stdout, err)
	// Output:
	// 13:8: c is not a constant or a variable
}

func Example_illegalAssignment() {
	_, err := ParseString("",
		`
	CONST a = 42;
	
	VAR b;
	
	PROCEDURE c;
	BEGIN
	END;
	
	BEGIN
		a := 1;
		b := 1;
		c := 1;
	END.
`)

	scanner.PrintError(os.Stdout, err)
	// Output:
	// 11:3: a is not a variable
	// 13:3: c is not a variable
}

func Example_illegalCall() {
	_, err := ParseString("",
		`
	CONST a = 42;
	
	VAR b;
	
	PROCEDURE c;
	BEGIN
	END;
	
	BEGIN
		CALL a;
		CALL b;
		CALL c;
	END.
`)

	scanner.PrintError(os.Stdout, err)
	// Output:
	// 11:8: a is not a procedure
	// 12:8: b is not a procedure
}

func Example_illegalRead() {
	_, err := ParseString("",
		`
	CONST a = 42;
	
	VAR b;
	
	PROCEDURE c;
	BEGIN
	END;
	
	BEGIN
		? a;
		? b;
		? c;
	END.
`)

	scanner.PrintError(os.Stdout, err)
	// Output:
	// 11:5: a is not a variable
	// 13:5: c is not a variable
}

func main() {
	flag.Usage = usage
	flag.Parse()

	if len(os.Args) == 1 {
		usage()
	}

	log.SetFlags(0)
	log.SetPrefix("FAIL! ")

	exitCode := 0
	proto := NewPrototype()
	filenamePath := ""

	// Scan all files passed in command line.
	for _, filename := range flag.Args() {
		switch info, err := os.Stat(filename); {
		case err != nil:
			log.Print(err)
			exitCode = 1
		case info.Mode()&os.ModeType == 0: // regular file
			if err := processFile(filename, proto); err != nil {
				log.Printf("\t%s\n\n", filename)
				scanner.PrintError(os.Stderr, err)
				exitCode = 1
			} else if filename == "" {
				filenamePath = filename
			}
		default:
			log.Print("not regular file: ", filename)
			exitCode = 1
		}
	}
	if exitCode != 0 {
		os.Exit(exitCode)
	}

	// Find in header files
	if errList := proto.find(); errList != nil {
		for _, e := range errList {
			log.Print(e)
		}
		os.Exit(1)
	}
	if len(proto.includes) == 0 {
		log.Print("prototypes not found")
		os.Exit(1)
	}

	// Create file
	var err error
	filew := os.Stdout
	if *Write {
		filew, err = os.Create(filepath.Join(filepath.Dir(filenamePath),
			fmt.Sprintf("z-sys_%s_%s.go", runtime.GOOS, runtime.GOARCH)))
		if err != nil {
			log.Fatal(err)
		}
		defer func() {
			if err = filew.Close(); err != nil {
				log.Print(err)
			}
		}()
	}

	sort.Strings(proto.includes)
	sort.Strings(proto.enums)
	sort.Strings(proto.structs)
	sort.Strings(proto.unions)

	// Return '_' for constants not exported.
	exportConst := func(name string) string {
		v, found := proto.export[name]
		if found {
			if !v {
				return "_"
			}
		} else if !*Export {
			return "_"
		}
		return ""
	}

	// Return the name in title case if it is exported.
	exportIdent := func(name string) string {
		v, found := proto.export[name]
		if found {
			if !v {
				return name
			}
		} else if !*Export {
			return name
		}
		return strings.Title(name)
	}

	// Write

	HEADER = fmt.Sprintf("// %s\n%s", strings.Join(os.Args, " "), HEADER)
//.........这里部分代码省略.........