New type  : uStringW

Freebasic unicode variable length type string , using wstring as container :  
            coded internally utf16 for windows / utf32 for linux

The process of allocated memory :
The dim  creates an allocated data of 1 wstring ( 2 or 4 bytes),
when assigned the allocation is done by steps of 16 wstrings (32 or 64 bytes) + 1 wstring (2 or 4 bytes) 
    to insure always uStringW with null character. 
The allocation is growing or reducing constantly according that 16 wstrings steps. (or 0)
The core for that allocation/reallocation  is the :
    hRealloc sub , initially from the fbc compiler source, it is  adapted for my usage.

The uStringW type is using :
constructors to directly assign uStringW from :
    uStringW (as it is evident)
    string  ( doing implicit conversion)
    wstring ptr (also with implicit conversion)
Operators : 
    + ; &		to concatenate with implicit conversion also for string ; wstring ptr ; longint ; double
    &= ; +=		also with implicit conversion for string ; wstring ptr
    = ; <>		to compare uStringW
    Let         for the implicit conversion
    Cast        to cast to string or wstring ptr when needed
Destructor:
    to free automatically the allocated mem according the uStringW scope
    
The global address list of the allocated memory is hold simply in a shared string array 
	managed by a pseudo linked-list, in fact a class type  
	( thanks to Paul Squires, who posted a very simple code to make it).
	That global address list manages the remaining allocated mem , and can be used to free the memory on demand.

	As the automatic destructor function is in place , it can be avoided if needed 
  		just comment that line   #define __U_CLEAN_MEM__  
  
The global process of allocating/reallocating/deallocating can be tracked with console messages, if you are in debug
mode or simply by putting that define   #define __VERBOSE_MODE__  before the include in your code

The "implicit conversion" for wstring ptr is very simple but not really interresting, 
if you already have wstring *XX : you have done the job yourself , 
        uStringW type is just done to not have to define the length at compile time.
But anyhow just take the @ (varptr) of the wstring *xx to assign it direcly to uStringW  
		like : ustr = @wst1
		same to concat, same to direcly assign at creation   : dim as uStringW ustr = @wst1

An automatic cast to wstring ptr is also implemented (interresting to win API usage)  
	it implicitly uses the function u_strptr     just put : pWstring_1 = uStringW_1


The conversion from strings is more interresting, it is done in different ways
the most explicit way : 
  ustr = varptr(wstr("abcd")) wich converts string literal to wstring ptr, and implicitly converts to uStringW
  the string converted can hold special escape sequence !"\uXXYY" to get the needed unicode direcly 
  notice that !"\uXXYY\uZZWW" that \u escape sequence with 4 Hex digits by unicode char. (and ! before the string)
you can also do the same like that   
  ustr = u_Wstr("Ansi string to convert" & !\uXXYY) with the u_Wstr provided function to simplify the input.
but you can simply do that  
  ustr="Ansi string to convert" & "\uXXYY" :   notice the pseudo escape sequence without !
  it is because implicitly the string is converted by an encoding function :  u_From_CodeString
  wich converts the ansi string to wstring but can recognize also 2 pseudo hex sequence of :
            6 char \uXXYY  as the normal escape sequence , for unicode < &h10000 (max \uFFFF) 
   but also 8 char \wZZXXYY  for another pseudo escape sequence for unicode >&hFFFF
  
  by default the ustr = "string to convert" use that u_From_CodeString to convert ansi sequences
  
note also : the automatic cast to string is also implemented it implicitly uses the function  u_to_Ansi
        you can do simply :  string_1 = uStringW_1
  
But it also possible to use explicitly the function you want  :
  u_From_string   - the string used as container with a sequence of wstring in 2 or 4 bytes    - without conversion
  u_From_ubyte    - 1 alternative ubyte array as container with wstring byte sequence          - without conversion
  u_from_Utf8s    - 1 string as container for utf8 coded sequence                              - convertion done
  
Or using read_utf8_file ; read_utf16_file or read_utf32_file 
  to direcly assign to uStringW  a complete file in the different coding ways  
  ( the cr\lf , the control codes , even chr(0) are put in the uStringW
  
For windows, as said, internally the coding is in UTF16 :
  that means it has to take care of the surrogate pairs
  all the functions provided are managing properly that feature of surrogate pairs. 
  That's also why it is included minimal manipulation uStringW functions to take care of that issue.
  
For linux, it is internally coded in UTF32, so minimal problem with surrogate story, 
  just reading/writing utf16 files have that need, it is done with : read_utf16_file or write_UTF16_File
  to convert the possible surrogate pair to an unique wstring (or oposite), 
  the provided functions are managing that point.

some core manipulation functions are also implemented :
        u_Trim  ; u_Ltrim ; u_Rtrim ; u_instr
        u_Ucase ; u_Lcase
        u_Mid   ; u_Left  ; u_Right
        u_Replace ; u_Parse ; u_Reverse ...
        
some format conversion 
        u_to_UTF32BE ; u_to_UTF32LE ; u_to_UTF8
        
and some write to file also
        write_UTF8_File ; write_UTF16_File : write_UTF32_File
        
    
