   stdlib
    file.g 
-------------------------------------------------------
  file
type file {
   uint fopen  //  
   uint handle
   str  name
}
uint close( uint handle ) -> 
      file.close()
uint getftime( uint handle, filetime ft ) -> 
      uint file.gettime( filetime ft )
uint getsize( uint handle ) -> 
      uint file.getsize( ) 
uint open( str name, uint flag ) -> 
      file.open( str name, uint flag )
uint read( uint handle, buf rbuf, uint size ) ->
      uint file.read( uint ptr, uint size ) 
      uint file.read( buf rbuf, uint size )
uint setftime( uint handle, filetime ft ) -> 
      uint file.settime( filetime ft )
uint setpos( uint handle, int offset, uint mode ) -> 
      uint file.setpos( int offset, uint mode ) 
uint write( uint handle, buf wbuf ) ->
      uint file.write( uint data, uint size )
      uint file.write( buf rbuf )
      uint file.writepos( uint pos, uint data, uint size )


-  buf.g 
-------------------------------------------------------
   
buf > buf
buf < buf
buf >= buf
buf <= buf
buf.regget //  registry
buf.regset //  registry

   
buf buf.alloc( uint size ) ->
      buf  buf.reserve( uint size ) // use  
buf.clear() -> 
      buf buf.clear()
arr buf.getmultistr( arr ret of str ) ->
      buf.getmultistr( arrstr ret, uint trim, arr offset )//stdlib.arrstr
      buf.getmultistr( arrstr ret, uint trim )//stdlib.arrstr
      arrstr buf.getmultistr<result>( uint trim )//stdlib.arrstr
buf.free() ->
      buf buf.free()//   buf
buf buf.read( str filename ) ->
      uint buf.read( str filename ) //     0
buf buf.setmultistr( arr ret of str ) ->
      arrstr.setmultistr( buf dest ) //stdlib.arrstr 
      buf arrstr.setmultistr <result> //stdlib.arrstr
uint buf.write( str filename ) ->
      uint buf.write( str filename ) //     0 
uint buf.write( uint handle ) ->
      uint file.write( buf rbuf ) //stdlib.file
uint buf.write( uint handle, uint pos, uint off, uint size ) ->
      uint file.writepos( uint pos, uint data, uint size ) //stdlib.file
uint buf.writeappend( str filename )->
      uint buf.writeappend( str filename ) //     0 

    
buf buf.align //  ( )  uint
uint buf.finch( uint ch )//    
buf  buf.load( uint ptr, uint size )// ,   -
uint buf.ptr()//    

 str.g
-------------------------------------------------------
str   buf
    
? str.search  
? str.quote   
   
    
str str.char2oem()
str str.oem2char()
str char2str( str par, uint ch )
 
     
uint str.findch( uint ch, uint right ) -> 
      uint str.findch( uint ch ) //   
      uint str.findchr( uint ch )//  
arr str.lines( arr ret of str, uint trim ) ->   
      arrstr str.lines<result>( uint trim )//arrstr   
arr str.lines( arr ret of str, uint trim, arr offset ) ->
      str.lines( arrstr ret, uint trim, arr offset )//arrstr
str str.read( str filename )  ->
      uint.read( str filename ) //     0 
str str.reserve( uint size ) ->
      buf buf.reserve( uint size ) //  buf
str.split( arr names of str, uint ch, uint flag ) ->
      str.split( arrstr ret, uint symbol, uint flag ) //arrstr  
uint str.write( str filename ) ->
      uint str.write( str filename )//      0
hex2strl -> 
      str hex2strl<result>( uint val )
      str str.hexl( uint val )
hex2stru -> 
      str hex2stru<result>( uint val )
      str str.hexu( uint val )

   
buf.expand
uint str.findchr( uint symbol )//  
str str.hexl( uint val )
str str.hexu( uint val )
uint str.writeappend( str filename )//    
uint str.fwildcard( str mask )
uint trimsys( uint ptr len )
method str str.dellast( uint ch )//  


 arr.g
-------------------------------------------------------
arr   buf
    
? arr arr.reserve( uint count ) 
? arr.sortstri()
? arr.sortstr()
? arr arr.sort( uint sortfunc 

         
!!!uint arr.expand( uint count ) ->
      uint arr.expand( uint count )//      !!!!

 collection.g
-------------------------------------------------------
collection   buf
   
collection.val

     
collection.append   
collection.clear   
collection.gettype        

   
uint collection.val( uint index ) ->
      collection[index]    uint  

   
  
type colitem {
   uint oftype
   uint val
   uint hival
   uint ptr
}
   foreach colitem, collection
    collection[i]

- hash.g
-------------------------------------------------------
     hkeys keys 
    
   foreach oftype, hash //oftype -    
 
   foreach str, hash.keys
   
  ustr.g
-------------------------------------------------------
ustr   buf
  ushort = ustr[index]
ustr = ustr
ustr = str
str = ustr
str.ustr()
ustr.str()
ustr += ustr
ustr += str
ustr + ustr
ustr + str

uint ustr.write( str filename ) //  
uint ustr.read( str filename )  //  
str ustr.toutf8( str dest )     //  str   utf8
ustr ustr.fromutf8( str src )   //  str   utf8

  arrstr.g
-------------------------------------------------------
arrstr   arr
    
?sort

str.split( arrstr ret, uint symbol, uint flag ) //     
arrstr str.split <result> ( uint symbol, uint flag )

buf.getmultistr( arrstr ret, uint trim, arr offset )//   0   
buf.getmultistr( arrstr ret, uint trim )
arrstr buf.getmultistr<result>( uint trim )

arrstr.setmultistr( buf dest )   //        0
buf arrstr.setmultistr <result>

str.lines( arrstr ret, uint trim, arr offset )//   
str.lines( arrstr ret, uint trim )
arrstr str.lines<result>( uint trim )
method arrstr arrstr.load( str input, uint flag )//   
method arrstr arrstr.loadtrim( str input )

method str arrstr.unite( str dest, str splitter )//       
method str arrstr.unite<result>( str splitter )

str arrstr.unitelines( str dest )//   
str arrstr.unitelines<result>()

uint arrstr.read( str filename )//  
uint arrstr.write( str filename )//  
arrstr arrstr.insert( uint index, str newstr ) // 
arrstr arrstr.append( str newstr ) // 
arrstr.exchange( uint curpos, newpos )// 

arrstr = ( arrstr dest, str src )
str = ( str dest, arrstr src )

arrstr = ( arrstr dest src )
arrstr += ( arrstr dest, str newstr )
arrstr += ( arrstr dest, src )
arrstr = ( arstr left, collection right ) 

    datetime.g 
-------------------------------------------------------
 

      strfile.g 
-------------------------------------------------------
 

    filefuncs.g 
-------------------------------------------------------
   
arr getdrives( arr ret of str ) ->
      arrstr getdrives <result> ()
uint verifypath( str name, arr dirs of str ) ->
      uint verifypath( str name, arrstr dirs )

 
-------------------------------------------------------
free -> mfree
alloc -> malloc
int2str   -> str.out4 @int
float2str -> str.out4 @float
long2str   -> str.out8 @long
double2str -> str.out8 @double 
type_hasdel -> type_hasdelete
''' -> 0x27
sfwildcard -> str.fwildcard

   
-------------------------------------------------------
? stack.g
? ffind.g
? process.g
? search.g
 
