func main() { var msg, country string flag.Parse() if *token_file == "" { flag.PrintDefaults() os.Exit(1) } token, err := ioutil.ReadFile(*token_file) if err != nil { log.Fatal(err) } bot, err := telebot.NewBot(string(token)) if err != nil { return } messages := make(chan telebot.Message) bot.Listen(messages, 1*time.Second) for message := range messages { // pretty.Println(message.Sender) msg = message.Text if msg == "/hi" { count := 1 for { pretty.Println(count) count++ bot.SendMessage(message.Chat, "Hello, "+message.Sender.FirstName+"!", nil) time.Sleep(1000 * time.Millisecond) } } else if strings.HasPrefix(msg, "/flag") { //check if flag is empty country = "ASEAN" //msg[6:] pretty.Print(country) photo := "./resources/flags/" + country + ".png" boom, err := telebot.NewFile(photo) if err != nil { pretty.Print(err) } pretty.Print(&bot) pretty.Print(&boom) // SendPhoto // telebot.File{}ASEAN&telebot.File{FileID:"", FileSize:0, filename:"./resources/flags/ASEAN.png"} // pretty.Print(reflect.TypeOf((*bot).SendMessage)) // // get from directory // err = bot.SendAudio(message.Chat, &boom, nil) // err = bot.SendMessage(message.Chat, &boom, nil) if err != nil { pretty.Print(err) } } } }
func main() { flag.Parse() if *inputFile == "" { log.Fatal("No input file specified") } if *outputFile == "" { *outputFile = *inputFile + ".gen.go" } f, err := os.Open(*inputFile) if err != nil { log.Fatal(err) } defer f.Close() s, err := schema.Parse(f) if err != nil { log.Fatal(err) } if *debug { pretty.Print(s) } output, _ := os.Create(*outputFile) s.(schema.Schema).Generate(output, *packageFile) }
func main() { if len(os.Args) == 1 { os.Exit(1) } backend, ok := schema.Backends[os.Args[1]] if !ok { fmt.Fprintln(os.Stderr, "No such backend, available backends are:") for name := range schema.Backends { fmt.Fprintln(os.Stderr, name) } os.Exit(1) } flags := backend.Flags() SchemaFile := "" Debug := false flags.StringVar(&SchemaFile, "schema", "", "Schema file to process") flags.BoolVar(&Debug, "debug", false, "Pretty print the resulting schema defs") flags.Parse(os.Args[2:]) if SchemaFile == "" { log.Fatal("No file specified") } file, err := os.Open(SchemaFile) if err != nil { log.Fatalf("Error opening schema file: %s", err) } if file == nil { log.Fatalf("error opening file %s", file) } s, err := schema.ParseSchema(file) if Debug { pretty.Print(s) } if err != nil { log.Fatalf("Error parsing schema: %s", err) } code, err := backend.Generate(s) if err != nil { log.Fatalf("Error generating output: %s", err) } err = ioutil.WriteFile(backend.GeneratedFilename(SchemaFile), []byte(code), 0666) if err != nil { log.Fatalf("Error writing output file: %s", err) } }
func TestParseHeader(t *testing.T) { input := ` 2|afrinic|20150612|7236|00000000|20150612|00000 afrinic|*|asn|*|2302|summary afrinic|*|ipv4|*|2935|summary afrinic|*|ipv6|*|1999|summary afrinic|ZA|asn|1228|1|19910301|allocated|F36B9F4B afrinic|ZA|asn|1229|1|19910301|allocated|F36B9F4B afrinic|ZA|asn|1230|1|19910301|allocated|F36B9F4B afrinic|ZA|asn|1231|1|19910301|allocated|F36B9F4B ` hdr, recs, err := Parse(strings.NewReader(input)) if err != nil { t.Fatal(err) } pretty.Print(hdr) pretty.Print(recs) }
// parseFile parses the given file and pretty-prints its abstract syntax tree to // standard output, optionally using the Gocc generated lexer. func parseFile(path string, goccLexer bool) error { // Create lexer for the input. buf, err := ioutilx.ReadFile(path) if err != nil { return errutil.Err(err) } if path == "-" { fmt.Fprintln(os.Stderr, "Parsing from standard input") } else { fmt.Fprintf(os.Stderr, "Parsing %q\n", path) } var s parser.Scanner if goccLexer { s = goccscanner.NewFromBytes(buf) } else { s = handscanner.NewFromBytes(buf) } // Parse input. p := parser.NewParser() file, err := p.Parse(s) if err != nil { if err, ok := err.(*errors.Error); ok { // Unwrap Gocc error. return parser.NewError(err) } return errutil.Err(err) } f := file.(*ast.File) for _, decl := range f.Decls { fmt.Println("=== [ Top-level declaration ] ===") fmt.Println() fmt.Printf("decl type: %T\n", decl) fmt.Println() fmt.Println("decl:", decl) fmt.Println() pretty.Print(decl) fmt.Println() spew.Print(decl) fmt.Println() fmt.Println() } return nil }
func main() { flag.Parse() p := MakeParser() data, err := ioutil.ReadFile(*inputFile) if err != nil { log.Fatal(err) } s, err := p.ParseString(string(data)) if err != nil { log.Fatal(err) } if *debug { pretty.Print(s) } output, _ := os.Create(*outputFile) s.(schema.Schema).Generate(output, *packageFile) }
func print(c *cli.Context, model Model) { var err error var value []byte key := c.String("encryptionKey") label := c.String("activeKeyLabel") if len(c.Args()) > 0 { value = []byte(c.Args()[0]) } else { bio := bufio.NewReader(os.Stdin) value, err = bio.ReadBytes(0) if err != io.EOF { panic(err) os.Exit(1) } } err = model.Unmarshal(decrypt([]byte(value), key, label)) if err != nil { fmt.Println(err) } else { pretty.Print(model) } }
func pp(a ...interface{}) (int, error) { if debug { return pretty.Print(a...) } return 0, nil }
func gdebug(g Graph, args ...interface{}) { fmt.Println("DEBUG: graph type", reflect.New(reflect.Indirect(reflect.ValueOf(g)).Type())) pretty.Print(args...) }