How to use parseFile method of main Package

...40	readFile := func(fname string) error {41		return eris.Wrapf(ErrUnexpectedEOF, "error reading file '%v'", fname) // line 642	}43	// example func that catches and returns an error without modification44	parseFile := func(fname string) error {45		// read the file46		err := readFile(fname) // line 1247		if err != nil {48			return err49		}50		return nil51	}52	// unpack and print the error via uerr.ToJSON(...)53	err := parseFile("example.json")                             // line 2054	u, _ := json.MarshalIndent(eris.ToJSON(err, true), "", "\t") // true: include stack trace55	fmt.Printf("%v\n", string(u))56	// example output:57	// {58	//   "root": {59	//     "message": "unexpected EOF",60	//     "stack": [61	//       "main.main:.../example/main.go:20",62	//       "main.parseFile:.../example/main.go:12",63	//       "main.readFile:.../example/main.go:6"64	//     ]65	//   },66	//   "wrap": [67	//     {68	//       "message": "error reading file 'example.json'",69	//       "stack": "main.readFile:.../example/main.go:6"70	//     }71	//   ]72	// }73}74func TestExampleToJSON_global(t *testing.T) {75	if !testing.Verbose() {76		return77	}78	ExampleToJSON_global()79}80// Demonstrates JSON formatting of wrapped errors that originate from local root errors (created at81// the source of the error via eris.New).82func ExampleToJSON_local() {83	// example func that returns an eris error84	readFile := func(fname string) error {85		return eris.New("unexpected EOF") // line 386	}87	// example func that catches an error and wraps it with additional context88	parseFile := func(fname string) error {89		// read the file90		err := readFile(fname) // line 991		if err != nil {92			return eris.Wrapf(err, "error reading file '%v'", fname) // line 1193		}94		return nil95	}96	// example func that just catches and returns an error97	processFile := func(fname string) error {98		// parse the file99		err := parseFile(fname) // line 19100		if err != nil {101			return err102		}103		return nil104	}105	// another example func that catches and wraps an error106	printFile := func(fname string) error {107		// process the file108		err := processFile(fname) // line 29109		if err != nil {110			return eris.Wrapf(err, "error printing file '%v'", fname) // line 31111		}112		return nil113	}114	// unpack and print the raw error115	err := printFile("example.json") // line 37116	u, _ := json.MarshalIndent(eris.ToJSON(err, true), "", "\t")117	fmt.Printf("%v\n", string(u))118	// example output:119	// {120	//   "root": {121	//     "message": "unexpected EOF",122	//     "stack": [123	//       "main.main:.../example/main.go:37",124	//       "main.printFile:.../example/main.go:31",125	//       "main.printFile:.../example/main.go:29",126	//       "main.processFile:.../example/main.go:19",127	//       "main.parseFile:.../example/main.go:11",128	//       "main.parseFile:.../example/main.go:9",129	//       "main.readFile:.../example/main.go:3"130	//     ]131	//   },132	//   "wrap": [133	//     {134	//       "message": "error printing file 'example.json'",135	//       "stack": "main.printFile:.../example/main.go:31"136	//     },137	//     {138	//       "message": "error reading file 'example.json'",139	//       "stack": "main.parseFile: .../example/main.go: 11"140	//     }141	//   ]142	// }143}144func TestExampleToJSON_local(t *testing.T) {145	if !testing.Verbose() {146		return147	}148	ExampleToJSON_local()149}150// Demonstrates string formatting of wrapped errors that originate from external (non-eris) error151// types.152func ExampleToString_external() {153	// example func that returns an IO error154	readFile := func(fname string) error {155		return io.ErrUnexpectedEOF156	}157	// unpack and print the error158	err := readFile("example.json")159	fmt.Println(eris.ToString(err, false)) // false: omit stack trace160	// example output:161	// unexpected EOF162}163func TestExampleToString_external(t *testing.T) {164	if !testing.Verbose() {165		return166	}167	ExampleToString_external()168}169// Demonstrates string formatting of wrapped errors that originate from global root errors.170func ExampleToString_global() {171	// example func that wraps a global error value172	readFile := func(fname string) error {173		return eris.Wrapf(FormattedErrUnexpectedEOF, "error reading file '%v'", fname) // line 6174	}175	// example func that catches and returns an error without modification176	parseFile := func(fname string) error {177		// read the file178		err := readFile(fname) // line 12179		if err != nil {180			return err181		}182		return nil183	}184	// example func that just catches and returns an error185	processFile := func(fname string) error {186		// parse the file187		err := parseFile(fname) // line 22188		if err != nil {189			return eris.Wrapf(err, "error processing file '%v'", fname) // line 24190		}191		return nil192	}193	// call processFile and catch the error194	err := processFile("example.json") // line 30195	// print the error via fmt.Printf196	fmt.Printf("%v\n", err) // %v: omit stack trace197	// example output:198	// unexpected EOF: error reading file 'example.json'199	// unpack and print the error via uerr.ToString(...)200	fmt.Printf("%v\n", eris.ToString(err, true)) // true: include stack trace201	// example output:202	// error reading file 'example.json'203	//   main.readFile:.../example/main.go:6204	// unexpected EOF205	//   main.main:.../example/main.go:30206	//   main.processFile:.../example/main.go:24207	//   main.processFile:.../example/main.go:22208	//   main.parseFile:.../example/main.go:12209	//   main.readFile:.../example/main.go:6210}211func TestExampleToString_global(t *testing.T) {212	if !testing.Verbose() {213		return214	}215	ExampleToString_global()216}217// Demonstrates string formatting of wrapped errors that originate from local root errors (created218// at the source of the error via eris.New).219func ExampleToString_local() {220	// example func that returns an eris error221	readFile := func(fname string) error {222		return eris.New("unexpected EOF") // line 3223	}224	// example func that catches an error and wraps it with additional context225	parseFile := func(fname string) error {226		// read the file227		err := readFile(fname) // line 9228		if err != nil {229			return eris.Wrapf(err, "error reading file '%v'", fname) // line 11230		}231		return nil232	}233	// call parseFile and catch the error234	err := parseFile("example.json") // line 17235	// print the error via fmt.Printf236	fmt.Printf("%v\n", err) // %v: omit stack trace237	// example output:238	// unexpected EOF: error reading file 'example.json'239	// unpack and print the error via uerr.ToString(...)240	fmt.Println(eris.ToString(err, true)) // true: include stack trace241	// example output:242	// error reading file 'example.json'243	//   main.parseFile:.../example/main.go:11244	// unexpected EOF245	//   main.main:.../example/main.go:17246	//   main.parseFile:.../example/main.go:11247	//   main.parseFile:.../example/main.go:9248	//   main.readFile:.../example/main.go:3249}250func TestExampleToString_local(t *testing.T) {251	if !testing.Verbose() {252		return253	}254	ExampleToString_local()255}...

...8)9const file = "../testfiles/Main.class"10func Test_class_parse(t *testing.T) {11	var cp ClassReader12	e := cp.parseFile(file)13	if e != nil {14		t.Fatal(e)15	}16	fmt.Println(cp)17}18func Test_get_class_file(t *testing.T) {19	var cp ClassReader20	_ = cp.parseFile(file)21	classFile := cp.ClassFile()22	fmt.Println("classFile is", classFile)23}24func Test_get_magic_num(t *testing.T) {25	var cp ClassReader26	_ = cp.parseFile(file)27	m := cp.ClassFile().Magic28	expect := core.Hex("CAFEBABE")29	if m.Hex != expect {30		t.Fatalf("magic num is  %s  except is %s", m.Hex, expect)31	}32}33func Test_get_Minor_Version(t *testing.T) {34	var cp ClassReader35	_ = cp.parseFile(file)36	mv := cp.ClassFile().MinorVersion37	v := mv.Version38	log.Println("minor_Version is ", v)39	expect := 040	if v != expect {41		t.Fatalf("minor version is %d,except is %d", v, expect)42	}43}44func Test_get_major_version(t *testing.T) {45	var cp ClassReader46	_ = cp.parseFile(file)47	mv := cp.ClassFile().MajorVersion48	expect := 5249	if (expect) != mv.Version {50		t.Fatalf("major version is %d,except is %d", mv.Version, expect)51	}52}53func Test_get_cp(t *testing.T) {54	var cp ClassReader55	_ = cp.parseFile(file)56	constPoolCount := cp.ClassFile().ConstantPoolCount57	v := constPoolCount.Count58	except := 21159	if v != except {60		t.Fatalf("constPoolCount is %d  except is %d", v, except)61	}62}63func Test_get_cp_info(t *testing.T) {64	var cp ClassReader65	_ = cp.parseFile(file)66	classFile := cp.ClassFile()67	cpInfos := classFile.CpInfos68	v := cpInfos.String()69	fmt.Println(v)70	f, _ := os.Create("../testfiles/cp_test.txt")71	defer f.Close()72	f.Write([]byte(v))73}74func Test_get_access_flags(t *testing.T) {75	var cp ClassReader76	_ = cp.parseFile(file)77	af := cp.ClassFile().AccessFlag78	view := af.String()79	except := "ACC_PUBLIC, ACC_SUPER"80	if view != except {81		t.Fatalf("access flags is %s  except is %s", view, except)82	}83}84func Test_get_this_class(t *testing.T) {85	var cp ClassReader86	_ = cp.parseFile(file)87	classFile := cp.ClassFile()88	tc := classFile.ThisClass89	s := tc.String90	fmt.Println(s)91	expect := "Main"92	if s != expect {93		t.Fatalf("\n expect is %v \n s is %v", expect, s)94	}95}96func Test_get_interface(t *testing.T) {97	var cp ClassReader98	_ = cp.parseFile(file)99	classFile := cp.ClassFile()100	fmt.Println(classFile)101	ifc := classFile.InterfacesCount102	if ifc.Count != 1 {103		t.Fatalf("ifc is %v expect is %d", ifc, 1)104	}105	ifcc := classFile.Interfaces[0]106	s := ifcc.NameString107	expect := "InterfaceMain"108	if s != expect {109		t.Fatalf("ifcc is %v expect is %s", ifcc, expect)110	}111}112func Test_get_attributes(t *testing.T) {113	var cp ClassReader114	_ = cp.parseFile(file)115	classFile := cp.ClassFile()116	core.Info.Println("tes output -------------------")117	fmt.Println(classFile.ClassDesc())118	file, err := os.Create("../testfiles/Main.txt")119	if err != nil {120		log.Fatalln("Failed to open error log file:", err)121	}122	defer file.Close()123	file.WriteString("\n")124	file.WriteString("\n")125	file.WriteString("\n")126	file.WriteString(classFile.ClassDesc())127}128func Test_log(t *testing.T) {129	core.Info.Println("INFO")130	core.Trace.Println("Trace")131	core.Warning.Println("Warning")132	core.Error.Println("Error")133}134func Test_getClassDesc(t *testing.T) {135	const file = "../testfiles/Main.class"136	f, err := os.Create("../testfiles/Main.txt")137	if err != nil {138		log.Fatalln("Failed to open error log file:", err)139	}140	var cp ClassReader141	_ = cp.parseFile(file)142	cf := cp.ClassFile()143	desc := cf.ClassDesc()144	fmt.Println(desc)145	defer f.Close()146	f.WriteString(cp.CpDesc(cf.ThisClass.String))147	f.WriteString(desc)148}...

1// Copyright 2009 The Go Authors. All rights reserved.2// Use of this source code is governed by a BSD-style3// license that can be found in the LICENSE file.4package parser5import (6	"go/token"7	"os"8	"testing"9)10var fset = token.NewFileSet()11var illegalInputs = []interface{}{12	nil,13	3.14,14	[]byte(nil),15	"foo!",16}17func TestParseIllegalInputs(t *testing.T) {18	for _, src := range illegalInputs {19		_, err := ParseFile(fset, "", src, 0)20		if err == nil {21			t.Errorf("ParseFile(%v) should have failed", src)22		}23	}24}25var validPrograms = []interface{}{26	"package main\n",27	`package main;`,28	`package main; import "fmt"; func main() { fmt.Println("Hello, World!") };`,29	`package main; func main() { if f(T{}) {} };`,30	`package main; func main() { _ = (<-chan int)(x) };`,31	`package main; func main() { _ = (<-chan <-chan int)(x) };`,32	`package main; func f(func() func() func());`,33	`package main; func f(...T);`,34	`package main; func f(float, ...int);`,35	`package main; func f(x int, a ...int) { f(0, a...); f(1, a...,) };`,36	`package main; type T []int; var a []bool; func f() { if a[T{42}[0]] {} };`,37	`package main; type T []int; func g(int) bool { return true }; func f() { if g(T{42}[0]) {} };`,38	`package main; type T []int; func f() { for _ = range []int{T{42}[0]} {} };`,39	`package main; var a = T{{1, 2}, {3, 4}}`,40}41func TestParseValidPrograms(t *testing.T) {42	for _, src := range validPrograms {43		_, err := ParseFile(fset, "", src, 0)44		if err != nil {45			t.Errorf("ParseFile(%q): %v", src, err)46		}47	}48}49var validFiles = []string{50	"parser.go",51	"parser_test.go",52}53func TestParse3(t *testing.T) {54	for _, filename := range validFiles {55		_, err := ParseFile(fset, filename, nil, 0)56		if err != nil {57			t.Errorf("ParseFile(%s): %v", filename, err)58		}59	}60}61func nameFilter(filename string) bool {62	switch filename {63	case "parser.go":64	case "interface.go":65	case "parser_test.go":66	default:67		return false68	}69	return true70}71func dirFilter(f *os.FileInfo) bool { return nameFilter(f.Name) }72func TestParse4(t *testing.T) {73	path := "."74	pkgs, err := ParseDir(fset, path, dirFilter, 0)75	if err != nil {76		t.Fatalf("ParseDir(%s): %v", path, err)77	}78	if len(pkgs) != 1 {79		t.Errorf("incorrect number of packages: %d", len(pkgs))80	}81	pkg := pkgs["parser"]82	if pkg == nil {83		t.Errorf(`package "parser" not found`)84		return85	}86	for filename := range pkg.Files {87		if !nameFilter(filename) {88			t.Errorf("unexpected package file: %s", filename)89		}90	}91}...

1package main2import (3	"testing"4)5func TestMiniPanda(t *testing.T) {6	c := NewCompiler(nil)7	c.ParseFile("./micro-panda/libc/io.mpd")8	c.ParseFile("./micro-panda/libc/memory.mpd")9	c.ParseFile("./micro-panda/llvm/memory.mpd")10	c.ParseFile("./micro-panda/test/test.mpd")11	c.ParseFile("./micro-panda/test/expression.mpd")12	c.ParseFile("./micro-panda/test/function.mpd")13	c.ParseFile("./micro-panda/test/statement.mpd")14	c.ParseFile("./micro-panda/test/struct.mpd")15	c.ParseFile("./micro-panda/main.mpd")16	if c.Validate() {17		c.GenerateIR("./micro-panda/main")18	}19	t.Fail()20}...

1import (2func main() {3	fmt.Println("Hello World")4}5import (6func main() {7	fmt.Println("Hello World")8}9import (10func main() {11	fmt.Println("Hello World")12}13import (14func main() {15	fmt.Println("Hello World")16}17import (18func main() {19	fmt.Println("Hello World")20}21import (22func main() {23	fmt.Println("Hello World")24}25import (26func main() {27	fmt.Println("Hello World")28}29import (30func main() {31	fmt.Println("Hello World")32}33import (34func main() {35	fmt.Println("Hello World")36}37import (38func main() {39	fmt.Println("Hello World")40}41import (42func main() {43	fmt.Println("Hello World")44}45import (46func main() {47	fmt.Println("Hello World")48}49import (50func main() {51	fmt.Println("Hello World")52}53import

1import (2func main() {3    fmt.Println("Enter the file name with path")4    fmt.Scanln(&filename)5    file, err := os.Open(filename)6    if err != nil {7        fmt.Println("Error in opening file")8    }9    defer file.Close()10    scanner := bufio.NewScanner(file)11    for scanner.Scan() {12        line := scanner.Text()13        if strings.Contains(line, "import") {14            fmt.Println(line)15        }16    }17}18import "fmt"19import "os"20import "bufio"21import "strings"22import (23func main() {24    fmt.Println("Enter the file name with path")25    fmt.Scanln(&filename)26    file, err := os.Open(filename)27    if err != nil {28        fmt.Println("Error in opening file")29    }30    defer file.Close()31    scanner := bufio.NewScanner(file)32    for scanner.Scan() {33        line := scanner.Text()34        fmt.Println(line)35    }36}37import (38func main() {39    fmt.Println("Enter the file name with path")40    fmt.Scanln(&filename)41    file, err := os.Open(filename)42    if err != nil {43        fmt.Println("Error in opening file")44    }45    defer file.Close()46    scanner := bufio.NewScanner(file)47    for scanner.Scan() {48        line := scanner.Text()49        fmt.Println(line)50    }51}52import (

1import (2func main() {3	scanner := bufio.NewScanner(os.Stdin)4	scanner.Scan()5	fmt.Println(scanner.Text())6}

1import (2func main() {3	p := parser.New()4	p.ParseFile("test2.txt")5}6import (7type Parser struct {8}9func New() *Parser {10	return &Parser{}11}12func (p *Parser) ParseFile(filename string) {13	f, err := os.Open(filename)14	if err != nil {15		fmt.Println(err)16	}17	defer f.Close()18	scanner := bufio.NewScanner(f)19	for scanner.Scan() {20		fmt.Println(scanner.Text())21	}22	if err := scanner.Err(); err != nil {23		fmt.Println(err)24	}25	fmt.Println("Parsing file: ", filename)26}

1import (2func main() {3	file, err := os.Open("c:/Users/HP/Desktop/1.txt")4	if err != nil {5		fmt.Println("Error in opening file")6	}7	defer file.Close()8	scanner := bufio.NewScanner(file)9	scanner.Split(bufio.ScanLines)10	for scanner.Scan() {11		txtlines = append(txtlines, scanner.Text())12	}13	file.Close()14	file, err = os.OpenFile("c:/Users/HP/Desktop/1.txt", os.O_WRONLY|os.O_TRUNC, 0666)15	if err != nil {16		fmt.Println("Error in opening file")17	}18	defer file.Close()19	for _, eachline := range txtlines {20		file.WriteString(eachline + "21	}22}

1import (2type mainClass struct {3	imports []string4}5func parseFile(fileName string) (mainClass, error) {6	file, err := os.Open(fileName)7	if err != nil {8		return mainClass{}, err9	}10	defer file.Close()11	scanner := bufio.NewScanner(file)12	mc := mainClass{}13	reMain := regexp.MustCompile(`func main\(\) {`)14	reImport := regexp.MustCompile(`import \(`)15	reClass := regexp.MustCompile(`type ([a-z0-9]+) struct {`)16	reMethod := regexp.MustCompile(`func \([a-z0-9]+ \*([a-z0-9]+)\) ([a-z0-9]+)\(`)17	reEndImport := regexp.MustCompile(`\)`)18	reEndMain := regexp.MustCompile(`}`)19	reEndClass := regexp.MustCompile(`}`)20	reEndMethod := regexp.MustCompile(`}`)21	reEndFile := regexp.MustCompile(`}`)22	reEndFile2 := regexp.MustCompile(`}`)23	reEndFile3 := regexp.MustCompile(`}`)24	reEndFile4 := regexp.MustCompile(`}`)