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; }
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; }
PHB_REGEX hb_regexGet( PHB_ITEM pRegExItm, int iFlags ) { PHB_REGEX pRegEx = NULL; HB_BOOL fArgError = HB_TRUE; if( pRegExItm ) { if( HB_IS_POINTER( pRegExItm ) ) { pRegEx = ( PHB_REGEX ) hb_itemGetPtrGC( pRegExItm, &s_gcRegexFuncs ); if( pRegEx ) fArgError = HB_FALSE; } else if( HB_IS_STRING( pRegExItm ) ) { HB_SIZE nLen = hb_itemGetCLen( pRegExItm ); const char * szRegEx = hb_itemGetCPtr( pRegExItm ); if( nLen > 0 ) { fArgError = HB_FALSE; pRegEx = hb_regexCompile( szRegEx, nLen, iFlags ); } } } if( fArgError ) hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, 1, pRegExItm ); else if( ! pRegEx ) /* hb_regexCompile() failed */ hb_errRT_BASE_SubstR( EG_ARG, 3015, NULL, HB_ERR_FUNCNAME, 1, pRegExItm ); return pRegEx; }
static const char * hb_i18n_description( PHB_I18N_TRANS pI18N, PHB_ITEM pItem ) { if( pI18N ) { PHB_ITEM pKey = hb_itemPutCConst( NULL, "DESCRIPTION" ), pValue; pValue = hb_hashGetItemPtr( pI18N->table, pKey, 0 ); if( pItem ) { if( HB_IS_STRING( pItem ) ) { if( pValue ) hb_itemCopy( pValue, pItem ); else { hb_hashAdd( pI18N->table, pKey, pItem ); pValue = hb_hashGetItemPtr( pI18N->table, pKey, 0 ); } } } hb_itemRelease( pKey ); return hb_itemGetCPtr( pValue ); } return NULL; }
static PHB_I18N_TRANS hb_i18n_deserialize( PHB_ITEM pItem ) { PHB_I18N_TRANS pI18N = NULL; if( pItem && HB_IS_STRING( pItem ) ) { HB_SIZE nLen = hb_itemGetCLen( pItem ); const char * pBuffer = hb_itemGetCPtr( pItem ); if( nLen > HB_I18N_HEADER_SIZE && hb_i18n_headercheck( pBuffer, nLen ) ) { PHB_ITEM pTable; pBuffer += HB_I18N_HEADER_SIZE; nLen -= HB_I18N_HEADER_SIZE; pTable = hb_itemDeserialize( &pBuffer, &nLen ); if( pTable ) { pI18N = hb_i18n_initialize( pTable ); if( ! pI18N ) hb_itemRelease( pTable ); } } } return pI18N; }
char * hb_memvarGetStrValuePtr( char * szVarName, HB_SIZE * pnLen ) { PHB_DYNS pDynVar; char * szValue = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_memvarGetStrValuePtr(%s, %p)", szVarName, pnLen ) ); pDynVar = hb_memvarFindSymbol( szVarName, *pnLen ); if( pDynVar ) { /* there is dynamic symbol with the requested name - check if it is * a memvar variable */ PHB_ITEM pMemvar = hb_dynsymGetMemvar( pDynVar ); if( pMemvar ) { /* variable contains some data */ if( HB_IS_BYREF( pMemvar ) ) pMemvar = hb_itemUnRef( pMemvar ); if( HB_IS_STRING( pMemvar ) ) { szValue = pMemvar->item.asString.value; *pnLen = pMemvar->item.asString.length; } } } return szValue; }
static HB_BOOL hb_i18n_setpluralform( PHB_I18N_TRANS pI18N, PHB_ITEM pForm, HB_BOOL fBase ) { HB_BOOL fResult = HB_FALSE; if( pI18N && pForm ) { if( HB_IS_EVALITEM( pForm ) ) { if( fBase ) { if( pI18N->base_plural_block ) hb_itemCopy( pI18N->base_plural_block, pForm ); else pI18N->base_plural_block = hb_itemNew( pForm ); } else { if( pI18N->plural_block ) hb_itemCopy( pI18N->plural_block, pForm ); else pI18N->plural_block = hb_itemNew( pForm ); } fResult = HB_TRUE; } else if( HB_IS_STRING( pForm ) ) { int iForm = hb_i18n_pluralformfind( hb_itemGetCPtr( pForm ) ); if( iForm ) { const char * szKey; if( fBase ) { if( pI18N->base_plural_block ) { hb_itemRelease( pI18N->base_plural_block ); pI18N->base_plural_block = NULL; } pI18N->base_plural_form = iForm; szKey = "BASE_LANG"; } else { if( pI18N->plural_block ) { hb_itemRelease( pI18N->plural_block ); pI18N->plural_block = NULL; } pI18N->plural_form = iForm; szKey = "LANG"; } hb_i18n_setitem( pI18N->table, szKey, hb_i18n_pluralformid( iForm ) ); fResult = HB_TRUE; } } } return fResult; }
void hb_socekxParamsGetStd( PHB_ITEM pParams, const void ** pKeydata, int * pKeylen, const void ** pIV, int * pIVlen, int * pLevel, int * pStrategy ) { if( pParams && HB_IS_HASH( pParams ) ) { PHB_ITEM pItem; if( pKeydata && pKeylen && ( pItem = hb_hashGetCItemPtr( pParams, "key" ) ) != NULL && HB_IS_STRING( pItem ) ) { *pKeydata = hb_itemGetCPtr( pItem ); *pKeylen = ( int ) hb_itemGetCLen( pItem ); } else if( pKeydata && pKeylen && ( pItem = hb_hashGetCItemPtr( pParams, "pass" ) ) != NULL && HB_IS_STRING( pItem ) ) { *pKeydata = hb_itemGetCPtr( pItem ); *pKeylen = ( int ) hb_itemGetCLen( pItem ); } if( pIV && pIVlen && ( pItem = hb_hashGetCItemPtr( pParams, "iv" ) ) != NULL && HB_IS_STRING( pItem ) ) { *pIV = hb_itemGetCPtr( pItem ); *pIVlen = ( int ) hb_itemGetCLen( pItem ); } if( pLevel && ( pItem = hb_hashGetCItemPtr( pParams, "zlib" ) ) != NULL && HB_IS_NUMERIC( pItem ) ) *pLevel = hb_itemGetNI( pItem ); if( pStrategy && ( pItem = hb_hashGetCItemPtr( pParams, "zs" ) ) != NULL && HB_IS_NUMERIC( pItem ) ) *pStrategy = hb_itemGetNI( pItem ); } }
PHB_ITEM hb_evalLaunch( PHB_EVALINFO pEvalInfo ) { PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_evalLaunch(%p)", pEvalInfo ) ); if( pEvalInfo ) { PHB_ITEM pItem = pEvalInfo->pItems[ 0 ]; PHB_SYMB pSymbol = NULL; if( HB_IS_STRING( pItem ) ) { PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value ); if( pDynSym ) { pSymbol = pDynSym->pSymbol; pItem = NULL; } } else if( HB_IS_SYMBOL( pItem ) ) { pSymbol = pItem->item.asSymbol.value; pItem = NULL; } else if( HB_IS_BLOCK( pItem ) ) { pSymbol = &hb_symEval; } if( pSymbol ) { HB_USHORT uiParam = 0; hb_vmPushSymbol( pSymbol ); if( pItem ) hb_vmPush( pItem ); else hb_vmPushNil(); while( uiParam < pEvalInfo->paramCount ) hb_vmPush( pEvalInfo->pItems[ ++uiParam ] ); if( pItem ) hb_vmSend( uiParam ); else hb_vmProc( uiParam ); pResult = hb_itemNew( hb_stackReturnItem() ); } } return pResult; }
/* For C Calls 2003.05.08 */ WORD _sx_select( PHB_ITEM vParam ) { WORD iSelected = SX_DUMMY_NUMBER; if( HB_IS_NUMERIC( vParam ) ) iSelected = sx_Select( ( WORD ) HB_GETNI( vParam ) ); else if( HB_IS_STRING( vParam ) ) iSelected = sx_Select( sx_WorkArea( ( PBYTE ) HB_GETC( vParam ) ) ); if( iSelected == SX_DUMMY_NUMBER ) hb_errRT_DBCMD( EG_ARG, EDBCMD_NOALIAS, NULL, "_sx_select" ); return iSelected; }
/* * This function creates a value for memvar variable * * pMemvar - an item that stores the name of variable - it can be either * the HB_IT_SYMBOL (if created by PUBLIC statement) or HB_IT_STRING * (if created by direct call to __MVPUBLIC function) * iScope - the scope of created variable - if a variable with the same name * exists already then it's value is hidden by new variable with * passed scope * pValue - optional item used to initialize the value of created variable * or NULL * */ void hb_memvarCreateFromItem( PHB_ITEM pMemvar, int iScope, PHB_ITEM pValue ) { PHB_DYNS pDynVar = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_memvarCreateFromItem(%p, %d, %p)", pMemvar, iScope, pValue ) ); /* find dynamic symbol or creeate one */ if( HB_IS_SYMBOL( pMemvar ) ) /* pDynVar = hb_dynsymGet( pMemvar->item.asSymbol.value->szName ); */ pDynVar = pMemvar->item.asSymbol.value->pDynSym; else if( HB_IS_STRING( pMemvar ) ) pDynVar = hb_dynsymGet( pMemvar->item.asString.value ); if( pDynVar ) hb_memvarCreateFromDynSymbol( pDynVar, iScope, pValue ); else hb_errRT_BASE( EG_ARG, 3008, NULL, "&", HB_ERR_ARGS_BASEPARAMS ); }
PHB_ITEM hb_evalLaunch( PHB_EVALINFO pEvalInfo ) { HB_THREAD_STUB PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_evalLaunch(%p)", pEvalInfo ) ); if( pEvalInfo ) { register USHORT uiParam = 1; if( HB_IS_STRING( pEvalInfo->pItems[ 0 ] ) ) { const char * ptr = pEvalInfo->pItems[ 0 ]->item.asString.value; hb_vmPushSymbol( hb_dynsymFindName( ptr )->pSymbol ); hb_vmPushNil(); while( uiParam <= pEvalInfo->paramCount ) hb_vmPush( pEvalInfo->pItems[ uiParam++ ] ); hb_vmDo( pEvalInfo->paramCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); } else if( HB_IS_BLOCK( pEvalInfo->pItems[ 0 ] ) ) { hb_vmPushSymbol( &hb_symEval ); hb_vmPush( pEvalInfo->pItems[ 0 ] ); while( uiParam <= pEvalInfo->paramCount ) hb_vmPush( pEvalInfo->pItems[ uiParam++ ] ); hb_vmSend( pEvalInfo->paramCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); } } return pResult; }
static HB_ERRCODE sqlbasePutValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { LPFIELD pField; HB_ERRCODE errCode; if( uiIndex == 0 || uiIndex > pArea->area.uiFieldCount ) return HB_FAILURE; if( ! pArea->fPositioned ) return HB_SUCCESS; if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; errCode = HB_SUCCESS; pField = pArea->area.lpFields + ( uiIndex - 1 ); if( ( ( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) ) && ( pField->uiType == HB_FT_STRING || pField->uiType == HB_FT_MEMO ) ) || ( HB_IS_DATE( pItem ) && pField->uiType == HB_FT_DATE ) || ( HB_IS_TIMESTAMP( pItem ) && pField->uiType == HB_FT_TIMESTAMP ) || ( HB_IS_NUMBER( pItem ) && ( pField->uiType == HB_FT_INTEGER || pField->uiType == HB_FT_LONG || pField->uiType == HB_FT_FLOAT || pField->uiType == HB_FT_DOUBLE ) ) || ( HB_IS_LOGICAL( pItem ) && pField->uiType == HB_FT_LOGICAL ) || HB_IS_NIL( pItem ) ) { hb_arraySet( ( PHB_ITEM ) pArea->pRecord, uiIndex, pItem ); } else { PHB_ITEM pError; pError = hb_errNew(); hb_errPutGenCode( pError, EG_DATATYPE ); hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) ); hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) ); hb_errPutSubCode( pError, errCode ); hb_errPutFlags( pError, EF_CANDEFAULT ); errCode = SELF_ERROR( ( AREAP ) pArea, pError ); hb_itemRelease( pError ); return errCode == E_DEFAULT ? HB_SUCCESS : HB_FAILURE; } return HB_SUCCESS; }
/* * Retorna uma STRING de uma variavel caracter do xHarbour, criada via .PRG! Ela * retorna em pulLen o tamanho da string encontrada. * 01/07/2008 - 08:40:47 */ char *wxMemvarGetCPtr( char * szVarName, ULONG *pulLen ) { HB_THREAD_STUB HB_DYNS_PTR pDynVar; char *szValue = NULL; HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %p)", szVarName, pulLen)); #ifdef HB_THREAD_SUPPORT pDynVar = s_memvarThFindName( szVarName, &HB_VM_STACK ); #else pDynVar = hb_dynsymFindName( szVarName ); #endif if( pDynVar ) { /* there is dynamic symbol with the requested name - check if it is * a memvar variable */ if( pDynVar->hMemvar ) { /* variable contains some data */ HB_ITEM_PTR pItem = hb_memvarGetValueByHandle( pDynVar->hMemvar ); if( HB_IS_BYREF( pItem ) ) { pItem = hb_itemUnRef( pItem ); /* it is a PARAMETER variable */ } if( HB_IS_STRING( pItem ) ) { szValue = pItem->item.asString.value; *pulLen = pItem->item.asString.length; } } } return szValue; }
/* This function releases all memory occupied by a memvar variable * It also restores the value that was hidden if there is another * PRIVATE variable with the same name. */ static void hb_memvarRelease( PHB_ITEM pMemvar ) { HB_TRACE( HB_TR_DEBUG, ( "hb_memvarRelease(%p)", pMemvar ) ); if( HB_IS_STRING( pMemvar ) ) { PHB_DYNS pDynSymbol = hb_memvarFindSymbol( pMemvar->item.asString.value, pMemvar->item.asString.length ); if( pDynSymbol && hb_dynsymGetMemvar( pDynSymbol ) ) { HB_STACK_TLS_PRELOAD HB_SIZE nBase = hb_stackGetPrivateStack()->count; /* Find the variable with a requested name that is currently visible * Start from the top of the stack. */ while( nBase > 0 ) { if( pDynSymbol == hb_stackGetPrivateStack()->stack[ --nBase ].pDynSym ) { /* reset current value to NIL - the overriden variables will be * visible after exit from current procedure */ pMemvar = hb_dynsymGetMemvar( pDynSymbol ); if( pMemvar ) hb_itemClear( pMemvar ); return; } } /* No match found for PRIVATEs - it's PUBLIC so let's remove it. */ hb_memvarDetachDynSym( pDynSymbol, NULL ); } } else hb_errRT_BASE( EG_ARG, 3008, NULL, "RELEASE", HB_ERR_ARGS_BASEPARAMS ); }
/* --- SDD METHODS --- */ static HB_ERRCODE mysqlConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { MYSQL * pMySql; PHB_ITEM pItemUnixSocket = hb_arrayGetItemPtr( pItem, 7 ); pMySql = mysql_init( NULL ); if( ! mysql_real_connect( pMySql, hb_arrayGetCPtr( pItem, 2 ) /* host */, hb_arrayGetCPtr( pItem, 3 ) /* user */, hb_arrayGetCPtr( pItem, 4 ) /* password */, hb_arrayGetCPtr( pItem, 5 ) /* db */, hb_arrayGetNI( pItem, 6 ) /* port */, pItemUnixSocket && HB_IS_STRING( pItemUnixSocket ) ? hb_itemGetCPtr( pItemUnixSocket ) : NULL, hb_arrayGetNI( pItem, 8 ) /* flags*/ ) ) { hb_rddsqlSetError( mysql_errno( pMySql ), mysql_error( pMySql ), NULL, NULL, 0 ); mysql_close( pMySql ); return HB_FAILURE; } pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); ( ( SDDCONN * ) pConnection->pSDDConn )->pMySql = pMySql; return HB_SUCCESS; }
static const char * _hb_jsonDecode( const char * szSource, PHB_ITEM pValue ) { if( *szSource == '\"' ) { char * szDest, * szHead; HB_SIZE nAlloc = 16; szHead = szDest = ( char * ) hb_xgrab( nAlloc ); szSource++; while( *szSource != '\"' ) { if( szHead + 6 >= szDest + nAlloc ) { HB_SIZE nLen = szHead - szDest; nAlloc += nAlloc << 1; szDest = ( char * ) hb_xrealloc( szDest, nAlloc ); szHead = szDest + nLen; } if( *szSource == '\\' ) { szSource++; switch( *szSource ) { case '\"': *szHead++ = '\"'; break; case '\\': *szHead++ = '\\'; break; case '/': *szHead++ = '/'; break; case 'b': *szHead++ = '\b'; break; case 'f': *szHead++ = '\f'; break; case 'n': *szHead++ = '\n'; break; case 'r': *szHead++ = '\r'; break; case 't': *szHead++ = '\t'; break; case 'u': { HB_WCHAR wc = 0; int i; for( i = 0; i < 4; i++ ) { char c = *++szSource; wc <<= 4; if( c >= '0' && c <= '9' ) wc += c - '0'; else if( c >= 'A' && c <= 'F' ) wc += c - 'A' + 10; else if( c >= 'a' && c <= 'f' ) wc += c - 'a' + 10; else { hb_xfree( szDest ); return NULL; } } szHead += hb_cdpU16ToStr( hb_vmCDP(), HB_CDP_ENDIAN_NATIVE, &wc, 1, szHead, szDest + nAlloc - szHead ); break; } default: hb_xfree( szDest ); return NULL; } szSource++; } else if( *( const unsigned char * ) szSource >= ' ' ) *szHead++ = *szSource++; else { hb_xfree( szDest ); return NULL; } } hb_itemPutCL( pValue, szDest, szHead - szDest ); hb_xfree( szDest ); return szSource + 1; } else if( *szSource == '-' || ( *szSource >= '0' && *szSource <= '9' ) ) { /* NOTE: this function is much less strict to number format than JSON syntax definition. This is allowed behaviour [Mindaugas] */ HB_MAXINT nValue = 0; double dblValue = 0; HB_BOOL fNeg, fDbl = HB_FALSE; int iDec = 0; fNeg = *szSource == '-'; if( fNeg ) szSource++; while( *szSource >= '0' && *szSource <= '9' ) { nValue = nValue * 10 + *szSource - '0'; szSource++; } if( *szSource == '.' ) { double mult = 1; dblValue = ( double ) nValue; fDbl = HB_TRUE; szSource++; while( *szSource >= '0' && *szSource <= '9' ) { mult /= 10; dblValue += ( ( double ) ( *szSource - '0' ) ) * mult; szSource++; iDec++; } } if( *szSource == 'e' || *szSource == 'E' ) { HB_BOOL fNegExp; int iExp = 0; szSource++; fNegExp = *szSource == '-'; if( fNegExp ) szSource++; while( *szSource >= '0' && *szSource <= '9' ) { iExp = iExp * 10 + *szSource - '0'; szSource++; } if( ! fDbl ) { dblValue = ( double ) nValue; fDbl = HB_TRUE; } if( fNegExp ) iDec += iExp; dblValue = hb_numExpConv( dblValue, fNegExp ? iExp : -iExp ); } if( fDbl ) hb_itemPutNDDec( pValue, hb_numRound( fNeg ? -dblValue : dblValue, iDec ), iDec ); else hb_itemPutNInt( pValue, fNeg ? -nValue : nValue ); return szSource; } else if( ! strncmp( szSource, "null", 4 ) ) { hb_itemClear( pValue ); return szSource + 4; } else if( ! strncmp( szSource, "true", 4 ) ) { hb_itemPutL( pValue, HB_TRUE ); return szSource + 4; } else if( ! strncmp( szSource, "false", 5 ) ) { hb_itemPutL( pValue, HB_FALSE ); return szSource + 5; } else if( *szSource == '[' ) { hb_arrayNew( pValue, 0 ); szSource = _skipws( szSource + 1 ); if( *szSource != ']' ) { PHB_ITEM pItem = hb_itemNew( NULL ); for( ;; ) { szSource = _hb_jsonDecode( szSource, pItem ); if( ! szSource ) { hb_itemRelease( pItem ); return NULL; } hb_arrayAddForward( pValue, pItem ); szSource = _skipws( szSource ); if( *szSource == ',' ) { szSource = _skipws( szSource + 1 ); continue; } else if( *szSource == ']' ) break; else { hb_itemRelease( pItem ); return NULL; } } hb_itemRelease( pItem ); } return szSource + 1; } else if( *szSource == '{' ) { hb_hashNew( pValue ); szSource = _skipws( szSource + 1 ); if( *szSource != '}' ) { PHB_ITEM pItemKey = hb_itemNew( NULL ); PHB_ITEM pItemValue = hb_itemNew( NULL ); for( ;; ) { /* Do we need to check if key does not exist yet? */ if( ( szSource = _hb_jsonDecode( szSource, pItemKey ) ) == NULL || ! HB_IS_STRING( pItemKey ) || * ( szSource = _skipws( szSource ) ) != ':' || ( szSource = _hb_jsonDecode( _skipws( szSource + 1 ), pItemValue ) ) == NULL) { hb_itemRelease( pItemKey ); hb_itemRelease( pItemValue ); return NULL; } hb_hashAdd( pValue, pItemKey, pItemValue ); szSource = _skipws( szSource ); if( *szSource == ',' ) { szSource = _skipws( szSource + 1 ); continue; } else if( *szSource == '}' ) break; else { hb_itemRelease( pItemKey ); hb_itemRelease( pItemValue ); return NULL; } } hb_itemRelease( pItemKey ); hb_itemRelease( pItemValue ); } return szSource + 1; } return NULL; }
static HB_ERRCODE adsxOrderInfo( ADSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERINFO pOrderInfo ) { PMIXTAG pTag = pArea->pTagCurrent; /* resolve any pending relations */ if( pArea->adsarea.lpdbPendingRel ) SELF_FORCEREL( ( AREAP ) pArea ); /* all others need an index handle */ if( uiIndex != DBOI_ORDERCOUNT ) { if( pOrderInfo->itmOrder ) { if( HB_IS_STRING( pOrderInfo->itmOrder ) ) { pTag = pArea->pTagList; while( pTag ) { if( ! hb_stricmp( hb_itemGetCPtr( pOrderInfo->itmOrder ), pTag->szName ) ) break; pTag = pTag->pNext; } } else if( HB_IS_NUMERIC( pOrderInfo->itmOrder ) ) { UNSIGNED16 usOrder = 0, usSearch = ( UNSIGNED16 ) hb_itemGetNI( pOrderInfo->itmOrder ); AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder ); pTag = usSearch <= usOrder ? NULL : pArea->pTagList; while( pTag ) { if( ++usOrder == usSearch ) break; pTag = pTag->pNext; } } } if( ! pTag ) return SUPER_ORDINFO( ( AREAP ) pArea, uiIndex, pOrderInfo ); } switch( uiIndex ) { case DBOI_CONDITION: hb_itemPutC( pOrderInfo->itmResult, pTag->szForExpr ); break; case DBOI_EXPRESSION: hb_itemPutC( pOrderInfo->itmResult, pTag->szKeyExpr ); break; case DBOI_ISCOND: hb_itemPutL( pOrderInfo->itmResult, pTag->pForItem != NULL ); break; case DBOI_ISDESC: hb_itemPutL( pOrderInfo->itmResult, HB_FALSE ); break; case DBOI_UNIQUE: hb_itemPutL( pOrderInfo->itmResult, HB_FALSE ); break; case DBOI_KEYTYPE: hb_itemPutCL( pOrderInfo->itmResult, ( char * ) &pTag->bType, 1 ); break; case DBOI_KEYSIZE: hb_itemPutNI( pOrderInfo->itmResult, pTag->uiLen ); break; case DBOI_KEYVAL: { PHB_ITEM pItem; PHB_CODEPAGE pCodepage = hb_cdpSelect( pArea->adsarea.area.cdPage ); pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem ); hb_cdpSelect( pCodepage ); hb_itemMove( pOrderInfo->itmResult, pItem ); break; } case DBOI_KEYCOUNT: case DBOI_KEYCOUNTRAW: /* ignore filter but RESPECT SCOPE */ hb_itemPutNL( pOrderInfo->itmResult, pTag->ulRecCount ); break; case DBOI_POSITION: case DBOI_RECNO: case DBOI_KEYNORAW: if( uiIndex == DBOI_POSITION && pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) ) { HB_ULONG ulPos; ulPos = hb_itemGetNL( pOrderInfo->itmNewVal ); if( ulPos > 0 && ulPos <= pTag->ulRecCount ) SELF_GOTO( ( AREAP ) pArea, pTag->pKeys[ ulPos - 1 ]->rec ); pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, ! pArea->adsarea.area.fEof ); } else { PMIXKEY pKey; HB_ULONG ulKeyPos; if( ! pArea->adsarea.fPositioned ) SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo ); else pArea->adsarea.area.fEof = HB_FALSE; pKey = mixKeyEval( pTag, pArea ); hb_itemPutNL( pOrderInfo->itmResult, mixFindKey( pTag, pKey, &ulKeyPos ) ? ( ulKeyPos + 1 ) : 0 ); mixKeyFree( pKey ); } break; case DBOI_RELKEYPOS: if( pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) ) { HB_ULONG ulPos; ulPos = ( HB_ULONG ) ( hb_itemGetND( pOrderInfo->itmNewVal ) * ( double ) pTag->ulRecCount ); if( ulPos > 0 && ulPos <= pTag->ulRecCount ) SELF_GOTO( ( AREAP ) pArea, pTag->pKeys[ ulPos - 1 ]->rec ); pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, ! pArea->adsarea.area.fEof ); } else { PMIXKEY pKey; HB_ULONG ulKeyPos; if( ! pArea->adsarea.fPositioned ) SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo ); else pArea->adsarea.area.fEof = HB_FALSE; pKey = mixKeyEval( pTag, pArea ); if( ! mixFindKey( pTag, pKey, &ulKeyPos + 1 ) ) ulKeyPos = 0; mixKeyFree( pKey ); pOrderInfo->itmResult = hb_itemPutND( pOrderInfo->itmResult, ( double ) ulKeyPos / ( double ) pTag->ulRecCount ); } break; case DBOI_NAME: hb_itemPutC( pOrderInfo->itmResult, pTag->szName ); break; case DBOI_BAGNAME: hb_itemPutC( pOrderInfo->itmResult, NULL ); break; case DBOI_FULLPATH: hb_itemPutC( pOrderInfo->itmResult, NULL ); break; case DBOI_BAGEXT: hb_itemPutC( pOrderInfo->itmResult, "mix" ); break; case DBOI_ORDERCOUNT: { UNSIGNED16 usOrder = 0; AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder ); pTag = pArea->pTagList; while( pTag ) { pTag = pTag->pNext; usOrder++; } hb_itemPutNI( pOrderInfo->itmResult, ( int ) usOrder ); break; } case DBOI_NUMBER: { PMIXTAG pTag2; UNSIGNED16 usOrder = 0; AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder ); pTag2 = pArea->pTagList; usOrder++; while( pTag2 && pTag != pTag2 ) { pTag2 = pTag2->pNext; usOrder++; } hb_itemPutNI( pOrderInfo->itmResult, ( int ) usOrder ); break; } case DBOI_CUSTOM: hb_itemPutL( pOrderInfo->itmResult, HB_FALSE ); break; case DBOI_OPTLEVEL: hb_itemPutNI( pOrderInfo->itmResult, DBOI_OPTIMIZED_NONE ); break; case DBOI_KEYADD: hb_itemPutL( pOrderInfo->itmResult, HB_FALSE ); break; case DBOI_KEYDELETE: hb_itemPutL( pOrderInfo->itmResult, HB_FALSE ); break; case DBOI_AUTOOPEN: hb_itemPutL( pOrderInfo->itmResult, HB_FALSE ); break; default: return SUPER_ORDINFO( ( AREAP ) pArea, uiIndex, pOrderInfo ); } return HB_SUCCESS; }
// 26/07/2008 - 11:32:47 static void printf_add_conv( PPrintInfo pInfo, PHB_ITEM pItem ) { char flag = 0; int width = 0; int precision = 0; char specifier = '\0'; char m = '\0'; char c; char mask[20]; const char *t1; const char *t2; char * cValue; double dValue; ULONG Length; /* * Procura por uma string de conversao com o formato: * 0 1 2 3 4 * %[flags][width][.precision][length]specifier * */ t1 = pInfo->Mask; mask[0] = '\0'; pInfo->Mask ++; pInfo->msk_len--; /* * Se nao tem nenhum item de argumento, e o proximo caracter de escape nao for * o "%", entao temos que abortar a rotina... indicando erro de argumento! */ if (pInfo->msk_len && // pInfo->Mask[0] != '%' && !pItem) { pInfo->error = FAILURE; return; } /* processamos a string como um todo */ while (pInfo->error == NONE && pInfo->msk_len && pInfo->Mask[0] ) { c = pInfo->Mask[0]; // setou o flag? if (strchr( "-+ #0", c )) { flag = c; c = 'A'; } // setar o width? if (strchr( "1234567890", c )) { char *t = (char *) hb_xgrab(15); char *s = t; do { *t = c; t++; pInfo->Mask ++; pInfo->msk_len--; c = pInfo->Mask[0]; } while (pInfo->msk_len && strchr( "1234567890", c )); *t = '\0'; width = atoi( s ); hb_xfree(s); } // setar precision? if (c == '.') { char *t = (char *) hb_xgrab(15); char *s = t; pInfo->Mask ++; pInfo->msk_len--; c = pInfo->Mask[0]; while (pInfo->msk_len && strchr( "1234567890", c )) { *t = c; t++; pInfo->Mask ++; pInfo->msk_len--; c = pInfo->Mask[0]; } *t = '\0'; precision = atoi( s ); hb_xfree(s); c = pInfo->Mask[0]; } if (c == 'l' && strchr( "idouxX", pInfo->Mask[1] )) m = c; if (c == 'h' && strchr( "idouxX", pInfo->Mask[1] )) m = c; if (c == 'L' && strchr( "eEfgG", pInfo->Mask[1] )) m = c; // Chegou no tipo? if (strchr( "cdieEfgGosuxXpn%", c )) { specifier = c; pInfo->Mask ++; pInfo->msk_len--; t2 = pInfo->Mask; switch( specifier ) { case '%': { printf_add_str( pInfo, "%", 1L ); break; } case 'c': // O argumento é tratado como um inteiro, e mostrado como o caractere ASCII correspondente. { char s[2]; memset( s, 0, 2 ); if (HB_IS_STRING( pItem )) { const char *t = hb_itemGetCPtr( pItem ); s[0] = ((t) ? t[0] : 0); } else if( HB_IS_NUMERIC( pItem ) ) { s[0] = (char) hb_itemGetNI( pItem ); } printf_add_str( pInfo, s, 1L ); break; } case 's': { Length = t2-t1; width = max( hb_itemGetCLen( pItem ), (ULONG) width ); cValue = (char *) hb_xgrab( width + 1 ); memmove( mask, t1, Length ); mask[Length] = '\0'; cValue[0] = '\0'; Length = sprintf( cValue, mask, hb_itemGetCPtr( pItem ) ); printf_add_str( pInfo, cValue, Length ); hb_xfree( cValue ); break; } case 'p': { char s[9]; s[0] = '\0'; sprintf( s, "%p", hb_itemGetPtr( pItem ) ); printf_add_str( pInfo, s, 8); break; } /* * Separamos aqui as operações sobre inteiros */ case 'i': case 'd': // O argumento é tratado como um INTEIRO, e mostrado como um número decimal com sinal. case 'o': // O argumento é tratado com um INTEIRO, e mostrado como un número octal. case 'u': // O argumento é tratado com um INTEIRO, e mostrado como um número decimal sem sinal. case 'x': // O argumento é tratado como um INTEIRO, e mostrado como um número hexadecimal (com as letras minúsculas). case 'X': // O argumento é tratado como um INTEIRO, e mostrado como um número hexadecimal (com as letras maiúsculas). { Length = t2-t1; width = ((width) ? width : 32 ); cValue = (char *) hb_xgrab( width + 1 ); memmove( mask, t1, Length ); mask[Length] = '\0'; cValue[0] = '\0'; if (m == '\0') Length = sprintf( cValue, mask, (int) hb_itemGetNI( pItem )); if (m == 'l') Length = sprintf( cValue, mask, (LONG) hb_itemGetNL( pItem )); // como LONG ??? if (m == 'h') Length = sprintf( cValue, mask, (LONG) hb_itemGetNL( pItem )); // como LONG ??? printf_add_str( pInfo, cValue, Length ); hb_xfree( cValue ); break; } /* * Separamos aqui as operações com numeros flutuantes */ case 'e' : // O argumento é tratado como notação científica (e.g. 1.2e+2). case 'E' : // O argumento é tratado como notação científica (e.g. 1.2e+2). case 'f' : // O argumento é tratado como um float, e mostrado como um número de ponto flutuante. case 'F' : // O argumento é tratado como um float, e mostrado como um número de ponto flutuante. { Length = t2-t1; width = ((width) ? width : 64 ); dValue = (double) hb_itemGetND( pItem ); // converting double --> float ??? cValue = (char *) hb_xgrab( width + 1 ); memmove( mask, t1, Length ); mask[Length] = '\0'; sprintf( cValue, mask, dValue ); printf_add_str( pInfo, cValue, strlen( cValue ) ); hb_xfree( cValue ); break; } default: break; } break; } else { pInfo->Mask ++; pInfo->msk_len--; } } }
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 ); } }
/* * Assign a value to a field. */ static HB_ERRCODE hb_delimPutValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem ) { char szBuffer[ 256 ]; HB_ERRCODE uiError; LPFIELD pField; USHORT uiSize; HB_TRACE(HB_TR_DEBUG, ("hb_delimPutValue(%p,%hu,%p)", pArea, uiIndex, pItem)); if( !pArea->fPositioned ) return HB_SUCCESS; if( !pArea->fRecordChanged ) return HB_FAILURE; uiError = HB_SUCCESS; --uiIndex; pField = pArea->lpFields + uiIndex; if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE ) { if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) ) { if( pField->uiType == HB_FT_STRING ) { uiSize = ( USHORT ) hb_itemGetCLen( pItem ); if( uiSize > pField->uiLen ) uiSize = pField->uiLen; memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_itemGetCPtr( pItem ), uiSize ); #ifndef HB_CDP_SUPPORT_OFF hb_cdpnTranslate( (char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_cdppage(), pArea->cdPage, uiSize ); #endif memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + uiSize, ' ', pField->uiLen - uiSize ); } else uiError = EDBF_DATATYPE; } else if( HB_IS_DATE( pItem ) ) { if( pField->uiType == HB_FT_DATE ) { hb_itemGetDS( pItem, szBuffer ); memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 ); } else uiError = EDBF_DATATYPE; } else if( HB_IS_NUMBER( pItem ) ) { if( pField->uiType == HB_FT_LONG ) { if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) ) { memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, pField->uiLen ); } else { uiError = EDBF_DATAWIDTH; memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], '*', pField->uiLen ); } } else uiError = EDBF_DATATYPE; } else if( HB_IS_LOGICAL( pItem ) ) { if( pField->uiType == HB_FT_LOGICAL ) pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F'; else uiError = EDBF_DATATYPE; } else uiError = EDBF_DATATYPE; } if( uiError != HB_SUCCESS ) { PHB_ITEM pError= hb_errNew(); USHORT uiGenCode = uiError == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE; hb_errPutGenCode( pError, uiGenCode ); hb_errPutDescription( pError, hb_langDGetErrorDesc( uiGenCode ) ); hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) ); hb_errPutSubCode( pError, uiError ); hb_errPutFlags( pError, EF_CANDEFAULT ); uiError = SELF_ERROR( ( AREAP ) pArea, pError ); hb_itemRelease( pError ); return uiError == E_DEFAULT ? HB_SUCCESS : HB_FAILURE; } return HB_SUCCESS; }
static void s_xhb_bitOper( int iOper ) { PHB_ITEM pItem1 = hb_param( 1, HB_IT_ANY ), pItem2 = hb_param( 2, HB_IT_ANY ); HB_SIZE nLen1 = hb_itemGetCLen( pItem1 ), nLen2 = hb_itemGetCLen( pItem2 ); if( pItem1 && pItem2 ) { if( HB_IS_NUMERIC( pItem1 ) && ( HB_IS_NUMERIC( pItem2 ) || nLen2 == 1 ) ) { HB_MAXINT nVal1 = hb_itemGetNInt( pItem1 ), nVal2 = nLen2 == 1 ? ( HB_BYTE ) hb_itemGetCPtr( pItem1 )[ 0 ] : hb_itemGetNInt( pItem2 ); switch( iOper ) { case XHB_AND: nVal1 &= nVal2; break; case XHB_OR: nVal1 |= nVal2; break; default: /* XHB_XOR */ nVal1 ^= nVal2; break; } hb_retnint( nVal1 ); return; } if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) ) { if( ( nLen1 | nLen2 ) != 0 ) { const char * pStr1 = hb_itemGetCPtr( pItem1 ), * pStr2 = hb_itemGetCPtr( pItem2 ); char * pRet = ( char * ) hb_xmemdup( pStr1, nLen1 + 1 ); HB_SIZE n1, n2; switch( iOper ) { case XHB_AND: for( n1 = n2 = 0; n1 < nLen1; n1++ ) { pRet[ n1 ] &= pStr2[ n2 ]; if( ++n2 == nLen2 ) n2 = 0; } break; case XHB_OR: for( n1 = n2 = 0; n1 < nLen1; n1++ ) { pRet[ n1 ] |= pStr2[ n2 ]; if( ++n2 == nLen2 ) n2 = 0; } break; default: /* XHB_XOR */ for( n1 = n2 = 0; n1 < nLen1; n1++ ) { pRet[ n1 ] ^= pStr2[ n2 ]; if( ++n2 == nLen2 ) n2 = 0; } break; } hb_retclen_buffer( pRet, nLen1 ); } else hb_itemReturn( pItem1 ); return; } if( HB_IS_STRING( pItem1 ) && ( HB_IS_NUMERIC( pItem2 ) || nLen2 == 1 ) ) { if( nLen1 ) { const char * pStr = hb_itemGetCPtr( pItem1 ); char * pRet = ( char * ) hb_xmemdup( pStr, nLen1 + 1 ); char cVal = nLen2 == 1 ? hb_itemGetCPtr( pItem2 )[ 0 ] : ( char ) hb_itemGetNI( pItem2 ); nLen2 = nLen1; switch( iOper ) { case XHB_AND: while( nLen2-- ) pRet[ nLen2 ] &= cVal; break; case XHB_OR: while( nLen2-- ) pRet[ nLen2 ] |= cVal; break; default: /* XHB_XOR */ while( nLen2-- ) pRet[ nLen2 ] ^= cVal; break; } hb_retclen_buffer( pRet, nLen1 ); } else hb_itemReturn( pItem1 ); return; } if( ( HB_IS_NUMERIC( pItem1 ) || nLen1 == 1 ) && HB_IS_STRING( pItem2 ) ) { const char * pStr = hb_itemGetCPtr( pItem2 ); int iVal = nLen1 == 1 ? hb_itemGetCPtr( pItem1 )[ 0 ] : hb_itemGetNI( pItem1 ); switch( iOper ) { case XHB_AND: while( nLen2 ) iVal &= ( HB_UCHAR ) pStr[ --nLen2 ]; break; case XHB_OR: while( nLen2 ) iVal |= ( HB_UCHAR ) pStr[ --nLen2 ]; break; default: /* XHB_XOR */ while( nLen2 ) iVal ^= ( HB_UCHAR ) pStr[ --nLen2 ]; break; } hb_retni( iVal ); return; } } hb_errRT_BASE_SubstR( EG_ARG, 1088, NULL, iOper == XHB_AND ? "&" : ( iOper == XHB_OR ? "|" : "^^" ), 2, pItem1, pItem2 ); }
/* * Assign a value to a field. */ static HB_ERRCODE hb_sdfPutValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { char szBuffer[ 256 ]; HB_ERRCODE errCode; LPFIELD pField; HB_SIZE nSize; HB_TRACE( HB_TR_DEBUG, ( "hb_sdfPutValue(%p,%hu,%p)", pArea, uiIndex, pItem ) ); if( ! pArea->fPositioned ) return HB_SUCCESS; if( ! pArea->fRecordChanged ) return HB_FAILURE; if( --uiIndex >= pArea->area.uiFieldCount ) return HB_FAILURE; errCode = HB_SUCCESS; pField = pArea->area.lpFields + uiIndex; if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE ) { if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) ) { if( pField->uiType == HB_FT_STRING ) { if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) { nSize = pField->uiLen; hb_cdpnDup2( hb_itemGetCPtr( pItem ), hb_itemGetCLen( pItem ), ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], &nSize, hb_vmCDP(), pArea->area.cdPage ); } else { nSize = hb_itemGetCLen( pItem ); if( nSize > ( HB_SIZE ) pField->uiLen ) nSize = pField->uiLen; memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_itemGetCPtr( pItem ), nSize ); } if( nSize < ( HB_SIZE ) pField->uiLen ) memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + nSize, ' ', pField->uiLen - nSize ); } else errCode = EDBF_DATATYPE; } else if( HB_IS_DATETIME( pItem ) ) { if( pField->uiType == HB_FT_DATE ) { hb_itemGetDS( pItem, szBuffer ); memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 ); } else if( pField->uiType == HB_FT_TIMESTAMP && ( pField->uiLen == 12 || pField->uiLen == 23 ) ) { long lDate, lTime; hb_itemGetTDT( pItem, &lDate, &lTime ); if( pField->uiLen == 12 ) hb_timeStr( szBuffer, lTime ); else hb_timeStampStr( szBuffer, lDate, lTime ); memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, pField->uiLen ); } else errCode = EDBF_DATATYPE; } else if( HB_IS_NUMBER( pItem ) ) { if( pField->uiType == HB_FT_LONG ) { if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) ) { memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, pField->uiLen ); } else { errCode = EDBF_DATAWIDTH; memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], '*', pField->uiLen ); } } else errCode = EDBF_DATATYPE; } else if( HB_IS_LOGICAL( pItem ) ) { if( pField->uiType == HB_FT_LOGICAL ) pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F'; else errCode = EDBF_DATATYPE; } else errCode = EDBF_DATATYPE; } if( errCode != HB_SUCCESS ) { PHB_ITEM pError = hb_errNew(); HB_ERRCODE errGenCode = errCode == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE; hb_errPutGenCode( pError, errGenCode ); hb_errPutDescription( pError, hb_langDGetErrorDesc( errGenCode ) ); hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) ); hb_errPutSubCode( pError, errCode ); hb_errPutFlags( pError, EF_CANDEFAULT ); errCode = SELF_ERROR( &pArea->area, pError ); hb_itemRelease( pError ); return errCode == E_DEFAULT ? HB_SUCCESS : HB_FAILURE; } return HB_SUCCESS; }
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_ULONG ulPCount, ... ) { PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %lu, ...)", 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; pItem = NULL; } } else if( HB_IS_SYMBOL( pItem ) ) { pSymbol = pItem->item.asSymbol.value; pItem = NULL; } else if( HB_IS_BLOCK( pItem ) ) { pSymbol = &hb_symEval; } if( pSymbol ) { if( hb_vmRequestReenter() ) { hb_vmPushSymbol( pSymbol ); if( pItem ) hb_vmPush( pItem ); else hb_vmPushNil(); if( ulPCount ) { HB_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 ); } if( pItem ) hb_vmSend( ( HB_USHORT ) ulPCount ); else hb_vmProc( ( HB_USHORT ) ulPCount ); pResult = hb_itemNew( hb_stackReturnItem() ); hb_vmRequestRestore(); } } } return pResult; }
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 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 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; }
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; }