wchar16.h

Go to the documentation of this file.

#ifndef __WCHAR16_H__
#define __WCHAR16_H__

// -----------------------------------------------------------------------
// MLPI - <wchar16.h>
// -----------------------------------------------------------------------
// Copyright (c) 2013 Bosch Rexroth. All rights reserved.
// Redistribution and use in source and binary forms of this MLPI software
// (SW) provided to you, with or without modification, are permitted
// without prior approval provided that the following conditions are met:
//
// 1. Redistributions of source code of SW must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form of SW must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. User recognizes and acknowledges that it acquires no right,
// title or interest in or to any of the names or trademarks used in
// connection with the SW ("names") by virtue of this License and waives
// any right to or interest in the names. User recognizes and acknowledges
// that names of companies or names or products of companies displayed
// in the documentation of SW to indicate the interoperability of products
// with the SW are the names of their respective owners. The use of such
// names in the documentation of SW does not imply any sponsorship,
// approval, or endorsement by such companies of this product.
//
// 4. Modified code versions, i.e. any addition to or deletion from
// the substance or structure of the original code of the SW running
// the MLPI must be plainly marked as such and must not be misrepresented
// as being original SW.
//
// 5. The SW may only be used in connection with a Bosch Rexroth product.
//
// THIS INFORMATION IS PROVIDED BY BOSCH REXROTH CORPORATION "AS IS"
// AND WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING
// (BUT NOTLIMITED TO) ANY IMPLIED WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR ANY PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WHILE THE
// INFORMATION PROVIDED IS BELIEVED TO BE ACCURATE, IT MAY INCLUDE
// ERRORS OR INACCURACIES.
// SUBJECT TO COMPULSORY STATUTORY PROVISIONS OF THE GERMAN LAW AS
// THE APPLICABLE LAW FOR THIS LICENSE BOSCH REXROTH CORPORATION WILL
// NOT BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING FROM THE USE OF
// THE  SOFTWARE  DISTRIBUTED HEREUNDER, INCLUDING BUT NOT LIMITED TO
// DIRECT, INDIRECT, INCIDENTAL, PUNITIVE, AND CONSEQUENTIAL DAMAGES.
// -----------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------







// -----------------------------------------------------------------------
// GLOBAL INCLUDES
// -----------------------------------------------------------------------
#include <string.h>

#include "mlpiGlobal.h"

// -----------------------------------------------------------------------
// GLOBAL MACROS
// -----------------------------------------------------------------------
#if defined(TARGET_COMPILER_GCC)
  // compiling with GNU gcc
  #define W2A16(strIn) (_wcstombs16((CHAR*)__builtin_alloca(sizeof(CHAR)*(wcslen16(strIn)+1)), strIn, wcslen16(strIn)+1))
  #define A2W16(strIn) (_mbstowcs16((WCHAR16*)__builtin_alloca(sizeof(WCHAR16)*(strlen(strIn)+1)), strIn, strlen(strIn)+1))
#elif defined(TARGET_COMPILER_MSVC)
  // compiling with Microsoft Visual Studio Compiler
  #include "malloc.h"
  #define W2A16(strIn) (_wcstombs16((CHAR*)alloca(sizeof(CHAR)*(wcslen16(strIn)+1)), strIn, wcslen16(strIn)+1))
  #define A2W16(strIn) (_mbstowcs16((WCHAR16*)alloca(sizeof(WCHAR16)*(strlen(strIn)+1)), strIn, strlen(strIn)+1))
#else
  // unknown compiler
  #pragma warning "unknown compiler"
#endif


// -----------------------------------------------------------------------
// GLOBAL EXPORTS
// -----------------------------------------------------------------------

inline size_t wcslen16(const WCHAR16 *src)
{
  const WCHAR16 *s;

  if(src == NULL)
    return 0;

  for (s = src; *s; ++s)
    continue;

  return (s - src);
}

inline WCHAR16 *wcschr16(const WCHAR16 *src, WCHAR16 character)
{
  const WCHAR16 *p;

  p = NULL;
  do
  {
    if (*src == character)
    {
      p = src;
    }
  } while (*src++);

  return const_cast<WCHAR16 *>(p);
}

inline int wcsncmp16(const WCHAR16 *src1, const WCHAR16 *src2, size_t len)
{
  while(len--)
  {
    if(*src1++ != *src2++)
    {
      return *(WCHAR16*)(src1 - 1) - *(WCHAR16*)(src2 - 1);
    }
  }

  return 0;
}

inline int wcscmp16(const WCHAR16 *src1, const WCHAR16 *src2)
{
  while (*src1 == *src2++)
  {
    if (!*src1++)
    {
      return 0;
    }
  }

  return src1[0] - src2[-1];
}

inline int wcscmp16_(const WCHAR16 *src1, const WCHAR16 *src2)
{
  while ((~0x0020 & *src1) == (~0x0020 & *src2++))    // ignore case sensitivity...
  {
    if (!*src1++)
    {
      return 0;
    }
  }

  return src1[0] - src2[-1];
}

inline WCHAR16* wcscpy16(WCHAR16 *dst, const WCHAR16 *src)
{
  WCHAR16 *run = dst;
  while ((*run++ = *src++) != L'\0');

  return dst;
}

inline WCHAR16* wcsncpy16(WCHAR16 *dst, const WCHAR16 *src, size_t len)
{
  if (len!=0)
  {
    int i = 0;
    while(len != 0) {
      len--;
      if ((dst[i++] = *src++) == 0)
        break;
    };
    while(len-- != 0)
      dst[i++] = 0;
  }
  return dst;
}

inline WCHAR16* wcscat16(WCHAR16 *dst, const WCHAR16 *src)
{
  int i,j;
  for (i = 0; dst[i] != '\0'; i++)
    ;
  for (j = 0; src[j] != '\0'; j++)
    dst[i+j] = src[j];
  dst[i+j] = '\0';

  return dst;
}

inline WCHAR16* wcsncat16(WCHAR16 *dst, const WCHAR16 *src, size_t len)
{
  int i = 0;

  while (dst[i++] != 0)
    ;
  if (len != 0) {
    i--;
    do {
      if ((dst[i++] = *src++) == 0)
        break;
    } while (--len != 0);
  }
  return dst;
}

inline WCHAR16* wcsdup16(const WCHAR16 *src)
{
  WCHAR16 *dst = new WCHAR16[wcslen16(src) + sizeof(WCHAR16)];
  if(dst != NULL)
    wcscpy16(dst, src);

  return dst;
}

inline int wcsfind16(const WCHAR16 *s, const WCHAR16 *t, const int pos=0)
{
  int i = 0, j;
  if ( (s==NULL) || (t==NULL) || (pos<0) ) return -2;
  while (s[pos+i] != 0)
  {
    j=0;
    while ( (s[pos+i+j] != 0) && (s[pos+i+j] == t[j]) )
    {
      if (t[j+1] == 0)
        return (i+j);
      j++;
    }
    i++;
    if(i < 0) return -3;
  }

  return -1;
}

inline int wcsspn16(const WCHAR16 *src1, const WCHAR16 *src2)
{
  const WCHAR16 *s = src1;
  const WCHAR16 *p = src2;

  while (*p)
  {
    if (*p++ == *s)
    {
      ++s;
      p = src2;
    }
  }

  return (int)(s - src1);
}

inline WCHAR16* wcspbrk16(const WCHAR16 *src1, const WCHAR16 *src2)
{
  const WCHAR16 *s;
  const WCHAR16 *p;

  for (s=src1; *s; s++)
  {
    for (p=src2; *p; p++)
    {
      if (*p == *s) return (WCHAR16 *) s;
    }
  }

  return NULL;
}

inline WCHAR16* wcstok_r16(WCHAR16 *s1, const WCHAR16 *s2, WCHAR16 **context)
{
  WCHAR16 *s;
  WCHAR16 *p;

  if (((s = s1) != NULL) || ((s = *context) != NULL))
  {
    if (*(s += wcsspn16(s, s2)))
    {
      if ((p = wcspbrk16(s, s2)) != NULL)
      {
        *p++ = 0;
      }
    } else
    {
      p = s = NULL;
    }
    *context = p;
  }

  return s;
}

inline WCHAR16 *wcsstr16(WCHAR16 *src1, WCHAR16 *src2)
{
  size_t n = wcslen16(src2);
  while(*src1)
    if(!memcmp(src1++, src2, sizeof(WCHAR16) * n))
      return src1 - 1;

  return 0;
}

inline const WCHAR16 *wcsstr16(const WCHAR16 *src1, const WCHAR16 *src2)
{
  size_t n = wcslen16(src2);
  while(*src1)
    if(!memcmp(src1++, src2, sizeof(WCHAR16) * n))
      return src1 - 1;

  return 0;
}

inline int wtoi16(const WCHAR16 *src)
{
  int result = 0;
  while (*src >= '0' && *src <= '9')
    result = result * 10 + *src++ - '0';

  return result;
}

inline size_t wcstombs16(char *dst, const WCHAR16 *src, size_t len)
{
  size_t count = 0;

  if (len != 0)
  {
    do
    {
      if ((*dst++ = (char)*src++) == 0)
        break;
      count++;
    } while (--len != 0);
  }

  return count;
}

inline size_t mbstowcs16(WCHAR16 *dst, const char *src, size_t len)
{
  size_t count = 0;

  if (len != 0)
  {
    do
    {
      if ((*dst++ = (WCHAR16)*src++) == 0)
        break;
      count++;
    } while (--len != 0);
  }

  return count;
}

inline char* _wcstombs16(char *dst, const WCHAR16 *src, size_t len)
{
  // same as wcstombs16, but returns pointer to dst instead of length
  wcstombs16(dst, src, len);
  return dst;
}

inline WCHAR16* _mbstowcs16(WCHAR16 *dst, const char *src, size_t len)
{
  // same as mbstowcs16, but returns pointer to dst instead of length
  mbstowcs16(dst, src, len);
  return dst;
}

template<typename T>
WCHAR16* itow16_binary(T src, WCHAR16* dst, const size_t len)
{
  size_t i = 0;
  const size_t numBits = sizeof(T) * 8;

  if(dst && len && (len > numBits + 1))
  {
    const T mask = 0x1;
    for(i = 0; i < numBits; i++)
    {
      T value = src & mask;
      dst[numBits - i - 1] = (value) ? '1' : '0';
      src = src >> 1;
    }
  }

  dst[i] = '\0';
  return dst;
}


#endif /* __WCHAR16_H__ */