int hb_dynsymToNum( PHB_DYNS pDynSym )
{
int iSymNum;
HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymToNum(%p)", pDynSym ) );
HB_DYNSYM_LOCK();
iSymNum = pDynSym->uiSymNum;
if( iSymNum > s_iDynIdxSize )
{
s_pDynIndex = ( PDYNHB_ITEM )
hb_xrealloc( s_pDynIndex, iSymNum * sizeof( DYNHB_ITEM ) );
memset( &s_pDynIndex[ s_iDynIdxSize ], 0, ( iSymNum - s_iDynIdxSize ) *
sizeof( DYNHB_ITEM ) );
s_iDynIdxSize = iSymNum;
}
if( s_pDynIndex[ iSymNum - 1 ].pDynSym == NULL )
s_pDynIndex[ iSymNum - 1 ].pDynSym = pDynSym;
HB_DYNSYM_UNLOCK();
return iSymNum;
}
HB_BYTE * hb_fileLoadData( PHB_FILE pFile, HB_SIZE nMaxSize,
HB_SIZE * pnSize )
{
HB_BYTE * pFileBuf = NULL;
HB_SIZE nSize = 0, nRead, nBufSize;
HB_FOFFSET nFileSize = hb_fileSize( pFile );
if( nFileSize == FS_ERROR ||
( nFileSize == 0 && hb_fsError() == HB_FILE_ERR_UNSUPPORTED ) )
{
for( nBufSize = 0;; )
{
if( nBufSize == nSize )
{
nBufSize += nBufSize == 0 ? HB_FILELOAD_BUFFERSIZE : nBufSize >> 1;
if( nMaxSize > 0 && nBufSize > nMaxSize )
{
nBufSize = nMaxSize;
if( nBufSize == nSize )
break;
}
pFileBuf = ( HB_BYTE * ) hb_xrealloc( pFileBuf, nBufSize );
}
nRead = hb_fileRead( pFile, pFileBuf + nSize, nBufSize - nSize, -1 );
if( nRead == 0 || nRead == ( HB_SIZE ) FS_ERROR )
break;
nSize += nRead;
}
}
static void hb_gt_std_Refresh( PHB_GT pGT )
{
int iHeight, iWidth;
PHB_GTSTD pGTSTD;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Refresh(%p)", pGT ) );
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
pGTSTD = HB_GTSTD_GET( pGT );
if( pGTSTD->iLineBufSize == 0 )
{
pGTSTD->sLineBuf = ( BYTE * ) hb_xgrab( iWidth );
pGTSTD->iLineBufSize = iWidth;
}
else if( pGTSTD->iLineBufSize != iWidth )
{
pGTSTD->sLineBuf = ( BYTE * ) hb_xrealloc( pGTSTD->sLineBuf, iWidth );
pGTSTD->iLineBufSize = iWidth;
}
pGTSTD->fFullRedraw = FALSE;
HB_GTSUPER_REFRESH( pGT );
if( pGTSTD->fFullRedraw )
{
int i;
if( pGTSTD->iRow < iHeight - 1 )
{
for( i = pGTSTD->iRow + 1; i < iHeight; ++i )
hb_gt_std_DispLine( pGT, i );
}
}
}
static v_param * va_arg_get( int iArg, v_paramlst * plst, int iType )
{
if( plst->maxarg == 0 )
{
plst->repeat = HB_TRUE;
memset( plst->arglst, 0, plst->size * sizeof( v_param ) );
}
if( plst->repeat )
{
if( iArg > plst->maxarg )
plst->maxarg = iArg;
if( iArg > plst->size )
{
int prev_size = plst->size;
plst->size = iArg + _ARGBUF_ALLOC;
if( prev_size == _ARGBUF_SIZE )
plst->arglst = ( v_param * ) memcpy( hb_xgrab( plst->size * sizeof( v_param ) ),
plst->arglst, _ARGBUF_SIZE * sizeof( v_param ) );
else
plst->arglst = ( v_param * ) hb_xrealloc( plst->arglst, plst->size * sizeof( v_param ) );
memset( &plst->arglst[ prev_size ], 0, ( plst->size - prev_size ) *
sizeof( v_param ) );
}
plst->arglst[ iArg - 1 ].id = iType;
}
return &plst->arglst[ iArg - 1 ];
}
static void hb_gt_std_Refresh( PHB_GT pGT )
{
int iHeight, iSize;
PHB_GTSTD pGTSTD;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Refresh(%p)", pGT ) );
pGTSTD = HB_GTSTD_GET( pGT );
HB_GTSELF_GETSIZE( pGT, &iHeight, &pGTSTD->iWidth );
iSize = pGTSTD->iWidth * HB_MAX_CHAR_LEN;
if( pGTSTD->iLineBufSize != iSize )
{
pGTSTD->sLineBuf = ( char * ) hb_xrealloc( pGTSTD->sLineBuf, iSize );
pGTSTD->iLineBufSize = iSize;
}
pGTSTD->fFullRedraw = HB_FALSE;
HB_GTSUPER_REFRESH( pGT );
if( pGTSTD->fFullRedraw )
{
int i;
if( pGTSTD->iRow < iHeight - 1 )
{
for( i = pGTSTD->iRow + 1; i < iHeight; ++i )
hb_gt_std_DispLine( pGT, i, 0, -1 );
}
}
}
static void bufadd( BUFFERTYPE * pBuf, const char * pAdd, HB_SIZE nLen )
{
if( pBuf->nLen + nLen >= pBuf->nMax )
{
pBuf->nMax += ( pBuf->nMax >> 1 ) + nLen;
pBuf->pData = ( char * ) hb_xrealloc( pBuf->pData, pBuf->nMax );
}
static void hb_compCodeTraceAddJump( PHB_CODETRACE_INFO pInfo, HB_SIZE nPCodePos )
{
/* Checking for nPCodePos < pInfo->nPCodeSize disabled intentionally
* for easier detecting bugs in generated PCODE
*/
/*
if( nPCodePos < pInfo->nPCodeSize && pInfo->pCodeMark[ nPCodePos ] == 0 )
*/
if( pInfo->pCodeMark[ nPCodePos ] == 0 )
{
if( pInfo->nJumpSize == 0 )
{
pInfo->nJumpSize = HB_JUMPADDR_ALLOC;
pInfo->pnJumps = ( HB_SIZE * ) hb_xgrab( pInfo->nJumpSize *
sizeof( HB_SIZE ) );
}
else if( pInfo->nJumpSize == pInfo->nJumpCount )
{
pInfo->nJumpSize += HB_JUMPADDR_ALLOC;
pInfo->pnJumps = ( HB_SIZE * ) hb_xrealloc( pInfo->pnJumps,
pInfo->nJumpSize * sizeof( HB_SIZE ) );
}
pInfo->pnJumps[ pInfo->nJumpCount++ ] = nPCodePos;
pInfo->pCodeMark[ nPCodePos ] = 1;
}
}
char * hb_jsonEncode( PHB_ITEM pValue, HB_SIZE * pnLen, HB_BOOL fHuman )
{
PHB_JSON_ENCODE_CTX pCtx;
char * szRet;
HB_SIZE nLen;
pCtx = ( PHB_JSON_ENCODE_CTX ) hb_xgrab( sizeof( HB_JSON_ENCODE_CTX ) );
pCtx->nAlloc = 16;
pCtx->pHead = pCtx->pBuffer = ( char * ) hb_xgrab( pCtx->nAlloc );
pCtx->nAllocId = 8;
pCtx->pId = ( void ** ) hb_xgrab( sizeof( void * ) * pCtx->nAllocId );
pCtx->fHuman = fHuman;
pCtx->szEol = hb_setGetEOL();
if( ! pCtx->szEol || ! pCtx->szEol[ 0 ] )
pCtx->szEol = hb_conNewLine();
pCtx->iEolLen = ( int ) strlen( pCtx->szEol );
_hb_jsonEncode( pValue, pCtx, 0, HB_FALSE );
nLen = pCtx->pHead - pCtx->pBuffer;
szRet = ( char * ) hb_xrealloc( pCtx->pBuffer, nLen + 1 );
szRet[ nLen ] = '\0';
hb_xfree( pCtx->pId );
hb_xfree( pCtx );
if( pnLen )
*pnLen = nLen;
return szRet;
}
/* Insert new symbol into dynamic symbol table.
* In MT mode caller should protected it by HB_DYNSYM_LOCK()
*/
static PHB_DYNS hb_dynsymInsert( PHB_SYMB pSymbol, HB_UINT uiPos )
{
PHB_DYNS pDynSym;
HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymInsert(%p,%u)", pSymbol, uiPos ) );
if( ++s_uiDynSymbols == 0 )
{
--s_uiDynSymbols;
hb_errInternal( 6004, "Internal error: size of dynamic symbol table exceed", NULL, NULL );
}
else if( s_uiDynSymbols == 1 )
{
s_pDynItems = ( PDYNHB_ITEM ) hb_xgrab( sizeof( DYNHB_ITEM ) );
}
else
{
s_pDynItems = ( PDYNHB_ITEM ) hb_xrealloc( s_pDynItems, s_uiDynSymbols * sizeof( DYNHB_ITEM ) );
memmove( &s_pDynItems[ uiPos + 1 ], &s_pDynItems[ uiPos ],
sizeof( DYNHB_ITEM ) * ( s_uiDynSymbols - uiPos - 1 ) );
}
pDynSym = ( PHB_DYNS ) hb_xgrab( sizeof( HB_DYNS ) );
memset( pDynSym, 0, sizeof( HB_DYNS ) );
pDynSym->pSymbol = pSymbol;
pDynSym->uiSymNum = s_uiDynSymbols;
pSymbol->pDynSym = s_pDynItems[ uiPos ].pDynSym = pDynSym;
return pDynSym;
}
static unsigned char *buf_append(unsigned char *buf, unsigned *buf_size, unsigned count,
unsigned char c, unsigned *buf_len)
{
if (*buf_len + count > *buf_size) {
*buf_size = HB_MAX(*buf_len + count, *buf_size + 32768);
buf = (unsigned char *) hb_xrealloc(buf, *buf_size);
}
memset(buf + *buf_len, c, count);
*buf_len += count;
return buf;
}
static HB_UCHAR * buf_append( HB_UCHAR * buf, HB_SIZE * buf_size, HB_SIZE count,
HB_UCHAR c, HB_SIZE * buf_len )
{
if( *buf_len + count > *buf_size )
{
*buf_size = HB_MAX( *buf_len + count, *buf_size + 32768 );
buf = ( HB_UCHAR * ) hb_xrealloc( buf, *buf_size );
}
memset( buf + *buf_len, c, count );
*buf_len += count;
return buf;
}
static void hb_fileDeleteLock( PHB_FILE pFile, HB_UINT uiPos )
{
pFile->uiLocks--;
memmove( &pFile->pLocks[ uiPos ], &pFile->pLocks[ uiPos + 1 ],
( pFile->uiLocks - uiPos ) * sizeof( HB_FLOCK ) );
if( pFile->uiSize - pFile->uiLocks >= ( HB_FLOCK_RESIZE << 1 ) )
{
pFile->uiSize -= HB_FLOCK_RESIZE;
pFile->pLocks = ( PHB_FLOCK ) hb_xrealloc( pFile->pLocks,
sizeof( HB_FLOCK ) * pFile->uiSize );
}
}
HB_ULONG hb_backgroundAddFunc( PHB_ITEM pBlock, int nMillisec, HB_BOOL bActive )
{
PHB_BACKGROUNDTASK pBkgTask;
/* store a copy of passed codeblock
*/
pBkgTask = ( PHB_BACKGROUNDTASK ) hb_xgrab( sizeof( HB_BACKGROUNDTASK ) );
pBkgTask->pTask = hb_itemNew( pBlock );
pBkgTask->dSeconds = hb_dateSeconds();
pBkgTask->millisec = nMillisec;
pBkgTask->bActive = bActive;
if( ! s_pBackgroundTasks )
{
pBkgTask->ulTaskID = s_ulBackgroundID = 1;
s_pBackgroundTasks = ( PHB_BACKGROUNDTASK * ) hb_xgrab( sizeof( HB_BACKGROUNDTASK ) );
}
else
{
pBkgTask->ulTaskID = ++s_ulBackgroundID;
if( pBkgTask->ulTaskID == 0 ) /* the counter reach maximum value */
{
/* find unique task ID and set the counter for next */
int iTask = 0;
while( iTask < s_uiBackgroundMaxTask )
{
if( s_pBackgroundTasks[ iTask ]->ulTaskID == pBkgTask->ulTaskID )
{
pBkgTask->ulTaskID++;
/* This list is unsorted so we have to scan from the begining again */
iTask = 0;
}
else
{
iTask++;
if( s_ulBackgroundID < pBkgTask->ulTaskID )
s_ulBackgroundID = pBkgTask->ulTaskID;
}
}
}
s_pBackgroundTasks = ( PHB_BACKGROUNDTASK * ) hb_xrealloc( s_pBackgroundTasks, sizeof( HB_BACKGROUNDTASK ) * ( s_uiBackgroundMaxTask ) );
}
s_pBackgroundTasks[ s_uiBackgroundMaxTask ] = pBkgTask;
++s_uiBackgroundMaxTask;
return pBkgTask->ulTaskID;
}
static HB_ERRCODE sqlbaseAppend( SQLBASEAREAP pArea, HB_BOOL bUnLockAll )
{
HB_SYMBOL_UNUSED( bUnLockAll );
/* This GOTO is GOCOLD + GOEOF */
if( SELF_GOTO( ( AREAP ) pArea, 0 ) == HB_FAILURE )
return HB_FAILURE;
if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE )
return HB_FAILURE;
if( pArea->ulRecCount + 1 >= pArea->ulRecMax )
{
pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) );
pArea->ulRecMax += SQLDD_ROWSET_RESIZE;
}
pArea->fAppend = pArea->fPositioned = HB_TRUE;
pArea->ulRecCount++;
pArea->ulRecNo = pArea->ulRecCount;
pArea->area.fBof = pArea->area.fEof = pArea->area.fFound = HB_FALSE;
return HB_SUCCESS;
}
void hb_compGenPCode1( HB_BYTE byte, HB_COMP_DECL )
{
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast; /* get the currently defined Clipper function */
if( ! pFunc->pCode ) /* has been created the memory block to hold the pcode ? */
{
pFunc->pCode = ( HB_BYTE * ) hb_xgrab( HB_PCODE_CHUNK );
pFunc->nPCodeSize = HB_PCODE_CHUNK;
pFunc->nPCodePos = 0;
}
else if( ( pFunc->nPCodeSize - pFunc->nPCodePos ) < 1 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->nPCodeSize += HB_PCODE_CHUNK );
pFunc->pCode[ pFunc->nPCodePos++ ] = byte;
}
static void _hb_jsonCtxAddIndent( PHB_JSON_ENCODE_CTX pCtx, HB_SIZE nCount )
{
if( nCount > 0 )
{
if( pCtx->pHead + nCount >= pCtx->pBuffer + pCtx->nAlloc )
{
HB_SIZE nSize = pCtx->pHead - pCtx->pBuffer;
pCtx->nAlloc += ( pCtx->nAlloc << 1 ) + nCount;
pCtx->pBuffer = ( char * ) hb_xrealloc( pCtx->pBuffer, pCtx->nAlloc );
pCtx->pHead = pCtx->pBuffer + nSize;
}
hb_xmemset( pCtx->pHead, ' ', nCount );
pCtx->pHead += nCount;
}
}
static void _hb_jsonCtxAdd( PHB_JSON_ENCODE_CTX pCtx, const char * szString, HB_SIZE nLen )
{
if( pCtx->pHead + nLen >= pCtx->pBuffer + pCtx->nAlloc )
{
HB_SIZE nSize = pCtx->pHead - pCtx->pBuffer;
pCtx->nAlloc += ( pCtx->nAlloc << 1 ) + nLen;
pCtx->pBuffer = ( char * ) hb_xrealloc( pCtx->pBuffer, pCtx->nAlloc );
pCtx->pHead = pCtx->pBuffer + nSize;
}
if( szString )
{
hb_xmemcpy( pCtx->pHead, szString, nLen );
pCtx->pHead += nLen;
}
}
static void hb_gt_cgi_Refresh( PHB_GT pGT )
{
int iHeight, iWidth;
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Refresh(%p)", ( void * ) pGT ) );
pGTCGI = HB_GTCGI_GET( pGT );
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
iWidth *= HB_MAX_CHAR_LEN;
if( pGTCGI->iLineBufSize < iWidth )
{
pGTCGI->sLineBuf = ( char * ) hb_xrealloc( pGTCGI->sLineBuf, iWidth );
pGTCGI->iLineBufSize = iWidth;
}
HB_GTSUPER_REFRESH( pGT );
}
static void hb_fileInsertLock( PHB_FILE pFile, HB_UINT uiPos,
HB_FOFFSET nStart, HB_FOFFSET nLen )
{
if( pFile->uiLocks == pFile->uiSize )
{
pFile->uiSize += HB_FLOCK_RESIZE;
pFile->pLocks = ( PHB_FLOCK ) hb_xrealloc( pFile->pLocks,
sizeof( HB_FLOCK ) * pFile->uiSize );
memset( &pFile->pLocks[ pFile->uiLocks ], 0,
sizeof( HB_FLOCK ) * HB_FLOCK_RESIZE );
}
memmove( &pFile->pLocks[ uiPos + 1 ], &pFile->pLocks[ uiPos ],
( pFile->uiLocks - uiPos ) * sizeof( HB_FLOCK ) );
pFile->pLocks[ uiPos ].start = nStart;
pFile->pLocks[ uiPos ].len = nLen;
pFile->uiLocks++;
}
/*
* Prepares a new WorkArea node.
*/
void * hb_rddNewAreaNode( LPRDDNODE pRddNode, HB_USHORT uiRddID )
{
AREAP pArea;
HB_TRACE( HB_TR_DEBUG, ( "hb_rddNewAreaNode(%p,%hu)", pRddNode, uiRddID ) );
if( pRddNode->uiAreaSize == 0 ) /* Calculate the size of WorkArea */
{
HB_USHORT uiSize;
pArea = ( AREAP ) hb_xgrab( sizeof( AREA ) );
memset( pArea, 0, sizeof( AREA ) );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
if( SELF_STRUCTSIZE( pArea, &uiSize ) != HB_SUCCESS )
return NULL;
/* Need more space? */
if( uiSize > sizeof( AREA ) ) /* Size of Area changed */
{
pArea = ( AREAP ) hb_xrealloc( pArea, uiSize );
memset( pArea, 0, uiSize );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
}
pRddNode->uiAreaSize = uiSize; /* Update the size of WorkArea */
}
else
{
pArea = ( AREAP ) hb_xgrab( pRddNode->uiAreaSize );
memset( pArea, 0, pRddNode->uiAreaSize );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
}
if( SELF_NEW( pArea ) != HB_SUCCESS )
{
SELF_RELEASE( pArea );
return NULL;
}
return ( void * ) pArea;
}
PHB_DYN_HANDLES hb_stackGetDynHandle( PHB_DYNS pDynSym )
{
HB_STACK_TLS_PRELOAD
int iDynSym;
HB_TRACE( HB_TR_DEBUG, ( "hb_stackGetDynHandle()" ) );
iDynSym = pDynSym->uiSymNum;
if( iDynSym > hb_stack.iDynH )
{
hb_stack.pDynH = ( PHB_DYN_HANDLES ) hb_xrealloc( hb_stack.pDynH,
iDynSym * sizeof( HB_DYN_HANDLES ) );
memset( &hb_stack.pDynH[ hb_stack.iDynH ], 0,
( iDynSym - hb_stack.iDynH ) * sizeof( HB_DYN_HANDLES ) );
hb_stack.iDynH = iDynSym;
}
return &hb_stack.pDynH[ iDynSym - 1 ];
}
/*
* Insert new WorkArea node at current WA position
*/
static void hb_waNodeInsert( PHB_STACKRDD pRddInfo, AREAP pArea )
{
HB_USHORT uiWaPos;
if( pRddInfo->uiCurrArea >= pRddInfo->uiWaNumMax )
{
int iSize = ( ( ( int ) pRddInfo->uiCurrArea + 256 ) >> 8 ) << 8;
if( iSize > HB_RDD_MAX_AREA_NUM )
iSize = HB_RDD_MAX_AREA_NUM;
if( pRddInfo->uiWaNumMax == 0 )
pRddInfo->waNums = ( HB_USHORT * ) hb_xgrab( iSize * sizeof( HB_USHORT ) );
else
pRddInfo->waNums = ( HB_USHORT * ) hb_xrealloc( pRddInfo->waNums, iSize * sizeof( HB_USHORT ) );
memset( &pRddInfo->waNums[ pRddInfo->uiWaNumMax ], 0, ( iSize - pRddInfo->uiWaNumMax ) * sizeof( HB_USHORT ) );
pRddInfo->uiWaNumMax = ( HB_USHORT ) iSize;
}
/* caller have to free return ITEM by hb_itemRelease() if it's not NULL */
PHB_ITEM hb_backgroundDelFunc( HB_ULONG ulID )
{
int iTask;
PHB_BACKGROUNDTASK pBkgTask;
PHB_ITEM pItem = NULL;
HB_BOOL bOldSet = s_bEnabled;
s_bEnabled = HB_FALSE;
iTask = 0;
while( iTask < s_uiBackgroundMaxTask )
{
pBkgTask = s_pBackgroundTasks[ iTask ];
if( ulID == pBkgTask->ulTaskID )
{
pItem = pBkgTask->pTask;
hb_xfree( pBkgTask );
if( --s_uiBackgroundMaxTask )
{
if( iTask != s_uiBackgroundMaxTask )
{
memmove( &s_pBackgroundTasks[ iTask ], &s_pBackgroundTasks[ iTask + 1 ],
sizeof( HB_BACKGROUNDTASK ) * ( s_uiBackgroundMaxTask - iTask ) );
}
s_pBackgroundTasks = ( PHB_BACKGROUNDTASK * ) hb_xrealloc( s_pBackgroundTasks, sizeof( HB_BACKGROUNDTASK ) * s_uiBackgroundMaxTask );
}
else
{
hb_xfree( s_pBackgroundTasks );
s_pBackgroundTasks = NULL;
}
/* Pitem has now a valid value */
break;
}
++iTask;
}
s_bEnabled = bOldSet;
return pItem;
}
static PHB_MEMFS_INODE memfsInodeAlloc( const char * szName )
{
PHB_MEMFS_INODE pInode = ( PHB_MEMFS_INODE ) hb_xgrab( sizeof( HB_MEMFS_INODE ) );
HB_ULONG ulInode = 0;
pInode->llSize = 0;
pInode->llAlloc = HB_MEMFS_INITSIZE;
pInode->pData = ( char * ) hb_xgrabz( ( HB_SIZE ) pInode->llAlloc );
pInode->szName = hb_strdup( szName );
pInode->uiCount = 1;
pInode->uiCountRead = pInode->uiCountWrite = 0;
pInode->uiDeny = 0;
/* Insert into inode array. Inode should not exist!!! */
if( s_fs.ulInodeCount >= s_fs.ulInodeAlloc )
{
s_fs.ulInodeAlloc += s_fs.ulInodeAlloc >> 1;
s_fs.pInodes = ( PHB_MEMFS_INODE * ) hb_xrealloc( s_fs.pInodes, s_fs.ulInodeAlloc * sizeof( PHB_MEMFS_INODE ) );
}
void hb_compGenPCodeN( const HB_BYTE * pBuffer, HB_SIZE nSize, HB_COMP_DECL )
{
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast; /* get the currently defined Clipper function */
if( ! pFunc->pCode ) /* has been created the memory block to hold the pcode ? */
{
pFunc->nPCodeSize = ( ( nSize / HB_PCODE_CHUNK ) + 1 ) * HB_PCODE_CHUNK;
pFunc->pCode = ( HB_BYTE * ) hb_xgrab( pFunc->nPCodeSize );
pFunc->nPCodePos = 0;
}
else if( pFunc->nPCodePos + nSize > pFunc->nPCodeSize )
{
/* not enough free space in pcode buffer - increase it */
pFunc->nPCodeSize += ( ( ( nSize / HB_PCODE_CHUNK ) + 1 ) * HB_PCODE_CHUNK );
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->nPCodeSize );
}
memcpy( pFunc->pCode + pFunc->nPCodePos, pBuffer, nSize );
pFunc->nPCodePos += nSize;
}
/*
*
* 26/07/2008 - 11:16:34
*/
static
void printf_add_str( PPrintInfo pInfo, char *text, ULONG request_len )
{
if (!request_len)
return;
// Precisa realocar memoria?
if (pInfo->out_len+request_len > pInfo->cap_len)
{
pInfo->cap_len += request_len;
pInfo->Result = (char *) hb_xrealloc( pInfo->Result, pInfo->cap_len+1 );
pInfo->Buffer = pInfo->Result + (pInfo->out_len);
pInfo->out_len += request_len;
} else {
pInfo->out_len += request_len;
}
memmove( pInfo->Buffer, text, request_len );
pInfo->Buffer += request_len;
return;
}
/* add a tokenizing position to a token environment */
static int sTokEnvAddPos( TOKEN_ENVIRONMENT * pEnv, TOKEN_POSITION * pPos )
{
HB_SIZE index;
TOKEN_ENVIRONMENT env = *pEnv;
/* new memory needed ? */
if( env[ 0 ].sStartPos == env[ 0 ].sEndPos )
{
env = *pEnv = ( TOKEN_ENVIRONMENT )
hb_xrealloc( env, sizeof( TOKEN_POSITION ) *
( 2 + env[ 0 ].sEndPos + TOKEN_ENVIRONMENT_STEP ) );
env[ 0 ].sEndPos += TOKEN_ENVIRONMENT_STEP;
}
index = env[ 0 ].sStartPos + 2; /* +2 because of extra elements */
env[ index ].sStartPos = pPos->sStartPos;
env[ index ].sEndPos = pPos->sEndPos;
env[ 0 ].sStartPos++;
return 1;
}
char * hb_jsonEncode( PHB_ITEM pValue, HB_SIZE * pnLen, HB_BOOL fHuman )
{
PHB_JSON_ENCODE_CTX pCtx;
char * szRet;
HB_SIZE nLen;
pCtx = ( PHB_JSON_ENCODE_CTX ) hb_xgrab( sizeof( HB_JSON_ENCODE_CTX ) );
pCtx->nAlloc = 16;
pCtx->pHead = pCtx->pBuffer = ( char * ) hb_xgrab( pCtx->nAlloc );
pCtx->nAllocId = 8;
pCtx->pId = ( void ** ) hb_xgrab( sizeof( void * ) * pCtx->nAllocId );
pCtx->fHuman = fHuman;
_hb_jsonEncode( pValue, pCtx, 0 );
nLen = pCtx->pHead - pCtx->pBuffer;
szRet = ( char * ) hb_xrealloc( pCtx->pBuffer, nLen + 1 );
szRet[ nLen ] = '\0';
hb_xfree( pCtx->pId );
hb_xfree( pCtx );
if( pnLen )
*pnLen = nLen;
return szRet;
}
static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem )
{
HB_ULONG ulConn;
SQLDDCONNECTION * pConn;
HB_SYMBOL_UNUSED( pRDD );
ulConn = ulConnect ? ulConnect : s_ulConnectionCurrent;
if( ulConn > 0 && ulConn <= s_ulConnectionCount )
pConn = s_pConnection[ ulConn - 1 ];
else
pConn = NULL;
switch( uiIndex )
{
case RDDI_REMOTE:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECTION:
{
HB_ULONG ulNewConnection = 0;
if( hb_itemType( pItem ) & HB_IT_NUMERIC )
ulNewConnection = hb_itemGetNL( pItem );
hb_itemPutNL( pItem, ulConnect ? ulConnect : s_ulConnectionCurrent );
if( ulNewConnection )
s_ulConnectionCurrent = ulNewConnection;
break;
}
case RDDI_ISDBF:
hb_itemPutL( pItem, HB_FALSE );
break;
case RDDI_CANPUTREC:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECT:
{
PSDDNODE pNode = NULL;
HB_ULONG ul;
const char * pStr;
pStr = hb_arrayGetCPtr( pItem, 1 );
if( pStr )
{
pNode = s_pSdd;
while( pNode )
{
if( ! hb_stricmp( pNode->Name, pStr ) )
break;
pNode = pNode->pNext;
}
}
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
pConn = ( SQLDDCONNECTION * ) hb_xgrab( sizeof( SQLDDCONNECTION ) );
memset( pConn, 0, sizeof( SQLDDCONNECTION ) );
if( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS )
{
pConn->pSDD = pNode;
/* Find free connection handle */
for( ul = 0; ul < s_ulConnectionCount; ul++ )
{
if( ! s_pConnection[ ul ] )
break;
}
if( ul >= s_ulConnectionCount )
{
/* Realloc connection table */
if( s_pConnection )
s_pConnection = ( SQLDDCONNECTION ** ) hb_xrealloc( s_pConnection, sizeof( SQLDDCONNECTION * ) * ( s_ulConnectionCount + CONNECTION_LIST_EXPAND ) );
else
s_pConnection = ( SQLDDCONNECTION ** ) hb_xgrab( sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
memset( s_pConnection + s_ulConnectionCount, 0, sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
ul = s_ulConnectionCount;
s_ulConnectionCount += CONNECTION_LIST_EXPAND;
}
s_pConnection[ ul ] = pConn;
ul++;
s_ulConnectionCurrent = ul;
}
else
{
hb_xfree( pConn );
ul = 0;
}
hb_itemPutNI( pItem, ul );
break;
}
case RDDI_DISCONNECT:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn && ! pConn->uiAreaCount && pConn->pSDD->Disconnect( pConn ) == HB_SUCCESS )
{
hb_xfree( pConn );
s_pConnection[ ulConn - 1 ] = NULL;
if( s_ulConnectionCurrent == ulConn )
s_ulConnectionCurrent = 0;
hb_itemPutL( pItem, HB_TRUE );
return HB_SUCCESS;
}
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_EXECUTE:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn )
hb_itemPutL( pItem, pConn->pSDD->Execute( pConn, pItem ) == HB_SUCCESS );
else
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_ERROR:
hb_itemPutC( pItem, s_szError );
return HB_SUCCESS;
case RDDI_ERRORNO:
hb_itemPutNI( pItem, s_errCode );
return HB_SUCCESS;
case RDDI_QUERY:
hb_itemPutC( pItem, s_szQuery );
return HB_SUCCESS;
case RDDI_NEWID:
hb_itemCopy( pItem, s_pItemNewID );
return HB_SUCCESS;
case RDDI_AFFECTEDROWS:
hb_itemPutNInt( pItem, s_ulAffectedRows );
return HB_SUCCESS;
#if 0
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
#endif
}
return HB_SUCCESS;
}
PHB_DEBUGINFO hb_compGetDebugInfo( HB_COMP_DECL )
{
PHB_DEBUGINFO pLineInfo = NULL, pInfo = NULL;
HB_SIZE nPos, nSkip, nOffset;
HB_ULONG ulLine;
const char * pszModuleName = "", * ptr;
PFUNCTION pFunc;
pFunc = HB_COMP_PARAM->functions.pFirst;
while( pFunc )
{
if( ( pFunc->funFlags & FUN_FILE_DECL ) == 0 )
{
nPos = ulLine = 0;
while( nPos < pFunc->nPCodePos )
{
nSkip = 0;
switch( pFunc->pCode[ nPos ] )
{
case HB_P_LINE:
ulLine = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPos + 1 ] );
break;
case HB_P_MODULENAME:
pszModuleName = ( const char * ) &pFunc->pCode[ nPos + 1 ];
pInfo = NULL;
break;
/*
* This enables checking also code block bodies,
* if it's not necessary then simply remove the
* code below. [druzus]
*/
case HB_P_PUSHBLOCKLARGE:
nSkip = 8 + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPos + 6 ] ) * 2;
break;
case HB_P_PUSHBLOCK:
nSkip = 7 + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPos + 5 ] ) * 2;
break;
case HB_P_PUSHBLOCKSHORT:
nSkip = 2;
break;
}
if( ulLine != 0 )
{
if( ! pInfo )
{
int i;
ptr = strchr( pszModuleName, ':' );
i = ptr ? ( int ) ( ptr - pszModuleName ) : ( int ) strlen( pszModuleName );
pInfo = pLineInfo;
while( pInfo != NULL )
{
if( strncmp( pszModuleName, pInfo->pszModuleName, i ) == 0 &&
( pInfo->pszModuleName[ i ] == '\0' ||
pInfo->pszModuleName[ i ] == ':' ) )
break;
pInfo = pInfo->pNext;
}
if( ! pInfo )
{
pInfo = ( PHB_DEBUGINFO ) hb_xgrab( sizeof( HB_DEBUGINFO ) );
pInfo->pszModuleName = hb_strndup( pszModuleName, i );
pInfo->ulFirstLine = pInfo->ulLastLine = ulLine;
/*
* allocate memory in 256 bytes chunks (for 2048 lines)
* The last 1 byte is reserved for additional 0 byte if
* the caller will want to use the returned buffer as
* parameter to hb_compGenPushString(). [druzus]
*/
pInfo->ulAllocated = ( ( ulLine >> 3 ) + 0x100 ) & 0xFFFFFF00L;
pInfo->pLineMap = ( HB_BYTE * ) hb_xgrab( pInfo->ulAllocated + 1 );
memset( pInfo->pLineMap, 0, pInfo->ulAllocated + 1 );
pInfo->pNext = pLineInfo;
pLineInfo = pInfo;
}
}
nOffset = ulLine >> 3;
if( pInfo->ulAllocated <= nOffset )
{
HB_ULONG ulNewSize = ( ( ulLine >> 3 ) + 0x100 ) & 0xFFFFFF00L;
pInfo->pLineMap = ( HB_BYTE * ) hb_xrealloc( pInfo->pLineMap, ulNewSize + 1 );
memset( pInfo->pLineMap + pInfo->ulAllocated, 0, ulNewSize - pInfo->ulAllocated + 1 );
pInfo->ulAllocated = ulNewSize;
}
pInfo->pLineMap[ nOffset ] |= 1 << ( ulLine & 0x7 );
/*
* It's possible the the line number will be ascending
* if some external file is included more then once. [druzus]
*/
if( pInfo->ulFirstLine > ulLine )
pInfo->ulFirstLine = ulLine;
if( pInfo->ulLastLine < ulLine )
pInfo->ulLastLine = ulLine;
ulLine = 0;
}
