libaegis/sub.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 1991-1993, 1995, 1997, 1999, 2002-2008 Peter Miller
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; either version 3 of the License, or
//      (at your option) any later version.
//
//      This program 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 General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program. If not, see
//      <http://www.gnu.org/licenses/>.
//

#ifndef SUB_H
#define SUB_H

#include <common/ac/stdarg.h>
#include <common/ac/time.h>
#include <common/str.h>
#include <libaegis/change.h>
#include <libaegis/sub/diversion/stack.h>
#include <libaegis/sub/functor/list.h>

struct project_ty; // forward
struct sub_context_ty; // forward
class nstring; // forward
class wstring; // forward
class wstring_list; // forward

class sub_context_ty
{
public:
    ~sub_context_ty();

    sub_context_ty(const char *file = 0, int line = 0);

    void clear();

    void var_set_format(const char *name, const char *fmt, ...)
                                                              ATTR_PRINTF(3, 4);
    void var_set_vformat(const char *name, const char *fmt, va_list args)
                                                                ATTR_VPRINTF(3);
    void var_set_string(const char *name, string_ty *value);

    void var_set_string(const char *name, const nstring &value);

    void var_set_charstar(const char *name, const char *value);

    void var_set_long(const char *name, long value);

    void var_set_time(const char *name, time_t value);

    void var_optional(const char *name);

    void var_append_if_unused(const char *name);

    void var_override(const char *name);

    void var_resubstitute(const char *name);

    void errno_setx(int value);

    string_ty *substitute(change::pointer cp, string_ty *the_command);

    string_ty *substitute_p(project_ty *pp, string_ty *the_command);

    string_ty *subst_intl(const char *substme);

    void subst_intl_project(struct project_ty *pp);

    void subst_intl_change(change::pointer cp);

    void error_intl(const char *message);

    void fatal_intl(const char *message) NORETURN;

    void verbose_intl(const char *message);

    void error_set(const char *message);

    project_ty *project_get();

    change::pointer change_get();

    int errno_sequester_get() const;

    wstring subst(const wstring &msg);

    wstring subst_intl_wide(const char *msg);

private:
    sub_diversion_stack diversion_stack;
    sub_functor_list var_list;
    change::pointer cp;
    project_ty *pp;

    const char *suberr;
    int errno_sequester;
    const char *file_name;
    int line_number;

    void diversion_close();

    enum getc_type
    {
        getc_type_control,
        getc_type_data
    };

    wchar_t getc_meta(getc_type &c);

    void getc_meta_undo(wchar_t c);

    wchar_t getch(getc_type &tr);

    wchar_t dollar();

    void execute(const wstring_list &arg);

    sub_context_ty(const sub_context_ty &);

    sub_context_ty &operator=(const sub_context_ty &);
};

inline sub_context_ty *
sub_context_New(const char *file, int line)
{
    return new sub_context_ty(file, line);
}

inline sub_context_ty *
sub_context_new()
{
    return new sub_context_ty();
}

inline void
sub_context_delete(sub_context_ty *scp)
{
    delete scp;
}

inline void
sub_var_clear(sub_context_ty *scp)
{
    scp->clear();
}

inline void ATTR_PRINTF(3, 4)
sub_var_set_format(sub_context_ty *scp, const char *name, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    scp->var_set_vformat(name, fmt, ap);
    va_end(ap);
}

inline void
sub_var_set_string(sub_context_ty *scp, const char *name, string_ty *value)
{
    scp->var_set_string(name, value);
}

inline void
sub_var_set_string(sub_context_ty *scp, const char *name, const nstring &value)
{
    scp->var_set_string(name, value);
}

inline void
sub_var_set_charstar(sub_context_ty *scp, const char *name, const char *value)
{
    scp->var_set_charstar(name, value);
}

inline void
sub_var_set_long(sub_context_ty *scp, const char *name, long value)
{
    scp->var_set_long(name, value);
}

inline void
sub_var_set_time(sub_context_ty *scp, const char *name, time_t value)
{
    scp->var_set_time(name, value);
}

inline void
sub_var_optional(sub_context_ty *scp, const char *name)
{
    scp->var_optional(name);
}

inline void
sub_var_append_if_unused(sub_context_ty *scp, const char *name)
{
    scp->var_append_if_unused(name);
}

inline void
sub_var_override(sub_context_ty *scp, const char *name)
{
    scp->var_override(name);
}

inline void
sub_var_resubstitute(sub_context_ty *scp, const char *name)
{
    scp->var_resubstitute(name);
}

inline void
sub_errno_setx(sub_context_ty *scp, int value)
{
    scp->errno_setx(value);
}

inline string_ty *
substitute(sub_context_ty *scp, change::pointer cp, string_ty *the_command)
{
    if (!scp)
    {
        sub_context_ty inner;
        return inner.substitute(cp, the_command);
    }
    return scp->substitute(cp, the_command);
}

inline string_ty *
substitute_p(sub_context_ty *scp, struct project_ty *pp, string_ty *the_command)
{
    if (!scp)
    {
        sub_context_ty inner;
        return inner.substitute_p(pp, the_command);
    }
    return scp->substitute_p(pp, the_command);
}

inline string_ty *
subst_intl(sub_context_ty *scp, const char *substme)
{
    if (!scp)
    {
        sub_context_ty inner;
        return inner.subst_intl(substme);
    }
    return scp->subst_intl(substme);
}

inline void
subst_intl_project(sub_context_ty *scp, struct project_ty *pp)
{
    if (!scp)
    {
        sub_context_ty inner;
        inner.subst_intl_project(pp);
    }
    else
        scp->subst_intl_project(pp);
}

inline void
subst_intl_change(sub_context_ty *scp, change::pointer cp)
{
    if (!scp)
    {
        sub_context_ty inner;
        inner.subst_intl_change(cp);
    }
    else
        scp->subst_intl_change(cp);
}

inline void
error_intl(sub_context_ty *scp, const char *message)
{
    if (!scp)
    {
        sub_context_ty inner;
        inner.error_intl(message);
    }
    else
        scp->error_intl(message);
}

inline void
fatal_intl(sub_context_ty *, const char *) NORETURN;

inline void
fatal_intl(sub_context_ty *scp, const char *message)
{
    if (!scp)
    {
        sub_context_ty inner;
        inner.fatal_intl(message);
    }
    else
        scp->fatal_intl(message);
}

inline void
verbose_intl(sub_context_ty *scp, const char *message)
{
    if (!scp)
    {
        sub_context_ty temp;
        temp.verbose_intl(message);
    }
    else
        scp->verbose_intl(message);
}

//
// The inline i18n function does nothing by itself, but it serves as a
// keyword for the xgettext program, when extracting internationalized
// msgid keys.
//
inline const char *
i18n(const char *x)
{
    return x;
}

inline DEPRECATED void
sub_context_error_set(sub_context_ty *scp, const char *message)
{
    scp->error_set(message);
}

inline project_ty *
sub_context_project_get(sub_context_ty *scp)
{
    return scp->project_get();
}

inline change::pointer
sub_context_change_get(sub_context_ty *scp)
{
    return scp->change_get();
}

#endif // SUB_H

---