shell.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_STRING_H_
#include <ucommon/string.h>
#endif
 
#ifndef _UCOMMON_MEMORY_H_
#include <ucommon/memory.h>
#endif
 
#ifndef _UCOMMON_SHELL_H_
#define _UCOMMON_SHELL_H_
 
#ifdef  _MSWINDOWS_
#define INVALID_PID_VALUE   INVALID_HANDLE_VALUE
#else
#define INVALID_PID_VALUE   -1
#endif
 
#ifdef  ERR
#undef  ERR
#endif
 
namespace ucommon {
 
class __EXPORT shell : public mempager
{
private:
    char **_argv;
    unsigned _argc;
    char *_argv0;
    char *_exedir;
    LinkedObject *_syms;
 
    __DELETE_COPY(shell);
 
    class __LOCAL args : public OrderedObject
    {
    public:
        char *item;
    };
 
    class __LOCAL syms : public LinkedObject
    {
    public:
        const char *name;
        const char *value;
    };
 
    void collapse(LinkedObject *first);
 
    void set0(char *argv0);
 
public:
    typedef enum {NOARGS = 0, NOARGUMENT, INVARGUMENT, BADOPTION, OPTION_USED, BAD_VALUE, NUMERIC_SET} errmsg_t;
 
    typedef enum {NONE = 0, CONSOLE_LOG, USER_LOG, SYSTEM_LOG, SECURITY_LOG} logmode_t;
 
    typedef enum {FAIL = 0, ERR, WARN, NOTIFY, INFO, DEBUG0} loglevel_t;
 
    typedef enum {NO_NUMERIC, NUMERIC_PLUS, NUMERIC_DASH, NUMERIC_ALL} numeric_t;
 
    typedef enum {
        PROGRAM_CONFIG, SERVICE_CONFIG, USER_DEFAULTS, SERVICE_CONTROL,
        USER_HOME = USER_DEFAULTS + 3, SERVICE_DATA, SYSTEM_TEMP, USER_CACHE,
        SERVICE_CACHE, USER_DATA, USER_CONFIG, SYSTEM_CFG, SYSTEM_ETC,
        SYSTEM_VAR, SYSTEM_PREFIX, SYSTEM_SHARE, PROGRAM_PLUGINS,
        PROGRAM_TEMP} path_t;
 
    typedef bool (*logproc_t)(loglevel_t level, const char *text);
 
    typedef cpr_service_t   mainproc_t;
 
    typedef void (*exitproc_t)(void);
 
#ifdef  _MSWINDOWS_
    typedef HANDLE pid_t;
#else
 
    typedef int pid_t;
#endif
 
    static const char *errmsg(errmsg_t id);
 
    static void errmsg(errmsg_t id, const char *text);
 
    class __EXPORT errormap
    {
    public:
        inline errormap(errmsg_t id, const char *text)
            {shell::errmsg(id, text);}
    };
 
    class __EXPORT Option : public LinkedObject
    {
    private:
        __DELETE_COPY(Option);
 
    public:
        char short_option;
        const char *long_option;
        const char *uses_option;
        const char *help_string;
        bool trigger_option;
 
        Option(char short_option = 0, const char *long_option = NULL, const char *value_type = NULL, const char *help = NULL);
 
        virtual ~Option();
 
        static LinkedObject *first(void);
 
        void disable(void);
 
        virtual const char *assign(const char *value) = 0;
 
        static void reset(void);
    };
 
    class __EXPORT flagopt : public Option
    {
    private:
        unsigned counter;
        bool single;
 
        virtual const char *assign(const char *value);
 
        __DELETE_DEFAULTS(flagopt);
 
    public:
        flagopt(char short_option, const char *long_option = NULL, const char *help = NULL, bool single_use = true);
 
        inline operator bool() const {
            return counter > 0;
        }
 
        inline bool operator!() const {
            return counter == 0;
        }
 
        inline operator unsigned() const {
            return counter;
        }
 
        inline unsigned operator*() const {
            return counter;
        }
 
        inline void set(unsigned value = 1) {
            counter = value;
        }
 
        inline flagopt& operator=(unsigned value) {
            counter = value;
            return *this;
        }
    };
 
    class __EXPORT groupopt : public Option
    {
    private:
        virtual const char *assign(const char *value);
 
        __DELETE_DEFAULTS(groupopt);
 
    public:
        groupopt(const char *help);
    };
 
    class __EXPORT stringopt : public Option
    {
    private:
        bool used;
 
        __DELETE_DEFAULTS(stringopt);
 
    protected:
        const char *text;
 
        virtual const char *assign(const char *value);
 
    public:
        stringopt(char short_option, const char *long_option = NULL, const char *help = NULL, const char *type = "text", const char *def_text = NULL);
 
        inline void set(const char *string) {
            text = string;
        }
 
        inline stringopt& operator=(const char *string) {
            text = string;
            return *this;
        }
 
        inline operator bool() const {
            return used;
        }
 
        inline bool operator!() const {
            return !used;
        }
 
        inline operator const char *() const {
            return text;
        }
 
        inline const char *operator*() const {
            return text;
        }
    };
 
    class __EXPORT charopt : public Option
    {
    private:
        bool used;
 
        __DELETE_DEFAULTS(charopt);
 
    protected:
        char code;
 
        virtual const char *assign(const char *value);
 
    public:
        charopt(char short_option, const char *long_option = NULL, const char *help = NULL, const char *type = "char", char default_code = ' ');
 
        inline void set(char value) {
            code = value;
        }
 
        inline charopt& operator=(char value) {
            code = value;
            return *this;
        }
 
        inline operator bool() const {
            return used;
        }
 
        inline bool operator!() const {
            return !used;
        }
 
        inline operator char() const {
            return code;
        }
 
        inline char operator*() const {
            return code;
        }
    };
 
    class __EXPORT numericopt : public Option
    {
    private:
        bool used;
 
        __DELETE_DEFAULTS(numericopt);
 
    protected:
        long number;
 
        virtual const char *assign(const char *value);
 
    public:
        numericopt(char short_option, const char *long_option = NULL, const char *help = NULL, const char *type = "numeric", long def_value = 0);
 
        inline void set(long value) {
            number = value;
        }
 
        inline numericopt& operator=(long value) {
            number = value;
            return *this;
        }
 
        inline operator bool() const {
            return used;
        }
 
        inline bool operator!() const {
            return !used;
        }
 
        inline operator long() const {
            return number;
        }
 
        inline long operator*() const {
            return number;
        }
    };
 
    class __EXPORT counteropt : public Option
    {
    private:
        bool used;
 
        __DELETE_DEFAULTS(counteropt);
 
    protected:
        long number;
 
        virtual const char *assign(const char *value);
 
    public:
        counteropt(char short_option, const char *long_option = NULL, const char *help = NULL, const char *type = "numeric", long def_value = 0);
 
        inline void set(long value) {
            number = value;
        }
 
        inline counteropt& operator=(long value) {
            number = value;
            return *this;
        }
 
        inline operator bool() const {
            return used;
        }
 
        inline bool operator!() const {
            return !used;
        }
 
        inline operator long() const {
            return number;
        }
 
        inline long operator*() const {
            return number;
        }
    };
 
    shell(const char *string, size_t pagesize = 0);
 
    shell(int argc, char **argv, size_t pagesize = 0);
 
    shell(size_t pagesize = 0);
 
    static void setNumeric(numeric_t);
 
    static long getNumeric(void);
 
    static void help(void);
 
    static int system(const char *command, const char **env = NULL);
 
    static int systemf(const char *format, ...) __PRINTF(1,2);
 
    static void relocate(const char *argv0);
 
    static String path(path_t id);
 
    static String userid(void);
 
    static String path(path_t id, const char *directory);
 
    static String path(String& prefix, const char *directory);
 
    static void bind(const char *name);
 
    static void rebind(const char *name = NULL);
 
    char **parse(const char *string);
 
    void parse(int argc, char **argv);
 
    const char *getenv(const char *name, const char *value = NULL);
 
    const char *getsym(const char *name, const char *value = NULL);
 
    void setsym(const char *name, const char *value);
 
    bool is_sym(const char *name) const;
 
    char *getargv0(char **argv);
 
    char **getargv(char **argv);
 
    void restart(char *argv0, char **argv, char **list);
 
    inline const char *argv0() const
        {return _argv0;}
 
    inline const char *execdir() const
        {return _exedir;}
 
    static void errlog(const char *format, ...) __PRINTF(1, 2);
 
    static void errexit(int exitcode, const char *format = NULL, ...) __PRINTF(2, 3);
 
    static inline int condition(bool test, int exitcode) {
        return (test) ? exitcode : 0;
    }
 
    static void debug(unsigned level, const char *format, ...) __PRINTF(2, 3);
 
    static void log(loglevel_t level, const char *format, ...) __PRINTF(2, 3);
 
    static void security(loglevel_t level, const char *format, ...) __PRINTF(2, 3);
 
    static void log(const char *name, loglevel_t level = ERR, logmode_t mode = USER_LOG, logproc_t handler = (logproc_t)NULL);
 
    static size_t printf(const char *format, ...) __PRINTF(1, 2);
 
    inline unsigned argc(void) const
        {return _argc;}
 
    inline char **argv(void) const
        {return _argv;}
 
    inline const char *operator[](unsigned offset)
        {return _argv[offset];}
 
    static void exiting(exitproc_t);
 
    void detach(mainproc_t mainentry = (mainproc_t)NULL);
 
    void restart(void);
 
    static shell::pid_t spawn(const char *path, char **argv, char **env = NULL, fd_t *stdio = NULL);
 
    static void priority(int pri = 1);
 
    static int  detach(const char *path, char **argv, char **env = NULL, fd_t *stdio = NULL);
 
    static void release(int exit_code = 0);
 
    static int wait(shell::pid_t pid);
 
    static int cancel(shell::pid_t pid);
 
    inline unsigned operator()(void) const
        {return _argc;}
 
    static const char *text(const char *string);
 
    static const char *texts(const char *singular, const char *plural, unsigned long count);
 
    static unsigned count(char **argv);
 
#ifdef  _MSWINDOWS_
 
    static inline fd_t input(void)
        {return GetStdHandle(STD_INPUT_HANDLE);}
 
    static inline fd_t output(void)
        {return GetStdHandle(STD_OUTPUT_HANDLE);}
 
    static inline fd_t error(void)
        {return GetStdHandle(STD_ERROR_HANDLE);}
 
#else
    static inline fd_t input(void)
        {return 0;}
 
    static inline fd_t output(void)
        {return 1;}
 
    static inline fd_t error(void)
        {return 2;}
#endif
 
    static int inkey(const char *prompt = NULL);
 
    static char *getpass(const char *prompt, char *buffer, size_t size);
 
    static char *getline(const char *prompt, char *buffer, size_t size);
};
 
typedef shell shell_t;
 
#undef  _TEXT
#undef  __TEXT
#undef  _STR
#undef  __STR
#define _STR(x)     ((const char *)(x))
#define __STR(x)    (static_cast<const char *>(x))
 
inline  const char *__TEXT(const char *s)
    {return shell::text(s);}
 
inline const char *_TEXT(const char *s)
    {return shell::text(s);}
 
} // namespace ucommon
 
#endif