toppers/trace.hpp

解説を見る。

/*
 *  TOPPERS/C++ API Template Library
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      C++ API Template Library
 *
 *  Copyright (C) 2004 by TAKAGI Nobuhisa
 *
 *  上記著作権者は，以下の (1)〜(4) の条件か，Free Software Foundation
 *  によって公表されている GNU General Public License の Version 2 に記
 *  述されている条件を満たす場合に限り，本ソフトウェア（本ソフトウェア
 *  を改変したものを含む．以下同じ）を使用・複製・改変・再配布（以下，
 *  利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，その適用可能性も
 *  含めて，いかなる保証も行わない．また，本ソフトウェアの利用により直
 *  接的または間接的に生じたいかなる損害に関しても，その責任を負わない．
 *
 *  @(#) $Id: trace.hpp,v 1.1.1.1 2004/04/14 09:30:31 takagi-n Exp $
 */

#ifndef TOPPERS_TRACE_HPP_
#define TOPPERS_TRACE_HPP_

#include <typeinfo>
#include <limits>
#include <toppers/diagnostics.hpp>
#include <toppers/kernelstatus.hpp>

#ifdef  __GNUC__
#define TOPPERS_TYPENAME(type)  toppers::type_name<__typeof__(type)>::get()
#else
#define TOPPERS_TYPENAME(type)  toppers::type_name_helper< type >()
#endif

#ifndef TOPPERS_HAS_SYSLOG
#if TKERNEL_MAKER == 0x0118
#define TOPPERS_HAS_SYSLOG  1
#else
#define TOPPERS_HAS_SYSLOG  0
#endif
#endif

namespace toppers
{

    class null_tracer
    {
    };

    template <typename T>
    null_tracer& operator<<(null_tracer& tr, const T& obj)
    {
        return tr;
    }

    namespace detail
    {

        enum
        {
            boolalpha = 0x0001,
            showbase  = 0x0002,
            uppercase = 0x0004,
            oct       = 0x0030,
            hex       = 0x0050,
            basefield = 0x0070
        };

        struct setpri_helper
        {
            UINT prio_;
        };

        struct setfill_helper
        {
            char fill_;
        };

        struct setwidth_helper
        {
            int width_;
        };

        template <typename Int, typename Putter, typename Dest>
        void convert(Int value, unsigned int base, bool uppercase, bool showbase,
                    int width, bool minus, char fill, Putter putter, Dest dest)
        {
            typedef std::numeric_limits<Int>    limits;
            TOPPERS_STATIC_ASSERT(limits::is_integer && !limits::is_signed);
            char    buf[33];
            int i = 0;
            Int t = value;
            do
            {
                static const char upper[] = "0123456789ABCDEF";
                static const char lower[] = "0123456789abcdef";
                int d = t % base;
                buf[i++] = uppercase ? upper[d] : lower[d];
                t /= base;
            } while (t != 0);

            if (minus)
                --width;
            if (minus && fill == '0')
            {
                putter('-', dest);
            }
            if (value != 0 && showbase)
            {
                switch (base)
                {
                case 8:
                    --width;
                    putter('0', dest);
                    break;
                case 16:
                    width -= 2;
                    putter('0', dest);
                    putter(uppercase ? 'X' : 'x', dest);
                    break;
                }
            }
            for (int j = i; j < width; j++)
            {
                putter(fill, dest);
            }
            if (minus && fill != '0')
            {
                putter('-', dest);
            }
            while (i > 0)
            {
                putter(buf[--i], dest);
            }
        }

        template <class Tracer, typename T>
        inline Tracer& puthex(Tracer& tr, T x)
        {
            // Tが符号付きの場合の誤作動を回避するためsizeof(T) * CHAR_BITでビット数を求める。
            const int char_bits = std::numeric_limits<unsigned char>::digits;
            unsigned long t = (unsigned long)x;
            tr << '0' << 'x';
            convert(t, 16, false, false, (sizeof(x) * char_bits + 3) / 4, false, '0', tr.putter, (void*)&tr);
            return tr;
        }

        inline const char* ta_asm_or_hlng(ATR atr)
        {
            return (atr & TA_ASM) ? "TA_ASM" : "TA_HLNG";
        }

        inline const char* ta_tfifo_or_tpri(ATR atr)
        {
            return (atr & TA_TPRI) ? "TA_TPRI" : "TA_TFIFO";
        }

        inline const char* ta_mfifo_or_mpri(ATR atr)
        {
            return (atr & TA_MPRI) ? "TA_MPRI" : "TA_MFIFO";
        }

        inline const char* ta_wsgl_or_wmul(ATR atr)
        {
#ifndef TA_WMUL
            return "TA_WSGL";
#else
            return (atr & TA_WMUL) ? "TA_WMUL" : "TA_WSGL";
#endif
        }

        inline const char* str_tmo(TMO tmout)
        {
            const char* s = 0;
            switch (tmout)
            {
            case TMO_POL:
                s = "TMO_POL";
                break;
            case TMO_FEVR:
                s = "TMO_FEVR";
                break;
            case TMO_NBLK:
                s = "TMO_NBLK";
                break;
            }
            return s;
        }

        inline const char* str_tskstat(STAT tskstat)
        {
            const char* s = 0;
#ifdef  TTS_RUN
            switch (tskstat)
            {
            case TTS_RUN:
                s = "TTS_RUN";
                break;
            case TTS_RDY:
                s = "TTS_RDY";
                break;

            case TTS_WAI:
                s = "TTS_WAI";
                break;
            case TTS_SUS:
                s = "TTS_SUS";
                break;
            case TTS_WAS:
                s = "TTS_WAS";
                break;
            case TTS_DMT:
                s = "TTS_DMT";
                break;
            }
#endif
            return s;
        }

        inline const char* str_tskwait(STAT tskwait)
        {
            const char* s = 0;
#ifdef  TTW_SLP
            switch (tskwait)
            {
            case TTW_SLP:
                s = "TTW_SLP";
                break;
            case TTW_DLY:
                s = "TTW_DLY";
                break;
            case TTW_SEM:
                s = "TTW_SEM";
                break;
            case TTW_FLG:
                s = "TTW_FLG";
                break;
            case TTW_SDTQ:
                s = "TTW_SDTQ";
                break;
            case TTW_RDTQ:
                s = "TTW_RDTQ";
                break;
            case TTW_MBX:
                s = "TTW_MBX";
                break;
            case TTW_MTX:
                s = "TTW_MTX";
                break;
            case TTW_SMBF:
                s = "TTW_SMBF";
                break;
            case TTW_RMBF:
                s = "TTW_RMBF";
                break;
            case TTW_CAL:
                s = "TTW_CAL";
                break;
            case TTW_ACP:
                s = "TTW_ACP";
                break;
            case TTW_RDV:
                s = "TTW_RDV";
                break;
            case TTW_MPF:
                s = "TTW_MPF";
                break;
            case TTW_MPL:
                s = "TTW_MPL";
                break;
            }
#endif
            return s;
        }

        inline const char* str_texstat(STAT texstat)
        {
            const char* s = 0;
#ifdef  TTEX_ENA
            switch (texstat)
            {
            case TTEX_ENA:
                s = "TTEX_ENA";
                break;
            case TTEX_DIS:
                s = "TTEX_DIS";
                break;
            }
#endif
            return s;
        }

    }

    template <std::size_t Count = 32,
              std::size_t BufferSize = 256,
              class Diagnostics = TOPPERS_DEFAULT_DIAGNOSTICS >
    class syslog_tracer : Diagnostics
    {
        TOPPERS_STATIC_ASSERT(TOPPERS_HAS_SYSLOG);
        UINT prio_;
        UINT flags_;
        int width_;
        char fill_;
        char* buf_, * ptr_;

        static char (&buffer())[Count][BufferSize]
        {
            static char b[Count][BufferSize];
            return b;
        }
        static std::size_t& cur()
        {
            static std::size_t c;
            return c;
        }

        void get_buf();

    public:
        explicit syslog_tracer(UINT prio = 5u)
            : prio_(prio)
        {
            get_buf();
            init();
        }

        void init()
        {
            flags_ = 0;
            width_ = 0;
            fill_  = ' ';
        }

        UINT flags() const
        {
            return flags_;
        }
        UINT flags(UINT fmtfl)
        {
            UINT prev = flags_;
            flags_ = fmtfl;
            return prev;
        }

        UINT setf(UINT fmtfl)
        {
            UINT prev = flags_;
            flags_ |= fmtfl;
            return prev;
        }
        UINT setf(UINT fmtfl, UINT mask)
        {
            UINT prev = flags_;
            flags_ = (flags_ & ~mask) | fmtfl;
            return prev;
        }
        UINT unsetf(UINT mask)
        {
            UINT prev = flags_;
            flags_ &= ~mask;
            return prev;
        }

        int width() const
        {
            return width_;
        }
        int width(int wide)
        {
            int prev = width_;
            width_ = wide >= 0 ? wide : 0;
            return prev;
        }

        char fill() const
        {
            return fill_;
        }
        char fill(char c)
        {
            char prev = fill_;
            fill_ = c ? c : ' ';
            return prev;
        }

        UINT priority() const
        {
            return prio_;
        }
        UINT priority(UINT prio)
        {
            UINT prev = prio_;
            prio_ = prio;
            return prev;
        }

        syslog_tracer<Count, BufferSize, Diagnostics>& flush();

        syslog_tracer<Count, BufferSize, Diagnostics>& put(char c)
        {
            if (ptr_ - buf_ < BufferSize)
            {
                *ptr_++ = c;
                *ptr_ = '\0';
            }
            return *this;
        }
        syslog_tracer<Count, BufferSize, Diagnostics>& put(const char* s);

        static void putter(char c, void* p)
        {
            static_cast<syslog_tracer<Count, BufferSize, Diagnostics>*>(p)->put(c);
        }

        syslog_tracer& operator<<(syslog_tracer& (*manip)(syslog_tracer&))
        {
            return (*manip)(*this);
        }
    };

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    void syslog_tracer<Count, BufferSize, Diagnostics>::get_buf()
    {
        bool locked = cpulock<Diagnostics>::sense();
        if (!locked)
            cpulock<Diagnostics>::lock(context_independent);

        static char buffer_[Count][BufferSize];
        static std::size_t cur_;

        buf_ = buffer_[cur_++];
        if (cur_ >= Count)
            cur_ = 0;

        if (!locked)
            cpulock<Diagnostics>::unlock(context_independent);

        ptr_ = buf_;
        *ptr_ = '\0';
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    syslog_tracer<Count, BufferSize, Diagnostics>& syslog_tracer<Count, BufferSize, Diagnostics>::flush()
    {
        SYSLOG log;
        log.logtype = LOG_TYPE_COMMENT;
        log.loginfo[0] = (VP_INT)"%s";
        log.loginfo[1] = (VP_INT)buf_;
        ER ercd = vwri_log(prio_, &log);
        Diagnostics::handle_error(ercd);
        get_buf();
        return *this;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    syslog_tracer<Count, BufferSize, Diagnostics>& syslog_tracer<Count, BufferSize, Diagnostics>::put(const char* s)
    {
        if (s == 0)
            s = "(null)";
        while (*s != '\0' && ptr_ - buf_ < BufferSize)
            *ptr_++ = *s++;
        *ptr_ = '\0';
        return *this;
    }

    inline detail::setpri_helper setpri(UINT prio)
    {
        detail::setpri_helper t;
        t.prio_ = prio;
        return t;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& operator<<(syslog_tracer<Count, BufferSize, Diagnostics>& tr, const detail::setpri_helper& helper)
    {
        tr.priority(helper.prio_);
        return tr;
    }

    template <class Tracer>
    inline Tracer& operator<<(Tracer& tr, const detail::setpri_helper& helper)
    {
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& endl(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        return tr.flush();
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& boolalpha(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.setf(detail::boolalpha);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& unboolalpha(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.unsetf(detail::boolalpha);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& showbase(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.setf(detail::showbase);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& unshowbase(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.unsetf(detail::showbase);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& uppercase(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.setf(detail::uppercase);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& lowercase(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.unsetf(detail::uppercase);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& dec(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.unsetf(detail::basefield);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& oct(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.setf(detail::oct, detail::basefield);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>& hex(syslog_tracer<Count, BufferSize, Diagnostics>& tr)
    {
        tr.setf(detail::hex, detail::basefield);
        return tr;
    }

    template <std::size_t Count, std::size_t BufferSize, class Diagnostics>
    inline syslog_tracer<Count, BufferSize, Diagnostics>&
        operator<<(syslog_tracer<Count, BufferSize, Diagnostics>& tr,
                   syslog_tracer<Count, BufferSize, Diagnostics>& (*manip)(syslog_tracer<Count, BufferSize, Diagnostics>&))
    {
        return (*manip)(tr);
    }

    template <class Tracer>
    inline Tracer& operator<<(Tracer& tr, Tracer& (*manip)(Tracer&))
    {
        return (*manip)(tr);
    }

    inline detail::setfill_helper setfill(char c)
    {
        detail::setfill_helper t;
        t.fill_ = c;
        return t;
    }

    template <class Tracer>
    inline Tracer& operator<<(Tracer& tr, const detail::setfill_helper& helper)
    {
        tr.fill(helper.fill_);
        return tr;
    }

    inline detail::setwidth_helper setw(int width)
    {
        detail::setwidth_helper t;
        t.width_ = width;
        return t;
    }

    template <class Tracer>
    inline Tracer& operator<<(Tracer& tr, const detail::setwidth_helper& helper)
    {
        tr.width(helper.width_);
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, bool x)
    {
        int width = tr.width();
        char fill = tr.fill();

        if (tr.flags() & detail::boolalpha)
        {
            for (int i = (x ? sizeof("true") : sizeof("false")) - 1; i < width; i++)
                tr.put(fill);
            tr.put(x ? "true" : "false");
        }
        else
        {
            for (int i = 1; i < width; i++)
                tr.put(fill);
            tr.put(x ? '1' : '0');
        }
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, char x)
    {
        int width = tr.width();
        char fill = tr.fill();

        for (int i = 1; i < width; i++)
            tr.put(fill);
        tr.put(x);
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const char* x)
    {
        int width = tr.width();
        if (width > 0)
        {
            char fill = tr.fill();
            const char* s;
            for (s = x; *s != '\0'; s++) {}
            for (int i = (int)(s - x); i < width; i++)
                tr.put(fill);
        }
        tr.put(x);
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, long x)
    {
        bool minus = x < 0;
        unsigned long t = static_cast<unsigned long>(minus ? -x : x);
        UINT flags = tr.flags();
        unsigned int base = flags & detail::basefield;

        if (base == detail::oct)
            base = 8;
        else if (base == detail::hex)
            base = 16;
        else
            base = 10;

        detail::convert(t, base, flags & detail::uppercase, flags & detail::showbase, tr.width(), minus, tr.fill(), tr.putter, (void*)&tr);
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, unsigned long x)
    {
        UINT flags = tr.flags();
        unsigned int base = flags & detail::basefield;

        if (base == detail::oct)
            base = 8;
        else if (base == detail::hex)
            base = 16;
        else
            base = 10;

        detail::convert(x, base, flags & detail::uppercase, flags & detail::showbase, tr.width(), false, tr.fill(), tr.putter, (void*)&tr);
        return tr;
    }

    template <class Tracer>
    inline Tracer& operator<<(Tracer& tr, int x)
    {
        return tr << static_cast<long>(x);
    }

    template <class Tracer>
    inline Tracer& operator<<(Tracer& tr, unsigned int x)
    {
        return tr << static_cast<unsigned long>(x);
    }

#ifdef  TOPPERS_LONG_LONG

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, TOPPERS_LONG_LONG x)
    {
        bool minus = x < 0;
        unsigned TOPPERS_LONG_LONG t = static_cast<unsigned TOPPERS_LONG_LONG>(minus ? -t : t);
        UINT flags = tr.flags();
        unsigned int base = flags & detail::basefield;

        if (base == detail::oct)
            base = 8;
        else if (base == detail::hex)
            base = 16;
        else
            base = 10;

        detail::convert(t, base, flags & detail::uppercase, flags & detail::showbase, tr.width(), minus, tr.fill(), tr.putter, (void*)&tr);
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, unsigned TOPPERS_LONG_LONG x)
    {
        UINT flags = tr.flags();
        unsigned int base = flags & detail::basefield;

        if (base == detail::oct)
            base = 8;
        else if (base == detail::hex)
            base = 16;
        else
            base = 10;

        detail::convert(x, base, flags & detail::uppercase, flags & detail::showbase, tr.width(), false, tr.fill(), tr.putter, (void*)&tr);
        return tr;
    }

#endif

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const volatile void* x)
    {
        if (x == 0)
            return tr << "NULL";
        return detail::puthex(tr, x);
    }

    template <class Tracer>
    inline Tracer& operator<<(Tracer& tr, FP x)
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R>
    inline Tracer& operator<<(Tracer& tr, R (*x)())
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R>
    inline Tracer& operator<<(Tracer& tr, R (*x)(...))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T, ...))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, ...))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3, ...))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3, typename T4>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3, T4))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3, typename T4>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3, T4, ...))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3, typename T4, typename T5>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3, T4, T5))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3, typename T4, typename T5>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3, T4, T5, ...))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3, T4, T5, T6))
    {
        return detail::puthex(tr, x);
    }
    template <class Tracer, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
    inline Tracer& operator<<(Tracer& tr, R (*x)(T1, T2, T3, T4, T5, T6, ...))
    {
        return detail::puthex(tr, x);
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_msg& x)
    {
        return tr << "{ " << (void*)x.next << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_msg_pri& x)
    {
        return tr << "{ " << x.msgque << ", " << x.msgpri << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_ctsk& x)
    {
        tr << "{ "
            << detail::ta_asm_or_hlng(x.tskatr);
        if (x.tskatr & TA_ACT)
            tr << "|TA_ACT";
        if (x.tskatr & ~(TA_ASM|TA_HLNG|TA_ACT))
        {
            tr << "|";
            detail::puthex(tr, x.tskatr);
        }
        tr << ", "
            << x.exinf << ", "
            << x.task << ", "
            << x.itskpri << ", "
            << x.stksz << ", "
            << x.stk
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rtsk& x)
    {
        const char* s;
        tr << "{ ";

            s = detail::str_tskstat(x.tskstat);
            if (s == 0)
                tr << x.tskstat;
            else
                tr << s;

        tr << ", "
            << x.tskpri << ", "
            << x.tskbpri << ", ";

            s = detail::str_tskwait(x.tskwait);
            if (s == 0)
                tr << x.tskwait;
            else
                tr << s;

        tr << ", "
            << x.wobjid << ", ";

            if (x.lefttmo >= 0)
                tr << x.lefttmo;
            else
                tr << detail::str_tmo(x.lefttmo);

        tr  << ", "
            << x.actcnt << ", "
            << x.wupcnt << ", "
            << x.suscnt
          << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rtst& x)
    {
        const char* s;
        tr << "{ ";

            s = detail::str_tskstat(x.tskstat);
            if (s == 0)
                tr << x.tskstat;
            else
                tr << s;

        tr << ", ";

            s = detail::str_tskwait(x.tskwait);
            if (s == 0)
                tr << x.tskwait;
            else
                tr << s;

        tr << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_dtex& x)
    {
        tr << "{ "
            << detail::ta_asm_or_hlng(x.texatr);
        if (x.texatr & ~(TA_ASM|TA_HLNG))
        {
            tr << "|";
            detail::puthex(tr, x.texatr);
        }
        tr << ", "
            << x.texrtn
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rtex& x)
    {
        const char* s;
        tr << "{ ";

            s = detail::str_texstat(x.texstat);
            if (s == 0)
                tr << x.texstat;
            else
                tr << s;

        tr << ", ";
            detail::puthex(tr, x.pndptn)
          << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_csem& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.sematr);
        if (x.sematr & ~(TA_TFIFO|TA_TPRI))
        {
            tr << "|";
            detail::puthex(tr, x.sematr);
        }
        tr << ", "
            << x.isemcnt << ", "
            << x.maxsem
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rsem& x)
    {
        return tr << "{ "
                    << x.wtskid << ", "
                    << x.semcnt
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cflg& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.flgatr) << '|'
            << detail::ta_wsgl_or_wmul(x.flgatr);
        if (x.flgatr & TA_CLR)
            tr << "|TA_CLR";
#ifndef TA_WMUL
        if (x.flgatr & ~(TA_TFIFO|TA_TPRI|TA_WSGL|TA_CLR))
#else
        if (x.flgatr & ~(TA_TFIFO|TA_TPRI|TA_WSGL|TA_WMUL|TA_CLR))
#endif
        {
            tr << "|";
            detail::puthex(tr, x.flgatr);
        }
        tr << ", ";
            detail::puthex(tr, x.iflgptn)
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rflg& x)
    {
        tr << "{ "
            << x.wtskid << ", ";
            detail::puthex(tr, x.flgptn)
          << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cdtq& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.dtqatr);
        if (x.dtqatr & ~(TA_TFIFO|TA_TPRI))
        {
            tr << "|";
            detail::puthex(tr, x.dtqatr);
        }
        tr << ", "
            << x.dtqcnt << ", "
            << x.dtq
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rdtq& x)
    {
        return tr << "{ "
                    << x.stskid << ", "
                    << x.rtskid << ", "
                    << x.sdtqcnt
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cmbx& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.mbxatr) << '|'
            << detail::ta_mfifo_or_mpri(x.mbxatr);
        if (x.mbxatr & ~(TA_TFIFO|TA_TPRI|TA_MFIFO|TA_MPRI))
        {
            tr << "|";
            detail::puthex(tr, x.mbxatr);
        }
        tr << ", "
            << x.maxmpri << ", "
            << x.mprihd
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rmbx& x)
    {
        return tr << "{ "
                    << x.wtskid << ", "
                    << x.pk_msg
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cmtx& x)
    {
        const char* s = "";
        switch (x.mtxatr & (TA_TFIFO|TA_TPRI|TA_INHERIT|TA_CEILING))
        {
        case TA_TFIFO:
            s = "TA_TFIFO";
            break;
        case TA_TPRI:
            s = "TA_TPRI";
            break;
        case TA_INHERIT:
            s = "TA_INHERIT";
            break;
        case TA_CEILING:
            s = "TA_CEILING";
            break;
        }
        tr << "{ "
            << s;
        if (x.mtxatr & ~(TA_TFIFO|TA_TPRI|TA_INHERIT|TA_CEILING))
        {
            tr << "|";
            detail::puthex(tr, x.mtxatr);
        }
        tr << ", "
            << x.ceilpri
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rmtx& x)
    {
        return tr << "{ "
                    << x.htskid << ", "
                    << x.wtskid
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cmbf& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.mbfatr);
        if (x.mbfatr & ~(TA_TFIFO|TA_TPRI))
        {
            tr << "|";
            detail::puthex(tr, x.mbfatr);
        }
        tr << ", "
            << x.maxmsz << ", "
            << x.mbfsz << ", "
            << x.mbf
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rmbf& x)
    {
        return tr << "{ "
                    << x.stskid << ", "
                    << x.rtskid << ", "
                    << x.smsgcnt << ", "
                    << x.fmbfsz
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cpor& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.poratr);
        if (x.poratr & ~(TA_TFIFO|TA_TPRI))
        {
            tr << "|";
            detail::puthex(tr, x.poratr);
        }
        tr << ", "
            << x.maxcmsz << ", "
            << x.maxrmsz
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rpor& x)
    {
        return tr << "{ "
                    << x.ctskid << ", "
                    << x.atskid
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rrdv& x)
    {
        return tr << "{ "
                    << x.wtskid
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cmpf& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.mpfatr);
        if (x.mpfatr & ~(TA_TFIFO|TA_TPRI))
        {
            tr << "|";
            detail::puthex(tr, x.mpfatr);
        }
        tr << ", "
            << x.blkcnt << ", "
            << x.blksz << ", "
            << x.mpf
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rmpf& x)
    {
        return tr << "{ "
                    << x.wtskid << ", "
                    << x.fblkcnt
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cmpl& x)
    {
        tr << "{ "
            << detail::ta_tfifo_or_tpri(x.mplatr);
        if (x.mplatr & ~(TA_TFIFO|TA_TPRI))
        {
            tr << "|";
            detail::puthex(tr, x.mplatr);
        }
        tr << ", "
            << x.mplsz << ", "
            << x.mpl
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rmpl& x)
    {
        return tr << "{ "
                    << x.wtskid << ", "
                    << x.fmplsz << ", "
                    << x.fblksz
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_ccyc& x)
    {
        tr << "{ "
            << detail::ta_asm_or_hlng(x.cycatr);
        if (x.cycatr & TA_STA)
            tr << "|TA_STA";
        if (x.cycatr & TA_PHS)
            tr << "|TA_PHS";
        if (x.cycatr & ~(TA_ASM|TA_HLNG|TA_STA|TA_PHS))
        {
            tr << "|";
            detail::puthex(tr, x.cycatr);
        }
        tr << ", "
            << x.exinf << ", "
            << x.cychdr << ", "
            << x.cyctim << ", "
            << x.cycphs
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rcyc& x)
    {
        tr << "{ ";
            switch (x.cycstat)
            {
            case TCYC_STP:
                tr << "TCYC_STP";
                break;
            case TCYC_STA:
                tr << "TCYC_STA";
                break;
            default:
                tr << x.cycstat;
                break;
            }
        tr << ", "
            << x.lefttim
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_calm& x)
    {
        tr << "{ "
            << detail::ta_asm_or_hlng(x.almatr);
        if (x.almatr & ~(TA_ASM|TA_HLNG))
        {
            tr << "|";
            detail::puthex(tr, x.almatr);
        }
        tr << ", "
            << x.exinf << ", "
            << x.almhdr
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_ralm& x)
    {
        tr << "{ ";
            switch (x.almstat)
            {
            case TALM_STP:
                tr << "TALM_STP";
                break;
            case TALM_STA:
                tr << "TALM_STA";
                break;
            default:
                tr << x.almstat;
                break;
            }
        tr << ", "
            << x.lefttim
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_dovr& x)
    {
        tr << "{ "
            << detail::ta_asm_or_hlng(x.ovratr);
        if (x.ovratr & ~(TA_ASM|TA_HLNG))
        {
            tr << "|";
            detail::puthex(tr, x.ovratr);
        }
        tr << ", "
            << x.ovrhdr
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rovr& x)
    {
        tr << "{ ";
            switch (x.ovrstat)
            {
            case TOVR_STP:
                tr << "TOVR_STP";
                break;
            case TOVR_STA:
                tr << "TOVR_STA";
                break;
            default:
                tr << x.ovrstat;
                break;
            }
        tr << ", "
            << x.leftotm
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rsys& x)
    {
        return tr << "{ "
#if TKERNEL_MAKER == 0x0118
#endif
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_dinh& x)
    {
        tr << "{ ";
            detail::puthex(tr, x.inhatr) << ", "
            << x.inthdr
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_cisr& x)
    {
        tr << "{ "
            << detail::ta_asm_or_hlng(x.isratr);
        if (x.isratr & ~(TA_ASM|TA_HLNG))
        {
            tr << "|";
            detail::puthex(tr, x.isratr);
        }
        tr << ", "
            << x.exinf << ", "
            << x.intno << ", "
            << x.isr
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_risr& x)
    {
        return tr << "{ "
#if TKERNEL_MAKER == 0x0118
#endif
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_dsvc& x)
    {
        tr << "{ "
            << detail::ta_asm_or_hlng(x.svcatr);
        if (x.svcatr & ~(TA_ASM|TA_HLNG))
        {
            tr << "|";
            detail::puthex(tr, x.svcatr);
        }
        tr << ", "
            << x.svcrtn
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_dexc& x)
    {
        tr << "{ ";
            detail::puthex(tr, x.excatr) << ", "
            << x.exchdr
           << " }";
        return tr;
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rcfg& x)
    {
        return tr << "{ "
#if TKERNEL_MAKER == 0x0118
#endif
                  << " }";
    }

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const t_rver& x)
    {
        tr << "{ ";
            detail::puthex(tr, x.maker) << ", ";
            detail::puthex(tr, x.prid) << ", ";
            detail::puthex(tr, x.spver) << ", ";
            detail::puthex(tr, x.prver) << ", ";

        tr  << "{ ";
            detail::puthex(tr, x.prno[0]) << ", ";
            detail::puthex(tr, x.prno[1]) << ", ";
            detail::puthex(tr, x.prno[2]) << ", ";
            detail::puthex(tr, x.prno[3])
            << " }";
        tr << " }";
        return tr;
    }

#ifdef  TOPPERS_STRUCT_SYSTIM

    template <class Tracer>
    Tracer& operator<<(Tracer& tr, const SYSTIM& x)
    {
        // SYSTIMが構造体の場合の最低限の対応のため、16進数で表現するものとする。
        TOPPERS_ASSERT(std::numeric_limits<unsigned char>::digits == 8);
        unsigned long t1 = (unsigned long)x.htime;
        unsigned long t1 = (unsigned long)x.ltime;
        tr << '0' << 'x';
        convert(t1, 16, false, false, (sizeof(x.htime) * 8 + 3) / 4, false, '0', tr.putter, (void*)&tr);
        convert(t2, 16, false, false, (sizeof(x.ltime) * 8 + 3) / 4, false, '0', tr.putter, (void*)&tr);
        return tr;
    }

#endif  // TOPPERS_STRUCT_SYSTIM

    template <typename T>
    inline const char* type_name_helper()
    {
        return typeid(T).name();
    }

#define TOPPERS_DEFINE_TYPE_NAME(type)  \
    template <> inline const char* type_name<type>::get() { return #type; }

    template <typename T> 
    void _(char* name) throw()
    {
        const int offset = sizeof "void toppers::_(char*) [with T =";
        const char* first = __PRETTY_FUNCTION__ + offset;
        const char* last  = first + sizeof __PRETTY_FUNCTION__ - offset - sizeof "]";
        for (const char* s = first; s < last; s++, name++)
            *name = *s;
        *name = '\0';
    }

    template <typename T>
    struct type_name
    {
        static const char* get();
    };

    template <typename T>
    inline const char* type_name<T>::get()
    {
        static const char* name;
        if (name == 0)
        {
            int state = sns_dsp();
            if (!state)
                dis_dsp();
            if (name == 0)
            {
                static char s[sizeof __PRETTY_FUNCTION__ - 45 + 1];
                _<T>(s);
                name = s;
            }
            if (!state)
                ena_dsp();
        }
        return name;
    }

    TOPPERS_DEFINE_TYPE_NAME(char)
    TOPPERS_DEFINE_TYPE_NAME(signed char)
    TOPPERS_DEFINE_TYPE_NAME(unsigned char)
    TOPPERS_DEFINE_TYPE_NAME(short)
    TOPPERS_DEFINE_TYPE_NAME(unsigned short)
    TOPPERS_DEFINE_TYPE_NAME(int)
    TOPPERS_DEFINE_TYPE_NAME(unsigned int)
    TOPPERS_DEFINE_TYPE_NAME(long)
    TOPPERS_DEFINE_TYPE_NAME(unsigned long)
    TOPPERS_DEFINE_TYPE_NAME(long long)
    TOPPERS_DEFINE_TYPE_NAME(unsigned long long)
    TOPPERS_DEFINE_TYPE_NAME(float)
    TOPPERS_DEFINE_TYPE_NAME(double)
    TOPPERS_DEFINE_TYPE_NAME(long double)
    TOPPERS_DEFINE_TYPE_NAME(bool)

    TOPPERS_DEFINE_TYPE_NAME(char*)
    TOPPERS_DEFINE_TYPE_NAME(signed char*)
    TOPPERS_DEFINE_TYPE_NAME(unsigned char*)
    TOPPERS_DEFINE_TYPE_NAME(short*)
    TOPPERS_DEFINE_TYPE_NAME(unsigned short*)
    TOPPERS_DEFINE_TYPE_NAME(int*)
    TOPPERS_DEFINE_TYPE_NAME(unsigned int*)
    TOPPERS_DEFINE_TYPE_NAME(long*)
    TOPPERS_DEFINE_TYPE_NAME(unsigned long*)
    TOPPERS_DEFINE_TYPE_NAME(long long*)
    TOPPERS_DEFINE_TYPE_NAME(unsigned long long*)
    TOPPERS_DEFINE_TYPE_NAME(float*)
    TOPPERS_DEFINE_TYPE_NAME(double*)
    TOPPERS_DEFINE_TYPE_NAME(long double*)
    TOPPERS_DEFINE_TYPE_NAME(bool*)

    TOPPERS_DEFINE_TYPE_NAME(const char*)
    TOPPERS_DEFINE_TYPE_NAME(const signed char*)
    TOPPERS_DEFINE_TYPE_NAME(const unsigned char*)
    TOPPERS_DEFINE_TYPE_NAME(const short*)
    TOPPERS_DEFINE_TYPE_NAME(const unsigned short*)
    TOPPERS_DEFINE_TYPE_NAME(const int*)
    TOPPERS_DEFINE_TYPE_NAME(const unsigned int*)
    TOPPERS_DEFINE_TYPE_NAME(const long*)
    TOPPERS_DEFINE_TYPE_NAME(const unsigned long*)
    TOPPERS_DEFINE_TYPE_NAME(const long long*)
    TOPPERS_DEFINE_TYPE_NAME(const unsigned long long*)
    TOPPERS_DEFINE_TYPE_NAME(const float*)
    TOPPERS_DEFINE_TYPE_NAME(const double*)
    TOPPERS_DEFINE_TYPE_NAME(const long double*)
    TOPPERS_DEFINE_TYPE_NAME(const bool*)

#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
    TOPPERS_DEFINE_TYPE_NAME(wchar_t)
    TOPPERS_DEFINE_TYPE_NAME(wchar_t*)
    TOPPERS_DEFINE_TYPE_NAME(const wchar_t*)
#endif

}

#endif  // ! TOPPERS_TRACE_HPP_

---

• Copyright © 2004 by TAKAGI Nobuhisa
• 本ソフトウェアはTOPPERSライセンスに基づいて配布されています。
• TRONは"The Real-time Operating system Nucleus"の略称です。
• ITRONは"Industrial TRON"の略称です。
• μITRONは"Micro Industrial TRON"の略称です。
• TRON、ITRON、およびμITRONは、特定の商品ないしは商品群を指す名称ではありません。
• TOPPERSは"Toyohashi OPen Platform for Embedded Real-time Systems"の略称、JSPは"Just Standard Profile"の略称です。
• 本ページ中の商品名は，各社の商標または登録商標です。