cuberite-2a/squirrel_3_0_1_stable/sqplus/SqPlusOCharBuf.h

#ifndef SQPLUS_OCHARBUF_H
#define SQPLUS_OCHARBUF_H

// Conversion routines between different character encodings, to be used in
// Push/Get/Match handlers of SqPlus. It enables using both of char* and 
// wchar_t* as function arguments.
//
// When converting from wchar_t to char, the choice is between using a Latin1 
// or a UTF8 representation in 8-bit mode. This is probably most useful if 
// Squirrel is compiled in ANSI mode and the app uses some wchar_t strings 
// (UNICODE mode on Win32). 
//

// A char is either
//  - A Latin1 character (first code page, coincides with Unicode points 0..255)
//  - Part of an UTF8 character
//
// Note: SQUTF8 requires Squirrel sources that have been patched for UTF8 strings 
// internally (when converting function arguments). 

#ifndef SQUTF8
  // Default to Latin1 conversion 
  //#undef SQPLUS_USE_LATIN1
  #ifndef SQPLUS_USE_LATIN1
    #define SQPLUS_USE_LATIN1 1
  #endif
#else
  // Using Squirrel with internal UTF8 string encoding 
  //#undef SQPLUS_USE_LATIN1
  #ifndef SQPLUS_USE_LATIN1
    #define SQPLUS_USE_LATIN1 0
  #endif
#endif 
 

// The various ol_... functions sets up for a conversion scheme 
// that can be used in both wchar_t => char and  char => wchar_t.
int ol_strlen(const wchar_t* pwc);
int ol_buflen(const wchar_t* pwc);
int ol_charlen(const wchar_t* pwc);
int ol_char(const wchar_t* pwc);
bool ol_writechar(wchar_t*& pwc, int ch);

int ol_strlen(const char* pc);
int ol_buflen(const char* pc);
int ol_charlen(const char* pc);
int ol_char(const char* pc);
bool ol_writechar(char*& pc, int ch);

#ifdef SQUNICODE
  // SQChar is wchar_t, convert to/from either Latin1 or UTF8
  typedef char SQOtherChar;
#else
  // SQChar is char, convert to/from wchar_t
  typedef wchar_t SQOtherChar;
#endif


// Buffer to hold a string and release it in destructor. 
// SQT is input character type 
// SQOT is the opposite type of SQChar
// If 'try_borrow' is set, it will not allocate a new buffer when no 
// conversion is done, it will just keep the input pointer (beware).
template<class SQT, class SQOT, bool use_latin1>
struct SQCharBufImpl {

	// Allocate a buffer from string of same type
	SQCharBufImpl(const SQT *poc=NULL, bool try_borrow=true ) : m_poc(0), m_own(false) { 
		Init( poc, try_borrow );
	}

	// This does conversion from other char type
	SQCharBufImpl(const SQOT *ps, bool try_borrow=false ) : m_poc(0), m_own(false) { 
		Init( ps ); // Cannot borrow pointer when doing conversion
	}

	void Init( const SQT *poc, bool try_borrow ){
		m_own = !try_borrow;
		if( try_borrow ){ 
			m_poc = (SQT*)poc;
		}
		else {
			int sl = poc ? ol_buflen(poc) : 0;
			if( poc ){
				m_poc = poc ? new SQT[sl+1] : NULL; 
				if( m_poc ) memcpy( m_poc, poc, (sl+1)*sizeof(SQT) );
			}
			else
				m_poc = NULL;
		}
    }

	void Init( const SQOT *ps ){
		m_own = true;
        if( ps ){
            int sl = ps ? ol_strlen(ps) : 0;	// Length of string in characters (not bytes)
		    int scl = 0;                        // Length of converted string in char/wchar_t count
			// How much storage needed? 
			if( !use_latin1 && sizeof(SQT)<sizeof(SQOT) ){
				// Converting wchar_t => UTF8 
				const SQOT *ps1 = ps;   // It is wchar_t* here
				SQT tmp_buf[8];
				SQT *ptmp;
				while( *ps1 ){
				    ptmp = tmp_buf;
                    if( ol_writechar(ptmp,*ps1++) )
                        scl += ol_charlen(tmp_buf);
                    else
                        scl++;
				}
			}
			else scl = sl;  // Converting to wchar_t or Latin1, keep length 

            m_poc = new SQT[scl+1]; 
			if( !m_poc ) return;

			// Convert 
			SQT *poc = m_poc;
			while( *ps ){
				ol_writechar( poc, ol_char(ps) );
				ps += ol_charlen(ps);
			}
			*poc = 0;	// Terminating zero
        }
        else
            m_poc = NULL;
    }
    
    ~SQCharBufImpl(){ Release(); }
    
	void Release( ){
		if(m_poc && m_own ) 
			delete [] m_poc; 
		m_poc = NULL;
	}

	SQT* Set( const SQOT *ps ){
		Release( );
		Init( ps );
		return m_poc;
	}

    operator SQT*() const { return m_poc; }
    
	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQT *ps){
		Release();
		Init( ps, false );
		return *this;
	}

	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQOT *ps){
		Release();
		Init( ps );
		return *this;
	}

	// Move string from other here - Note: Empties the input argument (other)
	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQCharBufImpl<SQT,SQOT,use_latin1>& other){
		Release();
		m_poc = other.m_poc;
		m_own = other.m_own;
		SQT **psqt = (SQT**)&other.m_poc;
		*psqt = NULL;
		return *this;
	}

protected:
    SQT *m_poc;
	bool m_own;
};

typedef SQCharBufImpl<SQOtherChar, SQChar, bool(SQPLUS_USE_LATIN1)> SQOthCharBuf;
typedef SQCharBufImpl<SQChar, SQOtherChar, bool(SQPLUS_USE_LATIN1)> SQDefCharBuf;
typedef SQCharBufImpl<wchar_t, char, bool(SQPLUS_USE_LATIN1)>       SQWCharBuf;
typedef SQCharBufImpl<char, wchar_t, bool(SQPLUS_USE_LATIN1)>       SQACharBuf;

#ifdef SQUNICODE
  // SQChar is wchar_t, convert to/from to either Latin1 or UTF8
  #define WC2SQ(s) s
  #define SQ2WC(s) s
  SQDefCharBuf CH2SQ( const char* ps );
  SQOthCharBuf SQ2CH( const wchar_t* pws );
#else
  // SQChar is char, convert to/from wchar_t
  SQDefCharBuf WC2SQ( const wchar_t* pws );
  SQOthCharBuf SQ2WC( const char* pws );
  #define CH2SQ(s) s
  #define SQ2CH(s) s
#endif

#endif // SQPLUS_CHARBUF_H