RECT * hbwapi_par_RECT( RECT * p, int iParam, HB_BOOL bMandatory )
{
PHB_ITEM pStru = hb_param( iParam, HB_IT_ANY );
memset( p, 0, sizeof( RECT ) );
if( pStru && HB_IS_HASH( pStru ) )
{
p->left = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "left" ) );
p->top = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "top" ) );
p->right = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "right" ) );
p->bottom = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "bottom" ) );
return p;
}
else if( pStru && HB_IS_ARRAY( pStru ) && hb_arrayLen( pStru ) >= 4 )
{
p->left = ( LONG ) hb_arrayGetNL( pStru, 1 );
p->top = ( LONG ) hb_arrayGetNL( pStru, 2 );
p->right = ( LONG ) hb_arrayGetNL( pStru, 3 );
p->bottom = ( LONG ) hb_arrayGetNL( pStru, 4 );
return p;
}
else if( bMandatory )
return p;
return NULL;
}
POINT * hbwapi_par_POINT( POINT * p, int iParam, HB_BOOL bMandatory )
{
PHB_ITEM pStru = hb_param( iParam, HB_IT_ANY );
memset( p, 0, sizeof( POINT ) );
if( pStru && HB_IS_HASH( pStru ) )
{
p->x = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "x" ) );
p->y = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "y" ) );
return p;
}
else if( pStru && HB_IS_ARRAY( pStru ) && hb_arrayLen( pStru ) >= 2 )
{
p->x = ( LONG ) hb_arrayGetNL( pStru, 1 );
p->y = ( LONG ) hb_arrayGetNL( pStru, 2 );
return p;
}
else if( bMandatory )
return p;
return NULL;
}
HB_BOOL wvt_Array2Point( PHB_ITEM aPoint, POINT * pt )
{
if( HB_IS_ARRAY( aPoint ) && hb_arrayLen( aPoint ) == 2 )
{
pt->x = hb_arrayGetNL( aPoint, 1 );
pt->y = hb_arrayGetNL( aPoint, 2 );
return HB_TRUE;
}
return HB_FALSE;
}
HB_BOOL wvt_Array2Size( PHB_ITEM aSize, SIZE * siz )
{
if( HB_IS_ARRAY( aSize ) && hb_arrayLen( aSize ) == 2 )
{
siz->cx = hb_arrayGetNL( aSize, 1 );
siz->cy = hb_arrayGetNL( aSize, 2 );
return HB_TRUE;
}
return HB_FALSE;
}
static LPTSTR s_StringList( int iParam )
{
PHB_ITEM pItem = hb_param( iParam, HB_IT_ARRAY | HB_IT_STRING ), pArrItem;
LPTSTR lpStr = NULL;
if( pItem )
{
HB_SIZE nLen, nSize, nTotal, n, n1;
if( HB_IS_ARRAY( pItem ) )
{
nSize = hb_arrayLen( pItem );
for( n = nLen = 0; n < nSize; ++n )
{
pArrItem = hb_arrayGetItemPtr( pItem, n + 1 );
if( HB_IS_STRING( pArrItem ) )
{
n1 = HB_ITEMCOPYSTR( pArrItem, NULL, 0 );
if( n1 )
nLen += n1 + 1;
}
}
if( nLen )
{
nTotal = nLen + 1;
lpStr = ( LPTSTR ) hb_xgrab( nTotal * sizeof( TCHAR ) );
for( n = nLen = 0; n < nSize; ++n )
{
pArrItem = hb_arrayGetItemPtr( pItem, n + 1 );
if( HB_IS_STRING( pArrItem ) )
{
n1 = HB_ITEMCOPYSTR( pArrItem,
lpStr + nLen, nTotal - nLen );
if( n1 )
nLen += n1 + 1;
}
}
lpStr[ nLen ] = 0;
}
}
else
{
nLen = HB_ITEMCOPYSTR( pItem, NULL, 0 );
if( nLen )
{
lpStr = ( LPTSTR ) hb_xgrab( ( nLen + 1 ) * sizeof( TCHAR ) );
HB_ITEMCOPYSTR( pItem, lpStr, nLen );
lpStr[ nLen ] = 0;
}
}
}
return lpStr;
}
HB_BOOL wvt_Array2Rect( PHB_ITEM aRect, RECT * rc )
{
if( HB_IS_ARRAY( aRect ) && hb_arrayLen( aRect ) == 4 )
{
rc->left = hb_arrayGetNL( aRect, 1 );
rc->top = hb_arrayGetNL( aRect, 2 );
rc->right = hb_arrayGetNL( aRect, 3 );
rc->bottom = hb_arrayGetNL( aRect, 4 );
return HB_TRUE;
}
return HB_FALSE;
}
PHB_ITEM hb_i18n_gettext( PHB_ITEM pMsgID, PHB_ITEM pContext )
{
PHB_I18N_TRANS pI18N = hb_i18n_table();
PHB_CODEPAGE cdpage = NULL;
PHB_ITEM pMsgDst = pMsgID;
if( pI18N )
{
PHB_ITEM pTable = pContext && pI18N->context_table ?
hb_hashGetItemPtr( pI18N->context_table, pContext, 0 ) :
pI18N->default_context;
cdpage = pI18N->base_cdpage;
if( pTable )
{
pTable = hb_hashGetItemPtr( pTable, pMsgID, 0 );
if( pTable )
{
if( HB_IS_ARRAY( pTable ) )
pTable = hb_arrayGetItemPtr( pTable, 1 );
if( pTable && HB_IS_STRING( pTable ) )
{
pMsgID = pTable;
cdpage = pI18N->cdpage;
}
}
}
}
if( pMsgID )
{
if( HB_IS_STRING( pMsgID ) )
{
if( cdpage )
{
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp != cdpage )
{
if( pMsgDst != pMsgID )
{
hb_itemCopy( pMsgDst, pMsgID );
pMsgID = pMsgDst;
}
hb_i18n_transitm( pMsgID, cdpage, cdp );
}
}
}
else
pMsgID = NULL;
}
return pMsgID;
}
/*
* Detach local variable (swap current value with a memvar handle)
*/
PHB_ITEM hb_memvarDetachLocal( PHB_ITEM pLocal )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_memvarDetachLocal(%p)", pLocal ) );
if( HB_IS_BYREF( pLocal ) )
{
do
{
if( HB_IS_MEMVAR( pLocal ) || HB_IS_EXTREF( pLocal ) )
break;
else if( HB_IS_ENUM( pLocal ) )
{
if( ! pLocal->item.asEnum.valuePtr )
{
PHB_ITEM pBase = HB_IS_BYREF( pLocal->item.asEnum.basePtr ) ?
hb_itemUnRef( pLocal->item.asEnum.basePtr ) :
pLocal->item.asEnum.basePtr;
if( HB_IS_ARRAY( pBase ) )
{
PHB_ITEM pItem = hb_itemNew( NULL );
hb_arrayGetItemRef( pBase, pLocal->item.asEnum.offset, pItem );
pLocal->item.asEnum.valuePtr = pItem;
pLocal = pItem;
break;
}
}
}
else if( pLocal->item.asRefer.value >= 0 &&
pLocal->item.asRefer.offset == 0 )
break;
pLocal = hb_itemUnRefOnce( pLocal );
}
while( HB_IS_BYREF( pLocal ) );
}
/* Change the value only if this variable is not referenced
* by another codeblock yet.
* In this case we have to copy the current value to a global memory
* pool so it can be shared by codeblocks
*/
if( ! HB_IS_MEMVAR( pLocal ) )
{
PHB_ITEM pMemvar = hb_memvarValueNew();
hb_itemRawCpy( pMemvar, pLocal );
pMemvar->type &= ~HB_IT_DEFAULT;
pLocal->type = HB_IT_BYREF | HB_IT_MEMVAR;
pLocal->item.asMemvar.value = pMemvar;
}
return pLocal;
}
void hbwapi_stor_POINT( POINT * p, int iParam )
{
PHB_ITEM pStru = hb_param( iParam, HB_IT_ANY );
if( pStru && HB_IS_HASH( pStru ) )
{
s_hb_hashSetCItemNL( pStru, "x", p->x );
s_hb_hashSetCItemNL( pStru, "y", p->y );
}
else if( pStru && HB_IS_ARRAY( pStru ) && hb_arrayLen( pStru ) >= 2 )
{
hb_arraySetNL( pStru, 1, p->x );
hb_arraySetNL( pStru, 2, p->y );
}
}
static const char * hb_dbTransFieldPos( PHB_ITEM pFields, HB_USHORT uiField )
{
const char * szField = NULL;
PHB_ITEM pItem;
pItem = hb_arrayGetItemPtr( pFields, uiField );
if( pItem )
{
if( HB_IS_ARRAY( pItem ) )
szField = hb_arrayGetCPtr( pItem, DBS_NAME );
else
szField = hb_itemGetCPtr( pItem );
if( *szField == '\0' )
szField = NULL;
}
return szField;
}
void hbwapi_stor_RECT( RECT * p, int iParam )
{
PHB_ITEM pStru = hb_param( iParam, HB_IT_ANY );
if( pStru && HB_IS_HASH( pStru ) )
{
s_hb_hashSetCItemNL( pStru, "left" , p->left );
s_hb_hashSetCItemNL( pStru, "top" , p->top );
s_hb_hashSetCItemNL( pStru, "right" , p->right );
s_hb_hashSetCItemNL( pStru, "bottom", p->bottom );
}
else if( pStru && HB_IS_ARRAY( pStru ) && hb_arrayLen( pStru ) >= 4 )
{
hb_arraySetNL( pStru, 1, p->left );
hb_arraySetNL( pStru, 2, p->top );
hb_arraySetNL( pStru, 3, p->right );
hb_arraySetNL( pStru, 4, p->bottom );
}
}
static void hb_compGenArgList( int iFirst, int iLast,
int * pArgC, const char *** pArgV,
PHB_ITEM * pIncItem,
PHB_PP_OPEN_FUNC * pOpenFunc,
PHB_PP_MSG_FUNC * pMsgFunc )
{
PHB_ITEM pParam;
HB_SIZE ul, nLen;
int argc = 1, i;
const char ** argv;
if( pMsgFunc )
{
*pMsgFunc = NULL;
if( HB_ISLOG( iFirst ) )
{
if( hb_parl( iFirst ) )
*pMsgFunc = s_pp_msg;
++iFirst;
}
}
if( pIncItem && pOpenFunc )
{
*pOpenFunc = NULL;
*pIncItem = hb_param( iFirst, HB_IT_HASH );
if( *pIncItem )
{
++iFirst;
*pOpenFunc = s_pp_openFile;
}
}
for( i = iFirst; i <= iLast; ++i )
{
pParam = hb_param( i, HB_IT_ARRAY | HB_IT_STRING );
if( pParam )
{
if( HB_IS_ARRAY( pParam ) )
{
ul = hb_arrayLen( pParam );
if( ul )
{
do
{
if( hb_arrayGetType( pParam, ul ) & HB_IT_STRING )
++argc;
}
while( --ul );
}
}
else if( HB_IS_STRING( pParam ) )
++argc;
}
}
argv = ( const char ** ) hb_xgrab( sizeof( char * ) * ( argc + 1 ) );
argc = 0;
for( i = iFirst; i <= iLast; ++i )
{
pParam = hb_param( i, HB_IT_ARRAY | HB_IT_STRING );
if( pParam )
{
if( HB_IS_ARRAY( pParam ) )
{
nLen = hb_arrayLen( pParam );
for( ul = 1; ul <= nLen; ++ul )
{
if( hb_arrayGetType( pParam, ul ) & HB_IT_STRING )
argv[ argc++ ] = hb_arrayGetCPtr( pParam, ul );
}
}
else if( HB_IS_STRING( pParam ) )
argv[ argc++ ] = hb_itemGetCPtr( pParam );
}
}
argv[ argc ] = NULL;
*pArgC = argc;
*pArgV = argv;
}
/* Mark a passed item as used so it will be not released by the GC
*/
void hb_gcItemRef( HB_ITEM_PTR pItem )
{
HB_THREAD_STUB
ULONG ulSize;
HB_ITEM FakedItem;
PHB_ITEM pKey;
PHB_ITEM pValue;
HB_CODEBLOCK_PTR pCBlock;
USHORT ui;
#ifdef SIMULATE_ITEMREF_RECURSION
PITEMREF_RESUMEINFO pResumeInfo = (PITEMREF_RESUMEINFO) hb_xgrab( sizeof( ITEMREF_RESUMEINFO ) );
int iResumeCounter = 0;
#endif
FakedItem.type = HB_IT_ARRAY;
ItemRef_Top:
while( HB_IS_BYREF( pItem ) )
{
if( HB_IS_EXTREF( pItem ) )
{
pItem->item.asExtRef.func->mark( pItem->item.asExtRef.value );
RETURN_OR_RESUME_ITEMREF();
}
if( HB_IS_MEMVAR( pItem ) == FALSE )
{
if( pItem->item.asRefer.offset == 0 )
{
FakedItem.item.asArray.value = pItem->item.asRefer.BasePtr.pBaseArray;
//hb_gcItemRef( &FakedItem );
NESTED_ITEMREF( &FakedItem, 1 );
ItemRef_ResumePoint_1:
// return;
RETURN_OR_RESUME_ITEMREF();
}
}
else
{
if( HB_VM_STACK.pPos == HB_VM_STACK.pItems )
{
//return;
RETURN_OR_RESUME_ITEMREF();
}
}
pItem = hb_itemUnRefOnce( pItem );
}
if( HB_IS_ARRAY( pItem ) )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) pItem->item.asArray.value;
//printf( "Array %p\n", pItem->item.asArray.value );
--pAlloc;
/* Check this array only if it was not checked yet */
if( pAlloc->used == s_uUsedFlag )
{
ulSize = pItem->item.asArray.value->ulLen;
/* mark this block as used so it will be no re-checked from
* other references
*/
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all array elements */
pItem = pItem->item.asArray.value->pItems;
//printf( "Items %p\n", pItem );
while( ulSize )
{
//printf( "Item %p\n", pItem );
//hb_gcItemRef( pItem );
NESTED_ITEMREF( pItem, 2 );
ItemRef_ResumePoint_2:
++pItem;
--ulSize;
}
}
}
else if( HB_IS_HASH( pItem ) )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) pItem->item.asHash.value;
--pAlloc;
/* Check this hash only if it was not checked yet */
if( pAlloc->used == s_uUsedFlag )
{
ulSize = pItem->item.asHash.value->ulLen;
pKey = pItem->item.asHash.value->pKeys;
pValue = pItem->item.asHash.value->pValues;
/* mark this block as used so it will be no re-checked from
* other references
*/
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all hash elements */
while( ulSize )
{
//printf( "Kry %p Value: %p\n", pKey, pValue );
//hb_gcItemRef( pKey );
NESTED_ITEMREF( pKey, 3 );
ItemRef_ResumePoint_3:
//hb_gcItemRef( pValue );
NESTED_ITEMREF( pValue, 4 );
ItemRef_ResumePoint_4:
++pKey;
++pValue;
--ulSize;
}
}
}
else if( HB_IS_BLOCK( pItem ) )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) pItem->item.asBlock.value;
--pAlloc;
/* Check this block only if it was not checked yet */
if( pAlloc->used == s_uUsedFlag )
{
pCBlock = pItem->item.asBlock.value;
ui = 1;
pAlloc->used ^= HB_GC_USED_FLAG; /* mark this codeblock as used */
/* mark as used all detached variables in a codeblock */
while( ui <= pCBlock->uiLocals )
{
//hb_gcItemRef( &pCBlock->pLocals[ ui ] );
NESTED_ITEMREF( &pCBlock->pLocals[ ui ] , 5 );
ItemRef_ResumePoint_5:
++ui;
}
}
}
else if( HB_IS_POINTER( pItem ) )
{
/* check if this memory was allocated by a hb_gcAlloc() */
if ( pItem->item.asPointer.collect )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) pItem->item.asPointer.value;
--pAlloc;
/* Check this memory only if it was not checked yet */
if( pAlloc->used == s_uUsedFlag )
{
/* mark this memory as used so it will be no re-checked from
* other references
*/
pAlloc->used ^= HB_GC_USED_FLAG;
}
}
}
/* all other data types don't need the GC */
RETURN_OR_RESUME_ITEMREF();
}
static void _hb_jsonEncode( PHB_ITEM pValue, PHB_JSON_ENCODE_CTX pCtx,
HB_SIZE nLevel, HB_BOOL fEOL, PHB_CODEPAGE cdp )
{
/* Protection against recursive structures */
if( ( HB_IS_ARRAY( pValue ) || HB_IS_HASH( pValue ) ) && hb_itemSize( pValue ) > 0 )
{
void * id = HB_IS_HASH( pValue ) ? hb_hashId( pValue ) : hb_arrayId( pValue );
HB_SIZE nIndex;
for( nIndex = 0; nIndex < nLevel; nIndex++ )
{
if( pCtx->pId[ nIndex ] == id )
{
if( ! fEOL && pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "null", 4 );
return;
}
}
if( nLevel >= pCtx->nAllocId )
{
pCtx->nAllocId += 8;
pCtx->pId = ( void ** ) hb_xrealloc( pCtx->pId, sizeof( void * ) * pCtx->nAllocId );
}
pCtx->pId[ nLevel ] = id;
}
if( fEOL )
{
--pCtx->pHead;
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
}
if( HB_IS_STRING( pValue ) )
{
HB_SIZE nPos, nLen = hb_itemGetCLen( pValue );
const char * szString = hb_itemGetCPtr( pValue );
char buf[ 8 ];
_hb_jsonCtxAdd( pCtx, "\"", 1 );
if( cdp )
{
HB_WCHAR wc;
nPos = 0;
while( HB_CDPCHAR_GET( cdp, szString, nLen, &nPos, &wc ) )
{
if( wc >= ' ' && wc < 0x7F && wc != '\\' && wc != '\"' )
{
buf[ 0 ] = ( char ) wc;
_hb_jsonCtxAdd( pCtx, buf, 1 );
continue;
}
switch( wc )
{
case '\\':
_hb_jsonCtxAdd( pCtx, "\\\\", 2 );
break;
case '\"':
_hb_jsonCtxAdd( pCtx, "\\\"", 2 );
break;
case '\b':
_hb_jsonCtxAdd( pCtx, "\\b", 2 );
break;
case '\f':
_hb_jsonCtxAdd( pCtx, "\\f", 2 );
break;
case '\n':
_hb_jsonCtxAdd( pCtx, "\\n", 2 );
break;
case '\r':
_hb_jsonCtxAdd( pCtx, "\\r", 2 );
break;
case '\t':
_hb_jsonCtxAdd( pCtx, "\\t", 2 );
break;
default:
hb_snprintf( buf, sizeof( buf ), "\\u%04X", wc );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
}
}
else
{
nPos = 0;
while( nPos < nLen )
{
unsigned char uch = szString[ nPos ];
HB_SIZE nPos2 = nPos;
while( uch >= ' ' && uch != '\\' && uch != '\"' )
uch = szString[ ++nPos2 ];
if( nPos2 > nPos )
{
_hb_jsonCtxAdd( pCtx, szString + nPos, nPos2 - nPos );
if( nPos2 >= nLen )
break;
nPos = nPos2;
}
switch( uch )
{
case '\\':
_hb_jsonCtxAdd( pCtx, "\\\\", 2 );
break;
case '\"':
_hb_jsonCtxAdd( pCtx, "\\\"", 2 );
break;
case '\b':
_hb_jsonCtxAdd( pCtx, "\\b", 2 );
break;
case '\f':
_hb_jsonCtxAdd( pCtx, "\\f", 2 );
break;
case '\n':
_hb_jsonCtxAdd( pCtx, "\\n", 2 );
break;
case '\r':
_hb_jsonCtxAdd( pCtx, "\\r", 2 );
break;
case '\t':
_hb_jsonCtxAdd( pCtx, "\\t", 2 );
break;
default:
hb_snprintf( buf, sizeof( buf ), "\\u00%02X", uch );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
nPos++;
}
}
_hb_jsonCtxAdd( pCtx, "\"", 1 );
}
else if( HB_IS_NUMINT( pValue ) )
{
char buf[ 24 ];
HB_MAXINT nVal = hb_itemGetNInt( pValue );
HB_BOOL fNeg = nVal < 0;
int i = 0;
if( fNeg )
nVal = -nVal;
do
buf[ sizeof( buf ) - ++i ] = ( nVal % 10 ) + '0';
while( ( nVal /= 10 ) != 0 );
if( fNeg )
buf[ sizeof( buf ) - ++i ] = '-';
_hb_jsonCtxAdd( pCtx, &buf[ sizeof( buf ) - i ], i );
}
else if( HB_IS_NUMERIC( pValue ) )
{
char buf[ 64 ];
int iDec;
double dblValue = hb_itemGetNDDec( pValue, &iDec );
hb_snprintf( buf, sizeof( buf ), "%.*f", iDec, dblValue );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
else if( HB_IS_NIL( pValue ) )
{
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
else if( HB_IS_LOGICAL( pValue ) )
{
if( hb_itemGetL( pValue ) )
_hb_jsonCtxAdd( pCtx, "true", 4 );
else
_hb_jsonCtxAdd( pCtx, "false", 5 );
}
else if( HB_IS_DATE( pValue ) )
{
char szBuffer[ 10 ];
hb_itemGetDS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 9 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 10 );
}
else if( HB_IS_TIMESTAMP( pValue ) )
{
char szBuffer[ 19 ];
hb_itemGetTS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 18 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 19 );
}
else if( HB_IS_ARRAY( pValue ) )
{
HB_SIZE nLen = hb_itemSize( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "[", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pItem = hb_arrayGetItemPtr( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
if( pCtx->fHuman &&
! ( ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) &&
hb_itemSize( pItem ) > 0 ) )
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
_hb_jsonEncode( pItem, pCtx, nLevel + 1, HB_FALSE, cdp );
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "]", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "[]", 2 );
}
else if( HB_IS_HASH( pValue ) )
{
HB_SIZE nLen = hb_hashLen( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "{", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pValue, nIndex );
if( HB_IS_STRING( pKey ) )
{
PHB_ITEM pItem = hb_hashGetValueAt( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
}
_hb_jsonEncode( pKey, pCtx, nLevel + 1, HB_FALSE, cdp );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, ": ", 2 );
fEOL = ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) && hb_itemSize( pItem ) > 0;
}
else
{
_hb_jsonCtxAdd( pCtx, ":", 1 );
fEOL = HB_FALSE;
}
_hb_jsonEncode( pItem, pCtx, nLevel + 1, fEOL, cdp );
}
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "}", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "{}", 2 );
}
else
{
/* All unsupported types are replacd by null */
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
}
static const char * hb_i18n_setcodepage( PHB_I18N_TRANS pI18N,
const char * szCdpID,
HB_BOOL fBase, HB_BOOL fTranslate )
{
const char * szOldCdpID = NULL, * szKey;
if( pI18N )
{
PHB_CODEPAGE cdp = szCdpID ? hb_cdpFind( szCdpID ) : NULL, cdpage;
cdpage = fBase ? pI18N->base_cdpage : pI18N->cdpage;
if( cdpage )
szOldCdpID = cdpage->id;
if( cdp && cdp != cdpage )
{
if( fTranslate && cdpage )
{
HB_SIZE nHashLen = hb_hashLen( pI18N->context_table ), ul;
for( ul = 1; ul <= nHashLen; ++ul )
{
PHB_ITEM pContext = hb_hashGetValueAt( pI18N->context_table, ul );
HB_SIZE nCount = hb_hashLen( pContext ), u;
for( u = 1; u <= nCount; ++u )
{
if( fBase )
{
hb_i18n_transitm( hb_hashGetKeyAt( pContext, u ),
cdpage, cdp );
}
else
{
PHB_ITEM pResult = hb_hashGetValueAt( pContext, u );
if( HB_IS_STRING( pResult ) )
{
hb_i18n_transitm( pResult, cdpage, cdp );
}
else if( HB_IS_ARRAY( pResult ) )
{
HB_SIZE nTrans = hb_arrayLen( pResult ), u2;
for( u2 = 1; u2 <= nTrans; ++u2 )
{
hb_i18n_transitm( hb_arrayGetItemPtr( pResult, u2 ),
cdpage, cdp );
}
}
}
}
if( fBase )
{
hb_i18n_transitm( hb_hashGetKeyAt( pI18N->context_table, ul ),
cdpage, cdp );
hb_hashSetFlags( pContext, HB_HASH_RESORT );
}
}
if( fBase )
hb_hashSetFlags( pI18N->context_table, HB_HASH_RESORT );
}
if( fBase )
{
pI18N->base_cdpage = cdp;
szKey = "BASE_CODEPAGE";
}
else
{
pI18N->cdpage = cdp;
szKey = "CODEPAGE";
}
hb_i18n_setitem( pI18N->table, szKey, szCdpID );
}
}
return szOldCdpID;
}
PHB_ITEM hb_i18n_ngettext( PHB_ITEM pNum, PHB_ITEM pMsgID, PHB_ITEM pContext )
{
PHB_I18N_TRANS pI18N = hb_i18n_table();
PHB_CODEPAGE cdpage = NULL;
PHB_ITEM pMsgDst = pMsgID;
PHB_ITEM pBlock = NULL;
int iPluralForm = 0;
if( pI18N )
{
PHB_ITEM pTable = pContext && pI18N->context_table ?
hb_hashGetItemPtr( pI18N->context_table, pContext, 0 ) :
pI18N->default_context;
cdpage = pI18N->base_cdpage;
pBlock = pI18N->base_plural_block;
iPluralForm = pI18N->base_plural_form;
if( pTable )
{
PHB_ITEM pMsg = HB_IS_ARRAY( pMsgID ) ?
hb_arrayGetItemPtr( pMsgID, 1 ) : pMsgID;
pTable = pMsg && HB_IS_STRING( pMsg ) ?
hb_hashGetItemPtr( pTable, pMsg, 0 ) : NULL;
if( pTable )
{
if( HB_IS_STRING( pTable ) ||
( HB_IS_ARRAY( pTable ) &&
( hb_arrayGetType( pTable, 1 ) & HB_IT_STRING ) != 0 ) )
{
pMsgID = pTable;
cdpage = pI18N->cdpage;
pBlock = pI18N->plural_block;
iPluralForm = pI18N->plural_form;
}
}
}
}
if( pMsgID && HB_IS_ARRAY( pMsgID ) )
{
long lIndex;
if( ! pNum )
lIndex = 1;
else if( pBlock )
{
hb_evalBlock1( pBlock, pNum );
lIndex = hb_parnl( -1 );
}
else
lIndex = hb_i18n_pluralindex( iPluralForm, pNum );
if( lIndex < 1 || ( lIndex != 1 &&
( hb_arrayGetType( pMsgID, lIndex ) & HB_IT_STRING ) == 0 ) )
lIndex = 1;
pMsgID = hb_arrayGetItemPtr( pMsgID, lIndex );
}
if( pMsgID )
{
if( HB_IS_STRING( pMsgID ) )
{
if( cdpage )
{
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp != cdpage )
{
if( pMsgDst != pMsgID )
{
hb_itemCopy( pMsgDst, pMsgID );
pMsgID = pMsgDst;
}
hb_i18n_transitm( pMsgID, cdpage, cdp );
}
}
}
else
pMsgID = NULL;
}
return pMsgID;
}
static void _hb_jsonEncode( PHB_ITEM pValue, PHB_JSON_ENCODE_CTX pCtx,
HB_SIZE nLevel, HB_BOOL fEOL )
{
/* Protection against recursive structures */
if( ( HB_IS_ARRAY( pValue ) || HB_IS_HASH( pValue ) ) && hb_itemSize( pValue ) > 0 )
{
void * id = HB_IS_HASH( pValue ) ? hb_hashId( pValue ) : hb_arrayId( pValue );
HB_SIZE nIndex;
for( nIndex = 0; nIndex < nLevel; nIndex++ )
{
if( pCtx->pId[ nIndex ] == id )
{
if( ! fEOL && pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "null", 4 );
return;
}
}
if( nLevel >= pCtx->nAllocId )
{
pCtx->nAllocId += 8;
pCtx->pId = ( void ** ) hb_xrealloc( pCtx->pId, sizeof( void * ) * pCtx->nAllocId );
}
pCtx->pId[ nLevel ] = id;
}
if( fEOL )
{
--pCtx->pHead;
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
}
if( HB_IS_STRING( pValue ) )
{
const char * szString = hb_itemGetCPtr( pValue );
HB_SIZE nPos, nPos2, nLen = hb_itemGetCLen( pValue );
_hb_jsonCtxAdd( pCtx, "\"", 1 );
nPos = 0;
while( nPos < nLen )
{
nPos2 = nPos;
while( *( ( const unsigned char * ) szString + nPos2 ) >= ' ' &&
szString[ nPos2 ] != '\\' && szString[ nPos2 ] != '\"' )
nPos2++;
if( nPos2 > nPos )
{
_hb_jsonCtxAdd( pCtx, szString + nPos, nPos2 - nPos );
nPos = nPos2;
continue;
}
switch( szString[ nPos ] )
{
case '\\':
_hb_jsonCtxAdd( pCtx, "\\\\", 2 );
break;
case '\"':
_hb_jsonCtxAdd( pCtx, "\\\"", 2 );
break;
case '\b':
_hb_jsonCtxAdd( pCtx, "\\b", 2 );
break;
case '\f':
_hb_jsonCtxAdd( pCtx, "\\f", 2 );
break;
case '\n':
_hb_jsonCtxAdd( pCtx, "\\n", 2 );
break;
case '\r':
_hb_jsonCtxAdd( pCtx, "\\r", 2 );
break;
case '\t':
_hb_jsonCtxAdd( pCtx, "\\t", 2 );
break;
default:
{
char buf[ 8 ];
hb_snprintf( buf, sizeof( buf ), "\\u00%02X", ( unsigned char ) szString[ nPos ] );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
}
nPos++;
}
_hb_jsonCtxAdd( pCtx, "\"", 1 );
}
else if( HB_IS_NUMINT( pValue ) )
{
char buf[ 32 ];
hb_snprintf( buf, sizeof( buf ), "%" PFHL "d", hb_itemGetNInt( pValue ) );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
else if( HB_IS_NUMERIC( pValue ) )
{
char buf[ 64 ];
int iDec;
double dblValue = hb_itemGetNDDec( pValue, &iDec );
hb_snprintf( buf, sizeof( buf ), "%.*f", iDec, dblValue );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
else if( HB_IS_NIL( pValue ) )
{
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
else if( HB_IS_LOGICAL( pValue ) )
{
if( hb_itemGetL( pValue ) )
_hb_jsonCtxAdd( pCtx, "true", 4 );
else
_hb_jsonCtxAdd( pCtx, "false", 5 );
}
else if( HB_IS_DATE( pValue ) )
{
char szBuffer[ 10 ];
hb_itemGetDS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 9 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 10 );
}
else if( HB_IS_TIMESTAMP( pValue ) )
{
char szBuffer[ 19 ];
hb_itemGetTS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 18 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 19 );
}
else if( HB_IS_ARRAY( pValue ) )
{
HB_SIZE nLen = hb_itemSize( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "[", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pItem = hb_arrayGetItemPtr( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
if( pCtx->fHuman &&
! ( ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) &&
hb_itemSize( pItem ) > 0 ) )
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
_hb_jsonEncode( pItem, pCtx, nLevel + 1, HB_FALSE );
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "]", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "[]", 2 );
}
else if( HB_IS_HASH( pValue ) )
{
HB_SIZE nLen = hb_hashLen( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "{", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pValue, nIndex );
if( HB_IS_STRING( pKey ) )
{
PHB_ITEM pItem = hb_hashGetValueAt( pValue, nIndex );
HB_BOOL fEOL = HB_FALSE;
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
}
_hb_jsonEncode( pKey, pCtx, nLevel + 1, HB_FALSE );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, ": ", 2 );
fEOL = ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) && hb_itemSize( pItem ) > 0;
}
else
_hb_jsonCtxAdd( pCtx, ":", 1 );
_hb_jsonEncode( pItem, pCtx, nLevel + 1, fEOL );
}
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "}", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "{}", 2 );
}
else
{
/* All unsupported types are replacd by null */
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
}
static LPTSTR s_dialogPairs( int iParam, DWORD * pdwIndex )
{
PHB_ITEM pItem = hb_param( iParam, HB_IT_ARRAY | HB_IT_STRING ), pArrItem;
LPTSTR lpStr = NULL;
DWORD dwMaxIndex = 0;
if( pItem )
{
HB_SIZE nLen, nSize, nTotal, n, n1, n2;
if( HB_IS_ARRAY( pItem ) )
{
nSize = hb_arrayLen( pItem );
for( n = nLen = 0; n < nSize; ++n )
{
pArrItem = hb_arrayGetItemPtr( pItem, n + 1 );
if( HB_IS_STRING( pArrItem ) )
{
n1 = HB_ITEMCOPYSTR( pArrItem, NULL, 0 );
if( n1 )
nLen += n1 * 2 + 2;
}
else if( hb_arrayLen( pArrItem ) >= 2 )
{
n1 = HB_ITEMCOPYSTR( hb_arrayGetItemPtr( pArrItem, 1 ), NULL, 0 );
n2 = HB_ITEMCOPYSTR( hb_arrayGetItemPtr( pArrItem, 2 ), NULL, 0 );
if( n1 && n2 )
nLen += n1 + n2 + 2;
}
}
if( nLen )
{
nTotal = nLen + 1;
lpStr = ( LPTSTR ) hb_xgrab( nTotal * sizeof( TCHAR ) );
for( n = nLen = 0; n < nSize; ++n )
{
pArrItem = hb_arrayGetItemPtr( pItem, n + 1 );
if( HB_IS_STRING( pArrItem ) )
{
n1 = HB_ITEMCOPYSTR( pArrItem,
lpStr + nLen, nTotal - nLen );
if( n1 )
{
nLen += n1 + 1;
n1 = HB_ITEMCOPYSTR( pArrItem,
lpStr + nLen, nTotal - nLen );
nLen += n1 + 1;
dwMaxIndex++;
}
}
else if( hb_arrayLen( pArrItem ) >= 2 )
{
n1 = HB_ITEMCOPYSTR( hb_arrayGetItemPtr( pArrItem, 1 ),
lpStr + nLen, nTotal - nLen );
if( n1 )
{
n2 = HB_ITEMCOPYSTR( hb_arrayGetItemPtr( pArrItem, 2 ),
lpStr + nLen + n1 + 1,
nTotal - nLen - n1 - 1 );
if( n2 )
{
nLen += n1 + n2 + 2;
dwMaxIndex++;
}
}
}
}
lpStr[ nLen ] = 0;
}
}
else
{
nLen = HB_ITEMCOPYSTR( pItem, NULL, 0 );
if( nLen )
{
lpStr = ( LPTSTR ) hb_xgrab( ( nLen * 2 + 3 ) * sizeof( TCHAR ) );
HB_ITEMCOPYSTR( pItem, lpStr, nLen + 1 );
for( n = n1 = 0; n < nLen; ++n )
{
if( lpStr[ n ] == 0 )
{
++n1;
if( lpStr[ n + 1 ] == 0 )
break;
}
}
if( n1 == 0 )
{
HB_ITEMCOPYSTR( pItem, lpStr + nLen + 1, nLen + 1 );
lpStr[ nLen * 2 + 2 ] = 0;
dwMaxIndex = 1;
}
else
{
if( n == nLen && lpStr[ n - 1 ] != 0 )
{
lpStr[ n + 1 ] = 0;
++n1;
}
if( ( n1 & 1 ) == 0 )
dwMaxIndex = ( DWORD ) n1;
else
{
hb_xfree( lpStr );
lpStr = NULL;
}
}
}
}
}
if( pdwIndex )
{
if( dwMaxIndex < *pdwIndex )
*pdwIndex = dwMaxIndex;
else if( dwMaxIndex && *pdwIndex == 0 )
*pdwIndex = 1;
}
return lpStr;
}
/* Mark a passed item as used so it will be not released by the GC
*/
void hb_gcItemRef( PHB_ITEM pItem )
{
while( HB_IS_BYREF( pItem ) )
{
if( HB_IS_ENUM( pItem ) )
return;
else if( HB_IS_EXTREF( pItem ) )
{
pItem->item.asExtRef.func->mark( pItem->item.asExtRef.value );
return;
}
else if( ! HB_IS_MEMVAR( pItem ) &&
pItem->item.asRefer.offset == 0 &&
pItem->item.asRefer.value >= 0 )
{
/* array item reference */
PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asRefer.BasePtr.array );
if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag )
{
/* mark this array as used */
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all array elements */
pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) );
}
return;
}
pItem = hb_itemUnRefOnce( pItem );
}
if( HB_IS_ARRAY( pItem ) )
{
PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asArray.value );
/* Check this array only if it was not checked yet */
if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag )
{
/* mark this array as used so it will be no re-checked from
* other references
*/
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all array elements */
pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) );
}
}
else if( HB_IS_HASH( pItem ) )
{
PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asHash.value );
/* Check this hash table only if it was not checked yet */
if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag )
{
/* mark this hash table as used */
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all hash elements */
pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) );
}
}
else if( HB_IS_BLOCK( pItem ) )
{
PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asBlock.value );
if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag )
{
/* mark this codeblock as used */
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark as used all detached variables in a codeblock */
pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) );
}
}
else if( HB_IS_POINTER( pItem ) )
{
if( pItem->item.asPointer.collect )
{
PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asPointer.value );
if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag )
{
/* mark this memory block as used */
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all internal user blocks attached to this block */
pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) );
}
}
}
/* all other data types don't need the GC */
}
LOGFONT * hbwapi_par_LOGFONT( LOGFONT * p, int iParam, HB_BOOL bMandatory )
{
PHB_ITEM pStru = hb_param( iParam, HB_IT_ANY );
void * hfFaceName;
LPCTSTR pfFaceName;
HB_SIZE nLen;
memset( p, 0, sizeof( LOGFONT ) );
if( pStru && HB_IS_HASH( pStru ) )
{
p->lfHeight = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfHeight" ) );
p->lfWidth = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfWidth" ) );
p->lfEscapement = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfEscapement" ) );
p->lfOrientation = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfOrientation" ) );
p->lfWeight = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfWeight" ) );
p->lfItalic = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfItalic" ) );
p->lfUnderline = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfUnderline" ) );
p->lfStrikeOut = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfStrikeOut" ) );
p->lfCharSet = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfCharSet" ) );
p->lfOutPrecision = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfOutPrecision" ) );
p->lfClipPrecision = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfClipPrecision" ) );
p->lfQuality = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfQuality" ) );
p->lfPitchAndFamily = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfPitchAndFamily" ) );
pfFaceName = HB_ITEMGETSTR( hb_hashGetCItemPtr( pStru, "lfFaceName" ), &hfFaceName, &nLen );
if( nLen > ( LF_FACESIZE - 1 ) )
nLen = LF_FACESIZE - 1;
memcpy( p->lfFaceName, pfFaceName, nLen * sizeof( TCHAR ) );
p->lfFaceName[ nLen ] = TEXT( '\0' );
hb_strfree( hfFaceName );
return p;
}
else if( pStru && HB_IS_ARRAY( pStru ) && hb_arrayLen( pStru ) >= 14 )
{
p->lfHeight = ( LONG ) hb_arrayGetNL( pStru, 1 );
p->lfWidth = ( LONG ) hb_arrayGetNL( pStru, 2 );
p->lfEscapement = ( LONG ) hb_arrayGetNL( pStru, 3 );
p->lfOrientation = ( LONG ) hb_arrayGetNL( pStru, 4 );
p->lfWeight = ( LONG ) hb_arrayGetNL( pStru, 5 );
p->lfItalic = ( BYTE ) hb_arrayGetNI( pStru, 6 );
p->lfUnderline = ( BYTE ) hb_arrayGetNI( pStru, 7 );
p->lfStrikeOut = ( BYTE ) hb_arrayGetNI( pStru, 8 );
p->lfCharSet = ( BYTE ) hb_arrayGetNI( pStru, 9 );
p->lfOutPrecision = ( BYTE ) hb_arrayGetNI( pStru, 10 );
p->lfClipPrecision = ( BYTE ) hb_arrayGetNI( pStru, 11 );
p->lfQuality = ( BYTE ) hb_arrayGetNI( pStru, 12 );
p->lfPitchAndFamily = ( BYTE ) hb_arrayGetNI( pStru, 13 );
pfFaceName = HB_ARRAYGETSTR( pStru, 14, &hfFaceName, &nLen );
if( nLen > ( LF_FACESIZE - 1 ) )
nLen = LF_FACESIZE - 1;
memcpy( p->lfFaceName, pfFaceName, nLen * sizeof( TCHAR ) );
p->lfFaceName[ nLen ] = TEXT( '\0' );
hb_strfree( hfFaceName );
return p;
}
else if( bMandatory )
return p;
return NULL;
}
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_SIZE ulPCount, ... )
{
HB_THREAD_STUB
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %hu, ...)", pItem, ulPCount ) );
if( pItem )
{
PHB_SYMB pSymbol = NULL;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
pSymbol = pDynSym->pSymbol;
}
else if( HB_IS_POINTER( pItem ) )
pSymbol = ( PHB_SYMB ) pItem->item.asPointer.value;
else if( HB_IS_SYMBOL( pItem ) )
pSymbol = pItem->item.asSymbol.value;
if( pSymbol )
{
hb_vmPushState();
hb_vmPushSymbol( pSymbol );
hb_vmPushNil();
if( ulPCount )
{
register ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmDo( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
else if( HB_IS_BLOCK( pItem ) )
{
hb_vmPushState();
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pItem );
if( ulPCount )
{
register ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmSend( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
else if( HB_IS_ARRAY( pItem ) )
{
hb_vmPushState();
if( hb_execFromArray( pItem ) )
{
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
}
hb_vmPopState();
}
}
return pResult;
}
HB_BOOL hb_execFromArray( PHB_ITEM pParam )
{
PHB_ITEM pArray = NULL;
PHB_ITEM pSelf = NULL;
HB_ULONG ulParamOffset = 0;
if( pParam && HB_IS_ARRAY( pParam ) && ! HB_IS_OBJECT( pParam ) )
{
pArray = pParam;
pParam = hb_arrayGetItemPtr( pArray, 1 );
if( HB_IS_OBJECT( pParam ) )
{
pSelf = pParam;
pParam = hb_arrayGetItemPtr( pArray, 2 );
ulParamOffset = 2;
}
else
ulParamOffset = 1;
}
if( pParam )
{
PHB_SYMB pExecSym = NULL;
if( HB_IS_SYMBOL( pParam ) )
pExecSym = hb_itemGetSymbol( pParam );
else if( HB_IS_STRING( pParam ) )
pExecSym = hb_dynsymGet( hb_itemGetCPtr( pParam ) )->pSymbol;
else if( HB_IS_BLOCK( pParam ) && ! pSelf )
{
pSelf = pParam;
pExecSym = &hb_symEval;
}
if( pExecSym )
{
int iPCount = 0;
hb_vmPushSymbol( pExecSym );
if( pSelf )
hb_vmPush( pSelf );
else
hb_vmPushNil();
if( pArray )
{
pParam = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
while( pParam && iPCount < 255 )
{
hb_vmPush( pParam );
++iPCount;
pParam = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
}
}
if( pSelf )
hb_vmSend( ( HB_USHORT ) iPCount );
else
hb_vmProc( ( HB_USHORT ) iPCount );
return HB_TRUE;
}
}
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return HB_FALSE;
}
