root/misc/optimpl.d

/*
Copyright (c) 2007 Kirk McDonald

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
/*
2007-08-15 - Added changes to make GDC happy, submitted by Tim Burrell.
*/
/**
 * Command-line option parsing, in the style of Python's optparse.
 *
 * Refer to the complete docs for more information.
 */
module optimpl;

version (Tango) {
    import tango.text.Util : find = locate, locatePrior;
    import tango.text.Ascii : toupper = toUpper;
    import tango.stdc.stdlib : exit, EXIT_FAILURE, EXIT_SUCCESS;
    import tango.text.convert.Integer : parse, toInt, toString = toUtf8;
    import tango.text.convert.Utf : toUTF8 = toUtf8, toUTF32 = toUtf32;
    int getNotFound(char[] s) {
        return s.length;
    }
    //alias char[] string;
} else {
    import std.string : find, toupper, toString;
    import std.c.stdlib : exit, EXIT_FAILURE, EXIT_SUCCESS;
    import std.conv : toInt, ConvError;
    import std.path : getBaseName;
    import std.utf : toUTF8, toUTF32;
    int getNotFound(char[] s) {
        return -1;
    }
}

/*
Options may be in two forms: long and short. Short options start with a single
dash and are one letter long. Long options start with two dashes and may
consist of any number of characters (so long as they don't start with a dash,
though they may contain dashes). Options are case-sensitive.

Short options may be combined. The following are equivalent:

$ myapp -a -b -c
$ myapp -abc
$ myapp -ab -c

If -f and --file are aliases of the same option, which accepts an argument,
the following are equivalent:

$ myapp -f somefile.txt
$ myapp -fsomefile.txt
$ myapp --file somefile.txt
$ myapp --file=somefile.txt

The following are also valid:

$ myapp -abcf somefile.txt
$ myapp -abcfsomefile.txt
$ myapp -abc --file somefile.txt

If an option occurs multiple times, the last one is the one recorded:

$ myapp -f somefile.txt --file otherfile.txt

Matches 'otherfile.txt'.
*/

bool startswith(char[] s, char[] start) {
    if (s.length < start.length) return false;
    return s[0 .. start.length] == start;
}
bool endswith(char[] s, char[] end) {
    if (s.length < end.length) return false;
    return s[$ - end.length .. $] == end;
}

/// Thrown if client code tries to set up an improper option.
class OptionError : Exception {
    this(char[] msg) { super(msg); }
}
/// Thrown if client code tries to extract the wrong type from an option.
class OptionTypeError : Exception {
    this(char[] msg) { super(msg); }
}
/// Thrown if there is a problem while parsing the command-line.
class OptionParsingError : Exception {
    this(char[] msg) { super(msg); }
}

/++
This class represents the results after parsing the command-line.
+/
class Options {
    char[][][char[]] opts;
    int[char[]] counted_opts;
    /// By default, leftover arguments are placed in this array.
    char[][] args;

    /// Retrieves the results of the Store and StoreConst actions.
    char[] opIndex(char[] opt) {
        char[][]* o = opt in opts;
        if (o) {
            return (*o)[0];
        } else {
            return "";
        }
    }
    /// Retrieves the results of the Store action, when the type is Integer.
    int value(char[] opt) {
        char[][]* o = opt in opts;
        if (o) {
            return toInt((*o)[0]);
        } else {
            return 0;
        }
    }
    /// Retrieves the results of the Append and AppendConst actions.
    char[][] list(char[] opt) {
        char[][]* o = opt in opts;
        if (o) {
            return *o;
        } else {
            return null;
        }
    }
    /// Retrieves the results of the Append action, when the type is Integer.
    int[] valueList(char[] opt) {
        char[][]* o = opt in opts;
        int[] l;
        if (o) {
            l.length = (*o).length;
            foreach (i, s; *o) {
                l[i] = toInt(s);
            }
        }
        return l;
    }
    /// Retrieves the results of the Count action.
    int count(char[] opt) {
        int* c = opt in counted_opts;
        if (c) {
            return *c;
        } else {
            return 0;
        }
    }
    /// Retrieves the results of the SetTrue and SetFalse actions.
    bool flag(char[] opt) {
        char[][]* o = opt in opts;
        if (o) {
            return (*o)[0] == "1";
        } else {
            return false;
        }
    }
    private {
        void storeArg(char[] name, char[] arg) {
            opts[name] = [arg];
        }
        void storeArg(char[] name, bool arg) {
            if (arg) {
                opts[name] = ["1"];
            } else {
                opts[name] = ["0"];
            }
        }
        void appendArg(char[] name, char[] arg) {
            opts[name] ~= arg;
        }
        void increment(char[] name) {
            ++counted_opts[name];
        }
        bool hasName(char[] name) {
            return name in opts || name in counted_opts;
        }
    }
}

// Options, args, this opt's index in args, name[, arg]
///
alias void delegate(Options, inout char[][], inout int, char[], char[]) OptionCallbackFancyArg;
///
alias void delegate(Options, inout char[][], inout int, char[], int)    OptionCallbackFancyInt;
///
alias void delegate(Options, inout char[][], inout int, char[])         OptionCallbackFancy;

///
alias void delegate(char[]) OptionCallbackArg;
///
alias void delegate(int)    OptionCallbackInt;
///
alias void delegate()       OptionCallback;

///
enum Action { /+++/Store, /+++/StoreConst, /+++/Append, /+++/AppendConst, /+++/Count, /+++/SetTrue, /+++/SetFalse, /+++/Callback, /+++/CallbackFancy, /+++/Help /+++/}
///
enum ArgType { /+/+++/None,+/ /+++/String, /+++/Integer, /+++/Bool /+++/}

/++
This class represents a single command-line option.
+/
abstract class Option {
    char[][] shortopts, longopts;
    char[] name, argname;
    char[] helptext;
    this(char[][] options, char[] name) {
        dchar[] opt;
        foreach (_opt; options) {
            // (Unicode note: We convert to dchar[] so the length checks work
            // out in the event of a short opt with a >127 character.)
            opt = toUTF32(_opt);
            if (opt.length < 2) {
                throw new OptionError(
                    "invalid option string '" ~ _opt ~ "': must be at least two characters long"
                );
            } else if (opt.length > 2) {
                if (opt[0 .. 2] != "--" || opt[2] == '-')
                    throw new OptionError(
                        "invalid long option string '" ~ _opt ~ "': must start with --, followed by non-dash"
                    );
                longopts ~= _opt;
            } else {
                if (opt[0] != '-' || opt[1] == '-')
                    throw new OptionError(
                        "invalid short option string '" ~ _opt ~ "': must be of the form -x, where x is non-dash"
                    );
                shortopts ~= _opt;
            }
        }
        if (name is null) {
            // (Unicode note: We know '-' is a single code unit, so these
            // slices are okay.)
            if (longopts.length > 0)
                this.name = longopts[0][2 .. $];
            else if (shortopts.length > 0)
                this.name = shortopts[0][1 .. 2];
            else
                throw new OptionError(
                    "No options provided to addOption!"
                );
        } else {
            this.name = name;
        }
        argname = toupper(this.name.dup);
    }
    char[] toString() {
        int optCount = this.shortopts.length + this.longopts.length;
        char[] result;
        //bool printed_arg = false;
        foreach(i, opt; this.shortopts ~ this.longopts) {
            result ~= opt;
            if (i < optCount-1) {
                result ~= ", ";
            } else if (this.hasArg()) {
                result ~= "=" ~ toupper(this.argname.dup);
            }
        }
        return result;
    }
    //enum Action { Store, StoreConst, Append, AppendConst, Count, SetTrue, SetFalse, Callback, CallbackFancy, Help }
    bool supports_default() {
        return false;
    }
    ArgType def_type() {
        throw new OptionError("Option "~name~" does not support default arguments.");
    }
    bool has_default() {
        throw new OptionError("Option "~name~" does not support default arguments.");
    }
    void issue_default(Options results) {
        return;
    }
    /// Does whatever this option is supposed to do.
    abstract void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg);
    /// Returns whether this option accepts an argument.
    bool hasArg() {
        return false;
    }
    /// Sets the help text for this option.
    Option help(char[] help) {
        this.helptext = help;
        return this;
    }
    /// Sets the name of this option's argument, if it has one.
    Option argName(char[] argname) {
        this.argname = argname;
        return this;
    }
    Option def(char[] val) {
        throw new OptionError("Cannot specify string default for non-string option '"~this.name~"'");
    }
    Option def(int val) {
        throw new OptionError("Cannot specify integer default for non-integer option '"~this.name~"'");
    }
    Option def(bool val) {
        throw new OptionError("Cannot specify boolean default for non-flag option '"~this.name~"'");
    }
    // Returns true if the passed option string matches this option.
    bool matches(char[] _arg) {
        dchar[] arg = toUTF32(_arg);
        if (
            arg.length < 2 ||
            arg.length == 2 && (arg[0] != '-' || arg[1] == '-') ||
            arg.length > 2 && (arg[0 .. 2] != "--" || arg[2] == '-')
        ) {
            return false;
        }
        if (arg.length == 2) {
            foreach (opt; shortopts) {
                if (_arg == opt) {
                    return true;
                }
            }
        } else {
            foreach (opt; longopts) {
                if (_arg == opt) {
                    return true;
                }
            }
        }
        return false;
    }
}

abstract class ArgOption : Option {
    static const ArgType default_type = ArgType.String;
    ArgType type;
    bool _has_default = false;
    char[] default_string;
    this(char[][] options, char[] name, ArgType type) {
        super(options, name);
        if (type != ArgType.Integer && type != ArgType.String) {
            throw new OptionError("Argument type for Store and Append must be Integer or String.");
        }
        this.type = type;
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        if (this.type == ArgType.Integer) {
            // Verify that it's an int.
            int i = parser.toOptInt(arg);
        }
    }
    override ArgType def_type() {
        return this.type;
    }
    override Option def(char[] val) {
        if (this.type != ArgType.String)
            super.def(val);
        this._has_default = true;
        this.default_string = val;
        return this;
    }
    override Option def(int val) {
        if (this.type != ArgType.Integer)
            super.def(val);
        this._has_default = true;
        this.default_string = .toString(val);
        return this;
    }
    override bool supports_default() {
        return true;
    }
    override bool has_default() {
        return _has_default;
    }
    override void issue_default(Options results) {
        if (_has_default) results.storeArg(this.name, this.default_string);
    }
    override bool hasArg() {
        return true;
    }
}

class Store : ArgOption {
    this(char[][] options, char[] name, ArgType type=Store.default_type) {
        super(options, name, type);
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        super.performAction(parser, results, args, idx, arg);
        results.storeArg(this.name, arg);
    }
}
class Append : ArgOption {
    this(char[][] options, char[] name, ArgType type=Append.default_type) {
        super(options, name, type);
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        super.performAction(parser, results, args, idx, arg);
        results.appendArg(this.name, arg);
    }
}
abstract class ConstOption : Option {
    bool _has_default = false;
    char[] default_value;
    char[] const_value;
    this(char[][] options, char[] name, char[] const_value) {
        super(options, name);
        this.const_value = const_value;
    }
    override Option def(char[] val) {
        this._has_default = true;
        this.default_value = val;
        return this;
    }
    override ArgType def_type() {
        return ArgType.String;
    }
    override bool supports_default() {
        return true;
    }
    override bool has_default() {
        return _has_default;
    }
    override void issue_default(Options results) {
        if (_has_default) results.storeArg(this.name, this.default_value);
    }
}
class StoreConst : ConstOption {
    this(char[][] options, char[] name, char[] const_value) {
        super(options, name, const_value);
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        results.storeArg(this.name, this.const_value);
    }
}
class AppendConst : ConstOption {
    this(char[][] options, char[] name, char[] const_value) {
        super(options, name, const_value);
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        results.appendArg(this.name, this.const_value);
    }
}
abstract class SetBool : Option {
    bool _has_default = false;
    bool default_flag = false;
    this(char[][] options, char[] name) {
        super(options, name);
    }
    override Option def(bool val) {
        this._has_default = true;
        this.default_flag = val;
        return this;
    }
    override ArgType def_type() {
        return ArgType.Bool;
    }
    override bool supports_default() {
        return true;
    }
    override bool has_default() {
        return _has_default;
    }
    override void issue_default(Options results) {
        if (_has_default) results.storeArg(this.name, this.default_flag);
    }
}
class SetTrue : SetBool {
    this(char[][] options, char[] name) {
        super(options, name);
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        results.storeArg(this.name, true);
    }
}
class SetFalse : SetBool {
    this(char[][] options, char[] name) {
        super(options, name);
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        results.storeArg(this.name, false);
    }
}
class Count : Option {
    this(char[][] options, char[] name) {
        super(options, name);
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        results.increment(this.name);
    }
}
class Callback : Option {
    OptionCallback cb;
    this(char[][] options, OptionCallback cb) {
        super(options, null);
        this.cb = cb;
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        this.cb();
    }
}
class CallbackArg : Option {
    OptionCallbackArg cb;
    this(char[][] options, OptionCallbackArg cb) {
        super(options, null);
        this.cb = cb;
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        this.cb(arg);
    }
    override bool hasArg() {
        return true;
    }
}
class CallbackInt : Option {
    OptionCallbackInt cb;
    this(char[][] options, OptionCallbackInt cb) {
        super(options, null);
        this.cb = cb;
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        int i = parser.toOptInt(arg);
        this.cb(i);
    }
    override bool hasArg() {
        return true;
    }
}
class FancyCallback : Option {
    OptionCallbackFancy cb;
    this(char[][] options, char[] name, OptionCallbackFancy cb) {
        super(options, name);
        this.cb = cb;
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        this.cb(results, args, idx, this.name);
    }
}
class FancyCallbackArg : Option {
    OptionCallbackFancyArg cb;
    this(char[][] options, char[] name, OptionCallbackFancyArg cb) {
        super(options, name);
        this.cb = cb;
    }
    override void performAction(OptionParser parser, Options results, inout char[][] args, inout int idx, char[] arg) {
        this.cb(results, args, idx, this.name, arg);
    }
    override bool hasArg() {
        return true;