Public API Reference

csutil/util.h

Go to the documentation of this file.

/*
    Copyright (C) 1998 by Jorrit Tyberghein

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_UTIL_H__
#define __CS_UTIL_H__

#include <stdio.h>
#include "csextern.h"
#include "csutil/csunicode.h"

namespace CS
{
  CS_CRYSTALSPACE_EXPORT char* StrDup (const char *s);
  CS_CRYSTALSPACE_EXPORT char* StrDup (const wchar_t *s);
  CS_CRYSTALSPACE_EXPORT wchar_t* StrDupW (const wchar_t *s);
  CS_CRYSTALSPACE_EXPORT wchar_t* StrDupW (const char *s);

  CS_CRYSTALSPACE_EXPORT const char* StrCaseStr (const char *str1, const char *str2);
}

CS_CRYSTALSPACE_EXPORT size_t cs_wcslen (wchar_t const* s);

inline char *csStrNew (const char *s)
{
  if (!s) return 0;
  size_t sl = strlen (s) + 1;
  char *r = new char [sl];
  memcpy (r, s, sl);
  return r;
}
inline char *csStrNew (const wchar_t *s)
{
  if (!s) return 0;
  char* cs = CS::StrDup (s);
  size_t sl = strlen (cs) + 1;
  char *r = new char [sl];
  memcpy (r, cs, sl);
  cs_free (cs);
  return r;
}
inline wchar_t* csStrNewW (const wchar_t *s)
{
  if (!s) return 0;
  size_t sl = cs_wcslen (s) + 1;
  wchar_t *r = new wchar_t [sl];
  memcpy (r, s, sl * sizeof (wchar_t));
  return r;
}
inline wchar_t* csStrNewW (const char *s)
{
  if (!s) return 0;
  wchar_t* ws = CS::StrDupW (s);
  size_t sl = cs_wcslen (ws) + 1;
  wchar_t *r = new wchar_t [sl];
  memcpy (r, ws, sl * sizeof (wchar_t));
  cs_free (ws);
  return r;
}

CS_CRYSTALSPACE_EXPORT int csStrCaseCmp(char const* str1, char const* str2);

CS_CRYSTALSPACE_EXPORT int csStrNCaseCmp(char const* str1, char const* str2,
  size_t n);

struct csWtoC
{
private:
  char* s;
public:
  csWtoC (const wchar_t* ws)
  { s = CS::StrDup (ws); }
  ~csWtoC ()
  { cs_free (s); }
  operator const char* () const
  { return s; }
};

struct csCtoW
{
private:
  wchar_t* ws;
public:
  csCtoW (const char* s)
  { ws = CS::StrDupW (s); }
  ~csCtoW ()
  { cs_free (ws); }
  operator const wchar_t* () const
  { return ws; }
};

CS_CRYSTALSPACE_EXPORT char *csExpandName (const char *iName);

CS_CRYSTALSPACE_EXPORT void csSplitPath (const char *iPathName, char *oPath,
  size_t iPathSize, char *oName, size_t iNameSize);

CS_CRYSTALSPACE_EXPORT bool csGlobMatches (const char *fName,
        const char *fMask);

static inline int csFindNearestPowerOf2 (int n)
{
  int v=n;

  v--;
  v |= v >> 1;
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v++;

  return v;
}

static inline bool csIsPowerOf2 (int n)
{
  return !(n & (n - 1)) && n;   // (n-1) ^ n >= n;
}

CS_CRYSTALSPACE_EXPORT int csLog2 (int n);

CS_CRYSTALSPACE_EXPORT void csReplaceAll (char *dest, const char *src,
  const char *search, const char *replace, int max);


#endif // __CS_UTIL_H__

---