Golang scanner.Scanner类代码示例

func readGridFromFile(path string) (*ttypes.Grid, []ttypes.BotConf) {
	gridFile, err := os.Open(path, os.O_RDONLY, 0)
	if err != nil {
		log.Panic(err)
	}
	defer gridFile.Close()

	var s scanner.Scanner
	s.Init(gridFile)
	w := scanAndReadUint(&s)
	h := scanAndReadUint(&s)
	grid := simpleGrid(w, h)

	botConfs := make([]ttypes.BotConf, 0)
	for j := uint(0); j < h; j++ {
		for i := uint(0); i < w; i++ {
			tok := uint8(scanAndReadUint(&s))
			if tok > 0 {
				botConfs = append(botConfs, ttypes.BotConf{"build/test", i, j})
			}
		}
	}

	return grid, botConfs
}

func expectToken(found token, expected string, s *scanner.Scanner) {
	if found.tokentype != expected {
		fmt.Println("On line ", s.LineNumber(), "; Expected ", expected, " found ", found.tokentype, " with value '", found.value, "'")
		os.Exit(1)
	}

}

func scanAndReadUint(s *scanner.Scanner) uint {
	s.Scan()
	tok, err := strconv.Atoui(s.TokenText())
	if err != nil {
		log.Panic(err)
	}
	return tok
}

/*func (d *Decoder) decode(src io.Reader) {

}
*/
func main() {
	flag.Parse()
	if flag.NArg() != 1 {
		fmt.Println("wrong number of arguments")
		os.Exit(1)
	}

	file, err := os.Open(flag.Arg(0), os.O_RDONLY, 0)
	if file == nil {
		fmt.Printf("can't open file; err=%s\n", err.String())
		os.Exit(1)
	}

	var s scanner.Scanner
	s.Init(file)
	tok := s.Scan()
	for tok != scanner.EOF {
		fmt.Println(scanner.TokenString(tok))
		tok = s.Scan()
	}
	fmt.Println()

	file.Close()
}

func main() {
	var s scanner.Scanner
	s.Init(os.Stdin)
	s.Scan()
	total, _ := strconv.Atoi(s.TokenText())
	for i := 1; i <= total; i++ {
		s.Scan()
		_ = s.TokenText()
		s.Scan()
		b, _ := strconv.Atoi(s.TokenText())
		var out string
		if b%2 == 0 {
			out = "WHITE"
		} else {
			out = "BLACK"
		}
		fmt.Printf("Case #%d: %s\n", i, out)
	}
}

func (h *Hyphenator) loadPatterns(reader io.Reader) os.Error {
	var s scanner.Scanner
	s.Init(reader)
	s.Mode = scanner.ScanIdents | scanner.ScanRawStrings | scanner.SkipComments

	var which string

	tok := s.Scan()
	for tok != scanner.EOF {
		switch tok {
		case scanner.Ident:
			// we handle two identifiers: 'patterns' and 'exceptions'
			switch ident := s.TokenText(); ident {
			case `patterns`, `exceptions`:
				which = ident
			default:
				return os.ErrorString(fmt.Sprintf("Unrecognized identifier '%s' at position %v",
					ident, s.Pos()))
			}
		case scanner.String, scanner.RawString:
			// trim the quotes from around the string
			tokstr := s.TokenText()
			str := tokstr[1 : len(tokstr)-1]

			switch which {
			case `patterns`:
				h.patterns.AddPatternString(str)
			case `exceptions`:
				key := strings.Replace(str, `-`, ``, -1)
				h.exceptions[key] = str
			}
		}
		tok = s.Scan()
	}
	return nil
}

func (h *Hyphenator) Hyphenate(s, hyphen string) (string, bool) {
	var sc scanner.Scanner
	sc.Init(strings.NewReader(s))
	sc.Mode = scanner.ScanIdents
	sc.Whitespace = 0

	var outstr string

	tok := sc.Scan()
	for tok != scanner.EOF {
		switch tok {
		case scanner.Ident:
			// a word (or part thereof) to hyphenate
			t := sc.TokenText()

			// try the exceptions first
			exc := h.exceptions[t]
			if len(exc) != 0 {
				if hyphen != `-` {
					strings.Replace(exc, `-`, hyphen, -1)
				}
				return exc, true
			}

			// not an exception, hyphenate normally
			outstr += h.hyphenateWord(sc.TokenText(), hyphen)
		default:
			// A Unicode rune to append to the output
			p := make([]byte, utf8.UTFMax)
			l := utf8.EncodeRune(tok, p)
			outstr += string(p[0:l])
		}

		tok = sc.Scan()
	}

	return outstr, true
}

func main() {

	var scanInput scanner.Scanner
	scanInput.Init(os.Stdin)

	// main loop, reads scanner input and parses, EOF is strictly not used at this time.
	for scanInput.Scan() != scanner.EOF {
		switch scanInput.TokenText() {
		case "load", "l":
			scanInput.Scan()
			fmt.Printf("Loading file \"%s\" from database\n", scanInput.TokenText())
			go readHandler.LoadFile(scanInput.TokenText())
		case "save", "store", "s":
			scanInput.Scan()
			fmt.Printf("Storing file \"%s\" to database\n", scanInput.TokenText())
			go storeFile(scanInput.TokenText())
		case "hora":
			fmt.Printf("kingkong IS ONE!")
			os.Exit(0)
		}
	}
}

func loadPatterns(reader io.Reader) (*Trie, os.Error) {
	trie := NewTrie()
	var s scanner.Scanner
	s.Init(reader)
	s.Mode = scanner.ScanIdents | scanner.ScanRawStrings | scanner.SkipComments

	var which string

	tok := s.Scan()
	for tok != scanner.EOF {
		switch tok {
		case scanner.Ident:
			// we handle two identifiers: 'patterns' and 'exceptions'
			switch ident := s.TokenText(); ident {
			case `patterns`, `exceptions`:
				which = ident
			default:
				return nil, os.ErrorString(fmt.Sprintf("Unrecognized identifier '%s' at position %v",
					ident, s.Pos()))
			}
		case scanner.String, scanner.RawString:
			// trim the quotes from around the string
			tokstr := s.TokenText()
			str := tokstr[1 : len(tokstr)-1]

			switch which {
			case `patterns`:
				trie.AddPatternString(str)
			}
		}
		tok = s.Scan()
	}

	return trie, nil
}

func scan(c *scanner.Scanner) token {
	c.EatWhitespaceAndComments()
	if c.Peek() == '/' {
		c.ReadChar()
		return token{"Divide", ""}
	} else if c.EndOfFile() {
		log.Println("Found EOF")
		return token{"EOF", ""}
	} else if c.Peek() == '-' {
		c.ReadChar()
		chr := c.ReadChar()
		if chr != '>' {
			c.Fail("Found -, and expected a \"to\" statement(->) but found ", chr)
		}
		return token{"To", ""}
	} else if utils.IsAlphabetic(c.Peek()) {
		word := c.ReadWord()
		if word == "States" {
			return token{"States", ""}
		} else if word == "Edges" {
			return token{"Edges", ""}
		}
		return token{"Word", word}

	} else if utils.IsNumeric(c.Peek()) {
		integer := strconv.Itoa(c.ReadNumber())
		return token{"Integer", integer}
	} else {
		c.Fail("Unexpected keyword ", c.Peek())
	}
	return token{}
}