Thread: mixing c++ with c, looking for suggestions

I've got a C api that has a lot of common behaviour typedefs (namely the char, wchar_t, char16_t etc lot), I've managed to do this so far:

string.cpp

Code:

#ifdef INC_PAW
#include INC_PAW(paw/global/string.h)
#include INC_PAW(paw/global/_block.h)
#else
#include <paw/global/string.h>
#include <paw/global/_block.h>
#endif

template<typename T> static pawd paw__length( T const *str )
{
	if ( str )
	{
		pawd i;
		for ( i = 0; str[i]; ++i );
		return i;
	}
	return -1;
}
template<typename T> static pawd paw__mbslen( T const *mbs )
{
	if ( mbs )
	{
		pawd i, len = 0;
		for ( i = 0; mbs[i]; len += !(mbs[i] & 0x80), ++i );
		return len;
	}
	return -1;
}
template<typename T> static T const *paw__locate( T const *src, T const *str )
{
	pawd src_len = paw__length<T>( src );
	pawd str_len = paw__length<T>( str );
	for ( src_len += (src_len >= 0); --src_len >= str_len; ++src )
	{
		if ( memcmp( src, str, sizeof(T) * str_len ) == 0 )
			return src;
	}
	return NULL;
}

PAW_API pawd	paws_length( paws str )
	{ return paw__length<pawc>( str ); }
PAW_API pawd	paws_mbslen( paws mbs )
	{ return paw__mbslen<pawc>( mbs ); }
PAW_API paws	paws_locate( paws src, paws str )
	{ return paw__locate<pawc>( src, str ); }

PAW_API pawd	pawls_length( pawls str )
	{ return paw__length<pawlc>( str ); }
PAW_API pawd	pawls_mbslen( pawls mbs )
	{ return paw__mbslen<pawlc>( mbs ); }
PAW_API pawls	pawls_locate( pawls src, pawls str )
	{ return paw__locate<pawlc>( src, str ); }
...

paw/global/string.h

Code:

#ifndef INC_PAW_GLOBAL_STRING_H
#define INC_PAW_GLOBAL_STRING_H

#ifdef INC_PAW
#include INC_PAW(paw/global/number.h)
#else
#include <paw/global/number.h>
#endif

PAW_OPEN_C_API
#include <string.h>
#include <wchar.h>
#include <uchar.h>
#include <ctype.h>

typedef char pawc;
typedef char const *paws;
#define PAWC_MAX CHAR_MAX
#define PAWC_MIN CHAR_MIN

typedef wchar_t pawlc;
typedef wchar_t const *pawls;
#define PAWLC_MAX WCHAR_MAX
#define PAWLC_MIN WCHAR_MIN

typedef wint_t pawzc;
#define PAWZC_MAX WINT_MAX
#define PAWZC_MIN WINT_MIN

typedef char16_t pawhc;
typedef char16_t const *pawhs;

typedef char32_t pawllc;
typedef char32_t const *pawlls;

typedef char pawsi[bitsof(pawjd)];

typedef char32_t pawjc;
typedef char32_t const *pawjs;
#define PAWJC_MAX UINT_LEAST32_MAX
#define PAWJC_MIN 0

#if CHAR_BIT >= 8
typedef char pawhhc;
typedef char const *pawhhs;
#define PRIpawhhc "c"
#define SCNpawhhc "c"
#define PRIpawhhs "s"
#define SCNpawhhs "s"
#define PAWHHC_C( LITERAL ) LITERAL
#define PAWHHC_MAX CHAR_MAX
#define PAWHHC_MIN CHAR_MIN
#else
typedef wchar_t pawhhc;
typedef wchar_t const *pawhhs;
#define PRIpawhhc "lc"
#define SCNpawhhc "lc"
#define PRIpawhhs "ls"
#define SCNpawhhs "ls"
#define _PAWHHC_C( LITERAL ) L##LITERAL
#define PAWHHC_C( LITERAL ) _PAWHHC_C( LITERAL )
#define PAWHHC_MAX WCHAR_MAX
#define PAWHHC_MIN WCHAR_MIN
#endif

#ifdef PAW_ON_WINDOWS
typedef TCHAR pawtc;
typedef TCHAR const *pawts;
#define PAWTC_C( LITERAL ) TEXT( LITERAL )
#define PAWTC_MAX TCHAR_MAX
#define PAWTC_MIN TCHAR_MIN
#else
typedef char pawtc;
typedef char const *pawts;
#define PAWTC_C( LITERAL ) LITERAL
#define PAWTC_MAX CHAR_MAX
#define PAWTC_MIN CHAR_MIN
#endif

#if defined(MB_LEN_MAX) && MB_LEN_MAX > 7
#define PAWMBC_MAX_LEN MB_LEN_MAX
#else
#define PAWMBC_MAX_LEN 7
#endif
typedef pawhhc pawmbc[PAWMBC_MAX_LEN+1];

/* By using strings paw doesn't need to check if uppercase or lowercase is to
 * be expected */
#define PAW_BASE2	"01"
#define PAW_BASE8	"01234567"
#define PAW_BASE10	"0123456789"
#define PAW_BASE16x	PAW_BASE10 "abcdef"
#define PAW_BASE16X	PAW_BASE10 "ABCDEF"
#define PAW_BASE16_REM	"aA0"

/* e.g. "\x80\x10\x7f" would return 3 */
PAW_API pawd	paws_length(	paws	str );
PAW_API pawd	pawls_length(	pawls	str );
PAW_API pawd	pawhhs_length(	pawhhs	str );
PAW_API pawd	pawhs_length(	pawhs	str );
PAW_API pawd	pawlls_length(	pawlls	str );
PAW_API pawd	pawjs_length(	pawjs	str );
PAW_API pawd	pawts_length(	pawts	str );
/* e.g. "\x80\x10\x7f" would return 2 */
PAW_API pawd	paws_mbslen(	paws	mbs );
PAW_API pawd	pawls_mbslen(	pawls	mbs );
PAW_API pawd	pawhhs_mbslen(	pawhhs	mbs );
PAW_API pawd	pawhs_mbslen(	pawhs	mbs );
PAW_API pawd	pawlls_mbslen(	pawlls	mbs );
PAW_API pawd	pawjs_mbslen(	pawjs	mbs );
PAW_API pawd	pawts_mbslen(	pawts	mbs );
/* Find first instance of str in src */
PAW_API paws	paws_locate(	paws	src, paws	str );
PAW_API pawls	pawls_locate(	pawls	src, pawls	str );
PAW_API pawhhs	pawhhs_locate(	pawhhs	src, pawhhs	str );
PAW_API pawhs	pawhs_locate(	pawhs	src, pawhs	str );
PAW_API pawlls	pawlls_locate(	pawlls	src, pawlls	str );
PAW_API pawjs	pawjs_locate(	pawjs	src, pawjs	str );
PAW_API pawts	pawts_locate(	pawts	src, pawts	str );


PAW_API pawd	pawu2s( pawsi *dst, pawju src, paws base );
/* e.g.
 * pawsi num = "A";
 * paws2u( &num, 16, PAW_BASE16_REM );
 * // Returns 10
*/
PAW_API pawju	paws2u( pawsi *src, pawd base, paws remove );

PAW_API pawzd	pawlc2hhc( pawmbc *dst, pawd src );
PAW_API pawzd	pawhhc2lc( pawd *dst, pawmbc *src );
PAW_API pawzd	pawls2hhs( pawhhc *dst, pawzd cap, pawls src, pawd len );
/* len here means same as result of pawsleng(src) */
PAW_API pawzd	pawhhs2ls( pawlc *dst, pawd max, pawhhs src, pawzd len );

PAW_SHUT_C_API
#endif

What tweaks/changes do you lot think may/should be made for this to later be a decent library piece to download and use and why? I'm aiming to ultimately make paw unreliant on the C api so that it doesn't have to deal with the multiple versions of the crt on windows, things like limits.h & stdint.h are fine since neither define any APIs or global variables however malloc.h & and other api containing headers are to be avoided in favour of system headers if possible.