How to use parseFieldList method of main Package

...118	var params []Permission119	var results []Permission120	// Parse either a "func" token or a receiver and a func token121	if tok, _ := p.sc.Accept(TokenParenLeft, TokenFunc); tok.Type == TokenParenLeft {122		receiver = p.parseFieldList(TokenComma)123		p.sc.Expect(TokenParenRight)124		p.sc.Expect(TokenFunc)125	}126	// Parse a name127	if nameTok, ok := p.sc.Accept(TokenWord); ok {128		name = nameTok.Value129	}130	// Pararameters131	p.sc.Expect(TokenParenLeft)132	if p.sc.Peek().Type != TokenParenRight {133		params = p.parseFieldList(TokenComma)134	}135	p.sc.Expect(TokenParenRight)136	// Results137	if tok, _ := p.sc.Accept(TokenParenLeft); tok.Type == TokenParenLeft {138		results = p.parseFieldList(TokenComma)139		p.sc.Expect(TokenParenRight)140	} else if tok := p.sc.Peek(); tok.Type == TokenWord {141		// permission starts with word. We peek()ed first, so we can backtrack.142		results = []Permission{p.parseInner()}143	}144	return &FuncPermission{BasePermission: bp, Name: name, Receivers: receiver, Params: params, Results: results}145}146// @syntax paramList <- inner (',' inner)*147// @syntax fieldList <- inner (';' inner)*148func (p *Parser) parseFieldList(sep TokenType) []Permission {149	var tok Token150	var perms []Permission151	perm := p.parseInner()152	perms = append(perms, perm)153	for tok = p.sc.Peek(); tok.Type == sep; tok = p.sc.Peek() {154		p.sc.Scan()155		perms = append(perms, p.parseInner())156	}157	return perms158}159// @syntax sliceOrArray <- '[' [NUMBER|_] ']' inner160func (p *Parser) parseSliceOrArray(bp BasePermission) Permission {161	p.sc.Expect(TokenBracketLeft)162	_, isArray := p.sc.Accept(TokenNumber, TokenWildcard)163	p.sc.Expect(TokenBracketRight)164	rhs := p.parseInner()165	if isArray {166		return &ArrayPermission{BasePermission: bp, ElementPermission: rhs}167	}168	return &SlicePermission{BasePermission: bp, ElementPermission: rhs}169}170// @syntax chan <- 'chan' inner171func (p *Parser) parseChan(bp BasePermission) Permission {172	p.sc.Expect(TokenChan)173	rhs := p.parseInner()174	return &ChanPermission{BasePermission: bp, ElementPermission: rhs}175}176// @syntax chan <- 'interface' '{' [fieldList] '}'177func (p *Parser) parseInterface(bp BasePermission) Permission {178	var fields []*FuncPermission179	p.sc.Expect(TokenInterface)180	p.sc.Expect(TokenBraceLeft)181	if p.sc.Peek().Type != TokenBraceRight {182		newFields := p.parseFieldList(TokenSemicolon)183		for _, field := range newFields {184			field, ok := field.(*FuncPermission)185			if !ok {186				panic(p.sc.wrapError(fmt.Errorf("Only methods can be part of interfaces in previous field list")))187			}188			fields = append(fields, field)189		}190	}191	p.sc.Expect(TokenBraceRight)192	return &InterfacePermission{BasePermission: bp, Methods: fields}193}194// @syntax map <- 'map' '[' inner ']' inner195func (p *Parser) parseMap(bp BasePermission) Permission {196	p.sc.Expect(TokenMap) // Map keyword197	p.sc.Expect(TokenBracketLeft)198	key := p.parseInner()199	p.sc.Expect(TokenBracketRight)200	val := p.parseInner()201	return &MapPermission{BasePermission: bp, KeyPermission: key, ValuePermission: val}202}203// @syntax pointer <- '*' inner204func (p *Parser) parsePointer(bp BasePermission) Permission {205	p.sc.Expect(TokenStar)206	rhs := p.parseInner()207	return &PointerPermission{BasePermission: bp, Target: rhs}208}209// @syntax struct <- 'struct' '{' fieldList '}'210func (p *Parser) parseStruct(bp BasePermission) Permission {211	p.sc.Expect(TokenStruct)212	p.sc.Expect(TokenBraceLeft)213	fields := p.parseFieldList(TokenSemicolon)214	p.sc.Expect(TokenBraceRight)215	return &StructPermission{BasePermission: bp, Fields: fields}216}...

...107	} else {108		return nil, fmt.Errorf("All fields must have 'type' defined.  The following field did not:  %q\n", fieldDef)109	}110	if tableFieldSchema, ok := fieldDef["fields"]; ok {111		fieldList, err := parseFieldList(tableFieldSchema.([]interface{}))112		if err != nil {113			return nil, err114		}115		fieldParsed.Fields = fieldList116	}117	return fieldParsed, nil118}119//  convert list of raw field data into list of TableFieldSchema refs120func parseFieldList(schema []interface{}) ([]*bigquery.TableFieldSchema, error) {121	tableFieldList := make([]*bigquery.TableFieldSchema, 0)122	for _, fieldInterface := range schema {123		fieldParsed, err := parseField(fieldInterface.(map[string]interface{}))124		if err != nil {125			return nil, err126		}127		tableFieldList = append(tableFieldList, fieldParsed)128	}129	return tableFieldList, nil130}131func resourceBigQueryTableCreate(d *schema.ResourceData, meta interface{}) error {132	config := meta.(*Config)133	// build tableRef134	datasetId := d.Get("datasetId").(string)135	tableId := d.Get("tableId").(string)136	tRef := &bigquery.TableReference{DatasetId: datasetId, ProjectId: config.Project, TableId: tableId}137	// build the table138	table := &bigquery.Table{TableReference: tRef}139	if description, ok := d.GetOk("description"); ok {140		table.Description = description.(string)141	}142	if expirationTime, ok := d.GetOk("expirationTime"); ok {143		table.ExpirationTime = expirationTime.(int64)144	}145	if friendlyName, ok := d.GetOk("friendlyName"); ok {146		table.FriendlyName = friendlyName.(string)147	}148	// build arbitrarily deep table schema149	//   first check that didn't specify both schema and schemaFile150	schema, schemaOk := d.GetOk("schema")151	schemaFile, schemaFileOk := d.GetOk("schemaFile")152	if schemaOk && schemaFileOk {153		return fmt.Errorf("Config contains both schema and schemaFile.  Specify at most one\n")154	} else if schemaOk {155		fieldList, err := parseFieldList(schema.([]interface{}))156		if err != nil {157			return err158		}159		table.Schema = &bigquery.TableSchema{Fields: fieldList}160	} else if schemaFileOk {161		schemaJson, err := ioutil.ReadFile(schemaFile.(string))162		if err != nil {163			return err164		}165		var schemaJsonInterface []interface{}166		err = json.Unmarshal(schemaJson, &schemaJsonInterface)167		if err != nil {168			return fmt.Errorf("Failed to decode json file with error: %q", err)169		}170		fieldList, err := parseFieldList(schemaJsonInterface)171		if err != nil {172			return err173		}174		table.Schema = &bigquery.TableSchema{Fields: fieldList}175	}176	call := config.clientBigQuery.Tables.Insert(config.Project, datasetId, table)177	_, err := call.Do()178	if err != nil {179		return err180	}181	err = resourceBigQueryTableRead(d, meta)182	if err != nil {183		return err184	}...

...13}14func errorExtraBytes(bytes int) error {15	return fmt.Errorf("Extra %d bytes at the end of the packet.", bytes)16}17func parseFieldList(buf *bytes.Buffer, count int) (list []Field) {18	list = make([]Field, count)19	for i := 0; i < count; i++ {20		binary.Read(buf, binary.BigEndian, &list[i])21	}22	return23}24func parseOptionsTemplateFlowSet(data []byte, header *FlowSetHeader) (interface{}, error) {25	var set OptionsTemplateFlowSet26	var t OptionsTemplateRecord27	set.Id = header.Id28	set.Length = header.Length29	buf := bytes.NewBuffer(data)30	headerLen := binary.Size(t.TemplateId) + binary.Size(t.ScopeLength) + binary.Size(t.OptionLength)31	for buf.Len() >= 4 { // Padding aligns to 4 byte boundary32		if buf.Len() < headerLen {33			return nil, errorMissingData(headerLen - buf.Len())34		}35		binary.Read(buf, binary.BigEndian, &t.TemplateId)36		binary.Read(buf, binary.BigEndian, &t.ScopeLength)37		binary.Read(buf, binary.BigEndian, &t.OptionLength)38		if buf.Len() < int(t.ScopeLength)+int(t.OptionLength) {39			return nil, errorMissingData(int(t.ScopeLength) + int(t.OptionLength) - buf.Len())40		}41		scopeCount := int(t.ScopeLength) / binary.Size(Field{})42		optionCount := int(t.OptionLength) / binary.Size(Field{})43		t.Scopes = parseFieldList(buf, scopeCount)44		t.Options = parseFieldList(buf, optionCount)45		set.Records = append(set.Records, t)46	}47	return set, nil48}49func parseTemplateFlowSet(data []byte, header *FlowSetHeader) (interface{}, error) {50	var set TemplateFlowSet51	var t TemplateRecord52	set.Id = header.Id53	set.Length = header.Length54	buf := bytes.NewBuffer(data)55	headerLen := binary.Size(t.TemplateId) + binary.Size(t.FieldCount)56	for buf.Len() >= 4 { // Padding aligns to 4 byte boundary57		if buf.Len() < headerLen {58			return nil, errorMissingData(headerLen - buf.Len())59		}60		binary.Read(buf, binary.BigEndian, &t.TemplateId)61		binary.Read(buf, binary.BigEndian, &t.FieldCount)62		fieldsLen := int(t.FieldCount) * binary.Size(Field{})63		if fieldsLen > buf.Len() {64			return nil, errorMissingData(fieldsLen - buf.Len())65		}66		t.Fields = parseFieldList(buf, int(t.FieldCount))67		set.Records = append(set.Records, t)68	}69	return set, nil70}71func parseDataFlowSet(data []byte, header *FlowSetHeader) (interface{}, error) {72	var set DataFlowSet73	set.Id = header.Id74	set.Length = header.Length75	set.Data = data76	return set, nil77}78func parseFlowSet(buf *bytes.Buffer) (interface{}, error) {79	var setHeader FlowSetHeader80	if buf.Len() < binary.Size(setHeader) {...

...96			}97			f := serviceFuncDef{Name: name}98			ft := m.Type.(*ast.FuncType)99			if ft.Params != nil {100				f.Args = parseFieldList(ft.Params)101			}102			if ft.Results != nil {103				f.Returns = parseFieldList(ft.Results)104			}105			funcs = append(funcs, f)106		}107	}108	return funcs109}110func parseFieldList(fl *ast.FieldList) []string {111	args := []string{}112	if fl.List == nil {113		return args114	}115	for _, a := range fl.List {116		argStr := ""117		switch a.Type.(type) {118		case *ast.SelectorExpr:119			as := a.Type.(*ast.SelectorExpr)120			argStr = as.X.(*ast.Ident).Name + "." + as.Sel.Name121		case *ast.StarExpr:122			as := a.Type.(*ast.StarExpr)123			argStr = "*service." + as.X.(*ast.Ident).Name124		case *ast.Ident:...

1package main2import (3	"go/ast"4	"strings"5)6// FindColumnInfo finds ColumnInfo in cols by name.7func FindColumnInfo(cols []*ColumnInfo, name string) *ColumnInfo {8	name = strings.ToLower(name)9	for _, col := range cols {10		if col.Name.L == name {11			return col12		}13	}14	return nil15}16// func ParseFuncDecl(decl *ast.FuncDecl) []string {17// 	var ret []string18// 	name := decl.Name.Name19// 	func_type := decl.Type20// 	params := ParseFieldList(func_type.Params)21// 	results := ParseFieldList(func_type.Results)22// 	if len(results) == 0 {23// 		ret = append(ret, "void " + name + "(" + strings.Join(params, " ") + ");")24// 	}25// 	return ret26// }27// func ParseFuncDecl1(decl *ast.FuncDecl) (string, string) {28// 	var ret []string29// 	var v1, v2, v3 string30// 	v1, v2, v3 = GetThreeValue()31// 	if _, st := GenInit(); st {32// 	}33// 	return ret34// }35// func ParseFuncDecl2(decl *ast.FuncDecl) (string, string, int, float64) {36// 	var ret []string37// 	return ret38// }...

1import (2func main() {3	f, err := parser.ParseFile(fset, "2.go", nil, parser.ParseComments)4	if err != nil {5		fmt.Println(err)6	}7	ast.Print(fset, f)8}9import (10func main() {11	f, err := parser.ParseFile(fset, "2.go", nil, parser.ParseComments)12	if err != nil {13		fmt.Println(err)14	}15	ast.Print(fset, f)16}

1import (2func main() {3    f, err := parser.ParseFile(fset, "1.go", nil, 0)4    if err != nil {5        fmt.Println(err)6    }7    ast.Print(fset, f)8    ast.Inspect(f, func(n ast.Node) bool {9        switch x := n.(type) {10            fmt.Println("Name:", x.Name)11            fmt.Println("Recv:", x.Recv)12            fmt.Println("Type:", x.Type)13            fmt.Println("Body:", x.Body)14            fmt.Println("Params", x.Type.Params)15            fmt.Println("Results", x.Type.Results)16            fmt.Println("FuncDecl:", x)17        }18    })19}20import (21func main() {22    f, err := parser.ParseFile(fset, "2.go", nil, 0)23    if err != nil {24        fmt.Println(err)25    }26    ast.Print(fset, f)27    ast.Inspect(f, func(n ast.Node) bool {28        switch x := n.(type) {29            fmt.Println("Name:", x.Name)30            fmt.Println("Recv:", x.Recv)31            fmt.Println("Type:", x.Type)32            fmt.Println("Body:", x.Body)33            fmt.Println("Params", x.Type.Params)34            fmt.Println("Results", x.Type.Results)35            fmt.Println("FuncDecl:", x)36        }37    })38}39import (40func main() {41    f, err := parser.ParseFile(fset,

1import (2func main() {3    f, err := parser.ParseFile(fset, "1.go", nil, parser.ParseComments)4    if err != nil {5        fmt.Println(err)6    }7    ast.Print(fset, f)8    for _, decl := range f.Decls {9        if genDecl, ok := decl.(*ast.GenDecl); ok {10            for _, spec := range genDecl.Specs {11                if typeSpec, ok := spec.(*ast.TypeSpec); ok {12                    if structType, ok := typeSpec.Type.(*ast.StructType); ok {13                        fields := parseFieldList(structType.Fields)14                        fmt.Printf("Fields: %v15                    }16                }17            }18        }19    }20}21import (22func main() {23    f, err := parser.ParseFile(fset, "1.go", nil, parser.ParseComments)24    if err != nil {25        fmt.Println(err)26    }27    ast.Print(fset, f)28    for _, decl := range f.Decls {29        if genDecl, ok := decl.(*ast.GenDecl); ok {30            for _, spec := range genDecl.Specs {31                if typeSpec, ok := spec.(*ast.TypeSpec); ok {32                    if structType, ok := typeSpec.Type.(*ast.StructType); ok {33                        fields := parseFieldList(structType.Fields)34                        fmt.Printf("Fields: %v35                    }36                }37            }38        }39    }40}41import (42func main() {43    f, err := parser.ParseFile(fset, "1.go", nil, parser.ParseComments)

1import (2func main() {3    if len(os.Args) != 2 {4        fmt.Printf("Usage: %s <file>5        os.Exit(1)6    }7    f, err := os.Open(filename)8    if err != nil {9        fmt.Println(err)10        os.Exit(1)11    }12    defer f.Close()13    fields, err := parseFieldList(f)14    if err != nil {15        fmt.Println(err)16        os.Exit(1)17    }18    for _, field := range fields {19        fmt.Println(field)20    }21}22import (23func main() {24    if len(os.Args) != 2 {25        fmt.Printf("Usage: %s <file>26        os.Exit(1)27    }28    f, err := os.Open(filename)29    if err != nil {30        fmt.Println(err)31        os.Exit(1)32    }33    defer f.Close()34    fields, err := parseFieldList(f)35    if err != nil {36        fmt.Println(err)37        os.Exit(1)38    }39    for _, field := range fields {40        fmt.Println(field)41    }42}43import (44func main() {45    if len(os.Args) != 2 {46        fmt.Printf("Usage: %s <file>47        os.Exit(1)48    }49    f, err := os.Open(filename)50    if err != nil {51        fmt.Println(err)52        os.Exit(1)53    }54    defer f.Close()55    fields, err := parseFieldList(f)56    if err != nil {57        fmt.Println(err)58        os.Exit(1)59    }60    for _, field := range fields {61        fmt.Println(field)62    }63}64import (65func main() {66    if len(os.Args)

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

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

1import(2func main(){3   m := main{}4   m.parseFieldList("a,b,c")5   fmt.Println(m.a)6   fmt.Println(m.b)7   fmt.Println(m.c)8}9import(10func main(){11   m := main{}12   m.parseFieldList("a,b,c")13   fmt.Println(m.a)14   fmt.Println(m.b)15   fmt.Println(m.c)16}17import(18func main(){19   m := main{}20   m.parseFieldList("a,b,c")21   fmt.Println(m.a)22   fmt.Println(m.b)23   fmt.Println(m.c)24}25import(26func main(){27   m := main{}28   m.parseFieldList("a,b,c")29   fmt.Println(m.a)30   fmt.Println(m.b)31   fmt.Println(m.c)32}33import(34func main(){35   m := main{}36   m.parseFieldList("a,b,c")37   fmt.Println(m.a)38   fmt.Println(m.b)39   fmt.Println(m.c)40}41import(42func main(){