static void adsxRegisterRDD( HB_USHORT * pusRddId, const char * szRddName ) { RDDFUNCS * pTable; HB_USHORT * puiCount, * puiSuperRddId, uiRddId; puiCount = ( HB_USHORT * ) hb_parptr( 1 ); pTable = ( RDDFUNCS * ) hb_parptr( 2 ); uiRddId = ( HB_USHORT ) hb_parni( 4 ); puiSuperRddId = ( HB_USHORT * ) hb_parptr( 5 ); if( pTable ) { HB_ERRCODE errCode; if( puiCount ) *puiCount = RDDFUNCSCOUNT; errCode = hb_rddInheritEx( pTable, &adsxTable, &adsxSuper, szRddName, puiSuperRddId ); if( errCode == HB_SUCCESS ) { *pusRddId = uiRddId; } hb_retni( errCode ); } else { hb_retni( HB_FAILURE ); } }
void hb_posix_result( int iResult ) { if( iResult == -1 ) hb_posix_save_errno(); else hb_posix_set_errno( 0 ); hb_retni( iResult ); }
HB_EXTERN_END HB_FUNC( HB_BLATSEND ) { if( HB_ISCHAR( 1 ) ) hb_retni( cSend( hb_parc( 1 ) ) ); else hb_errRT_BASE_SubstR( EG_ARG, 0, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); }
HB_EXTERN_END #endif HB_FUNC( HB_BLATSEND ) { if( HB_ISCHAR( 1 ) ) { #if defined( HBMK_HAS_BLAT ) void * hCmdLine = NULL; hb_retni( cSend( HB_PARSTR( 1, &hCmdLine, NULL ) ) ); hb_strfree( hCmdLine ); #else hb_retni( cSend( hb_parc( 1 ) ) ); #endif } else hb_errRT_BASE_SubstR( EG_ARG, 0, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); }
/* helper function */ static void do_ascpos( int iSwitch ) { if( HB_ISCHAR( 1 ) ) { HB_SIZE sStrSize = hb_parclen( 1 ); const HB_BYTE * pcString = ( const HB_BYTE * ) hb_parc( 1 ); HB_SIZE sPos = hb_parnsdef( 2, sStrSize ); if( sPos == 0 || sPos > sStrSize ) hb_retni( 0 ); else { if( iSwitch == DO_ASCPOS_VALPOS ) { if( HB_ISDIGIT( ( HB_UCHAR ) pcString[ sPos - 1 ] ) ) hb_retni( pcString[ sPos - 1 ] - '0' ); else hb_retni( 0 ); } else hb_retni( pcString[ sPos - 1 ] ); } } else { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if( iArgErrorMode != CT_ARGERR_IGNORE ) pSubst = ct_error_subst( ( HB_USHORT ) iArgErrorMode, EG_ARG, iSwitch == DO_ASCPOS_VALPOS ? CT_ERROR_VALPOS : CT_ERROR_ASCPOS, NULL, HB_ERR_FUNCNAME, 0, EF_CANSUBSTITUTE, HB_ERR_ARGS_BASEPARAMS ); if( pSubst != NULL ) hb_itemReturnRelease( pSubst ); else hb_retni( 0 ); } }
void hb_ipclose( HB_SOCKET_T hSocket ) { #if defined( HB_OS_WIN_32 ) shutdown( hSocket, SD_BOTH ); #elif defined(HB_OS_OS2) shutdown( hSocket, SO_RCV_SHUTDOWN + SO_SND_SHUTDOWN ); #elif !defined(__WATCOMC__) shutdown( hSocket, SHUT_RDWR ); #endif hb_retni( HB_IP_CLOSE( hSocket ) ); #ifdef HB_OS_LINUX kill( 0, HB_IP_LINUX_INTERRUPT ); #endif }
static void s_inetRecvInternal( int iMode ) { PHB_SOCKET_STRUCT socket = HB_PARSOCKET( 1 ); PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING ); if( socket == NULL || pBuffer == NULL || ! HB_ISBYREF( 2 ) ) hb_inetErrRT(); else if( ! hb_inetIsOpen( socket ) ) hb_retni( -1 ); else { int iLen, iMaxLen, iReceived, iTimeElapsed; char * buffer; HB_SIZE nLen; if( hb_itemGetWriteCL( pBuffer, &buffer, &nLen ) ) iLen = ( int ) nLen; else { iLen = 0; buffer = NULL; } if( HB_ISNUM( 3 ) ) { iMaxLen = hb_parni( 3 ); if( iMaxLen < 0 ) iMaxLen = 0; else if( iLen < iMaxLen ) iMaxLen = iLen; } else iMaxLen = iLen; iReceived = iTimeElapsed = 0; socket->iError = HB_INET_ERR_OK; do { iLen = s_inetRecv( socket, buffer + iReceived, iMaxLen - iReceived, HB_FALSE, socket->iTimeout ); if( iLen >= 0 ) { iReceived += iLen; if( iMode == 0 ) /* Called from hb_inetRecv()? */ break; } else if( iLen == -1 && s_inetIsTimeout( socket ) ) { /* if we have a pPeriodicBlock, timeLimit is our REAL timeout */ if( socket->pPeriodicBlock ) { /* timed out; let's see if we have to run a cb routine */ iTimeElapsed += socket->iTimeout; hb_execFromArray( socket->pPeriodicBlock ); /* do we continue? */ if( hb_parl( -1 ) && hb_vmRequestQuery() == 0 && ( socket->iTimeLimit == -1 || iTimeElapsed < socket->iTimeLimit ) ) iLen = 1; /* Declare success to continue loop */ } } } while( iReceived < iMaxLen && iLen > 0 ); socket->iCount = iReceived; if( iLen == 0 ) socket->iError = HB_INET_ERR_CLOSEDCONN; else if( iLen < 0 ) hb_inetGetError( socket ); hb_retni( iReceived > 0 ? iReceived : iLen ); } }
static void s_inetSendInternal( HB_BOOL lAll ) { PHB_SOCKET_STRUCT socket = HB_PARSOCKET( 1 ); PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING ); const char * buffer; int iLen, iSent, iSend; long lLastSnd = 1; if( socket == NULL || pBuffer == NULL ) hb_inetErrRT(); else if( ! hb_inetIsOpen( socket ) ) hb_retni( -1 ); else { buffer = hb_itemGetCPtr( pBuffer ); iSend = ( int ) hb_itemGetCLen( pBuffer ); if( HB_ISNUM( 3 ) ) { iLen = hb_parni( 3 ); if( iLen < iSend ) iSend = iLen; } socket->iError = HB_INET_ERR_OK; iSent = iLen = 0; while( iSent < iSend ) { if( socket->sendFunc ) { iLen = socket->sendFunc( socket->stream, socket->sd, buffer + iSent, iSend - iSent, socket->iTimeout, &lLastSnd ); if( lLastSnd <= 0 && iLen > 0 ) { iSent += iLen; iLen = ( int ) lLastSnd; } } else iLen = hb_socketSend( socket->sd, buffer + iSent, iSend - iSent, 0, socket->iTimeout ); if( iLen > 0 ) { iSent += iLen; if( ! lAll ) break; } else { hb_inetGetError( socket ); break; } } socket->iCount = iSent; if( socket->flushFunc && ( lLastSnd > 0 || ( lLastSnd == -1 && socket->iTimeout >= 0 && socket->iTimeout < 10000 && s_inetIsTimeout( socket ) ) ) ) { /* TODO: safe information about unflushed data and try to call flush before entering receive wait sate */ socket->flushFunc( socket->stream, socket->sd, socket->iTimeout < 0 ? socket->iTimeout : HB_MAX( socket->iTimeout, 10000 ), HB_FALSE ); } hb_retni( iSent > 0 ? iSent : iLen ); } }
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 ); }