OW_SafeCString.hpp

Go to the documentation of this file.

#include <cstring>

namespace OW_NAMESPACE
{
   class String;

namespace SafeCString
{

   char * str_dup(char const * s);

   char * str_dup_nothrow(char const * s);


   inline char const * nonull(char const * s)
   {
      return s ? s : "";
   }


   char * strcpy_trunc(char * dst, std::size_t dstsize, char const * src);

   char * strcpy_trunc(
      char * dst, std::size_t dstsize, char const * src, std::size_t srclen
   );

   template <std::size_t N> inline
   char * strcpy_trunc(char (&dst)[N], char const * src)
   {
      return strcpy_trunc(dst, N, src);
   }

   template <std::size_t N> inline
   char * strcpy_trunc(char (&dst)[N], char const * src, std::size_t srclen)
   {
      return strcpy_trunc(dst, N, src, srclen);
   }

   template <std::size_t N> inline
   std::size_t strcpy_to_pos_trunc(
      char (&dst)[N], std::size_t pos, char const * src
   )
   {
      return strcpy_trunc(dst + pos, N - pos, src) - dst;
   }

   template <std::size_t N> inline
   std::size_t strcpy_to_pos_trunc(
      char (&dst)[N], std::size_t pos, char const * src, std::size_t srclen
   )
   {
      return strcpy_trunc(dst + pos, N - pos, src, srclen) - dst;
   }

   OW_DECLARE_EXCEPTION(Overflow);
   int const RESULT_TRUNCATED = 0;
   int const DEST_UNTERMINATED = 1;

   char * strcpy_check(char * dst, std::size_t dstsize, char const * src);

   char * strcpy_check(
      char * dst, std::size_t dstsize, char const * src, std::size_t srclen
   );

   template <std::size_t N> inline
   char * strcpy_check(char (&dst)[N], char const * src)
   {
      return strcpy_check(dst, N, src);
   }

   template <std::size_t N> inline
   char * strcpy_check(char (&dst)[N], char const * src, std::size_t srclen)
   {
      return strcpy_check(dst, N, src, srclen);
   }

   template <std::size_t N> inline
   std::size_t strcpy_to_pos_check(
      char (&dst)[N], std::size_t pos, char const * src
   )
   {
      return strcpy_check(dst + pos, N - pos, src) - dst;
   }

   template <std::size_t N> inline
   std::size_t strcpy_to_pos_check(
      char (&dst)[N], std::size_t pos, char const * src, std::size_t srclen
   )
   {
      return strcpy_check(dst + pos, N - pos, src, srclen) - dst;
   }


   char * strcat_trunc(char * dst, std::size_t dstsize, char const * src);

   char * strcat_trunc(
      char * dst, std::size_t dstsize, char const * src, std::size_t srclen
   );

   template <std::size_t N> inline
   char * strcat_trunc(char (&dst)[N], char const * src)
   {
      return strcat_trunc(dst, N, src);
   }

   template <std::size_t N> inline
   char * strcat_trunc(char (&dst)[N], char const * src, std::size_t srclen)
   {
      return strcat_trunc(dst, N, src, srclen);
   }

   char * strcat_check(char * dst, std::size_t dstsize, char const * src);

   char * strcat_check(
      char * dst, std::size_t dstsize, char const * src, std::size_t srclen
   );

   template <std::size_t N> inline
   char * strcat_check(char (&dst)[N], char const * src)
   {
      return strcat_check(dst, N, src);
   }

   template <std::size_t N> inline
   char * strcat_check(char (&dst)[N], char const * src, std::size_t srclen)
   {
      return strcat_check(dst, N, src, srclen);
   }


namespace Impl
{
   inline std::size_t nchars_output(int retval, std::size_t dstsize)
   {
      return (
         retval < 0 || retval >= static_cast<int>(dstsize) ?   dstsize - 1
         : static_cast<std::size_t>(retval)
      );
   }

   std::size_t nchars_check(int retval, std::size_t dstsize);
}

   template <typename T1>
   std::size_t sprintf_trunc(
      char * dst, std::size_t dstsize, char const * fmt, T1 const & x1
   )
   {
      return Impl::nchars_output(snprintf(dst, dstsize, fmt, x1), dstsize);
   }

   template <typename T1, typename T2>
   std::size_t sprintf_trunc(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_output(
         snprintf(dst, dstsize, fmt, x1, x2), dstsize);
   }

   template <typename T1, typename T2>
   std::size_t sprintf_trunc(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_output(
         snprintf(dst, dstsize, fmt, x1, x2), dstsize);
   }

   template <typename T1, typename T2, typename T3>
   std::size_t sprintf_trunc(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3
   )
   {
      return Impl::nchars_output(
         snprintf(dst, dstsize, fmt, x1, x2, x3), dstsize);
   }

   template <typename T1, typename T2, typename T3, typename T4>
   std::size_t sprintf_trunc(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4
   )
   {
      return Impl::nchars_output(
         snprintf(dst, dstsize, fmt, x1, x2, x3, x4), dstsize);
   }

   template <typename T1, typename T2, typename T3, typename T4, typename T5>
   std::size_t sprintf_trunc(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4, T5 const & x5
   )
   {
      return Impl::nchars_output(
         snprintf(dst, dstsize, fmt, x1, x2, x3, x4, x5), dstsize);
   }

   template <std::size_t N, typename T1>
   std::size_t sprintf_trunc(char (&dst)[N], char const * fmt, T1 const & x1)
   {
      return Impl::nchars_output(snprintf(dst, N, fmt, x1), N);
   }

   template <std::size_t N, typename T1, typename T2>
   std::size_t sprintf_trunc(
      char (&dst)[N], char const * fmt, T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_output(snprintf(dst, N, fmt, x1, x2), N);
   }

   template <std::size_t N, typename T1, typename T2>
   std::size_t sprintf_trunc(
      char (&dst)[N], char const * fmt, T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_output(snprintf(dst, N, fmt, x1, x2), N);
   }

   template <std::size_t N, typename T1, typename T2, typename T3>
   std::size_t sprintf_trunc(
      char (&dst)[N], char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3
   )
   {
      return Impl::nchars_output(snprintf(dst, N, fmt, x1, x2, x3), N);
   }

   template <std::size_t N, typename T1, typename T2, typename T3, typename T4>
   std::size_t sprintf_trunc(
      char (&dst)[N], char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4
   )
   {
      return Impl::nchars_output(snprintf(dst, N, fmt, x1, x2, x3, x4), N);
   }

   template <std::size_t N, typename T1, typename T2, typename T3, typename T4,
           typename T5>
   std::size_t sprintf_trunc(
      char (&dst)[N], char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4, T5 const & x5
   )
   {
      return Impl::nchars_output(
         snprintf(dst, N, fmt, x1, x2, x3, x4, x5), N);
   }


   template <typename T1>
   std::size_t sprintf_check(
      char * dst, std::size_t dstsize, char const * fmt, T1 const & x1
   )
   {
      return Impl::nchars_check(snprintf(dst, dstsize, fmt, x1), dstsize);
   }

   template <typename T1, typename T2>
   std::size_t sprintf_check(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_check(
         snprintf(dst, dstsize, fmt, x1, x2), dstsize);
   }

   template <typename T1, typename T2>
   std::size_t sprintf_check(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_check(
         snprintf(dst, dstsize, fmt, x1, x2), dstsize);
   }

   template <typename T1, typename T2, typename T3>
   std::size_t sprintf_check(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3
   )
   {
      return Impl::nchars_check(
         snprintf(dst, dstsize, fmt, x1, x2, x3), dstsize);
   }

   template <typename T1, typename T2, typename T3, typename T4>
   std::size_t sprintf_check(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4
   )
   {
      return Impl::nchars_check(
         snprintf(dst, dstsize, fmt, x1, x2, x3, x4), dstsize);
   }

   template <typename T1, typename T2, typename T3, typename T4, typename T5>
   std::size_t sprintf_check(
      char * dst, std::size_t dstsize, char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4, T5 const & x5
   )
   {
      return Impl::nchars_check(
         snprintf(dst, dstsize, fmt, x1, x2, x3, x4, x5), dstsize);
   }

   template <std::size_t N, typename T1>
   std::size_t sprintf_check(char (&dst)[N], char const * fmt, T1 const & x1)
   {
      return Impl::nchars_check(snprintf(dst, N, fmt, x1), N);
   }

   template <std::size_t N, typename T1, typename T2>
   std::size_t sprintf_check(
      char (&dst)[N], char const * fmt, T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_check(snprintf(dst, N, fmt, x1, x2), N);
   }

   template <std::size_t N, typename T1, typename T2>
   std::size_t sprintf_check(
      char (&dst)[N], char const * fmt, T1 const & x1, T2 const & x2
   )
   {
      return Impl::nchars_check(snprintf(dst, N, fmt, x1, x2), N);
   }

   template <std::size_t N, typename T1, typename T2, typename T3>
   std::size_t sprintf_check(
      char (&dst)[N], char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3
   )
   {
      return Impl::nchars_check(snprintf(dst, N, fmt, x1, x2, x3), N);
   }

   template <std::size_t N, typename T1, typename T2, typename T3, typename T4>
   std::size_t sprintf_check(
      char (&dst)[N], char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4
   )
   {
      return Impl::nchars_check(snprintf(dst, N, fmt, x1, x2, x3, x4), N);
   }

   template <std::size_t N, typename T1, typename T2, typename T3, typename T4,
           typename T5>
   std::size_t sprintf_check(
      char (&dst)[N], char const * fmt,
      T1 const & x1, T2 const & x2, T3 const & x3, T4 const & x4, T5 const & x5
   )
   {
      return Impl::nchars_check(snprintf(dst, N, fmt, x1, x2, x3, x4, x5), N);
   }


   template <typename T1>
   std::size_t vprintf_trunc(
      char * dst, std::size_t dstsize, char const * fmt, va_list ap
   )
   {
      return Impl::nchars_output(vsnprintf(dst, dstsize, fmt, ap), dstsize);
   }

   template <std::size_t N> inline
   std::size_t vprintf_trunc(char (&dst)[N], char const * fmt, va_list ap)
   {
      return vprintf_trunc(dst, N, fmt, ap);
   }


   inline std::size_t vprintf_check(
      char * dst, std::size_t dstsize, char const * fmt, va_list ap
   )
   {
      return Impl::nchars_check(vsnprintf(dst, dstsize, fmt, ap), dstsize);
   }

   template <std::size_t N> inline
   std::size_t vprintf_check(char (&dst)[N], char const * fmt, va_list ap)
   {
      return vprintf_check(dst, N, fmt, ap);
   }


   struct FILE;

   char * fgets_trunc(char * dst, std::size_t dstsize, FILE * fp);

   template <std::size_t N> inline
   char * fgets_trunc(char (&dst)[N], FILE * fp)
   {
      return fgets_trunc(dst, N, fp);
   }

   char * fgets_check(char * dst, std::size_t dstsize, FILE * fp);

   template <std::size_t N> inline
   char * fgets_check(char (&dst)[N], FILE * fp)
   {
      return fgets_check(dst, N, fp);
   }

   String fget_string(FILE * fp, std::size_t const max_chars);


#define OW_INTSTR_AUX(x) # x
   /*
    * Use the OW_INTSTR macro to insert symbolic constants into format strings.
    * A typical usage would be for a maximum field width when using the
    * scanf family of functions.  For example, suppose that buf is an array of
    * STRMAX + 1 characters, and STRMAX is a manifest constant.  Then one
    * might write
    *
    *   sscanf(inpstr, "Name: %." OW_INTSTR(STRMAX) "s\n", buf);
   */
#define OW_INTSTR(x) OW_INTSTR_AUX(x)

} // namespace SafeCString
} // namespace OW_NAMESPACE

---