Mojom formatter incorporated in the mojom binary.

mojom/mojom_parser/parse_cmd.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /*
- This file contains the main() for the Mojom parser binary. This tool parses
- a set of .mojom files and emits a serialized MojomFileGraph struct. See
- mojom_files.mojom for the definition of MojomFileGraph.
+ This file contains parseCmd which parses a set of .mojom files and emits a
+ serialized MojomFileGraph struct. See mojom_files.mojom for the definition of
+ MojomFileGraph.
 
- The tool is invoked as follows:
+ The parse command is invoked as follows:
 
-     mojom_parser [-I <include_dirs>] [-out <out_file>] [-debug] <mojom_file>...
+     mojom parse [-I <include_dirs>] [-out <out_file>] [-debug] <mojom_file>...
 
  <include_dirs> is comma-separated list of directory paths to search for mojom imports.
  <out_file> is the path to the output file. If not given the output will be written to standard out.
  <mojom_file>... is one or more paths to  .mojom files to be parsed.
 
  If there are no errors then the program returns status zero and writes nothing
  to standard error and writes nothing to standard out except possibly the output
  if <out_file> is not specified. If there are any errors then the program returns
  status code 1 and writes error messages to standard error.
 
@@ skipping 34 matching lines @@
                         return err
                 }
                 if !info.IsDir() {
                         return fmt.Errorf("%s is not a directory.", name)
                 }
                 *dl = append(*dl, name)
         }
         return nil
 }
 
-var directoryListFlag DirectoryList
+// parseCmd implements the parse command for the mojom tool.
+// The slice of strings |args| is the list of arguments passed on the command
+// line starting with the program name and followed by the invoked command.
+func parseCmd(args []string) {
+        flagSet := flag.NewFlagSet("parse", flag.ContinueOnError)
+        var directoryListFlag DirectoryList
+        flagSet.Var(&directoryListFlag, "I", "comma-separated list of directory paths to search for mojom imports")
+        outFile := flagSet.String("out", "", "The path to the output file. If not present the output will "+
+                "be written to standard out.")
+        debug := flagSet.Bool("debug", false, "Generate debug data including the parse tree and print it to standard out.")
+        metaDataOnly := flagSet.Bool("meta-data-only", false, "Only parse file attributes and 'module' statement, "+
+                "not mojom declarations or import statements.")
 
-func init() {
-        flag.Var(&directoryListFlag, "I", "comma-separated list of directory paths to search for mojom imports")
-}
+        printUsage := func() {
+                fmt.Fprintf(os.Stderr, "Usage: %s parse [-I <include_dirs>] [-out <out_file>] [-debug] [-meta-data-only] <mojom_file>...\n\n", filepath.Base(args[0]))
+                flagSet.PrintDefaults()
+        }
 
-func main() {
-        outFile := flag.String("out", "", "The path to the output file. If not present the output will "+
-                "be written to standard out.")
-        debug := flag.Bool("debug", false, "Generate debug data including the parse tree and print it to standard out.")
-        metaDataOnly := flag.Bool("meta-data-only", false, "Only parse file attributes and 'module' statement, "+
-                "not mojom declarations or import statements.")
-        flag.Parse()
+        if err := flagSet.Parse(args[2:]); err != nil {
+                fmt.Fprintln(os.Stderr, err.Error())

[rudominer, 2016/02/19 20:42:42]

This is still not working perfectly. When I type
./mojom_parser_linux_amd64 parse

I get the nice usage line, but when I type

./mojom_parser_linux_amd64 parse -h

I don't. I think we always want the nice usage line.

I'm reading my previous comment to you that caused you to remove the call to
printUsage() and I can't understand how the result that I claimed I was seeing
would be possible with the previous version of the code. But I copied and pasted
it from the console.
Would you please just play around with different possible user inputs and make
sure that the output message is good in all cases.
I think what we want is the usage line followed by the table of flag
definitions.

[azani, 2016/02/19 23:23:24]

Done.

+                os.Exit(1)
+        }
 
-        fileNames := flag.Args()
+        fileNames := flagSet.Args()
         if len(fileNames) == 0 {
-                ErrorExit(fmt.Sprintf("No .mojom files given.\n"+
-                        "Usage: %s [-I <include_dirs>] [-out <out_file>] [-debug] [-meta-data-only] <mojom_file>...",
-                        filepath.Base(os.Args[0])))
+                fmt.Fprintln(os.Stderr, "No .mojom files given.")
+                printUsage()
+                os.Exit(1)
         }
 
         parseDriver := parser.NewDriver(directoryListFlag, *debug, *metaDataOnly)
 
         // Do the parsing
         descriptor, err := parseDriver.ParseFiles(fileNames)
         if err != nil {
                 ErrorExit(fmt.Sprintf("%s", err.Error()))
         } else if *debug {
                 fmt.Println("Parsing complete.")
@@ skipping 21 matching lines @@
                 if err := ioutil.WriteFile(*outFile, bytes, os.ModePerm); err != nil {
                         ErrorExit(fmt.Sprintf("Error writing output to %s: %s.", *outFile, err.Error()))
                 } else {
                         if *debug {
                                 fmt.Printf("The output was written to %s.\n", *outFile)
                         }
                 }
         }
 }
 
-func ErrorExit(message string) {
-        fmt.Fprintf(os.Stderr, "%s\n", message)
-        os.Exit(1)
-}
-
 func PrintDebugOutput(debugString string, descriptor *mojom.MojomDescriptor) {
         fmt.Println("\n\n=============================================")
         fmt.Println("\n Pre-Serialized Go Object:")
         fmt.Printf("\n%s\n", descriptor.String())
         fmt.Println("\n\n=============================================")
         fmt.Println("\n Debug Serialized Output:")
         fmt.Println(debugString)
 }