trace.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2015 Liviu Ionescu.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
 
#ifndef CMSIS_PLUS_DIAG_TRACE_H_
#define CMSIS_PLUS_DIAG_TRACE_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
#include <cstdint>
#include <cstddef>
#include <cstdarg>
#include <cstdlib>
#else
#include <stdint.h>
#include <stdarg.h>
#include <stdlib.h>
#endif
 
#include <sys/types.h>
 
#if defined(__cplusplus)
 
// To be effective, <stdio.h> must be included *before* this patch.
#include <stdio.h>
 
// This is a very annoying issue, some very old libraries still
// define putchar() as a macro. This is abusive, since it prevents
// the use of putchar() in other name spaces.
#if defined(putchar)
#undef putchar
#endif
 
#endif
 
// ----------------------------------------------------------------------------
 
inline void
__attribute__((always_inline))
trace_dbg_bkpt (void)
{
#if defined(__ARM_EABI__)
  asm volatile ("bkpt 0");
#endif
}
 
#if defined(TRACE)
 
#if defined(__cplusplus)
 
namespace os
{
  namespace trace
  {
    // ----------------------------------------------------------------------
 
    void
    initialize (void);
 
    ssize_t
    write (const void* buf, std::size_t nbyte);
 
    // ----------------------------------------------------------------------
 
    int
    printf (const char* format, ...);
 
    int
    vprintf (const char* format, std::va_list args);
 
    int
    puts (const char* s);
 
    int
    putchar (int c);
 
    void
    dump_args (int argc, char* argv[]);
 
    void
    flush(void);
 
    // ------------------------------------------------------------------------
 
    inline void
    __attribute__((always_inline))
    dbg_bkpt (void)
    {
      trace_dbg_bkpt ();
    }
 
  } /* namespace trace */
} /* namespace os */
 
#endif /* defined(__cplusplus) */
 
#if defined(__cplusplus)
extern "C"
{
#endif
 
  // ----- Implementation -----
  // These functions must be implemented for a specific trace channel.
 
  void
  trace_initialize (void);
 
  ssize_t
  trace_write (const void* buf, size_t nbyte);
 
  void
  trace_flush (void);
 
  // ----- Portable -----
 
  int
  trace_printf (const char* format, ...);
 
  int
  trace_vprintf (const char* format, va_list args);
 
  int
  trace_puts (const char* s);
 
  int
  trace_putchar (int c);
 
  void
  trace_dump_args (int argc, char* argv[]);
 
#if defined(__cplusplus)
}
#endif
 
#else /* !defined(TRACE) */
 
// Empty definitions when trace is not defined
 
#if defined(__cplusplus)
 
namespace os
  {
    namespace trace
      {
        // ----------------------------------------------------------------
 
        inline void
        initialize (void);
 
        inline ssize_t
        write (const void* buf, std::size_t nbyte);
 
        // ----------------------------------------------------------------
 
        inline int
        printf (const char* format, ...);
 
        inline int
        vprintf (const char* format, std::va_list args);
 
        inline int
        puts (const char* s);
 
        inline int
        putchar (int c);
 
        inline void
        dump_args (int argc, char* argv[]);
 
        // ----------------------------------------------------------------
 
        inline void __attribute__((always_inline))
        initialize (void)
          {
          }
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
 
        inline ssize_t __attribute__((always_inline))
        write (const void* buf, std::size_t nbyte)
          {
            return static_cast<ssize_t> (nbyte);
          }
 
        inline void __attribute__((always_inline))
        flush (void)
          {
            ;
          }
 
        inline int __attribute__((always_inline))
        printf (const char* format, ...)
          {
            return 0;
          }
 
        inline int __attribute__((always_inline))
        vprintf (const char* format, std::va_list args)
          {
            return 0;
          }
 
        inline int __attribute__((always_inline))
        puts (const char* s)
          {
            return 0;
          }
 
        inline int __attribute__((always_inline))
        putchar (int c)
          {
            return c;
          }
 
        inline void __attribute__((always_inline))
        dump_args (int argc, char* argv[])
          {
          }
 
#pragma GCC diagnostic pop
 
      } /* namespace trace */
  } /* namespace os */
 
#endif /* defined(__cplusplus) */
 
#if defined(__cplusplus)
extern "C"
  {
#endif
 
    inline void
    trace_initialize (void);
 
    // Implementation dependent
    inline ssize_t
    trace_write (const void* buf, size_t nbyte);
 
    inline void
    trace_flush (void);
 
    inline int
    trace_printf (const char* format, ...);
 
    inline int
    trace_vprintf (const char* format, va_list args);
 
    inline int
    trace_puts (const char* s);
 
    inline int
    trace_putchar (int c);
 
    inline void
    trace_dump_args (int argc, char* argv[]);
 
#if defined(__cplusplus)
  }
#endif
 
inline void
__attribute__((always_inline))
trace_initialize (void)
  {
    ;
  }
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
 
#pragma GCC diagnostic push
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
 
inline ssize_t
__attribute__((always_inline))
trace_write (const void* buf, size_t nbyte)
  {
    return (ssize_t) (nbyte);
  }
 
inline void
__attribute__((always_inline))
trace_flush (void)
  {
    ;
  }
 
#pragma GCC diagnostic pop
 
inline int
__attribute__((always_inline))
trace_printf (const char* format, ...)
  {
    return 0;
  }
 
inline int
__attribute__((always_inline))
trace_vprintf (const char* format, va_list args)
  {
    return 0;
  }
 
inline int
__attribute__((always_inline))
trace_puts (const char* s)
  {
    return 0;
  }
 
inline int
__attribute__((always_inline))
trace_putchar (int c)
  {
    return c;
  }
 
inline void
__attribute__((always_inline))
trace_dump_args (int argc, char* argv[])
  {
  }
 
#pragma GCC diagnostic pop
 
#endif /* defined(TRACE) */
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_DIAG_TRACE_H_ */