// Prototype: 
// BSTR _stdcall MTRandomStr(long len, const short style=RANDOM_STYLE_MIXED)
VARIANT v[2];
DLLParamInit((VARIANT*)&v,howbig(v)); // Ensure variant array zeroed out
v[0].vt=VT_I4;    // long (4 byte) data type
v[0].lVal=60;     // string length - 60 chars
v[1].vt=VT_I2;    // short (2 byte) data type
for(int i=0; i<15; i++)
{
    v[1].iVal=i;  // Call with each type of string format
    printf("Randomstr(%i)=[%s]\n",v[1].iVal,
	(LPSTR)CallDLL("mslib145.dll","MTRandomStr",&errcode,2,(VARIANT*)&v));
}

// Wordlist ////////////////
// Prototype: VARIANT _stdcall WordList(LPCSTR s, long base=0)
VARIANT v[2];
VARIANT vt;	     // Return variant
DLLParamInit((VARIANT*)&v,howbig(v));        
v[0].vt=VT_BSTR;
v[0].bstrVal=(BSTR)"Now is the time for all good men to come to the aid of the party";
v[1].vt=VT_I2;       // short (2 byte) data type
v[1].iVal=0;
vt=CallDLLVariant("mslib145.dll","WordList",&errcode,2,(VARIANT*)&v);
printf("Done WordList. Calling PrintR()\n");
// Prototype: VARIANT _stdcall QSort(VARIANT* v, 
//	const short reverse_sort=0, const short ignore_case=0)
QSort(&vt,0,1);      // Call VBToolbox LIB function directly
// Prototype: long _stdcall PrintR(const VARIANT* v, 
//	const short show_empty=0, const short show_address=0);
PrintR(&vt,0);       // Call VBToolbox LIB function directly
VariantClear(&vt);   // Release dynamic memory

// CSVSplit and ElementCount 
// Prototype: VARIANT _stdcall CSVSplit(LPCSTR s, 
//	const long inbase=0, char separator=',')
// Prototype: long _stdcall ElementCount(VARIANT* v)
DLLParamInit((VARIANT*)&v,howbig(v));
VARIANT v[3];
VARIANT vt;	    // Return variant
v[0].vt=VT_BSTR;
v[0].bstrVal=(BSTR)"One,two,three four,five,six seven, eight";
v[1].vt=VT_I4;	    // long (4 byte) data type
v[1].lVal=1;
v[2].vt=VT_I1; 	    // char (1 byte) data type
v[2].bVal=',';
vt=CallDLLVariant("mslib145.dll","CSVSplit",&errcode,3,(VARIANT*)&v);
printf("Finished CSVSplit - calling PrintR...\n");
PrintR(&vt,0);      // Call VBToolbox function

// Now call ElementCount with variant vt
v[0].vt=vt.vt;      // Copy original variant flag type
v[0].pvarVal=&vt;   // pointer to variant
printf("Element count=%i\n",CallDLL("mslib145.dll","ElementCount",&errcode,1,(VARIANT*)&v));
VariantClear(&vt);  // Release dynamic memory

// Win32 API Prototype: int WINAPI MessageBox(HWND hWnd, 
//	LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);
DLLParamInit((VARIANT*)&v,howbig(v));        
v[0].vt=VT_NULL;        // Use this for NULL parameters
v[1].vt=VT_BSTR;
v[1].bstrVal=(BSTR) "Now is the time for all good men to vote against the party";
v[2].vt=VT_BSTR;
v[2].bstrVal=(BSTR) "Hello world";
v[3].vt=VT_UI4; 
v[3].ulVal=MB_ICONINFORMATION | MB_ICONQUESTION | MB_OKCANCEL;
ret=CallDLL("User32.dll","MessageBoxA",&errcode,4,(VARIANT*)&v);
printf("Check: MessageBox=[%i] (0==FAIL) (errcode=%i)\n",ret,errcode);

// Prototype: char* asctime( const struct tm* timeptr );
// Calling a __cdecl DLL which takes a struct 
struct tm when;
time_t now;
time(&now);			// Get current time as c time
when = *localtime(&now);	// Convert from c time to struct
DLLParamInit((VARIANT*)&v,howbig(v));
v[0].vt=VT_I4;
v[0].lVal=(long)&when;		// Cast struct address to long
LPSTR ptr=(LPSTR)CallDLLCDecl("msvcrt40.dll","asctime",&errcode,1,(VARIANT*)&v);
printf("asctime() returned %s errcode=%i\n",ptr,errcode);
// asctime() returned [Mon Apr 23 00:45:33 2012

// Test calling variable-arg C function
// int printf( const char *format [, argument]... );
DLLParamInit((VARIANT*)&v,howbig(v));
v[0].vt=VT_I4;
v[0].lVal=(long)"* Hello from %s short=%i long=%i double=%f *\n";
v[1].vt=VT_I4;
v[1].lVal=(long)"printf()";
v[2].vt=VT_I2;
v[2].iVal=1234;
v[3].vt=VT_I4;
v[3].lVal=123456790;
v[4].vt=VT_R8;
v[4].dblVal=1234.56789;
long ret=CallDLLCDecl("msvcrt40.dll","printf",&errcode,5,(VARIANT*)&v);
printf("printf() returned: %i char(s) errcode=%i\n",ret,errcode);
// Console echo from printf...
// * Hello from printf() short=1234 long=123456790 double=1234.567890 *

Dim v(5) As Variant
Dim i As Integer
v(0) = VBStrToCStr("c:\windows\system32\drivers\hosts.txt")
v(1) = VBStrToCStr(String$(255, " "))	' Create C ANSI buffers using malloc()
v(2) = VBStrToCStr(String$(255, " "))	' VBStrToCStr returns a 32-bit long
v(3) = VBStrToCStr(String$(255, " "))
v(4) = VBStrToCStr(String$(255, " "))
CallDLLCDecl "msvcrt40.dll", "_splitpath", ErrCode, 5, v(0)
Debug.Print "_splitpath: Errcode="; ErrCode
CStrFree v(0)		' Release memory using free()
For i = 1 To 4
	Debug.Print i; "=["; CStrToVBStr(v(i)); "]"
	CStrFree v(i)	' Release memory using free()
Next

DLLParamInit((VARIANT*)&v,howbig(v));
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
v[0].vt=VT_I4;
v[0].lVal=(long)"c:\windows\system32\drivers\etc\fred.txt";
v[1].vt=VT_I4;
v[1].lVal=(long)&drive;
v[2].vt=VT_I4;
v[2].lVal=(long)&dir;
v[3].vt=VT_I4;
v[3].lVal=(long)&fname;
v[4].vt=VT_I4;
v[4].lVal=(long)&ext;
CallDLLCDecl("msvcrt40.dll","_splitpath",&errcode,5,(VARIANT*)&v);
printf("_splitpath returned drive [%s]\n",drive);    
printf("_splitpath returned dir [%s]\n",dir);
printf("_splitpath returned fname [%s]\n",fname);    
printf("_splitpath returned ext [%s]\n",ext);    
printf("_splitpath() returned void errcode=%li\n",errcode);

DWORD _stdcall CallDLL(LPCSTR dllname, LPCSTR funct, 
	long* errcode=NULL, long paramcount=0, VARIANT* data=NULL);
float _stdcall CallDLLSingle(LPCSTR dllname, LPCSTR funct, 
	long* errcode=NULL, long paramcount=0, VARIANT* data=NULL);
double _stdcall CallDLLDouble(LPCSTR dllname, LPCSTR funct, 
	long* errcode=NULL, long paramcount=0, VARIANT* data=NULL);
VARIANT CallDLLVariant(LPCSTR dllname, LPCSTR funct, 
	long* errcode=NULL, long paramcount=0, VARIANT* data=NULL);
// Cdecl variants... (v1.40+).
DWORD _stdcall CallDLLCDecl(LPCSTR dllname, LPCSTR funct, 
	long* errcode=NULL, long paramcount=0, VARIANT* data=NULL);
float _stdcall CallDLLCDeclSingle(LPCSTR dllname, LPCSTR funct, 
	long* errcode=NULL, long paramcount=0, VARIANT* data=NULL);
double _stdcall CallDLLCDeclDouble(LPCSTR dllname, LPCSTR funct, 
	long* errcode=NULL, long paramcount=0, VARIANT* data=NULL);
// CallDLLCDeclVariant is not implemented

printf("IsNetworked=%i\n",CallDLL("mslib145.dll","IsNetworked",&errcode,0,NULL));

// Prototype: msvcrt40.dll - long atol(const char *string);
DLLParamInit((VARIANT*)&v,howbig(v));    
long errcode=0;
v[0].vt=VT_I4;
v[0].lVal=(long) "1234567890";
long ret=CallDLLCDecl("msvcrt40.dll","atol",&errcode,1,(VARIANT*)&v);
printf("atol=[%i] errcode=%i\n",ret,errcode);

//Prototype: LPSTR _stdcall CreateGUID(const short formatted=TRUE)
v[0].vt=VT_I4;		// 32-bit integer.
v[0].lVal=1;            // 1L (TRUE)
LPSTR ptr=(LPSTR)CallDLL("mslib145.dll","CreateGUID",&errcode,1,(VARIANT*)&v);
printf("CreateGUID=%s\n",ptr);
SysFreeString((BSTR)ptr);

// Partial (incomplete) C# example code calling VBToolbox via CallDLL interface
namespace ConsoleApplication1
{
  // VT_* Enums for interfacing with VARAIANT routines 
  public enum Vnt: ushort // (enum definition omitted) ... 

  unsafe class Program
  {
    // Struct definition (incomplete) - emulates a C union
    [StructLayout(LayoutKind.Explicit, Pack = 1, Size = 16)]
    public unsafe struct Variant // (code omitted) ...

    [DLLImport("mslib145.dll")]
    private static extern int CallDLL(string dllName, string funct, 
                   int* errcode, int paramcount = 0, Variant* v = null);
    // Other DLL definitions omitted ....

    static unsafe void main(string[] args)
    {
      double d;
      Variant[] vt = new Variant[10];
      // General service lib routine calls 
      Console.WriteLine("LibVersion=" + (LibVersion() / 100.0).ToString("0.00")); 
      Console.WriteLine("LibUnicode=" + LibUnicode());
      Console.WriteLine("LibName=" + LibName());
      Console.WriteLine("LibName=" + LibDate());
      
      // Test short-form call 
      d = CallDLLDouble("mslib145.dll", "VBNow", &errcode);
      Console.WriteLine("errcode=" + errcode);
      Console.WriteLine("VBNow=" + d);
      
      // Long form call with CC++ malloc() memory allocation  
      //  char *__stdcall MKTempName(const char * path,const char * ftype,
      //	const short pathlen,const short style);
      vt[0].vt = (ushort)Vnt.VT_BSTR;
      vt[0].bstrVal = 0;  // Path (NULL)
      vt[1].vt = (ushort)Vnt.VT_BSTR;
      ptr = VBStrToCStr(".tmp"); // Allocate a C string using malloc() 
      vt[1].bstrVal = ptr;
      vt[2].vt = (ushort)Vnt.VT_I2;
      vt[2].iVal = 8;
      vt[3].vt = (ushort)Vnt.VT_I2;
      vt[3].iVal = 0;     // RANDOM_STYLE_MIXED==0
      fixed (Variant* v = &vt[0])  // This wrapper sucks but appears necessary
      {             	           // ... or a variable-scoping error may occur
        ptr2 = CallDLL("mslib145.dll", "MKTempName", &errcode, 4, v); 
      }
      CStrFree(ptr);      // Call to CC++ free() for malloc()ed string
      Console.WriteLine("MKTempName: " + StrCast(ptr2));
    }
  }
}