yaggo 1.5.10

data/lib/yaggo/man_page.rb

@@ -0,0 +1,449 @@
+# This file is part of Yaggo.
+
+# Yaggo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Yaggo is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Yaggo.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'pathname'
+
+def display_man_page out
+  manual = <<EOS
+.TH yaggo 1  "2015-06-24" "version #{$yaggo_version}" "USER COMMANDS"
+
+.SH NAME
+yaggo \- command line switch parser generator
+
+.SH SYNOPSIS
+.B yaggo
+[-o|--output FILE] [-l|--license PATH] [-s|--stub] [--zc PATH] [-e|--extended-syntax] [--man] [-h|--help]
+
+.SH DESCRIPTION
+Yaggo stands for Yet Another GenGetOpt. It is inspired by gengetopt
+software from the FSF.
+
+Yaggo generates a C++ class to parse command line switches (usually
+argc and argv passed to main) using getopt_long. The switches and
+arguments to the program are specified in a description file. To each
+description file, yaggo generates one C++ header file containing the
+parsing code.
+.PP
+See the EXAMPLES section for a complete and simple example.
+
+.SH OPTIONS
+.TP
+\-l|\-\-license
+Display the file at the top of the generated headers. It usually
+contains the license governing the distribution of the headers.
+.TP
+-m|\-\-man
+Display this man page
+.TP
+\-s|\-\-stub
+Generate a stub: a simple yaggo file that can be modified for one's use.
+.TP
+\-e|--extended-syntax
+Use the extended syntax: blocks can be defined on the next line of a command.
+.TP
+\-h|--help
+Display a short help text
+.PP
+
+.SH EXAMPLE
+
+Consider the description files 'example_args.yaggo' which defines a
+switch "-i" (or "--int") that takes an unsigned integer and defaults
+to 42; a switch "-s" (or "--string") that takes a string and can be
+given multiple times; a switch "--flag" which does not take any
+argument; a switch "--severity" which can take only 3 values: "low",
+"middle" and "high".
+
+It takes the following arguments: a string followed by zero or more floating point numbers.
+
+.nf
+purpose "Example of yaggo usage"
+package "example"
+description "This is just an example.
+And a multi-line description."
+
+option("int", "i") {
+  description "Integer switch"
+  uint32; default "42" }
+option("string", "s") {
+  description "Many strings"
+  string; multiple }
+option("flag") {
+  description "A flag switch"
+  flag; off }
+option("severity") {
+  description "An enum switch"
+  enum "low", "middle", "high" }
+arg("first") {
+  description "First arg"
+  c_string }
+arg("rest") {
+  description "Rest of'em"
+  double; multiple }
+.fi
+
+The associated simple C++ program 'examples.cpp' which display information about the switches and arguments passed:
+
+.nf
+#include <iostream>
+#include "example_args.hpp"
+
+int main(int argc, char *argv[]) {
+  example_args args(argc, argv);
+
+  std::cout << "Integer switch: " << args.int_arg << "\\\\n";
+  if(args.string_given)
+    std::cout << "Number of string(s): " << args.string_arg.size() << "\\\\n";
+  else
+    std::cout << "No string switch\\\\n";
+  std::cout << "Flag is " << (args.flag_flag ? "on" : "off") << "\\\\n";
+  std::cout << "First arg: " << args.first_arg << "\\\\n";
+  std::cout << "Severity arg: " << args.severity_arg << " " << example_args::severity::strs[args.severity_arg] << "\\\\n";
+  if(args.severity_arg == example_args::severity::high)
+    std::cout << "Warning: severity is high\\\\n";
+  std::cout << "Rest:";
+  for(example_args::rest_arg_it it = args.rest_arg.begin(); it != args.rest_arg.end(); ++it)
+    std::cout << " " << *it;
+  std::cout << std::endl;
+
+  return 0;
+}
+.fi
+
+This can be compiled with the following commands:
+
+.nf
+% yaggo example_args.yaggo
+% g++ -o example example.cpp
+.fi
+
+The yaggo command above will create by default the file
+'example_args.hpp' (changed '.yaggo' extension to '.hpp'). The output
+file name can be changed with the 'output' keyword explained below.
+
+.SH DESCRIPTION FORMAT
+
+A description file is a sequence of statements. A statement is a
+keyword followed by some arguments. Strings must be surrounded by
+quotes ("" or '') and can span multiple lines. The order of the
+statements is irrelevant. Statements are separated by new lines or
+semi-colons ';'.
+
+.IP *
+Technically speaking, yaggo is implemented as a DSL (Domain Specific
+Language) using ruby. The description file is a valid ruby script and
+the keywords are ruby functions.
+.PP
+
+The following statements are global, not attached to a particular option or argument.
+
+.TP
+purpose
+A one line description of the program.
+.TP
+package
+The name of the package for the usage string. Defaults to the name of the class.
+.TP
+usage
+The usage string. If none given a standard one is generated by yaggo.
+.TP
+description
+A longer description of the program displayed before the list of switch. Displayed by the help.
+.TP
+text
+Some text to be displayed after the list of switches. Displayed by the help.
+.TP
+version
+The version string of the software.
+.TP
+license
+The license and copyright string of the software.
+.TP
+name
+The name of the class generated. Defaults to the name of the
+description file minus the .yaggo extension.
+.TP
+posix
+Posix correct behavior (instead of GNU behavior): switch processing
+stops at the first non-option argument
+.TP
+output
+The name of the output file. Defaults to the name of the
+description file with the .yaggo extension changed to .hpp.
+.PP
+
+The 'option' statement takes one or two arguments, which must be in
+parentheses, and a block of statements surrounded by curly braces
+({...}). The arguments are the long and short version of the
+option. Either one of the long or short version can be omitted. The
+block of statements describe the option in more details, as described
+below.
+
+A switch is named after the long version, or the short version if no
+long version. An 'option' statement for an option named 'switch'
+defines one or two public members in the class. For a flag, it
+creates 'switch_flag' as a boolean. Otherwise, it
+creates 'switch_arg', with a type as specified, and 'switch_given', a
+boolean indicating whether or not the switch was given on the command
+line.
+
+For example, the statement:
+
+.nf
+option("integer", "i") {
+  int; default 5
+}
+.fi
+
+will add the following members to the C++ class:
+
+.nf
+int integer_arg;
+bool integer_given;
+.fi
+
+where "integer_arg" is initialized to 5 and "integer_given" is
+initialized to "false". If the switch "--integer 10" or "-i 10" is
+passed on the command line "integer_arg" is set to 10 and
+integer_given is set to "true".
+
+The statement:
+
+.nf
+option("verbose") {
+  off
+}
+.fi
+
+will add the following member to the C++ class:
+
+.nf
+bool verbose_flag;
+.fi
+
+where "verbose_flag" is initialized to "false". Passing the switch
+"--verbose" on the command line sets "verbose_flag" to true".
+
+
+In addition to the switch created by 'option', the following switches
+are defined by default (unless some option statement overrides them):
+
+.TP
+\-h, \-\-help
+Display the help message.
+.TP
+\-\-full\-help
+Display hidden options as well.
+.TP
+\-\-version
+Display version string.
+.PP
+
+The following statement are recognized in an option block:
+
+.TP
+description "str"
+A short description for this switch.
+
+.TP
+int32, int64, uint32, uint64, double, int, long
+This switch is parsed as a number with the corresponding type int32_t,
+int64_t, uint32_t, uint64_t, double, int and long.
+
+.TP
+suffix
+Valid for numerical type switches as above. It can be appended
+with a SI suffix (e.g. 1M mean 1000000). The suffixes k, M, G, T, P,
+and E are supported for all the numerical types. The suffixes m, u, n,
+p, f, and a are supported for the double type.
+
+.TP
+c_string, string
+This switch is taken as a C string (const char *) or a C++ string
+(inherits from std::string). The C++ string type has the extra
+methods '<type> as_<type>(bool suffix)', where <type> is any numerical
+type as above, to convert the string into that type. If the 'suffix'
+boolean is true, parsing is done using SI suffixes.
+
+.TP
+enum
+This statement must be followed by a comma separated list of strings
+(as in 'enum "choice0", "choice1", "choice2"'). This switch takes value
+a string in the list and is converted to int. C enum type named
+"switchname::enum" is defined with the same choices in the given order.
+
+.TP
+required
+This switch is required. An error is generated if not given on the
+command line.
+.TP
+conflict
+Specify a comma separated list of switches that conflicts with this
+one.
+.TP
+imply
+Specify a comma separated list of switches (of type flag) which are
+implied by this one.
+.TP
+hidden
+This switch is not shown with --help. Use --full-help to see the
+hidden switches, if any.
+.TP
+secret
+This switch is not shown in any help message. Neither --help nor
+--full-help.
+.TP
+multiple
+This switch can be passed multiple times. The values are stored in a
+std::vector. A type for the iterator is also defined in the class with
+the name 'switch_arg_it', where 'switch' is the name of the option.
+.TP
+flag
+This switch is a flag and does not take an argument.
+.TP
+on, off
+The default state for a flag switch. Implies flag. Unless the 'no'
+option is used (see below), with 'off', the default value of the flag
+is "false" and passing --flag sets it to true. With 'on', the default
+value of the flag is "true" and passing --flag sets it to false.
+.TP
+no
+A flag with two switches. If the switch is named "flag", two switches
+are generated: --flag and --noflag, respectively setting it to "true"
+and "false". The 'on' and 'off' options define the default value.
+.TP
+default "val"
+The default value for this switch. It can be a string or a valid
+number. SI suffixes are supported as well (for example "1M" means 1
+m`illion).
+.TP
+typestr "str"
+In the help message, by default, the type of the option is
+displayed. It can be replaced by the string given to 'typestr'.
+.TP
+at_least n
+The given switch must be given at least n times. Implies multiple.
+.TP
+access "type"
+Make sure that the string passed is a path to which we have
+access. "type" is a comma separated list of "read", "write" or
+"exec". It is checked with access(2). The same warning applies:
+
+"Warning: Using access() to check if a user is authorized to, for
+example, open a file before actually doing so using open(2) creates a
+security hole, because the user might exploit the short time interval
+between checking and opening the file to manipulate it.  For this
+reason, the use of this system call should be avoided.  (In the
+example just described, a safer alternative would be to temporarily
+switch the process's effective user ID to the real ID and then call
+open(2).)"
+
+.PP
+
+A 'arg' statement defines an arg passed to the command line. The
+statement takes a single argument, the name of the arg, and a block of
+statements. The block of statements are similar to the option block,
+except that "hidden", "flag", "on", "off" and "no" are not allowed. At
+most one arg can have the 'multiple' statement, and it must be the
+last one.
+
+.SH EXAMPLE USAGE
+
+The argument object parses the switches on construction or later on
+using the parse method. For example, the two pieces code show these
+two different usage.
+
+Using parse method:
+.nf
+  example_args args; // Global variable with switches
+
+  int main(int argc, char* argv[]) {
+    args.parse(argc, argv);
+  }
+.fi
+
+Parse on construction:
+.nf
+  int main(int argc, char* argv[]) {
+    example_args args(argc, argv);
+  }
+.fi
+
+The subclass error can be used to output error messsage (and terminate
+program). It output an error message, the usage string, etc. The error
+class behave like an output stream, it can be used to create
+complicated error message. For example:
+
+.nf
+  if(false_condition)
+    example_args::error() << "Failed to open file '" << args.file_arg << "'";
+.fi
+
+An error object prints an error message and terminate the program with
+exit upon destruction. An exit code can be passed to error. By default
+the exit code (passed to exit) is the constant EXIT_FAILURE (normally
+1). For example:
+
+.nf
+  example_args::error(77) << "Failed with return code 77";
+.fi
+
+.SH LICENSE
+
+There are 2 parts to the software: the yaggo ruby script itself, and
+the header files generated by yaggo from the description files. The
+licenses are as follow:
+
+.TP
+yaggo the ruby script
+This software is licensed under the GNU General
+Public License version 3 or any later version. Copyright (c) 2011
+Guillaume Marcais.
+
+.TP The generated header files.  These files have the license and
+copyright that you, the user of yaggo, assign with the 'license'
+keyword.  .PP In short: only yaggo the software is GPL. The generated
+header files are considered derivative of your work (e.g. the
+description), and you define the copyright and license of those as you
+see fit.
+
+.SH BUGS
+.IP *
+The error message returned by ruby can be a little confusing.
+
+.SH AUTHOR
+Guillaume Marcais (gmarcais@umd.edu)
+.SH SEE ALSO
+getopt_long(3), gengetopt(1), exit(2)
+EOS
+
+  if !out && STDOUT.isatty
+    require 'tempfile'
+    Tempfile.open("yaggo_man") do |fd|
+      begin
+        fd.write(manual)
+        fd.flush
+        system("man", fd.path)
+      ensure
+        fd.unlink
+      end
+    end
+  elsif !out
+    STDOUT.puts(manual)
+  else
+    path = Pathname.new(out)
+    path.write manual
+  end
+end

data/lib/yaggo/parser.rb

@@ -0,0 +1,404 @@
+# This file is part of Yaggo.
+
+# Yaggo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Yaggo is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Yaggo.  If not, see <http://www.gnu.org/licenses/>.
+
+def quote_newline_dquotes str, spaces = ""
+  str.gsub(/"/, '\\"').split(/\n/).join("\\n\" \\\n#{spaces}\"")
+end
+
+def output_options_descriptions out, opts, hidden
+  opts.each { |o|
+    # need to be improved. break lines if too long
+    next if o.secret || (o.hidden ^ hidden)
+    s = " " + o.switches
+    if s.size >= $switchesjust
+      s += "\\n" + "".ljust($switchesjust)
+    else
+      s = s.ljust($switchesjust)
+    end
+    out.puts("    \"#{s} #{o.help}\\n\"") 
+  }
+end
+
+def output_cpp_parser(h, class_name)
+  $options.each { |o| o.check }
+  $args.each { |a| a.check }
+  if $args.size > 1
+    mul_args = $args[0..-2].select { |a| a.multiple }
+    if mul_args.size > 0
+      gram = mul_args.size > 1 ? "s are" : " is"
+      raise "The following#{gram} not the last arg but marked multiple: #{mul_args.map { |a| a.name }.join(", ")}"
+    end
+  end
+
+  # Headers
+
+  h.puts(<<EOS)
+/***** This code was generated by Yaggo. Do not edit ******/
+
+EOS
+
+  if $license
+    lines = $license.split(/\n/)
+    h.puts("/* #{lines[0]}", *(lines[1..-1].map { |l| " * " + l }))
+    h.puts(" */", "")
+  elsif $yaggo_options[:license]
+    open($yaggo_options[:license]) { |fd|
+      h.puts(fd.read)
+    }
+    h.puts("")
+  end
+
+h.puts(<<EOS)
+#ifndef __#{class_name.upcase()}_HPP__
+#define __#{class_name.upcase()}_HPP__
+
+#include <stdint.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <errno.h>
+#include <string.h>
+#include <stdexcept>
+#include <string>
+#include <limits>
+#include <vector>
+#include <iostream>
+#include <sstream>
+#include <memory>
+
+class #{class_name} {
+ // Boiler plate stuff. Conversion from string to other formats
+EOS
+
+  output_conversion_code h
+
+  h.puts(<<EOS)
+public:
+EOS
+
+  static_decl = $options.map { |o| o.static_decl }.flatten
+  h.puts("  " + static_decl.join("\n  "), "") unless static_decl.empty?
+
+  ($options + $args).each { |o| h.puts("  " + o.var_decl.join("\n  ")) }
+  h.puts("")
+
+  # Create enum if option with no short version
+  only_long = $options.map { |o| o.long_enum }.flatten.compact
+  need_full = $options.any? { |o| o.hidden }
+
+  help_no_h = $options.any? { |o| o.short == "h" }
+  version_no_V = $options.any? { |o| o.short == "V" }
+  usage_no_U = $options.any? { |o| o.short == "U" }
+  h.print("  enum {\n    START_OPT = 1000")
+  h.print(",\n    FULL_HELP_OPT") if need_full
+  h.print(",\n    HELP_OPT") if help_no_h
+  h.print(",\n    VERSION_OPT") if version_no_V
+  h.print(",\n    USAGE_OPT") if usage_no_U
+  if only_long.empty?
+    h.puts("\n  };")
+  else
+    h.puts(",", "    " + only_long.join(",\n    "), "  };")
+  end
+
+  # Constructors and initialization
+  h.puts("", "  #{class_name}() :")
+  h.puts("    " + ($options + $args).map { |o| o.init }.join(",\n    "), "  { }")
+  h.puts("", "  #{class_name}(int argc, char* argv[]) :")
+  h.puts("    " + ($options + $args).map { |o| o.init }.join(",\n    "))
+  h.puts("  { parse(argc, argv); }", "");
+
+  # Main arsing function
+  h.puts("  void parse(int argc, char* argv[]) {",
+         "    static struct option long_options[] = {")
+  $options.empty? or
+    h.puts("      " + $options.map { |o| o.struct }.flatten.join(",\n      ") + ",")
+  h.puts("      {\"help\", 0, 0, #{help_no_h ? "HELP_OPT" : "'h'"}},")
+  h.puts("      {\"full-help\", 0, 0, FULL_HELP_OPT},") if need_full
+  h.puts("      {\"usage\", 0, 0, #{usage_no_U ? "USAGE_OPT" : "'U'"}},",
+         "      {\"version\", 0, 0, #{version_no_V ? "VERSION_OPT" : "'V'"}},",
+         "      {0, 0, 0, 0}", "    };")
+  short_str = $posix ? "+" : ""
+  short_str += "h" unless help_no_h
+  short_str += "V" unless version_no_V
+  short_str += "U" unless usage_no_U
+  short_str += $options.map { |o| o.short_str }.compact.join("")
+  
+  h.puts("    static const char *short_options = \"#{short_str}\";", "")
+
+  need_err   = $options.any? { |o| o.type != :flag && o.type != :string && o.type != :c_string}
+  need_err ||= $args.any? { |a| a.type != :string && a.type != :c_string }
+  need_err ||= ($options + $args).any? { |o| !o.access_types.empty? }
+  h.puts("    ::std::string err;") if need_err
+
+  # Actual parsing
+  h.puts(<<EOS)
+#define CHECK_ERR(type,val,which) if(!err.empty()) { ::std::cerr << "Invalid " #type " '" << val << "' for [" which "]: " << err << "\\n"; exit(1); }
+    while(true) {
+      int index = -1;
+      int c = getopt_long(argc, argv, short_options, long_options, &index);
+      if(c == -1) break;
+      switch(c) {
+      case ':':
+        ::std::cerr << \"Missing required argument for \"
+                  << (index == -1 ? ::std::string(1, (char)optopt) : std::string(long_options[index].name))
+                  << ::std::endl;
+        exit(1);
+      case #{help_no_h ? "HELP_OPT" : "'h'"}:
+        ::std::cout << usage() << \"\\n\\n\" << help() << std::endl;
+        exit(0);
+      case #{usage_no_U ? "USAGE_OPT" : "'U'"}:
+        ::std::cout << usage() << \"\\nUse --help for more information.\" << std::endl;
+        exit(0);
+      case 'V':
+        print_version();
+        exit(0);
+      case '?':
+        ::std::cerr << \"Use --usage or --help for some help\\n\";
+        exit(1);
+EOS
+  if need_full
+    h.puts(<<EOS)
+      case FULL_HELP_OPT:
+        ::std::cout << usage() << \"\\n\\n\" << help() << \"\\n\\n\" << hidden() << std::flush;
+        exit(0);
+EOS
+  end
+  
+  $options.each { |o|
+    if o.type == :flag && o.noflag
+      h.puts("      case #{o.long_enum[0]}:",
+             "        " + o.parse_arg.join("\n        "),
+             "        break;",
+             "      case #{o.long_enum[1]}:",
+             "        " + o.parse_arg(true).join("\n        "),
+             "        break;")
+    else
+      h.puts("      case #{o.long_enum ? o.long_enum[0] : "'" + o.short + "'"}:",
+             "        " + o.parse_arg.join("\n        "),
+             "        break;")
+    end
+  }
+  h.puts("      }", # close case
+         "    }") # close while(true)
+
+  # Check required
+  $options.any? { |o| o.required} and
+    h.puts("", "    // Check that required switches are present")
+  $options.each { |o|
+    next unless o.required
+    h.puts(<<EOS)
+    if(!#{o.var}_given)
+      error("[#{o.switches}] required switch");
+EOS
+  }
+  # Check conflict
+  $options.any? { |o| !o.conflict.empty? } and
+    h.puts("", "    // Check mutually exlusive switches")
+  $options.each { |o|
+    o_check = o.var + (o.type == :flag ? "_flag" : "_given")
+    o.conflict.each { |cos|
+      co = $opt_hash[cos]
+      co_check = co.var + (co.type == :flag ? "_flag" : "_given")
+      h.puts(<<EOS)
+    if(#{o_check} && #{co_check})
+      error("Switches [#{o.switches}] and [#{co.switches}] are mutually exclusive");
+EOS
+    }
+  }
+  # Check at_least
+  $options.any? { |o| o.at_least } and
+    h.puts("", "    // Check at_least requirements")
+  $options.each { |o|
+    next unless o.multiple && !o.at_least.nil?
+    h.puts(<<EOS)
+    if(#{o.var}_arg.size() < #{o.at_least})
+      error("[#{o.switches}] must be given at least #{o.at_least} times");
+EOS
+  }
+  
+  # Parse arguments
+  h.puts("", "    // Parse arguments")
+  if $args.size == 0 || !$args[-1].multiple
+    h.puts(<<EOS)
+    if(argc - optind != #{$args.size})
+      error("Requires exactly #{$args.size} argument#{$args.size > 1 ? "s" : ""}.");
+EOS
+  else
+    min_args = $args.size - 1 + $args[-1].at_least
+    h.puts(<<EOS)
+    if(argc - optind < #{min_args})
+      error("Requires at least #{min_args} argument#{min_args > 1 ? "s" : ""}.");
+EOS
+  end
+  $args.each { |a| h.puts("    " + a.parse_arg.join("\n    ")) }
+
+  # Check access rights
+  if ($options + $args).any? { |o| !o.access_types.empty? }
+    r_to_f = { "read" => "R_OK", "write" => "W_OK", "exec" => "X_OK" }
+    h.puts("", "    // Check access rights")
+    ($args + $options).each { |o|
+      next if o.access_types.empty?
+      mode = o.access_types.map { |t| r_to_f[t] }.join("|")
+      msg = Arg === o ? "Argument " + o.name : "Switch " + o.switches
+      msg += ", access right (#{o.access_types.join("|")}) failed for file '"
+      h.puts("    if(access(#{o.var}_arg, #{mode})) {",
+             "      err = \"#{msg}\";",
+             "      ((err += #{o.var}_arg) += \"': \") += strerror(errno);",
+             "      error(err.c_str());",
+             "    }")
+    }
+  end
+
+  h.puts("  }") # close parser
+
+  # Usage
+  if !$usage.nil?
+    ausage = quote_newline_dquotes($usage, "  ")
+  else
+    ausage = "Usage: #{$package || class_name} [options]"
+    $args.each { |a|
+     ausage += " #{a.name}:#{a.typestr || dflt_typestr(a.type)}#{a.multiple ? "+" : ""}"
+    }
+  end
+
+  h.puts(<<EOS)
+  static const char * usage() { return "#{ausage}"; }
+  class error {
+    int code_;
+    std::ostringstream msg_;
+
+    // Select the correct version (GNU or XSI) version of
+    // strerror_r. strerror_ behaves like the GNU version of strerror_r,
+    // regardless of which version is provided by the system.
+    static const char* strerror__(char* buf, int res) {
+      return res != -1 ? buf : "Invalid error";
+    }
+    static const char* strerror__(char* buf, char* res) {
+      return res;
+    }
+    static const char* strerror_(int err, char* buf, size_t buflen) {
+      return strerror__(buf, strerror_r(err, buf, buflen));
+    }
+    struct no_t { };
+
+  public:
+    static no_t no;
+    error(int code = EXIT_FAILURE) : code_(code) { }
+    explicit error(const char* msg, int code = EXIT_FAILURE) : code_(code)
+      { msg_ << msg; }
+    error(const std::string& msg, int code = EXIT_FAILURE) : code_(code)
+      { msg_ << msg; }
+    error& operator<<(no_t) {
+      char buf[1024];
+      msg_ << ": " << strerror_(errno, buf, sizeof(buf));
+      return *this;
+    }
+    template<typename T>
+    error& operator<<(const T& x) { msg_ << x; return (*this); }
+    ~error() {
+      ::std::cerr << "Error: " << msg_.str() << "\\n"
+                  << usage() << "\\n"
+                  << "Use --help for more information"
+                  << ::std::endl;
+      exit(code_);
+    }
+  };
+EOS
+
+  # Help
+  desc = ""
+  unless $purpose.nil?
+    desc += $purpose + "\\n\\n"
+  end
+  unless $description.nil?
+    desc += $description.split(/\n/).join("\\n\" \\\n    \"") + "\\n\\n"
+  end
+
+  h.puts(<<EOS)
+  static const char * help() { return
+    "#{desc}"
+    "Options (default value in (), *required):\\n"
+EOS
+  output_options_descriptions(h, $options, false)
+  usage_switch = " -U, "
+  usage_switch = " " * usage_switch.size if usage_no_U
+  usage_switch += "--usage"
+  h.puts("    \"#{usage_switch.ljust($switchesjust)}  Usage\\n\"")
+  help_switch = " -h, "
+  help_switch = " " * help_switch.size if help_no_h
+  help_switch += "--help"
+  h.puts("    \"#{help_switch.ljust($switchesjust)}  This message\\n\"")
+  h.puts("    \"#{"     --full-help".ljust($switchesjust)}  Detailed help\\n\"") if need_full
+  version_switch = " -V, "
+  version_switch = " " * version_switch.size if version_no_V
+  version_switch += "--version"
+  h.print("    \"#{version_switch.ljust($switchesjust)}  Version")
+  if $after_text.nil?
+    h.puts("\";")
+  else
+    h.puts("\\n\" \\", "  \"\\n\"")
+    atext = quote_newline_dquotes($after_text, "  ")
+    h.puts("    \"#{atext}\";")
+  end
+  h.puts("  }")
+
+  # Hidden help
+  has_hidden = $options.any? { |o| o.hidden }
+  if has_hidden 
+    h.puts(<<EOS)
+  static const char* hidden() { return
+    "Hidden options:\\n"
+EOS
+  output_options_descriptions(h, $options, true)
+  h.puts(<<EOS)
+    "";
+  }
+EOS
+  else
+    h.puts(<<EOS)
+  static const char* hidden() { return ""; }
+EOS
+  end
+  
+
+  # Version
+  h.puts("  void print_version(::std::ostream &os = std::cout) const {",
+         "#ifndef PACKAGE_VERSION",
+         "#define PACKAGE_VERSION \"0.0.0\"",
+         "#endif",
+         "    os << #{$version ? "\"" + $version + "\"" : "PACKAGE_VERSION"} << \"\\n\";",
+         "  }")
+  
+  # Dump
+  h.puts("  void dump(::std::ostream &os = std::cout) {")
+  ($options + $args).each { |o| h.puts("    os << #{o.dump.join(" << ")} << \"\\n\";") }
+  h.puts("  }")
+
+  # Private methods
+  h.puts(<<EOS)
+};
+EOS
+
+  # Initialize static members
+  # TODO: Should we have an option to put this in a .cc file?
+  $options.each { |o|
+    next unless o.type == :enum
+    h.puts("const char* const #{class_name}::#{o.var}::strs[#{o.enum.size + 1}] = { #{o.enum.map { |x| "\"#{x}\"" }.join(", ") }, (const char*)0 };")
+  }
+
+h.puts(<<EOS)
+#endif // __#{class_name.upcase}_HPP__"
+EOS
+end