Hi Dan,

>I'm am also intereted in the code. <s>

Before I spend days in sending the source code to anyone.... *bg* Here it is, really simple, nothing special, not even the best way to write C and translated to English:

//-----------------------------------------------------------------------------------------
// Convert.Fll
// 
// This library converts numbers into binary character strings and back (similar to
// BINTOC() and CTOBIN()).
//
// (c) 1997 Christof Lange Computer Service
//
// last modification: May 20, 1997
//-----------------------------------------------------------------------------------------


#include "pro_Ext.h"

//-----------------------------------------------------------------------------------------
void LongToChar(ParamBlk *LongPara)
//-----------------------------------------------------------------------------------------
{
	Value val;
	if ((val.ev_handle = _AllocHand(sizeof( val.ev_long ))) == 0) {_Error(182);}
	_HLock(val.ev_handle);
	* (unsigned long *) _HandToPtr(val.ev_handle) = LongPara->p[0].val.ev_long;
	_HUnLock(val.ev_handle);
	val.ev_type = 'C';
	val.ev_length = sizeof( val.ev_long );
	_RetVal( &val );
	_FreeHand( val.ev_handle );
};


//-----------------------------------------------------------------------------------------
void CharToSLong(ParamBlk *CharPara)
//-----------------------------------------------------------------------------------------
{
	_HLock(CharPara->p[0].val.ev_handle);
	_RetInt(* (signed long int *) _HandToPtr(CharPara->p[0].val.ev_handle), 10);
	_HUnLock(CharPara->p[0].val.ev_handle);
};


//-----------------------------------------------------------------------------------------
void CharToLong(ParamBlk *CharPara)
//-----------------------------------------------------------------------------------------
{
	_HLock(CharPara->p[0].val.ev_handle);
	_RetFloat(* (unsigned long int *) _HandToPtr(CharPara->p[0].val.ev_handle), 20, 0);
	_HUnLock(CharPara->p[0].val.ev_handle);
};


//-----------------------------------------------------------------------------------------
void RealToChar(ParamBlk *RealPara)
//-----------------------------------------------------------------------------------------
{
	Value val;
	if ((val.ev_handle = _AllocHand(sizeof( val.ev_real ))) == 0) {_Error(182);}
	_HLock(val.ev_handle);
	* (double *) _HandToPtr(val.ev_handle) = RealPara->p[0].val.ev_real;
	_HUnLock(val.ev_handle);
	val.ev_type = 'C';
	val.ev_length = sizeof( val.ev_real );
	_RetVal( &val );
	_FreeHand( val.ev_handle );
};


//-----------------------------------------------------------------------------------------
void CharToReal(ParamBlk *CharPara)
//-----------------------------------------------------------------------------------------
{
	_HLock(CharPara->p[0].val.ev_handle);
	_RetFloat(* (double *) _HandToPtr(CharPara->p[0].val.ev_handle), 20, CharPara->p[1].val.ev_long);
	_HUnLock(CharPara->p[0].val.ev_handle);
};


//-----------------------------------------------------------------------------------------
void WordToChar(ParamBlk *WordPara)
//-----------------------------------------------------------------------------------------
{
	Value val;
	if ((val.ev_handle = _AllocHand(sizeof( short int ))) == 0) {_Error(182);}
	_HLock(val.ev_handle);
	* (unsigned short int *) _HandToPtr(val.ev_handle) = (unsigned short int) WordPara->p[0].val.ev_long;
	_HUnLock(val.ev_handle);
	val.ev_type = 'C';
	val.ev_length = sizeof( short int );
	_RetVal( &val );
	_FreeHand( val.ev_handle );
};


//-----------------------------------------------------------------------------------------
void CharToWord(ParamBlk *CharPara)
//-----------------------------------------------------------------------------------------
{
	_HLock(CharPara->p[0].val.ev_handle);
	_RetInt((unsigned long int) * (unsigned short int *) _HandToPtr(CharPara->p[0].val.ev_handle), 10);
	_HUnLock(CharPara->p[0].val.ev_handle);
};


//-----------------------------------------------------------------------------------------
void CharToSWord(ParamBlk *CharPara)
//-----------------------------------------------------------------------------------------
{
	_HLock(CharPara->p[0].val.ev_handle);
	_RetInt((signed long int) * (signed short int *) _HandToPtr(CharPara->p[0].val.ev_handle), 10);
	_HUnLock(CharPara->p[0].val.ev_handle);
};


//-----------------------------------------------------------------------------------------
void ByteToChar(ParamBlk *BytePara)
//-----------------------------------------------------------------------------------------
{
	Value val;
	if ((val.ev_handle = _AllocHand(sizeof( char ))) == 0) {_Error(182);}
	_HLock(val.ev_handle);
	* (unsigned char *) _HandToPtr(val.ev_handle) = (unsigned char) BytePara->p[0].val.ev_long;
	_HUnLock(val.ev_handle);
	val.ev_type = 'C';
	val.ev_length = sizeof( char );
	_RetVal( &val );
	_FreeHand( val.ev_handle );
};


//-----------------------------------------------------------------------------------------
void CharToByte(ParamBlk *CharPara)
//-----------------------------------------------------------------------------------------
{
	_HLock(CharPara->p[0].val.ev_handle);
	_RetInt((unsigned long int) * (unsigned char *) _HandToPtr(CharPara->p[0].val.ev_handle), 10);
	_HUnLock(CharPara->p[0].val.ev_handle);
};


//-----------------------------------------------------------------------------------------
void CharToSByte(ParamBlk *CharPara)
//-----------------------------------------------------------------------------------------
{
	_HLock(CharPara->p[0].val.ev_handle);
	_RetInt((signed long int) * (signed char *) _HandToPtr(CharPara->p[0].val.ev_handle), 10);
	_HUnLock(CharPara->p[0].val.ev_handle);
};


//-----------------------------------------------------------------------------------------
void MemToString(ParamBlk *Param)
//-----------------------------------------------------------------------------------------
{
	Value String;

	String.ev_type = 'C';
	String.ev_length = Param->p[1].val.ev_long;
	if( (String.ev_handle = _AllocHand(String.ev_length)) == 0 ) { _Error(182); }
	_HLock( String.ev_handle );
    _MemMove( _HandToPtr(String.ev_handle), (char FAR *) Param->p[0].val.ev_long, String.ev_length );
	_HUnLock( String.ev_handle );
	_RetVal( &String );
};


//-----------------------------------------------------------------------------------------
void StringToMem(ParamBlk *Param)
//-----------------------------------------------------------------------------------------
{
	_HLock( Param->p[0].val.ev_handle );
    _MemMove( (char FAR *) Param->p[1].val.ev_long, _HandToPtr(Param->p[0].val.ev_handle), Param->p[0].val.ev_length );
	_HUnLock( Param->p[0].val.ev_handle );
};


FoxInfo myFoxInfo[] = {
	{"FLL_MemToString",  (FPFI) MemToString, 2, "II"},
	{"FLL_StringToMem",  (FPFI) StringToMem, 2, "CI"},
	{"FLL_RealToChar",   (FPFI) RealToChar,  1, "N"},
	{"FLL_CharToReal",   (FPFI) CharToReal,  2, "CI"},
	{"FLL_DoubleToChar", (FPFI) RealToChar,  1, "N"},
	{"FLL_CharToDouble", (FPFI) CharToReal,  2, "CI"},
	{"FLL_LongToChar",   (FPFI) LongToChar,  1, "I"},
	{"FLL_CharToLong",   (FPFI) CharToLong,  1, "C"},
	{"FLL_CharToSLong",  (FPFI) CharToSLong, 1, "C"},
	{"FLL_WordToChar",   (FPFI) WordToChar,  1, "I"},
	{"FLL_CharToWord",   (FPFI) CharToWord,  1, "C"},
	{"FLL_CharToSWord",  (FPFI) CharToSWord, 1, "C"},
	{"FLL_ShortToChar",  (FPFI) WordToChar,  1, "I"},
	{"FLL_CharToShort",  (FPFI) CharToWord,  1, "C"},
	{"FLL_CharToSShort", (FPFI) CharToSWord, 1, "C"},
	{"FLL_ByteToChar",   (FPFI) ByteToChar,  1, "I"},
	{"FLL_CharToByte",   (FPFI) CharToByte,  1, "C"},
	{"FLL_CharToSByte",  (FPFI) CharToSByte, 1, "C"},
};


FoxTable _FoxTable = {
    (FoxTable FAR *)0, sizeof(myFoxInfo) / sizeof(FoxInfo), myFoxInfo
};

Christof