options.hpp

// COPY/REUSE POLICY
// =================
// Permission is hereby granted to freely copy and redistribute this
// software, provided that the author is clearly credited in all copies
// and derivations. Neither the names of the authors nor that of their
// employers may be used to endorse or promote products derived from this
// software without specific written permission.
//
//
// DISCLAIMER
// ==========
// This software is provided ``As Is'' and without any express or implied
// warranties.  Neither the authors nor any of their employers (including
// any of their subsidiaries and subdivisions) are responsible for maintaining
// or supporting this software or for any consequences resulting from the
// use of this software, no matter how awful, even if they arise from flaws
// in the software.
// ****************************************************************************
// ^FILE: options.h - option parsing classes
//
// ^DESCRIPTION:
//    This file defines classes used to parse command-line options.
//    Options may be parsed from an array of strings, or from any structure
//    for which a corresponding option-iterator exists.
//
// ^HISTORY:
//    03/06/92  Brad Appleton   <bradapp@enteract.com>   Created
//
//    03/23/93  Brad Appleton   <bradapp@enteract.com>
//    - Added OptIstreamIter class
//
//    03/08/94  Brad Appleton   <bradapp@enteract.com>
//    - Added Options::reset() member function
//
//    07/31/97  Brad Appleton   <bradapp@enteract.com>
//    - Added PARSE_POS control flag and POSITIONAL return value
//
//    04/30/06  Chris Reed
//    - Updated to modern C++ and STL
//    - Converted comments to doxygen style
// ^^**************************************************************************

#ifndef _options_h
#define _options_h

#ifdef USE_STDIO
#include <cstdio>
#else
#include <iostream>
#endif

class OptIter
{
public:
    OptIter(void) {}

    virtual ~OptIter(void);

    virtual const char *curr(void) = 0;

    virtual void next(void) = 0;

    virtual const char *operator()(void);
};

class OptIterRwd : public OptIter
{
public:
    OptIterRwd(void);

    virtual ~OptIterRwd(void);

    virtual const char *curr(void) override = 0;

    virtual void next(void) override = 0;

    virtual const char *operator()(void) override = 0;

    virtual void rewind(void) = 0;
};

class OptArgvIter : public OptIterRwd
{
private:
    int ndx;               // index of current arg
    int ac;                // arg count
    const char *const *av; // arg vector

public:
    explicit OptArgvIter(const char *const argv[]) : ndx(0), ac(-1), av(argv) {}

    OptArgvIter(int argc, const char *const argv[]) : ndx(0), ac(argc), av(argv) {}

    virtual ~OptArgvIter(void);

    virtual const char *curr(void) override;

    virtual void next(void) override;

    virtual const char *operator()(void) override;

    virtual void rewind(void) override;

    int index(void) { return ndx; }
};

class OptStrTokIter : public OptIterRwd
{
private:
    unsigned len;     // length of token-string
    const char *str;  // the token-string
    const char *seps; // delimiter-set (separator-characters)
    const char *cur;  // current token
    char *tokstr;     // our copy of the token-string

    static const char *default_delims; // default delimiters = whitespace

public:
    explicit OptStrTokIter(const char *tokens, const char *delimiters = 0);

    virtual ~OptStrTokIter(void);

    virtual const char *curr(void) override;

    virtual void next(void) override;

    virtual const char *operator()(void) override;

    virtual void rewind(void) override;

    const char *delimiters(void) { return seps; }

    void delimiters(const char *delims) { seps = (delims) ? delims : default_delims; }
};

class OptIstreamIter : public OptIter
{
private:
    std::istream &is;
    OptStrTokIter *tok_iter;

    void fill(void);

public:
    static const unsigned MAX_LINE_LEN;

    explicit OptIstreamIter(std::istream &input);

    virtual ~OptIstreamIter(void);

    virtual const char *curr(void) override;

    virtual void next(void) override;

    virtual const char *operator()(void) override;
};

class Options
{
private:
    unsigned explicit_end : 1; 
    unsigned optctrls : 7;     
    const char *const *optvec; 
    const char *nextchar;      
    const char *listopt;       
    const char *cmdname;       

    void check_syntax(void) const;

    const char *match_opt(char opt, int ignore_case = 0) const;

    const char *match_longopt(const char *opt, int len, int &ambiguous) const;

    int parse_opt(OptIter &iter, const char *&optarg);

    int parse_longopt(OptIter &iter, const char *&optarg);

public:
    enum class OptCtrl
    {
        DEFAULT = 0x00,    
        ANYCASE = 0x01,    
        QUIET = 0x02,      
        PLUS = 0x04,       
        SHORT_ONLY = 0x08, 
        LONG_ONLY = 0x10,  
        NOGUESSING = 0x20, 
        PARSE_POS = 0x40   
    };

    enum class OptRC
    {
        ENDOPTS = 0,
        BADCHAR = -1,
        BADKWD = -2,
        AMBIGUOUS = -3,
        POSITIONAL = -4
    };

    Options(const char *name, const char *const optv[]);

    virtual ~Options(void);

    const char *name(void) const { return cmdname; }

    unsigned ctrls(void) const { return optctrls; }

    void ctrls(unsigned newctrls) { optctrls = newctrls; }

    void reset(void) { nextchar = listopt = NULL; }

    void usage(std::ostream &os, const char *positionals) const;

    int operator()(OptIter &iter, const char *&optarg);

    int explicit_endopts() const { return explicit_end; }
};

#endif /* _options_h */