func main() {
format := "tree"
formats := make([]string, 0, len(formatters))
for k := range formatters {
formats = append(formats, k)
}
sort.Strings(formats)
var traceP string
var help bool
getopt.CommandLine.ListVarLong(&yang.Path, "path", 0, "comma separated list of directories to add to PATH")
getopt.CommandLine.StringVarLong(&format, "format", 0, "format to display: "+strings.Join(formats, ", "))
getopt.CommandLine.StringVarLong(&traceP, "trace", 0, "file to write trace into")
getopt.CommandLine.BoolVarLong(&help, "help", '?', "display help")
getopt.Parse()
if traceP != "" {
fp, err := os.Create(traceP)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
trace.Start(fp)
stop = func(c int) { trace.Stop(); os.Exit(c) }
defer func() { trace.Stop() }()
}
if help {
getopt.CommandLine.PrintUsage(os.Stderr)
fmt.Fprintf(os.Stderr, "\nFormats:\n")
for _, fn := range formats {
f := formatters[fn]
fmt.Fprintf(os.Stderr, " %s - %s\n", f.name, f.help)
}
stop(0)
}
if _, ok := formatters[format]; !ok {
fmt.Fprintf(os.Stderr, "%s: invalid format. Choices are %s\n", format, strings.Join(formats, ", "))
stop(1)
}
files := getopt.Args()
if len(files) > 0 && !strings.HasSuffix(files[0], ".yang") {
e, errs := yang.GetModule(files[0], files[1:]...)
exitIfError(errs)
Write(os.Stdout, e)
return
}
// Okay, either there are no arguments and we read stdin, or there
// is one or more file names listed. Read them in and display them.
ms := yang.NewModules()
if len(files) == 0 {
data, err := ioutil.ReadAll(os.Stdin)
if err == nil {
err = ms.Parse(string(data), "<STDIN>")
}
if err != nil {
fmt.Fprintln(os.Stderr, err)
stop(1)
}
}
for _, name := range files {
if err := ms.Read(name); err != nil {
fmt.Fprintln(os.Stderr, err)
continue
}
}
// Process the read files, exiting if any errors were found.
exitIfError(ms.Process())
// Keep track of the top level modules we read in.
// Those are the only modules we want to print below.
mods := map[string]*yang.Module{}
var names []string
for _, m := range ms.Modules {
if mods[m.Name] == nil {
mods[m.Name] = m
names = append(names, m.Name)
}
}
sort.Strings(names)
entries := make([]*yang.Entry, len(names))
for x, n := range names {
entries[x] = yang.ToEntry(mods[n])
}
formatters[format].f(os.Stdout, entries)
}
func main() {
format := "tree"
getopt.CommandLine.ListVarLong(&yang.Path, "path", 0, "comma separated list of directories to add to PATH")
getopt.CommandLine.StringVarLong(&format, "format", 0, "format to display: tree, proto, types")
getopt.Parse()
files := getopt.Args()
if len(files) > 0 && !strings.HasSuffix(files[0], ".yang") {
e, errs := yang.GetModule(files[0], files[1:]...)
exitIfError(errs)
Write(os.Stdout, e)
return
}
// Okay, either there are no arguments and we read stdin, or there
// is one or more file names listed. Read them in and display them.
ms := yang.NewModules()
if len(files) == 0 {
data, err := ioutil.ReadAll(os.Stdin)
if err == nil {
err = ms.Parse(string(data), "<STDIN>")
}
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
for _, name := range files {
if err := ms.Read(name); err != nil {
fmt.Fprintln(os.Stderr, err)
continue
}
}
// Keep track of the top level modules we read in.
// Those are the only modules we want to print below.
mods := map[string]*yang.Module{}
var names []string
for _, m := range ms.Modules {
if mods[m.Name] == nil {
mods[m.Name] = m
names = append(names, m.Name)
}
}
sort.Strings(names)
// Print any errors found in the tree. This will return false if
// there were no errors.
exitIfError(ms.Process())
switch format {
case "tree":
for _, n := range names {
Write(os.Stdout, yang.ToEntry(mods[n]))
}
case "proto":
for _, n := range names {
for _, e := range flatten(yang.ToEntry(mods[n])) {
FormatNode(os.Stdout, e)
}
}
case "types":
types := Types{}
for _, n := range names {
types.AddEntry(yang.ToEntry(mods[n]))
}
for t := range types {
YTPrint(os.Stdout, t)
}
default:
fmt.Fprintf(os.Stderr, "unknown format: %s\n", format)
os.Exit(1)
}
}