ucommon/shell.h

Go to the documentation of this file.

// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
//
// 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_BUFFER_H_
#include <ucommon/buffer.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

NAMESPACE_UCOMMON

class __EXPORT shell : public mempager
{
private:
    char **_argv;
    unsigned _argc;
    char *_argv0;

    class __LOCAL args : public OrderedObject
    {
    public:
        char *item;
    };
    
    void collapse(LinkedObject *first);

    void set0(char *argv0);

public:
    typedef enum {NOARGS = 0, NOARGUMENT, INVARGUMENT, BADOPTION, OPTION_USED, BAD_VALUE} errmsg_t;

#ifdef  _MSWINDOWS_
    typedef HANDLE pid_t;
#else

    typedef int pid_t;
#endif

    typedef enum {RD = IOBuffer::BUF_RD, WR = IOBuffer::BUF_WR, RDWR = IOBuffer::BUF_RDWR} pmode_t;

    class __EXPORT pipeio
    {
    protected:
        friend class shell;

        pipeio();

        int spawn(const char *path, char **argv, pmode_t mode, size_t size = 512, char **env = NULL);
        
        int wait(void);

        int cancel(void);

        size_t read(void *address, size_t size);

        size_t write(const void *address, size_t size);
            
        pid_t pid;
        fd_t input, output; // input to and output from child process...
        int perror, presult;
    };

    class __EXPORT iobuf : public IOBuffer, protected pipeio
    {
    protected:
        friend class shell;

        virtual size_t _push(const char *address, size_t size);
        virtual size_t _pull(char *address, size_t size);

    public:
        iobuf(size_t size = 0);

        iobuf(const char *path, char **argv, pmode_t mode, size_t size = 512, char **env = NULL);

        ~iobuf();

        void open(const char *path, char **argv, pmode_t mode, size_t size = 512, char **env = NULL);

        void close(void);

        void cancel(void);
    };

    typedef iobuf io_t;

    typedef pipeio *pipe_t;

    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 OrderedObject
    {
    private:
        static OrderedIndex index;

    public:
        char short_option;
        const char *long_option;
        const char *uses_option;
        const char *help_string;

        Option(char short_option = 0, const char *long_option = NULL, const char *value_type = NULL, const char *help = NULL);

        virtual ~Option();

        inline static LinkedObject *first(void)
            {return index.begin();};

        virtual const char *assign(const char *value) = 0;
    };

    class __EXPORT flagopt : public Option
    {
    private:
        unsigned counter;
        bool single;

        virtual const char *assign(const char *value);

    public:
        flagopt(char short_option, const char *long_option = NULL, const char *help = NULL, bool single_use = true);

        inline operator bool()
            {return counter > 0;};

        inline bool operator!()
            {return counter == 0;};

        inline operator unsigned()
            {return counter;};

        inline unsigned operator*()
            {return counter;};
    };

    class __EXPORT stringopt : public Option
    {
    private:
        bool used;

    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 operator bool()
            {return used;};

        inline bool operator!()
            {return !used;};

        inline operator const char *()
            {return text;};

        inline const char *operator*()
            {return text;};

        char operator[](size_t index);
    };

    class __EXPORT charopt : public Option
    {
    private:
        bool used;

    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 operator bool()
            {return used;};

        inline bool operator!()
            {return !used;};

        inline operator char()
            {return code;};

        inline char operator*()
            {return code;};
    };

    class __EXPORT numericopt : public Option
    {
    private:
        bool used;

    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 operator bool()
            {return used;};

        inline bool operator!()
            {return !used;};

        inline operator long()
            {return number;};

        inline long operator*()
            {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 help(void);

    static int system(const char *command, const char **env = NULL);

    static int systemf(const char *format, ...) __PRINTF(1,2);

    char **parse(const char *string);

    void parse(int argc, char **argv);

    inline static char **parse(shell &args, const char *string)
        {return args.parse(string);};

    inline const char *argv0() const
        {return _argv0;};

    static void errexit(int exitcode, const char *format = NULL, ...) __PRINTF(2, 3);

    static size_t printf(const char *format, ...) __PRINTF(1, 2);

    static size_t readln(char *address, size_t size);

    static size_t writes(const char *string);

    static size_t read(String& string);

    inline static size_t write(String& string)
        {return writes(string.c_str());};

    static size_t printf(pipe_t pipe, const char *format, ...) __PRINTF(2, 3);

    static size_t readln(pipe_t pipe, char *buffer, size_t size);

    static size_t read(pipe_t pipe, String& string);

    static size_t writes(pipe_t pipe, const char *string);

    inline static size_t write(pipe_t pipe, String& string)
        {return writes(pipe, string.c_str());};

    inline unsigned argc(void) const
        {return _argc;};

    inline char **argv(void) const
        {return _argv;};

    inline const char *operator[](unsigned offset)
        {return _argv[offset];};

    static shell::pid_t spawn(const char *path, char **argv, char **env = NULL, fd_t *stdio = NULL);

    static shell::pipe_t spawn(const char *path, char **argv, pmode_t mode, size_t size = 512, char **env = NULL);

    int detach(const char *path, char **argv, char **env = NULL, fd_t *stdio = NULL);

    static int wait(shell::pid_t pid);

    static int cancel(shell::pid_t pid);

    static int wait(shell::pipe_t pointer);

    static int cancel(shell::pipe_t pointer);

    inline unsigned operator()(void)
        {return _argc;};

    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
};
    
END_NAMESPACE

#endif

---