// file      : xsde/cxx/options.cli
// author    : Boris Kolpackov <boris@codesynthesis.com>
// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file

include <cstddef>; // std::size_t

include <types.hxx>; // NarrowString, NarrowStrings

include <options.cli>;

namespace CXX
{
  class options: ::options = 0
  {
    NarrowString --output-dir
    {
      "<dir>",
      "Write generated files to <dir> instead of the current directory."
    };

    NarrowString --char-encoding = "utf8"
    {
      "<enc>",
      "Specify the application character encoding. Valid values are \cb{utf8}
       (default) and \cb{iso8859-1}. Note that this encoding is not the same
       as the XML document encoding that is being parsed or serialized.
       Rather, it is the encoding that is used inside the application. When
       an XML document is parsed, the character data is automatically
       converted to the application encoding. Similarly, when an XML
       document is serialized, the data in the application encoding is
       automatically converted to the resulting document encoding."
    };

    // C++ features.
    //
    bool --no-stl
    {
      "Generate code that does not use the C++ Standard Template Library
       (STL)."
    };

    bool --no-iostream
    {
      "Generate code that does not use the C++ standard input/output stream
       library (iostream)."
    };

    bool --no-exceptions
    {
      "Generate code that does not use C++ exceptions."
    };

    bool --no-long-long
    {
      "Generate code that does not use the \cb{long long} and \cb{unsigned
       long long} types. The 64 bit \cb{long} and \cb{unsignedLong} built-in
       XML Schema types are then mapped to \cb{long} and \cb{unsigned long}."
    };

    bool --custom-allocator
    {
      "Generate code that performs memory management using custom allocator
       functions provided by your application instead of the standard operator
       \cb{new} and \cb{delete}."
    };

    bool --generate-inline
    {
      "Generate simple functions inline. This option triggers creation of the
       inline file."
    };

    bool --suppress-reset
    {
      "Suppress the generation of parser/serializer reset code. Reset support
       allows you to reuse parsers/serializers after an error."
    };

    // Extern XML Schema.
    //
    bool --generate-xml-schema
    {
      "Generate a C++ header files as if the schema being compiled defines the
       XML Schema namespace. For the C++/Parser mapping, the resulting file
       will contain definitions for all the parser skeletons and
       implementations corresponding to the XML Schema built-in types. For
       the C++/Serializer mapping, the resulting file will contain definitions
       for all the serializer skeletons and implementations corresponding to
       the XML Schema built-in types. For the C++/Hybrid mapping, in addition
       the the above, a third header file will contain definitions for all
       the object model types corresponding to the XML Schema built-in types.

       The schema file provided to the compiler need not exist and is only
       used to derive the name of the resulting header file. Use the
       \cb{--extern-xml-schema} option to include this file in the
       generated files for other schemas."
     };

    NarrowString --extern-xml-schema
    {
      "<file>",
      "Include a header file derived from <file> instead of generating the
       XML Schema namespace mapping inline. The provided file need not
       exist and is only used to derive the name of the included header
       file. Use the \cb{--generate-xml-schema} option to generate this
       header file."
     };

    // Namespace mapping.
    //
    NarrowStrings --namespace-map
    {
      "<xns>=<cns>",
      "Map XML Schema namespace <xns> to C++ namespace <cns>. Repeat
       this option to specify mapping for more than one XML Schema namespace.
       For example, the following option:

       \cb{--namespace-map http://example.com/foo/bar=foo::bar}

       Will map the \cb{http://example.com/foo/bar} XML Schema namespace to
       the \cb{foo::bar} C++ namespace."
    };

    NarrowStrings --namespace-regex
    {
      "<regex>",
      "Add <regex> to the list of regular expressions used to translate XML
       Schema namespace names to C++ namespace names. <regex> is a Perl-like
       regular expression in the form
       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be
       used as a delimiter instead of \cb{/}. Escaping of the delimiter
       character in \ci{pattern} or \ci{replacement} is not supported.

       All the regular expressions are pushed into a stack with the last
       specified expression considered first. The first match that
       succeeds is used. Regular expressions are applied to a string in
       the form

       \c{\i{filename} \i{namespace}}

       For example, if you have file \cb{hello.xsd} with namespace
       \cb{http://example.com/hello} and you run \cb{xsd} on this file,
       then the string in question will be:

       \cb{hello.xsd. http://example.com/hello}

       For the built-in XML Schema namespace the string is:

       \cb{XMLSchema.xsd http://www.w3.org/2001/XMLSchema}

       The following three steps are performed for each regular expression
       until the match is found:

       1. The expression is applied and if the result is empty the next
       expression is considered.

       2. All \cb{/} are replaced with \cb{::}.

       3. The result is verified to be a valid C++ scope name (e.g.,
       \cb{foo::bar}). If this test succeeds, the result is used as a
       C++ namespace name.

       As an example, the following expression maps XML  Schema namespaces
       in the form \cb{http://example.com/foo/bar} to C++ namespaces in the
       form \cb{foo::bar}:

       \cb{%.* http://example.com/(.+)%$1%}

       See also the REGEX AND SHELL QUOTING section below."
    };

    bool --namespace-regex-trace
    {
      "Trace the process of applying regular expressions specified with the
       \cb{--namespace-regex} option. Use this option to find out why your
       regular expressions don't do what you expected them to do."
    };

    // Reserved names.
    //
    NarrowStrings --reserved-name
    {
      "<n>[=<r>]",
      "Add name <n> to the list of names that should not be used as
       identifiers. The name can optionally be followed by \cb{=} and the
       replacement name <r> that should be used instead. All the C++ keywords
       are already in this list."
    };

    // Include options.
    //
    bool --include-with-brackets
    {
      "Use angle brackets (<>) instead of quotes (\"\") in generated
       \cb{#include} directives."
    };

    NarrowString --include-prefix
    {
      "<prefix>",
      "Add <prefix> to generated \cb{#include} directive paths.

       For example, if you had the following import element in your schema

       \cb{<import namespace=\"...\" schemaLocation=\"base.xsd\"/>}

       and compiled this fragment with \cb{--include-prefix schemas/}, then
       the include directive in the generated code would be:

       \cb{#include \"schemas/base.hxx\"}"
    };

    NarrowStrings --include-regex
    {
      "<regex>",
      "Add <regex> to the list of regular expressions used to transform
       \cb{#include} directive paths. <regex> is a Perl-like regular
       expression in the form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
       Any character can be used as a delimiter instead of \cb{/}. Escaping
       of the delimiter character in \ci{pattern} or \ci{replacement} is not
       supported.

       All the regular expressions are pushed into a stack with the last
       specified expression considered first. The first match that succeeds
       is used.

       As an example, the following expression transforms paths in the form
       \cb{schemas/foo/bar} to paths in the form \cb{generated/foo/bar}:

       \cb{%schemas/(.+)%generated/$1%}

       See also the REGEX AND SHELL QUOTING section below."
    };

    bool --include-regex-trace
    {
      "Trace the process of applying regular expressions specified with the
       \cb{--include-regex} option. Use this option to find out why your
       regular expressions don't do what you expected them to do."
    };

    NarrowString --guard-prefix
    {
      "<prefix>",
      "Add <prefix> to generated header inclusion guards. The prefix is
       transformed to upper case and characters that are illegal in a
       preprocessor macro name are replaced with underscores. If this
       option is not specified then the directory part of the input schema
       file is used as a prefix."
    };

    // File suffixes.
    //
    NarrowString --hxx-suffix = ".hxx"
    {
      "<suffix>",
      "Use the provided <suffix> instead of the default \cb{.hxx} to
       construct the name of the header file. Note that this suffix is also
       used to construct names of header files corresponding to
       included/imported schemas."
    };

    NarrowString --ixx-suffix = ".ixx"
    {
      "<suffix>",
      "Use the provided <suffix> instead of the default \cb{.ixx} to
       construct the name of the inline file."
    };

    NarrowString --cxx-suffix = ".cxx"
    {
      "<suffix>",
      "Use the provided <suffix> instead of the default \cb{.cxx} to
       construct the name of the source file."
    };

    NarrowString --fwd-suffix = "-fwd.hxx"
    {
      "<suffix>",
      "Use the provided <suffix> instead of the default \cb{-fwd.hxx} to
       construct the name of the forward declaration file."
    };

    NarrowString --hxx-regex
    {
      "<regex>",
      "Use the provided expression to construct the name of the header file.
       <regex> is a Perl-like regular expression in the form
       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
       Note that this expression is also used to construct names of header
       files corresponding to included/imported schemas.

       For the C++/Hybrid mapping, the <regex> argument can be optionally
       prefixed with a file key in the form \c{\i{key}=\i{regex}}. The valid
       values for \ci{key} are \cb{pskel} (parser skeleton files), \cb{pimpl}
       (parser implementation files), \cb{sskel} (serializer skeleton files),
       \cb{simpl} (serializer implementation files), and \cb{*} (all files).
       If \ci{key} is empty or not present then the expression is used for the
       object model files only.

       See also the REGEX AND SHELL QUOTING section below."
    };

    NarrowString --ixx-regex
    {
      "<regex>",
      "Use the provided expression to construct the name of the inline file.
       <regex> is a Perl-like regular expression in the form
       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. For the C++/Hybrid
       mapping, the <regex> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-regex} option for details. See also the REGEX
       AND SHELL QUOTING section below."
    };

    NarrowString --cxx-regex
    {
      "<regex>",
      "Use the provided expression to construct the name of the source file.
       <regex> is a Perl-like regular expression in the form
       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. For the C++/Hybrid
       mapping, the <regex> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-regex} option for details. See also the REGEX
       AND SHELL QUOTING section below."
    };

    NarrowString --fwd-regex
    {
      "<regex>",
      "Use the provided expression to construct the name of the forward
       declaration file. <regex> is a Perl-like regular expression in the
       form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX
       AND SHELL QUOTING section below."
    };

    // Prologues/epilogues.
    //
    NarrowStrings --hxx-prologue
    {
      "<text>",
      "Insert <text> at the beginning of the header file.

       For the C++/Hybrid mapping, the <text> argument can be optionally
       prefixed with a file key in the form \c{\i{key}=\i{text}}. The valid
       values for \ci{key} are \cb{pskel} (parser skeleton files), \cb{pimpl}
       (parser implementation files), \cb{sskel} (serializer skeleton files),
       \cb{simpl} (serializer implementation files), and \cb{*} (all files).
       If \ci{key} is empty or not present then the text is used for the
       object model files only."
    };

    NarrowStrings --ixx-prologue
    {
      "<text>",
      "Insert <text> at the beginning of the inline file. For the C++/Hybrid
       mapping, the <text> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-prologue} option for details."
    };

    NarrowStrings --cxx-prologue
    {
      "<text>",
      "Insert <text> at the beginning of the source file. For the C++/Hybrid
       mapping, the <text> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-prologue} option for details."
    };

    NarrowStrings --fwd-prologue
    {
      "<text>",
      "Insert <text> at the beginning of the forward declaration file."
    };

    NarrowStrings --prologue
    {
      "<text>",
      "Insert <text> at the beginning of each generated file for which
       there is no file-specific prologue. For the C++/Hybrid mapping, the
       <text> argument can be optionally prefixed with a file key. See the
       \cb{--hxx-prologue} option for details."
    };

    NarrowStrings --hxx-epilogue
    {
      "<text>",
      "Insert <text> at the end of the header file. For the C++/Hybrid
       mapping, the <text> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-prologue} option for details."
    };

    NarrowStrings --ixx-epilogue
    {
      "<text>",
      "Insert <text> at the end of the inline file. For the C++/Hybrid
       mapping, the <text> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-prologue} option for details."
    };

    NarrowStrings --cxx-epilogue
    {
      "<text>",
      "Insert <text> at the end of the source file. For the C++/Hybrid
       mapping, the <text> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-prologue} option for details."
    };

    NarrowStrings --fwd-epilogue
    {
      "<text>",
      "Insert <text> at the end of the forward declaration file."
    };

    NarrowStrings --epilogue
    {
      "<text>",
      "Insert <text> at the end of each generated file for which there
       is no file-specific epilogue. For the C++/Hybrid mapping, the <text>
       argument can be optionally prefixed with a file key. See the
       \cb{--hxx-prologue} option for details."
    };

    NarrowString --hxx-prologue-file
    {
      "<file>",
      "Insert the content of the <file> at the beginning of the header file.

       For the C++/Hybrid mapping, the <file> argument can be optionally
       prefixed with a file key in the form \c{\i{key}=\i{file}}. The valid
       values for \ci{key} are \cb{pskel} (parser skeleton files), \cb{pimpl}
       (parser implementation files), \cb{sskel} (serializer skeleton files),
       \cb{simpl} (serializer implementation files), and \cb{*} (all files).
       If \ci{key} is empty or not present then the file is used for the
       object model files only."
    };

    NarrowString --ixx-prologue-file
    {
      "<file>",
      "Insert the content of the <file> at the beginning of the inline file.
       For the C++/Hybrid mapping, the <file> argument can be optionally
       prefixed with a file key. See the \cb{--hxx-prologue-file} option
       for details."
    };

    NarrowString --cxx-prologue-file
    {
      "<file>",
      "Insert the content of the <file> at the beginning of the source file.
       For the C++/Hybrid mapping, the <file> argument can be optionally
       prefixed with a file key. See the \cb{--hxx-prologue-file} option
       for details."
    };

    NarrowString --fwd-prologue-file
    {
      "<file>",
      "Insert the content of the <file> at the beginning of the forward
       declaration file."
    };

    NarrowString --prologue-file
    {
      "<file>",
      "Insert the content of the <file> at the beginning of each generated
       file for which there is no file-specific prologue file. For the
       C++/Hybrid mapping, the <file> argument can be optionally prefixed
       with a file key. See the \cb{--hxx-prologue-file} option for details."
    };

    NarrowString --hxx-epilogue-file
    {
      "<file>",
      "Insert the content of the <file> at the end of the header file.
       For the C++/Hybrid mapping, the <file> argument can be optionally
       prefixed with a file key. See the \cb{--hxx-prologue-file} option
       for details."
    };

    NarrowString --ixx-epilogue-file
    {
      "<file>",
      "Insert the content of the <file> at the end of the inline file.
       For the C++/Hybrid mapping, the <file> argument can be optionally
       prefixed with a file key. See the \cb{--hxx-prologue-file} option
       for details."
    };

    NarrowString --cxx-epilogue-file
    {
      "<file>",
      "Insert the content of the <file> at the end of the source file.
       For the C++/Hybrid mapping, the <file> argument can be optionally
       prefixed with a file key. See the \cb{--hxx-prologue-file} option
       for details."
    };

    NarrowString --fwd-epilogue-file
    {
      "<file>",
      "Insert the content of the <file> at the end of the forward declaration
       file."
    };

    NarrowString --epilogue-file
    {
      "<file>",
      "Insert the content of the <file> at the end of each generated file
       for which there is no file-specific epilogue file. For the C++/Hybrid
       mapping, the <file> argument can be optionally prefixed with a file
       key. See the \cb{--hxx-prologue-file} option for details."
    };
  };
}