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; }