| abs.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | ABS(void)
HB_FUNC( ABS )
{
PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC );
if( pNumber )
{
int iWidth;
int iDec;
hb_itemGetNLen( pNumber, &iWidth, &iDec );
if( HB_IS_INTEGER( pNumber ) )
{
int iNumber = hb_itemGetNI( pNumber );
if( iNumber >= 0 )
hb_retnilen( iNumber, iWidth );
#if -HB_INT_MAX > HB_INT_MIN
else if( iNumber < -HB_INT_MAX )
#if HB_LONG_MAX > HB_INT_MAX
hb_retnint( - ( HB_LONG ) iNumber );
#else
hb_retndlen( - ( double ) iNumber, 0, iDec );
#endif
#endif
else
hb_retni( -iNumber );
}
else if( HB_IS_LONG( pNumber ) )
{
HB_LONG lNumber = hb_itemGetNInt( pNumber );
if( lNumber >= 0 )
hb_retnintlen( lNumber, iWidth );
#if -HB_LONG_MAX > HB_LONG_MIN
else if( lNumber < -HB_LONG_MAX )
hb_retndlen( - ( double ) lNumber, 0, iDec );
#endif
else
hb_retnint( -lNumber );
}
else
{
double dNumber = hb_itemGetND( pNumber );
hb_retndlen( dNumber >= 0.0 ? dNumber : -dNumber, 0, iDec );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1089, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| abs.c | 57 |
| accept.c |
| Type | Function | Source | Line |
|---|
| STATIC CHAR * | hb_acceptBuffer( void )
static char * hb_acceptBuffer( void )
{
return ( char * ) hb_stackGetTSD( &s_szAcceptResult );
}
| accept.c | 78 |
| HB_FUNC | __ACCEPTSTR(void)
HB_FUNC( __ACCEPTSTR )
{
hb_retc( hb_acceptBuffer() );
}
| accept.c | 83 |
| HB_FUNC | __ACCEPT(void)
HB_FUNC( __ACCEPT )
{
char szAcceptResult[ ACCEPT_BUFFER_LEN ];
ULONG ulLen = 0;
int input = 0;
/* cPrompt(s) passed ? */
if( hb_pcount() >= 1 )
HB_FUNC_EXEC( QOUT );
szAcceptResult[ 0 ] = '\0';
while( input != K_ENTER && hb_vmRequestQuery() == 0 )
{
/* Wait forever, for keyboard events only */
input = hb_inkey( TRUE, 0.0, INKEY_KEYBOARD );
switch( input )
{
case K_BS:
case K_LEFT:
if( ulLen > 0 )
{
hb_conOutAlt( "\x8", sizeof( char ) ); /* Erase it from the screen. */
ulLen--; /* Adjust input count to get rid of last character */
}
break;
default:
if( ulLen < ( ACCEPT_BUFFER_LEN - 1 ) && input >= 32 && input <= 255 )
{
szAcceptResult[ ulLen ] = ( char ) input; /* Accept the input */
hb_conOutAlt( &szAcceptResult[ ulLen ], sizeof( char ) ); /* Then display it */
ulLen++; /* Then adjust the input count */
}
}
}
szAcceptResult[ ulLen ] = '\0';
#ifdef HB_C52_UNDOC
hb_strncpy( hb_acceptBuffer(), szAcceptResult, ACCEPT_BUFFER_LEN - 1 );
#endif
hb_retc( szAcceptResult );
}
| accept.c | 90 |
| ampm.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | AMPM(void)
HB_FUNC( AMPM )
{
ULONG ulTimeLen = hb_parclen( 1 );
char * pszResult = ( char * ) hb_xgrab( HB_MAX( ulTimeLen, 2 ) + 3 + 1 );
USHORT uiHour = 0;
BOOL bAM;
if( ulTimeLen )
{
char * pszTime = hb_parc( 1 );
memcpy( pszResult, pszTime, ulTimeLen );
uiHour = ( USHORT ) hb_strVal( pszTime, ulTimeLen );
}
if( uiHour == 0 || uiHour == 24 )
{
if( ulTimeLen < 2 )
ulTimeLen = 2;
pszResult[ 0 ] = '1';
pszResult[ 1 ] = '2';
bAM = TRUE;
}
else if( uiHour > 12 )
{
if( ulTimeLen < 2 )
ulTimeLen = 2;
uiHour -= 12;
pszResult[ 0 ] = ( char ) ( uiHour / 10 ) + '0';
pszResult[ 1 ] = ( char ) ( uiHour % 10 ) + '0';
if( pszResult[ 0 ] == '0' )
pszResult[ 0 ] = ' ';
bAM = FALSE;
}
else
bAM = ( uiHour != 12 );
memcpy( pszResult + ulTimeLen, bAM ? " am" : " pm", 4 );
hb_retclen_buffer( pszResult, ulTimeLen + 3 );
}
| ampm.c | 55 |
| at.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_AT(void)
HB_FUNC( HB_AT )
{
PHB_ITEM pSub = hb_param( 1, HB_IT_STRING );
PHB_ITEM pText = hb_param( 2, HB_IT_STRING );
if( pText && pSub )
{
ULONG ulTextLength = hb_itemGetCLen( pText );
ULONG ulStart = ISNUM( 3 ) ? hb_parnl( 3 ) : 1;
ULONG ulEnd = ISNUM( 4 ) ? ( ULONG ) hb_parnl( 4 ) : ulTextLength;
ULONG ulPos;
if( ulStart > ulTextLength || ulEnd < ulStart )
hb_retnl( 0 );
else
{
if( ulEnd > ulTextLength )
ulEnd = ulTextLength;
ulPos = hb_strAt( hb_itemGetCPtr( pSub ), hb_itemGetCLen( pSub ),
hb_itemGetCPtr( pText ) + ulStart - 1, ulEnd - ulStart + 1 );
if( ulPos > 0)
ulPos += ( ulStart - 1 );
hb_retnl( ulPos );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1108, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| at.c | 59 |
| HB_FUNC | AT(void)
HB_FUNC( AT )
{
HB_FUNC_EXEC( HB_AT );
}
| at.c | 93 |
| HB_FUNC | AT(void)
HB_FUNC( AT )
{
PHB_ITEM pSub = hb_param( 1, HB_IT_STRING );
PHB_ITEM pText = hb_param( 2, HB_IT_STRING );
if( pText && pSub )
{
hb_retnl( hb_strAt( hb_itemGetCPtr( pSub ), hb_itemGetCLen( pSub ),
hb_itemGetCPtr( pText ), hb_itemGetCLen( pText ) ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1108, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| at.c | 100 |
| binnum.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | BIN2W(void)
HB_FUNC( BIN2W )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_STRING );
if( pItem )
{
char * pszString = hb_itemGetCPtr( pItem );
ULONG ulLen = hb_itemGetCLen( pItem );
hb_retnl( HB_MKUSHORT( ( ulLen >= 1 ) ? ( BYTE ) pszString[ 0 ] : 0,
( ulLen >= 2 ) ? ( BYTE ) pszString[ 1 ] : 0 ) );
}
else
hb_retni( 0 );
}
| binnum.c | 39 |
| HB_FUNC | BIN2I(void)
HB_FUNC( BIN2I )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_STRING );
if( pItem )
{
char * pszString = hb_itemGetCPtr( pItem );
ULONG ulLen = hb_itemGetCLen( pItem );
hb_retni( HB_MKSHORT( ( ulLen >= 1 ) ? ( BYTE ) pszString[ 0 ] : 0,
( ulLen >= 2 ) ? ( BYTE ) pszString[ 1 ] : 0 ) );
}
else
hb_retni( 0 );
}
| binnum.c | 55 |
| HB_FUNC | BIN2L(void)
HB_FUNC( BIN2L )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_STRING );
if( pItem )
{
char * pszString = hb_itemGetCPtr( pItem );
ULONG ulLen = hb_itemGetCLen( pItem );
hb_retnl( HB_MKLONG( ( ulLen >= 1 ) ? ( BYTE ) pszString[ 0 ] : 0,
( ulLen >= 2 ) ? ( BYTE ) pszString[ 1 ] : 0,
( ulLen >= 3 ) ? ( BYTE ) pszString[ 2 ] : 0,
( ulLen >= 4 ) ? ( BYTE ) pszString[ 3 ] : 0 ) );
}
else
hb_retnl( 0 );
}
| binnum.c | 71 |
| HB_FUNC | I2BIN(void)
HB_FUNC( I2BIN )
{
char szString[ 2 ];
if( ISNUM( 1 ) )
{
SHORT iValue = ( SHORT ) hb_parni( 1 );
HB_PUT_LE_UINT16( szString, iValue );
}
else
{
szString[ 0 ] =
szString[ 1 ] = '\0';
}
hb_retclen( szString, 2 );
}
| binnum.c | 89 |
| HB_FUNC | L2BIN(void)
HB_FUNC( L2BIN )
{
char szString[ 4 ];
if( ISNUM( 1 ) )
{
long lValue = hb_parnl( 1 );
HB_PUT_LE_UINT32( szString, lValue );
}
else
{
szString[ 0 ] =
szString[ 1 ] =
szString[ 2 ] =
szString[ 3 ] = '\0';
}
hb_retclen( szString, 4 );
}
| binnum.c | 108 |
| binnumx.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | BIN2U(void)
HB_FUNC( BIN2U )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_STRING );
if( pItem )
{
char * pszString = hb_itemGetCPtr( pItem );
ULONG ulLen = hb_itemGetCLen( pItem );
hb_retnint( HB_MKULONG( ( ulLen >= 1 ) ? ( BYTE ) pszString[ 0 ] : 0,
( ulLen >= 2 ) ? ( BYTE ) pszString[ 1 ] : 0,
( ulLen >= 3 ) ? ( BYTE ) pszString[ 2 ] : 0,
( ulLen >= 4 ) ? ( BYTE ) pszString[ 3 ] : 0 ) );
}
else
hb_retnl( 0 );
}
| binnumx.c | 60 |
| HB_FUNC | W2BIN(void)
HB_FUNC( W2BIN )
{
char szString[ 2 ];
if( ISNUM( 1 ) )
{
USHORT uiValue = ( USHORT ) hb_parni( 1 );
szString[ 0 ] = ( uiValue & 0x00FF );
szString[ 1 ] = ( uiValue & 0xFF00 ) >> 8;
}
else
{
szString[ 0 ] =
szString[ 1 ] = '\0';
}
hb_retclen( szString, 2 );
}
| binnumx.c | 78 |
| HB_FUNC | U2BIN(void)
HB_FUNC( U2BIN )
{
char szString[ 4 ];
if( ISNUM( 1 ) )
{
ULONG ulValue = ( ULONG ) hb_parnl( 1 );
szString[ 0 ] = ( char ) ( ulValue & 0x000000FF );
szString[ 1 ] = ( char ) ( ( ulValue & 0x0000FF00 ) >> 8 );
szString[ 2 ] = ( char ) ( ( ulValue & 0x00FF0000 ) >> 16 );
szString[ 3 ] = ( char ) ( ( ulValue & 0xFF000000 ) >> 24 );
}
else
{
szString[ 0 ] =
szString[ 1 ] =
szString[ 2 ] =
szString[ 3 ] = '\0';
}
hb_retclen( szString, 4 );
}
| binnumx.c | 98 |
| box.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DISPBOX(void)
HB_FUNC( DISPBOX )
{
PHB_ITEM pTop = hb_param( 1, HB_IT_NUMERIC );
PHB_ITEM pLeft = hb_param( 2, HB_IT_NUMERIC );
PHB_ITEM pBottom = hb_param( 3, HB_IT_NUMERIC );
PHB_ITEM pRight = hb_param( 4, HB_IT_NUMERIC );
if( pTop && pLeft && pBottom && pRight )
{
char * pszColor = hb_parc( 6 );
char szOldColor[ HB_CLRSTR_LEN ];
char * pszBox = hb_parc( 5 );
if( pszColor )
{
hb_gtGetColorStr( szOldColor );
hb_gtSetColorStr( pszColor );
}
if( pszBox )
hb_gtBox( ( SHORT ) hb_itemGetNI( pTop ),
( SHORT ) hb_itemGetNI( pLeft),
( SHORT ) hb_itemGetNI( pBottom ),
( SHORT ) hb_itemGetNI( pRight ),
( BYTE * ) ( *pszBox ? pszBox : " " ) );
else if( hb_parni( 5 ) == 2 )
hb_gtBoxD( ( SHORT ) hb_itemGetNI( pTop ),
( SHORT ) hb_itemGetNI( pLeft),
( SHORT ) hb_itemGetNI( pBottom ),
( SHORT ) hb_itemGetNI( pRight ) );
else
hb_gtBoxS( ( SHORT ) hb_itemGetNI( pTop ),
( SHORT ) hb_itemGetNI( pLeft),
( SHORT ) hb_itemGetNI( pBottom ),
( SHORT ) hb_itemGetNI( pRight ) );
if( pszColor )
hb_gtSetColorStr( szOldColor );
}
}
| box.c | 57 |
| cdpapi.c |
| Type | Function | Source | Line |
|---|
| STATIC INT | utf8Size( USHORT uc )
static int utf8Size( USHORT uc )
{
if( uc < 0x0080 )
return 1;
else if( uc < 0x0800 )
return 2;
else /* if( uc <= 0xffff ) */
return 3;
}
| cdpapi.c | 118 |
| STATIC INT | u16toutf8( BYTE * szUTF8, USHORT uc )
static int u16toutf8( BYTE * szUTF8, USHORT uc )
{
int n;
if( uc < 0x0080 )
{
szUTF8[0] = uc & 0xff;
n = 1;
}
else if( uc < 0x0800 )
{
szUTF8[0] = 0xc0 | ( ( uc >> 6 ) & 0x1f );
szUTF8[1] = 0x80 | ( uc & 0x3f );
n = 2;
}
else /* if( uc <= 0xffff ) */
{
szUTF8[0] = 0xe0 | ( ( uc >> 12 ) & 0x0f );
szUTF8[1] = 0x80 | ( ( uc >> 6 ) & 0x3f );
szUTF8[2] = 0x80 | ( uc & 0x3f );
n = 3;
}
/*
else
{
n = 0;
}
*/
return n;
}
| cdpapi.c | 130 |
| STATIC BOOL | utf8tou16nextchar( BYTE byChar, int *n, USHORT * uc )
static BOOL utf8tou16nextchar( BYTE byChar, int *n, USHORT * uc )
{
if( *n > 0 )
{
if( ( byChar & 0xc0 ) != 0x80 )
return FALSE;
*uc = ( *uc << 6 ) | ( byChar & 0x3f );
( *n )--;
return TRUE;
}
*n = 0;
*uc = byChar;
if( byChar >= 0xc0 )
{
if( byChar < 0xe0 )
{
*uc &= 0x1f;
*n = 1;
}
else if( byChar < 0xf0 )
{
*uc &= 0x0f;
*n = 2;
}
else if( byChar < 0xf8 )
{
*uc &= 0x07;
*n = 3;
}
else if( byChar < 0xfc )
{
*uc &= 0x03;
*n = 4;
}
else if( byChar < 0xfe )
{
*uc &= 0x01;
*n = 5;
}
}
return TRUE;
}
| cdpapi.c | 161 |
| STATIC INT | utf8tou16( const BYTE * szUTF8, USHORT * uc )
static int utf8tou16( const BYTE * szUTF8, USHORT * uc )
{
int n = 1, m = 1;
UINT32 u32;
u32 = *szUTF8;
if( u32 >= 0xc0 )
{
if( u32 < 0xe0 )
{
u32 &= 0x1f;
m = 2;
}
else if( u32 < 0xf0 )
{
u32 &= 0x0f;
m = 3;
}
else if( u32 < 0xf8 )
{
u32 &= 0x07;
m = 4;
}
else if( u32 < 0xfc )
{
u32 &= 0x03;
m = 5;
}
else if( u32 < 0xfe )
{
u32 &= 0x01;
m = 6;
}
while( n < m && ( szUTF8[n] & 0xc0 ) == 0x80 )
{
u32 = ( u32 << 6 ) | ( szUTF8[n++] & 0x3f );
}
if( n < m )
{
u32 <<= 6 * ( m - n );
}
}
*uc = ( USHORT ) u32;
return n;
}
| cdpapi.c | 206 |
| STATIC ULONG | utf8pos( const BYTE * szUTF8, ULONG ulLen, ULONG ulUTF8Pos )
static ULONG utf8pos( const BYTE * szUTF8, ULONG ulLen, ULONG ulUTF8Pos )
{
if( ulUTF8Pos )
{
ULONG ul, ul2;
USHORT uc;
int n = 0;
for( ul = ul2 = 0; ul < ulLen; ++ul )
{
if( utf8tou16nextchar( szUTF8[ul], &n, &uc ) )
{
if( n == 0 )
{
if( --ulUTF8Pos == 0 )
return ul2 + 1;
ul2 = ul + 1;
}
}
}
}
return 0;
}
| cdpapi.c | 254 |
| STATIC INT | hb_cdpFindPos( const char *pszID )
static int hb_cdpFindPos( const char *pszID )
{
int iPos;
if( pszID != NULL )
{
for( iPos = 0; iPos < HB_CDP_MAX_ && s_cdpList[iPos]; iPos++ )
{
if( strcmp( s_cdpList[iPos]->id, pszID ) == 0 )
return iPos;
}
}
return -1;
}
| cdpapi.c | 278 |
| HB_EXPORT BOOL | hb_cdpRegister( PHB_CODEPAGE cdpage )
HB_EXPORT BOOL hb_cdpRegister( PHB_CODEPAGE cdpage )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_cdpRegister(%p)", cdpage ) );
if( cdpage )
{
int iPos = hb_cdpFindPos( cdpage->id );
if( iPos == -1 )
{
for( iPos = 0; iPos < HB_CDP_MAX_; iPos++ )
{
if( !s_cdpList[iPos] )
{
int i, ia, iu, il, iumax = 0, ilmax = 0;
char *ptrUpper = ( char * ) cdpage->CharsUpper;
char *ptrLower = ( char * ) cdpage->CharsLower;
char *ptr;
HB_MULTICHAR multi[12];
int nMulti = 0;
s_cdpList[iPos] = cdpage;
cdpage->lSort = cdpage->lAccInterleave || cdpage->lAccEqual;
cdpage->lChClone = FALSE;
if( cdpage->nChars )
{
int nAddLower = cdpage->nChars + ( ( cdpage->lLatin ) ? 6 : 0 );
cdpage->s_chars = ( BYTE * ) hb_xgrab( 256 );
memset( cdpage->s_chars, '\0', 256 );
cdpage->s_upper = ( BYTE * ) hb_xgrab( 256 );
cdpage->s_lower = ( BYTE * ) hb_xgrab( 256 );
if( cdpage->lAccInterleave )
{
cdpage->s_accent = ( BYTE * ) hb_xgrab( 256 );
memset( cdpage->s_accent, '\0', 256 );
}
else
cdpage->s_accent = NULL;
for( i = 0; i < 256; i++ )
{
cdpage->s_upper[i] = ( char ) toupper( ( UCHAR ) i );
cdpage->s_lower[i] = ( char ) tolower( ( UCHAR ) i );
}
if( strpbrk( cdpage->CharsUpper, "~." ) != NULL )
{
cdpage->CharsUpper = ptrUpper = hb_strdup( cdpage->CharsUpper );
cdpage->CharsLower = ptrLower = hb_strdup( cdpage->CharsLower );
cdpage->lChClone = TRUE;
}
for( i = ia = 1; *ptrUpper; i++, ia++, ptrUpper++, ptrLower++ )
{
if( ( cdpage->lAccEqual || cdpage->lAccInterleave ) &&
*ptrUpper == '~' && *ptrLower == '~' )
{
for( ptr = ptrUpper + 1; *ptr; ptr++ )
*( ptr - 1 ) = *ptr;
*( ptr - 1 ) = '\0';
for( ptr = ptrLower + 1; *ptr; ptr++ )
*( ptr - 1 ) = *ptr;
*( ptr - 1 ) = '\0';
if( cdpage->lAccEqual )
i--;
}
else if( *ptrUpper == '.' && *ptrLower == '.' &&
ptrUpper[1] && ptrUpper[2] && ptrUpper[3] == '.' &&
ptrLower[1] && ptrLower[2] && ptrLower[3] == '.' )
{
multi[nMulti].cFirst[0] = *( ptrUpper + 1 );
multi[nMulti].cFirst[1] = *( ptrLower + 1 );
multi[nMulti].cLast[0] = *( ptrUpper + 2 );
multi[nMulti].cLast[1] = *( ptrLower + 2 );
multi[nMulti].nCode = i;
for( ptr = ptrUpper + 4; *ptr; ptr++ )
*( ptr - 4 ) = *ptr;
*( ptr - 4 ) = '\0';
for( ptr = ptrLower + 4; *ptr; ptr++ )
*( ptr - 4 ) = *ptr;
*( ptr - 4 ) = '\0';
nMulti++;
ptrUpper--;
ptrLower--;
cdpage->lSort = TRUE;
continue;
}
iu = ( UCHAR ) * ptrUpper;
il = ( UCHAR ) * ptrLower;
if( iu < iumax || il < ilmax )
cdpage->lSort = TRUE;
iumax = iu;
ilmax = il;
cdpage->s_chars[iu] = ( char ) i;
cdpage->s_chars[il] = ( char ) ( i + nAddLower );
if( cdpage->lAccInterleave )
{
cdpage->s_accent[iu] = ( char ) ia;
cdpage->s_accent[il] = ( char ) ( ia + nAddLower );
}
cdpage->s_upper[il] = *ptrUpper;
cdpage->s_lower[iu] = *ptrLower;
}
if( cdpage->lLatin )
{
for( i = 91; i <= 96; i++ )
{
if( !cdpage->s_chars[i] )
cdpage->s_chars[i] = ( char ) ( cdpage->nChars + ( i - 90 ) );
}
for( i = 123; i < 256; i++ )
{
if( !cdpage->s_chars[i] )
cdpage->s_chars[i] = ( char ) ( cdpage->nChars + nAddLower + ( i - 122 ) );
}
}
/*
for( i=0; i<32; i++ )
printf( "\n %3d %3d %3d %3d %3d %3d %3d %3d",cdpage->s_chars[i*8],
cdpage->s_chars[i*8+1],cdpage->s_chars[i*8+2],
cdpage->s_chars[i*8+3],cdpage->s_chars[i*8+4],
cdpage->s_chars[i*8+5],cdpage->s_chars[i*8+6],
cdpage->s_chars[i*8+7] );
if( nMulti )
{
printf( "\n" );
for( i=0; imulti = ( PHB_MULTICHAR ) hb_xgrab( sizeof( HB_MULTICHAR ) * nMulti );
memcpy( ( BYTE * ) cdpage->multi, ( BYTE * ) multi,
sizeof( HB_MULTICHAR ) * nMulti );
cdpage->nMulti = nMulti;
}
else
cdpage->multi = NULL;
}
return TRUE;
}
}
}
}
return FALSE;
}
| cdpapi.c | 294 |
| HB_EXPORT PHB_CODEPAGE | hb_cdpFind( const char *pszID )
HB_EXPORT PHB_CODEPAGE hb_cdpFind( const char *pszID )
{
int iPos;
HB_TRACE( HB_TR_DEBUG, ( "hb_cdpFind(%s)", pszID ) );
iPos = hb_cdpFindPos( pszID );
return ( iPos != -1 ) ? s_cdpList[iPos] : NULL;
}
| cdpapi.c | 447 |
| HB_EXPORT PHB_CODEPAGE | hb_cdpSelect( PHB_CODEPAGE cdpage )
HB_EXPORT PHB_CODEPAGE hb_cdpSelect( PHB_CODEPAGE cdpage )
{
PHB_CODEPAGE cdpOld;
HB_TRACE( HB_TR_DEBUG, ( "hb_cdpSelect(%p)", cdpage ) );
cdpOld = hb_vmCDP();
if( cdpage )
hb_vmSetCDP( cdpage );
return cdpOld;
}
| cdpapi.c | 458 |
| HB_EXPORT CHAR * | hb_cdpID( void )
HB_EXPORT char * hb_cdpID( void )
{
PHB_CODEPAGE cdp;
HB_TRACE( HB_TR_DEBUG, ( "hb_cdpID()" ) );
cdp = hb_vmCDP();
return cdp ? ( char * ) cdp->id : NULL;
}
| cdpapi.c | 471 |
| HB_EXPORT CHAR * | hb_cdpSelectID( const char *pszID )
HB_EXPORT char * hb_cdpSelectID( const char *pszID )
{
char *pszIDOld;
HB_TRACE( HB_TR_DEBUG, ( "hb_cdpSelectID(%s)", pszID ) );
pszIDOld = hb_cdpID();
hb_cdpSelect( hb_cdpFind( pszID ) );
return pszIDOld;
}
| cdpapi.c | 482 |
| HB_EXPORT VOID | hb_cdpTranslate( char *psz, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut )
HB_EXPORT void hb_cdpTranslate( char *psz, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut )
{
if( cdpIn != cdpOut && cdpIn->nChars == cdpOut->nChars )
{
if( cdpIn->lAccEqual )
{
for( ; *psz; psz++ )
{
char * ptr;
ptr = strchr( ( char * ) cdpIn->CharsUpper, *psz );
if( ptr )
*psz = cdpOut->CharsUpper[ ptr - cdpIn->CharsUpper ];
else
{
ptr = strchr( ( char * ) cdpIn->CharsLower, *psz );
if( ptr )
*psz = cdpOut->CharsLower[ ptr - cdpIn->CharsLower ];
}
}
}
else
{
int nAddLower = ( cdpIn->lLatin ) ? 6 : 0;
for( ; *psz; psz++ )
{
int n = ( int ) cdpIn->s_chars[( UCHAR ) * psz];
if( n != 0 &&
( n <= cdpOut->nChars || ( n > ( cdpOut->nChars + nAddLower ) &&
n <= ( cdpOut->nChars * 2 + nAddLower ) ) ) )
{
n--;
*psz = ( n >= ( cdpOut->nChars + nAddLower ) ) ?
cdpOut->CharsLower[n - cdpOut->nChars - nAddLower] : cdpOut->CharsUpper[n];
}
}
}
}
}
| cdpapi.c | 494 |
| HB_EXPORT VOID | hb_cdpnTranslate( char *psz, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut, ULONG nChars )
HB_EXPORT void hb_cdpnTranslate( char *psz, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut, ULONG nChars )
{
if( cdpIn != cdpOut && cdpIn->nChars == cdpOut->nChars )
{
if( cdpIn->lAccEqual )
{
for( ; nChars--; psz++ )
{
char * ptr;
ptr = strchr( ( char * ) cdpIn->CharsUpper, *psz );
if( ptr )
*psz = cdpOut->CharsUpper[ ptr - cdpIn->CharsUpper ];
else
{
ptr = strchr( ( char * ) cdpIn->CharsLower, *psz );
if( ptr )
*psz = cdpOut->CharsLower[ ptr - cdpIn->CharsLower ];
}
}
}
else
{
int nAddLower = ( cdpIn->lLatin ) ? 6 : 0;
for( ; nChars--; psz++ )
{
int n = ( int ) cdpIn->s_chars[( UCHAR ) * psz];
if( n != 0 &&
( n <= cdpOut->nChars || ( n > ( cdpOut->nChars + nAddLower ) &&
n <= ( cdpOut->nChars * 2 + nAddLower ) ) ) )
{
n--;
*psz = ( n >= ( cdpOut->nChars + nAddLower ) ) ?
cdpOut->CharsLower[n - cdpOut->nChars - nAddLower] : cdpOut->CharsUpper[n];
}
}
}
}
}
| cdpapi.c | 536 |
| HB_EXPORT USHORT | hb_cdpGetU16( PHB_CODEPAGE cdp, BOOL fCtrl, BYTE ch )
HB_EXPORT USHORT hb_cdpGetU16( PHB_CODEPAGE cdp, BOOL fCtrl, BYTE ch )
{
USHORT u;
if( ( fCtrl || ch >= 32 ) && cdp && cdp->uniTable &&
cdp->uniTable->uniCodes && ch < cdp->uniTable->nChars )
{
u = cdp->uniTable->uniCodes[ch];
}
else
{
u = ch;
}
return u;
}
| cdpapi.c | 578 |
| HB_EXPORT UCHAR | hb_cdpGetChar( PHB_CODEPAGE cdp, BOOL fCtrl, USHORT uc )
HB_EXPORT UCHAR hb_cdpGetChar( PHB_CODEPAGE cdp, BOOL fCtrl, USHORT uc )
{
if( ( fCtrl || uc >= 32 ) && cdp && cdp->uniTable && cdp->uniTable->uniCodes )
{
int i;
for( i = fCtrl ? 0 : 32; i < cdp->uniTable->nChars; i++ )
{
if( cdp->uniTable->uniCodes[i] == uc )
{
uc = ( USHORT ) i;
break;
}
}
}
return uc >= 0x100 ? '?' : ( UCHAR ) uc;
}
| cdpapi.c | 594 |
| HB_EXPORT BYTE | hb_cdpUTF8StringSubstr( const BYTE * pSrc, ULONG ulLen, ULONG ulFrom, ULONG ulCount, ULONG * pulDest )
HB_EXPORT BYTE *hb_cdpUTF8StringSubstr( const BYTE * pSrc, ULONG ulLen,
ULONG ulFrom, ULONG ulCount, ULONG * pulDest )
{
ULONG ul, ulCnt, ulDst = 0;
USHORT uc;
int n;
BYTE *pDst = NULL;
if( ulCount && ulLen )
{
n = 0;
for( ul = 0; ul < ulLen && ulFrom; ++ul )
{
if( utf8tou16nextchar( pSrc[ul], &n, &uc ) )
{
if( n == 0 )
--ulFrom;
}
}
if( ul < ulLen )
{
ulFrom = ul;
ulCnt = ulCount;
n = 0;
do
{
if( utf8tou16nextchar( pSrc[ul], &n, &uc ) )
{
if( n == 0 )
--ulCnt;
}
}
while( ++ul < ulLen && ulCnt );
ulDst = ul - ulFrom;
pDst = ( BYTE * ) hb_xgrab( ulDst + 1 );
memcpy( pDst, &pSrc[ulFrom], ulDst );
}
}
if( pulDest )
*pulDest = ulDst;
return pDst;
}
| cdpapi.c | 612 |
| HB_EXPORT ULONG | hb_cdpUTF8StringPeek( const BYTE * pSrc, ULONG ulLen, ULONG ulPos )
HB_EXPORT ULONG hb_cdpUTF8StringPeek( const BYTE * pSrc, ULONG ulLen, ULONG ulPos )
{
if( ulLen )
{
ULONG ul;
USHORT uc = 0;
int n = 0;
for( ul = 0; ul < ulLen && ulPos; ++ul )
{
if( utf8tou16nextchar( pSrc[ul], &n, &uc ) )
{
if( n == 0 )
--ulPos;
}
}
if( ul < ulLen )
{
n = 0;
do
{
if( utf8tou16nextchar( pSrc[ul], &n, &uc ) )
{
if( n == 0 )
return uc;
}
}
while( ++ul < ulLen );
}
}
return 0;
}
| cdpapi.c | 659 |
| HB_EXPORT ULONG | hb_cdpUTF8StringLength( const BYTE * pSrc, ULONG ulLen )
HB_EXPORT ULONG hb_cdpUTF8StringLength( const BYTE * pSrc, ULONG ulLen )
{
ULONG ul, ulDst;
USHORT uc;
int n = 0;
for( ul = ulDst = 0; ul < ulLen; ++ul )
{
if( utf8tou16nextchar( pSrc[ul], &n, &uc ) )
{
if( n == 0 )
++ulDst;
}
}
return ulDst;
}
| cdpapi.c | 694 |
| HB_EXPORT ULONG | hb_cdpStringInUTF8Length( PHB_CODEPAGE cdp, BOOL fCtrl, const BYTE * pSrc, ULONG ulLen )
HB_EXPORT ULONG hb_cdpStringInUTF8Length( PHB_CODEPAGE cdp, BOOL fCtrl,
const BYTE * pSrc, ULONG ulLen )
{
ULONG ul, ulDst;
for( ul = ulDst = 0; ul < ulLen; ++ul )
{
ulDst += utf8Size( hb_cdpGetU16( cdp, fCtrl, pSrc[ul] ) );
}
return ulDst;
}
| cdpapi.c | 712 |
| HB_EXPORT ULONG | hb_cdpUTF8ToStrn( PHB_CODEPAGE cdp, BOOL fCtrl, const BYTE * pSrc, ULONG ulSrc, BYTE * pDst, ULONG ulDst )
HB_EXPORT ULONG hb_cdpUTF8ToStrn( PHB_CODEPAGE cdp, BOOL fCtrl,
const BYTE * pSrc, ULONG ulSrc,
BYTE * pDst, ULONG ulDst )
{
ULONG ulS, ulD;
USHORT uc = 0;
int n = 0;
for( ulS = ulD = 0; ulS < ulSrc; ++ulS )
{
if( utf8tou16nextchar( pSrc[ulS], &n, &uc ) )
{
if( n == 0 )
{
if( ulD < ulDst )
{
if( ( fCtrl || uc >= 32 ) && cdp->uniTable && cdp->uniTable->uniCodes )
{
int i;
for( i = fCtrl ? 0 : 32; i < cdp->uniTable->nChars; i++ )
{
if( cdp->uniTable->uniCodes[i] == uc )
{
uc = ( USHORT ) i;
break;
}
}
}
pDst[ulD] = uc >= 0x100 ? '?' : ( BYTE ) uc;
}
++ulD;
}
}
}
if( ulD < ulDst )
pDst[ulD] = '\0';
return ulD;
}
| cdpapi.c | 725 |
| HB_EXPORT BOOL | hb_cdpGetFromUTF8( PHB_CODEPAGE cdp, BOOL fCtrl, BYTE ch, int *n, USHORT * uc )
HB_EXPORT BOOL hb_cdpGetFromUTF8( PHB_CODEPAGE cdp, BOOL fCtrl, BYTE ch,
int *n, USHORT * uc )
{
if( utf8tou16nextchar( ch, n, uc ) )
{
if( *n == 0 && cdp && ( fCtrl || *uc >= 32 ) && cdp->uniTable && cdp->uniTable->uniCodes )
{
int i;
for( i = fCtrl ? 0 : 32; i < cdp->uniTable->nChars; i++ )
{
if( cdp->uniTable->uniCodes[i] == *uc )
{
*uc = ( USHORT ) i;
break;
}
}
}
return TRUE;
}
return FALSE;
}
| cdpapi.c | 767 |
| HB_EXPORT ULONG | hb_cdpStrnToUTF8( PHB_CODEPAGE cdp, BOOL fCtrl, const BYTE * pSrc, ULONG ulLen, BYTE * pDst )
HB_EXPORT ULONG hb_cdpStrnToUTF8( PHB_CODEPAGE cdp, BOOL fCtrl,
const BYTE * pSrc, ULONG ulLen, BYTE * pDst )
{
USHORT u, *uniCodes, nChars;
ULONG i, n;
if( cdp && cdp->uniTable )
{
if( cdp->nMulti || cdp->uniTable->lMulti )
{
/*
* TODO: this translation is bad, please fix me!!!
*/
for( i = 0, n = 0; i < ulLen; i++ )
{
u = hb_cdpGetU16( cdp, fCtrl, pSrc[i] );
n += u16toutf8( &pDst[n], u );
}
return n;
}
else
{
uniCodes = cdp->uniTable->uniCodes;
nChars = ( USHORT ) cdp->uniTable->nChars;
}
}
else
{
nChars = 0;
uniCodes = NULL;
}
for( i = 0, n = 0; i < ulLen; i++ )
{
u = pSrc[i];
if( uniCodes && u < nChars && ( fCtrl || u >= 32 ) )
u = uniCodes[u];
n += u16toutf8( &pDst[n], u );
}
pDst[n] = '\0';
return n;
}
| cdpapi.c | 790 |
| HB_EXPORT ULONG | hb_cdpStrnToU16( PHB_CODEPAGE cdp, BOOL fCtrl, const BYTE * pSrc, ULONG ulLen, BYTE * pDst )
HB_EXPORT ULONG hb_cdpStrnToU16( PHB_CODEPAGE cdp, BOOL fCtrl,
const BYTE * pSrc, ULONG ulLen, BYTE * pDst )
{
USHORT u, *uniCodes, nChars;
ULONG i;
if( cdp && cdp->uniTable )
{
if( cdp->nMulti || cdp->uniTable->lMulti )
{
/*
* TODO: this translation is bad, please fix me!!!
*/
for( i = 0; i < ulLen; i++, pDst += 2 )
{
u = hb_cdpGetU16( cdp, fCtrl, pSrc[i] );
HB_PUT_BE_UINT16( pDst, u );
}
return i << 1;
}
else
{
uniCodes = cdp->uniTable->uniCodes;
nChars = ( USHORT ) cdp->uniTable->nChars;
}
}
else
{
nChars = 0;
uniCodes = NULL;
}
for( i = 0; i < ulLen; i++, pDst += 2 )
{
u = pSrc[i];
if( uniCodes && u < nChars && ( fCtrl || u >= 32 ) )
u = uniCodes[u];
HB_PUT_BE_UINT16( pDst, u );
}
return i << 1;
}
| cdpapi.c | 834 |
| HB_EXPORT INT | hb_cdpchrcmp( char cFirst, char cSecond, PHB_CODEPAGE cdpage )
HB_EXPORT int hb_cdpchrcmp( char cFirst, char cSecond, PHB_CODEPAGE cdpage )
{
int n1, n2;
if( cFirst == cSecond )
return 0;
if( ( n1 = ( int ) cdpage->s_chars[( UCHAR ) cFirst] ) != 0 &&
( n2 = ( int ) cdpage->s_chars[( UCHAR ) cSecond] ) != 0 )
return ( n1 < n2 ) ? -1 : 1;
return ( ( UCHAR ) cFirst < ( UCHAR ) cSecond ) ? -1 : 1;
}
| cdpapi.c | 876 |
| STATIC INT | hb_cdpMultiWeight( PHB_CODEPAGE cdpage, const char *szChar )
static int hb_cdpMultiWeight( PHB_CODEPAGE cdpage, const char *szChar )
{
PHB_MULTICHAR pmulti = cdpage->multi;
int j;
for( j = 0; j < cdpage->nMulti; ++j, ++pmulti )
{
if( ( *szChar == pmulti->cFirst[0] ||
*szChar == pmulti->cFirst[1] ) &&
( *( szChar + 1 ) == pmulti->cLast[0] || *( szChar + 1 ) == pmulti->cLast[1] ) )
{
return pmulti->nCode +
( ( *szChar == pmulti->cFirst[0] ) ? 0 :
( cdpage->nChars + ( cdpage->lLatin ? 6 : 0 ) ) );
}
}
return 0;
}
| cdpapi.c | 890 |
| HB_EXPORT INT | hb_cdpcmp( const char *szFirst, ULONG ulLenFirst, const char *szSecond, ULONG ulLenSecond, PHB_CODEPAGE cdpage, BOOL fExact )
HB_EXPORT int hb_cdpcmp( const char *szFirst, ULONG ulLenFirst,
const char *szSecond, ULONG ulLenSecond,
PHB_CODEPAGE cdpage, BOOL fExact )
{
int iRet = 0, iAcc = 0, n1 = 0, n2 = 0;
ULONG ul, ulLen;
ulLen = ulLenFirst < ulLenSecond ? ulLenFirst : ulLenSecond;
for( ul = 0; ul < ulLen; ++szFirst, ++szSecond, ++ul )
{
if( *szFirst != *szSecond )
{
if( cdpage->nMulti )
{
int nd1, nd2;
if( ul > 0 )
{
nd1 = hb_cdpMultiWeight( cdpage, szFirst - 1 );
nd2 = hb_cdpMultiWeight( cdpage, szSecond - 1 );
if( nd1 )
{
if( nd2 )
{
if( nd1 == nd2 )
{
nd1 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szFirst];
nd2 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szSecond];
if( nd1 == nd2 || !nd1 || !nd2 )
{
nd1 = ( UCHAR ) * szFirst;
nd2 = ( UCHAR ) * szSecond;
}
}
}
else
nd2 = n2;
iRet = ( nd1 < nd2 ) ? -1 : 1;
break;
}
else if( nd2 )
{
iRet = ( n1 < nd2 ) ? -1 : 1;
break;
}
}
nd1 = ( ul < ulLenFirst - 1 ) ? hb_cdpMultiWeight( cdpage, szFirst ) : 0;
nd2 = ( ul < ulLenSecond - 1 ) ? hb_cdpMultiWeight( cdpage, szSecond ) : 0;
if( nd1 )
{
if( nd2 )
{
if( nd1 == nd2 )
{
nd1 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szFirst];
nd2 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szSecond];
if( nd1 == nd2 || !nd1 || !nd2 )
{
nd1 = ( UCHAR ) * szFirst;
nd2 = ( UCHAR ) * szSecond;
}
}
}
else
nd2 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szSecond];
iRet = ( nd1 < nd2 ) ? -1 : 1;
break;
}
else if( nd2 )
{
nd1 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szFirst];
iRet = ( nd1 < nd2 ) ? -1 : 1;
break;
}
}
if( ( n1 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szFirst] ) == 0 ||
( n2 = ( UCHAR ) cdpage->s_chars[( UCHAR ) * szSecond] ) == 0 )
{
/* One of characters doesn't belong to the national characters */
iRet = ( ( UCHAR ) * szFirst < ( UCHAR ) * szSecond ) ? -1 : 1;
break;
}
else if( n1 == n2 )
{
if( iAcc == 0 && ( fExact || ( ulLenFirst == ulLenSecond && cdpage->lAccInterleave ) ) )
{
if( cdpage->lAccInterleave )
iAcc = ( cdpage->s_accent[( UCHAR ) * szFirst] <
cdpage->s_accent[( UCHAR ) * szSecond] ) ? -1 : 1;
else
iAcc = ( ( UCHAR ) * szFirst < ( UCHAR ) * szSecond ) ? -1 : 1;
}
}
else
{
iRet = ( n1 < n2 ) ? -1 : 1;
break;
}
}
}
if( !iRet )
{
if( iAcc )
iRet = iAcc;
else if( ulLenSecond > ulLenFirst )
iRet = -1;
else if( fExact && ulLenSecond < ulLenFirst )
iRet = 1;
}
return iRet;
}
| cdpapi.c | 910 |
| STATIC INT | hb_cdpMultiWeightI( PHB_CODEPAGE cdpage, const char *szChar )
static int hb_cdpMultiWeightI( PHB_CODEPAGE cdpage, const char *szChar )
{
PHB_MULTICHAR pmulti = cdpage->multi;
int j;
for( j = 0; j < cdpage->nMulti; ++j, ++pmulti )
{
if( ( *szChar == pmulti->cFirst[0] ||
*szChar == pmulti->cFirst[1] ) &&
( *( szChar + 1 ) == pmulti->cLast[0] || *( szChar + 1 ) == pmulti->cLast[1] ) )
{
return pmulti->nCode;
}
}
return 0;
}
| cdpapi.c | 1025 |
| HB_EXPORT INT | hb_cdpicmp( const char *szFirst, ULONG ulLenFirst, const char *szSecond, ULONG ulLenSecond, PHB_CODEPAGE cdpage, BOOL fExact )
HB_EXPORT int hb_cdpicmp( const char *szFirst, ULONG ulLenFirst,
const char *szSecond, ULONG ulLenSecond,
PHB_CODEPAGE cdpage, BOOL fExact )
{
int iRet = 0, iAcc = 0, n1 = 0, n2 = 0, u1, u2;
ULONG ul, ulLen;
ulLen = ulLenFirst < ulLenSecond ? ulLenFirst : ulLenSecond;
for( ul = 0; ul < ulLen; ++szFirst, ++szSecond, ++ul )
{
u1 = ( UCHAR ) cdpage->s_upper[( UCHAR ) * szFirst];
u2 = ( UCHAR ) cdpage->s_upper[( UCHAR ) * szSecond];
if( u1 != u2 )
{
if( cdpage->nMulti )
{
int nd1, nd2;
if( ul > 0 )
{
nd1 = hb_cdpMultiWeightI( cdpage, szFirst - 1 );
nd2 = hb_cdpMultiWeightI( cdpage, szSecond - 1 );
if( nd1 )
{
if( nd2 )
{
if( nd1 == nd2 )
{
nd1 = ( UCHAR ) cdpage->s_chars[u1];
nd2 = ( UCHAR ) cdpage->s_chars[u2];
if( nd1 == nd2 || !nd1 || !nd2 )
{
nd1 = u1;
nd2 = u2;
}
}
}
else
nd2 = n2;
iRet = ( nd1 < nd2 ) ? -1 : 1;
break;
}
else if( nd2 )
{
iRet = ( n1 < nd2 ) ? -1 : 1;
break;
}
}
nd1 = ( ul < ulLenFirst - 1 ) ? hb_cdpMultiWeightI( cdpage, szFirst ) : 0;
nd2 = ( ul < ulLenSecond - 1 ) ? hb_cdpMultiWeightI( cdpage, szSecond ) : 0;
if( nd1 )
{
if( nd2 )
{
if( nd1 == nd2 )
{
nd1 = ( UCHAR ) cdpage->s_chars[u1];
nd2 = ( UCHAR ) cdpage->s_chars[u2];
if( nd1 == nd2 || !nd1 || !nd2 )
{
nd1 = u1;
nd2 = u2;
}
}
}
else
nd2 = ( UCHAR ) cdpage->s_chars[u2];
iRet = ( nd1 < nd2 ) ? -1 : 1;
break;
}
else if( nd2 )
{
nd1 = ( UCHAR ) cdpage->s_chars[u1];
iRet = ( nd1 < nd2 ) ? -1 : 1;
break;
}
}
if( ( n1 = ( UCHAR ) cdpage->s_chars[u1] ) == 0 ||
( n2 = ( UCHAR ) cdpage->s_chars[u2] ) == 0 )
{
/* One of characters doesn't belong to the national characters */
iRet = ( u1 < u2 ) ? -1 : 1;
break;
}
else if( n1 == n2 )
{
if( iAcc == 0 && ( fExact || ( ulLenFirst == ulLenSecond && cdpage->lAccInterleave ) ) )
{
if( cdpage->lAccInterleave )
iAcc = ( cdpage->s_accent[u1] < cdpage->s_accent[u2] ) ? -1 : 1;
else
iAcc = ( u1 < u2 ) ? -1 : 1;
}
}
else
{
iRet = ( n1 < n2 ) ? -1 : 1;
break;
}
}
}
if( !iRet )
{
if( iAcc )
iRet = iAcc;
else if( ulLenSecond > ulLenFirst )
iRet = -1;
else if( fExact && ulLenSecond < ulLenFirst )
iRet = 1;
}
return iRet;
}
| cdpapi.c | 1043 |
| HB_EXPORT VOID | hb_cdpReleaseAll( void )
HB_EXPORT void hb_cdpReleaseAll( void )
{
int iPos = 0;
while( iPos < HB_CDP_MAX_ && s_cdpList[iPos] )
{
if( s_cdpList[iPos]->s_chars )
hb_xfree( s_cdpList[iPos]->s_chars );
if( s_cdpList[iPos]->s_upper )
hb_xfree( s_cdpList[iPos]->s_upper );
if( s_cdpList[iPos]->s_lower )
hb_xfree( s_cdpList[iPos]->s_lower );
if( s_cdpList[iPos]->s_accent )
hb_xfree( s_cdpList[iPos]->s_accent );
if( s_cdpList[iPos]->multi )
hb_xfree( s_cdpList[iPos]->multi );
if( s_cdpList[iPos]->lChClone )
{
hb_xfree( ( void * ) s_cdpList[iPos]->CharsUpper );
hb_xfree( ( void * ) s_cdpList[iPos]->CharsLower );
}
iPos++;
}
}
| cdpapi.c | 1159 |
| HB_FUNC | HB_SETCODEPAGE(void)
HB_FUNC( HB_SETCODEPAGE )
{
hb_retc( hb_cdpID() );
if( ISCHAR( 1 ) )
hb_cdpSelectID( hb_parc( 1 ) );
}
| cdpapi.c | 1184 |
| HB_FUNC | HB_TRANSLATE(void)
HB_FUNC( HB_TRANSLATE )
{
ULONG ulLen = hb_parclen( 1 );
char *szIdIn = hb_parc( 2 );
char *szIdOut = hb_parc( 3 );
if( ulLen && ( szIdIn || szIdOut ) )
{
PHB_CODEPAGE cdpIn = szIdIn ? hb_cdpFind( szIdIn ) : hb_vmCDP();
PHB_CODEPAGE cdpOut = szIdOut ? hb_cdpFind( szIdOut ) : hb_vmCDP();
if( cdpIn && cdpOut && cdpIn != cdpOut )
{
char *szResult = ( char * ) hb_xgrab( ulLen + 1 );
memcpy( szResult, hb_parc( 1 ), ulLen + 1 );
hb_cdpnTranslate( szResult, cdpIn, cdpOut, ulLen );
hb_retclen_buffer( szResult, ulLen );
}
else
hb_itemReturn( hb_param( 1, HB_IT_STRING ) );
}
else
hb_retc( NULL );
}
| cdpapi.c | 1192 |
| HB_FUNC | HB_CDPLIST(void)
HB_FUNC( HB_CDPLIST )
{
int iCount, iPos;
for( iCount = 0; iCount < HB_CDP_MAX_; ++iCount )
{
if( !s_cdpList[iCount] )
break;
}
hb_reta( iCount );
for( iPos = 0; iPos < iCount; ++iPos )
{
hb_storc( s_cdpList[iPos]->id, -1, iPos + 1 );
}
}
| cdpapi.c | 1218 |
| HB_FUNC | HB_STRTOUTF8(void)
HB_FUNC( HB_STRTOUTF8 )
{
ULONG ulLen = hb_parclen( 1 ), ulDest = 0;
char *szString, *szDest = NULL;
if( ulLen )
{
PHB_CODEPAGE cdp = ISCHAR( 2 ) ? hb_cdpFind( hb_parc( 2 ) ) : hb_vmCDP();
if( cdp )
{
szString = hb_parc( 1 );
ulDest = hb_cdpStringInUTF8Length( cdp, FALSE, ( BYTE * ) szString, ulLen );
szDest = ( char * ) hb_xgrab( ulDest + 1 );
hb_cdpStrnToUTF8( cdp, FALSE, ( BYTE * ) szString, ulLen, ( BYTE * ) szDest );
}
}
if( szDest )
hb_retclen_buffer( szDest, ulDest );
else
hb_retc( NULL );
}
| cdpapi.c | 1235 |
| HB_FUNC | HB_UTF8CHR(void)
HB_FUNC( HB_UTF8CHR )
{
if( ISNUM( 1 ) )
{
char utf8Char[ HB_MAX_UTF8 ];
int iLen;
iLen = u16toutf8( ( BYTE * ) utf8Char, ( USHORT ) hb_parni( 1 ) );
hb_retclen( utf8Char, iLen );
}
else
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
}
| cdpapi.c | 1258 |
| HB_FUNC | HB_UTF8TOSTR(void)
HB_FUNC( HB_UTF8TOSTR )
{
char *szString = hb_parc( 1 );
if( szString )
{
ULONG ulLen = hb_parclen( 1 ), ulDest = 0;
char *szDest = NULL;
if( ulLen )
{
PHB_CODEPAGE cdp = ISCHAR( 2 ) ? hb_cdpFind( hb_parc( 2 ) ) : hb_vmCDP();
if( cdp )
{
szString = hb_parc( 1 );
ulDest = hb_cdpUTF8StringLength( ( BYTE * ) szString, ulLen );
szDest = ( char * ) hb_xgrab( ulDest + 1 );
hb_cdpUTF8ToStrn( cdp, FALSE, ( BYTE * ) szString, ulLen, ( BYTE * ) szDest, ulDest );
}
}
if( szDest )
hb_retclen_buffer( szDest, ulDest );
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| cdpapi.c | 1274 |
| HB_FUNC | HB_UTF8SUBSTR(void)
HB_FUNC( HB_UTF8SUBSTR )
{
char *szString = hb_parc( 1 );
int iPCount = hb_pcount();
if( szString && ( iPCount < 2 || ( ISNUM( 2 ) && ( iPCount < 3 || ISNUM( 3 ) ) ) ) )
{
char *szDest = NULL;
ULONG ulLen = hb_parclen( 1 ), ulDest = 0;
LONG lFrom = hb_parnl( 2 );
LONG lCount = iPCount < 3 ? ( LONG ) ulLen : hb_parnl( 3 );
if( lFrom < 0 )
{
lFrom += hb_cdpUTF8StringLength( ( BYTE * ) szString, ulLen );
if( lFrom < 0 )
lFrom = 0;
}
else if( lFrom )
--lFrom;
if( ulLen && lCount > 0 )
szDest = ( char * ) hb_cdpUTF8StringSubstr( ( BYTE * ) szString,
ulLen, lFrom, lCount, &ulDest );
if( szDest )
hb_retclen_buffer( szDest, ulDest );
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| cdpapi.c | 1305 |
| HB_FUNC | HB_UTF8LEFT(void)
HB_FUNC( HB_UTF8LEFT )
{
char *szString = hb_parc( 1 );
if( szString && ISNUM( 2 ) )
{
LONG lLen = hb_parnl( 2 );
ULONG ulDest = 0;
char *szDest = NULL;
if( lLen > 0 )
szDest = ( char * ) hb_cdpUTF8StringSubstr( ( BYTE * ) szString,
hb_parclen( 1 ), 0, lLen, &ulDest );
if( szDest )
hb_retclen_buffer( szDest, ulDest );
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| cdpapi.c | 1338 |
| HB_FUNC | HB_UTF8RIGHT(void)
HB_FUNC( HB_UTF8RIGHT )
{
char *szString = hb_parc( 1 );
if( szString && ISNUM( 2 ) )
{
LONG lLen = hb_parnl( 2 ), lFrom;
ULONG ulLen = hb_parclen( 1 ), ulDest = 0;
char *szDest = NULL;
if( ulLen && lLen > 0 )
{
lFrom = hb_cdpUTF8StringLength( ( BYTE * ) szString, ulLen ) - lLen;
if( lFrom < 0 )
lFrom = 0;
szDest = ( char * ) hb_cdpUTF8StringSubstr( ( BYTE * ) szString,
ulLen, lFrom, lLen, &ulDest );
}
if( szDest )
hb_retclen_buffer( szDest, ulDest );
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| cdpapi.c | 1361 |
| HB_FUNC | HB_UTF8PEEK(void)
HB_FUNC( HB_UTF8PEEK )
{
char *szString = hb_parc( 1 );
if( szString && ISNUM( 2 ) )
{
ULONG ulPos = hb_parnl( 2 );
ULONG ulLen = hb_parclen( 1 );
if( ulPos > 0 && ulPos <= ulLen )
hb_retnint( hb_cdpUTF8StringPeek( ( BYTE * ) szString, ulLen, ulPos - 1 ) );
else
hb_retni( 0 );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| cdpapi.c | 1389 |
| HB_FUNC | HB_UTF8POKE(void)
HB_FUNC( HB_UTF8POKE )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText && ISNUM( 2 ) && ISNUM( 3 ) )
{
char *szString = hb_itemGetCPtr( pText );
ULONG ulLen = hb_parclen( 1 ), ulPos;
ulPos = utf8pos( ( BYTE * ) szString, ulLen, hb_parnl( 2 ) );
if( ulPos )
{
USHORT uc, uc2;
int n, n2;
--ulPos;
uc = ( USHORT ) hb_parni( 3 );
n = utf8Size( uc );
n2 = 0;
utf8tou16nextchar( ( BYTE ) szString[ulPos], &n2, &uc2 );
++n2;
if( n == n2 )
{
pText = hb_itemUnShareString( pText );
u16toutf8( ( BYTE * ) & hb_itemGetCPtr( pText )[ulPos], uc );
hb_itemReturn( pText );
}
else
{
char *szResult = ( char * ) hb_xgrab( ulLen - n2 + n + 1 );
memcpy( szResult, szString, ulPos );
u16toutf8( ( BYTE * ) & szResult[ulPos], uc );
memcpy( szResult + ulPos + n, szString + ulPos + n2, ulLen - ulPos - n2 );
if( ISBYREF( 1 ) )
hb_storclen( szResult, ulLen - n2 + n, 1 );
hb_retclen_buffer( szResult, ulLen - n2 + n );
}
}
else
hb_itemReturn( pText );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| cdpapi.c | 1407 |
| HB_FUNC | HB_UTF8STUFF(void)
HB_FUNC( HB_UTF8STUFF )
{
char *szString = hb_parc( 1 );
if( szString && ISNUM( 2 ) && ISNUM( 3 ) && ISCHAR( 4 ) )
{
ULONG ulLen = hb_parclen( 1 );
ULONG ulPos = hb_parnl( 2 );
ULONG ulDel = hb_parnl( 3 );
ULONG ulIns = hb_parclen( 4 );
ULONG ulTot;
if( ulPos )
{
ulPos = utf8pos( ( BYTE * ) szString, ulLen, ulPos );
if( ulPos == 0 )
ulPos = ulLen;
else
ulPos--;
}
if( ulDel )
{
if( ulPos < ulLen )
{
ulDel = utf8pos( ( BYTE * ) szString + ulPos, ulLen - ulPos, ulDel + 1 );
if( ulDel == 0 )
ulDel = ulLen - ulPos;
else
ulDel--;
}
else
ulDel = 0;
}
if( ( ulTot = ulLen + ulIns - ulDel ) > 0 )
{
char *szResult = ( char * ) hb_xgrab( ulTot + 1 );
hb_xmemcpy( szResult, szString, ulPos );
hb_xmemcpy( szResult + ulPos, hb_parc( 4 ), ulIns );
hb_xmemcpy( szResult + ulPos + ulIns, szString + ulPos + ulDel,
ulLen - ( ulPos + ulDel ) );
hb_retclen_buffer( szResult, ulTot );
}
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| cdpapi.c | 1453 |
| HB_FUNC | HB_UTF8LEN(void)
HB_FUNC( HB_UTF8LEN )
{
char *szString = hb_parc( 1 );
if( szString )
hb_retnint( hb_cdpUTF8StringLength( ( BYTE * ) szString, hb_parclen( 1 ) ) );
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
/* non of numeric parameters in STRTRAN() (4-th and 5-th) refers to
* character position in string so we do not need to create new
* HB_UTF8STRTRAN() but we can safely use normal STRTRAN() function
*/
HB_FUNC_EXTERN( STRTRAN );
| cdpapi.c | 1504 |
| HB_FUNC | HB_UTF8STRTRAN(void)
HB_FUNC( HB_UTF8STRTRAN )
{
HB_FUNC_EXEC( STRTRAN )
}
| cdpapi.c | 1520 |
| chrasc.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | CHR(void)
HB_FUNC( CHR )
{
if( ISNUM( 1 ) )
{
/* NOTE: CA-Cl*pper's compiler optimizer will be wrong for those
CHR() cases where the passed parameter is a constant which
can be divided by 256 but it's not zero, in this case it
will return an empty string instead of a Chr(0). [vszakats] */
/* Believe it or not, clipper does this! */
#ifdef HB_C52_STRICT
char szChar[ 2 ];
szChar[ 0 ] = hb_parnl( 1 ) % 256;
szChar[ 1 ] = '\0';
hb_retclen( szChar, 1 );
#else
hb_retclen( hb_szAscii[ hb_parni( 1 ) & 0xff ], 1 );
#endif
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1104, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| chrasc.c | 59 |
| HB_FUNC | ASC(void)
HB_FUNC( ASC )
{
char * szValue = hb_parc( 1 );
if( szValue )
hb_retni( ( UCHAR ) szValue[ 0 ] );
else
hb_errRT_BASE_SubstR( EG_ARG, 1107, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| chrasc.c | 83 |
| colorind.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_COLORINDEX(void)
HB_FUNC( HB_COLORINDEX )
{
if( ISCHAR( 1 ) && ISNUM( 2 ) )
{
char * pszColor = hb_parc( 1 );
ULONG ulColorPos;
ULONG ulColorLen;
USHORT uiColorIndex = ( USHORT ) hb_parni( 2 );
/* Skip the given number of commas */
for( ulColorPos = 0; pszColor[ ulColorPos ] != '\0' && uiColorIndex > 0; ulColorPos++ )
{
if( pszColor[ ulColorPos ] == ',' )
uiColorIndex--;
}
/* if found, continue */
if( uiColorIndex == 0 )
{
/* Skip the spaces after the comma */
while( pszColor[ ulColorPos ] == ' ' )
ulColorPos++;
/* Search for next comma or end of string */
ulColorLen = 0;
while( pszColor[ ulColorPos + ulColorLen ] != '\0' &&
pszColor[ ulColorPos + ulColorLen ] != ',' )
ulColorLen++;
/* Skip the trailing spaces */
while( ulColorLen > 0 &&
pszColor[ ulColorPos + ulColorLen - 1 ] == ' ' )
ulColorLen--;
/* Return the string */
hb_retclen( pszColor + ulColorPos, ulColorLen );
}
else
hb_retc( NULL );
}
else
hb_retc( NULL );
}
| colorind.c | 55 |
| console.c |
| Type | Function | Source | Line |
|---|
| STATIC PHB_PRNPOS | hb_prnPos( void )
static PHB_PRNPOS hb_prnPos( void )
{
return ( PHB_PRNPOS ) hb_stackGetTSD( &s_prnPos );
}
| console.c | 113 |
| VOID | hb_conInit( void )
void hb_conInit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conInit()"));
#if !defined( HB_WIN32_IO )
/* when HB_WIN32_IO is set file handles with numbers 0, 1, 2 are
transalted inside filesys to:
GetStdHandle( STD_INPUT_HANDLE ), GetStdHandle( STD_OUTPUT_HANDLE ),
GetStdHandle( STD_ERROR_HANDLE ) */
s_hFilenoStdin = fileno( stdin );
s_hFilenoStdout = fileno( stdout );
s_hFilenoStderr = fileno( stderr );
#endif
#ifdef HB_C52_UNDOC
{
/* Undocumented CA-Cl*pper switch //STDERR:x */
int iStderr = hb_cmdargNum( "STDERR" );
if( iStderr == 0 || iStderr == 1 ) /* //STDERR with no parameter or 0 */
s_hFilenoStderr = s_hFilenoStdout;
/* disabled in default builds. It's not multiplatform and very
* dangerous because it can redirect error messages to data files
* [druzus]
*/
#ifdef HB_C52_STRICT
else if( iStderr > 0 ) /* //STDERR:x */
s_hFilenoStderr = ( HB_FHANDLE ) iStderr;
#endif
}
#endif
/*
* Some compilers open stdout and stderr in text mode, but
* Harbour needs them to be open in binary mode.
*/
hb_fsSetDevMode( s_hFilenoStdout, FD_BINARY );
hb_fsSetDevMode( s_hFilenoStderr, FD_BINARY );
hb_gtInit( s_hFilenoStdin, s_hFilenoStdout, s_hFilenoStderr );
}
| console.c | 118 |
| VOID | hb_conRelease( void )
void hb_conRelease( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conRelease()"));
/*
* Clipper does not restore screen size on exit so I removed the code with:
* hb_gtSetMode( s_originalMaxRow + 1, s_originalMaxCol + 1 );
* If the low level GT drive change some video adapter parameters which
* have to be restored on exit then it should does it in its Exit()
* method. Here we cannot force any actions because it may cause bad
* results in some GTs, f.e. when the screen size is controlled by remote
* user and not Harbour application (some terminal modes), [Druzus]
*/
hb_gtExit();
hb_fsSetDevMode( s_hFilenoStdout, FD_TEXT );
hb_fsSetDevMode( s_hFilenoStderr, FD_TEXT );
}
| console.c | 162 |
| CHAR * | hb_conNewLine( void )
char * hb_conNewLine( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conNewLine()"));
return ( char * ) s_szCrLf;
}
| console.c | 182 |
| HB_FUNC | HB_OSNEWLINE(void)
HB_FUNC( HB_OSNEWLINE )
{
hb_retc( s_szCrLf );
}
| console.c | 189 |
| VOID | hb_conOutStd( const char * pStr, ULONG ulLen )
void hb_conOutStd( const char * pStr, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conOutStd(%s, %lu)", pStr, ulLen));
if( ulLen == 0 )
ulLen = strlen( pStr );
if( ulLen > 0 )
hb_gtOutStd( ( BYTE * ) pStr, ulLen );
}
| console.c | 194 |
| VOID | hb_conOutErr( const char * pStr, ULONG ulLen )
void hb_conOutErr( const char * pStr, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conOutErr(%s, %lu)", pStr, ulLen));
if( ulLen == 0 )
ulLen = strlen( pStr );
if( ulLen > 0 )
hb_gtOutErr( ( BYTE * ) pStr, ulLen );
}
| console.c | 206 |
| VOID | hb_conOutAlt( const char * pStr, ULONG ulLen )
void hb_conOutAlt( const char * pStr, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conOutAlt(%s, %lu)", pStr, ulLen));
if( hb_setGetConsole() )
hb_gtWriteCon( ( BYTE * ) pStr, ulLen );
if( hb_setGetAlternate() && hb_setGetAltHan() != FS_ERROR )
{
/* Print to alternate file if SET ALTERNATE ON and valid alternate file */
hb_fsWriteLarge( hb_setGetAltHan(), ( BYTE * ) pStr, ulLen );
}
if( hb_setGetExtraHan() != FS_ERROR )
{
/* Print to extra file if valid alternate file */
hb_fsWriteLarge( hb_setGetExtraHan(), ( BYTE * ) pStr, ulLen );
}
if( hb_setGetPrinter() && hb_setGetPrintHan() != FS_ERROR )
{
/* Print to printer if SET PRINTER ON and valid printer file */
hb_fsWriteLarge( hb_setGetPrintHan(), ( BYTE * ) pStr, ulLen );
hb_prnPos()->col += ( USHORT ) ulLen;
}
}
| console.c | 218 |
| STATIC VOID | hb_conOutDev( const char * pStr, ULONG ulLen )
static void hb_conOutDev( const char * pStr, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conOutDev(%s, %lu)", pStr, ulLen));
if( hb_setGetPrintHan() != FS_ERROR &&
hb_stricmp( hb_setGetDevice(), "PRINTER" ) == 0 )
{
/* Display to printer if SET DEVICE TO PRINTER and valid printer file */
hb_fsWriteLarge( hb_setGetPrintHan(), ( BYTE * ) pStr, ulLen );
hb_prnPos()->col += ( USHORT ) ulLen;
}
else
/* Otherwise, display to console */
hb_gtWrite( ( BYTE * ) pStr, ulLen );
}
typedef void hb_out_func_typedef( const char *, ULONG );
| console.c | 246 |
| STATIC CHAR * | hb_itemStringCon( PHB_ITEM pItem, ULONG * pulLen, BOOL * pfFreeReq )
static char * hb_itemStringCon( PHB_ITEM pItem, ULONG * pulLen, BOOL * pfFreeReq )
{
/* logical values in device output (not console, stdout or stderr) are
shown as single letter */
if( HB_IS_LOGICAL( pItem ) )
{
*pulLen = 1;
*pfFreeReq = FALSE;
return ( char * ) ( hb_itemGetL( pItem ) ? "T" : "F" );
}
return hb_itemString( pItem, pulLen, pfFreeReq );
}
| console.c | 265 |
| STATIC VOID | hb_conOut( USHORT uiParam, hb_out_func_typedef * pOutFunc )
static void hb_conOut( USHORT uiParam, hb_out_func_typedef * pOutFunc )
{
char * pszString;
ULONG ulLen;
BOOL bFreeReq;
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_conOut(%hu, %p)", uiParam, pOutFunc));
pItem = hb_param( uiParam, HB_IT_ANY );
if( pOutFunc == hb_conOutDev )
pszString = hb_itemStringCon( pItem, &ulLen, &bFreeReq );
else
pszString = hb_itemString( pItem, &ulLen, &bFreeReq );
if( ulLen )
pOutFunc( pszString, ulLen );
if( bFreeReq )
hb_xfree( pszString );
}
| console.c | 278 |
| HB_FUNC | OUTSTD(void)
HB_FUNC( OUTSTD ) /* writes a list of values to the standard output device */
{
USHORT uiPCount = ( USHORT ) hb_pcount();
USHORT uiParam;
for( uiParam = 1; uiParam <= uiPCount; uiParam++ )
{
hb_conOut( uiParam, hb_conOutStd );
if( uiParam < uiPCount )
hb_conOutStd( " ", 1 );
}
}
| console.c | 302 |
| HB_FUNC | OUTERR(void)
HB_FUNC( OUTERR ) /* writes a list of values to the standard error device */
{
USHORT uiPCount = ( USHORT ) hb_pcount();
USHORT uiParam;
for( uiParam = 1; uiParam <= uiPCount; uiParam++ )
{
hb_conOut( uiParam, hb_conOutErr );
if( uiParam < uiPCount )
hb_conOutErr( " ", 1 );
}
}
| console.c | 315 |
| HB_FUNC | QQOUT(void)
HB_FUNC( QQOUT ) /* writes a list of values to the current device (screen or printer) and is affected by SET ALTERNATE */
{
USHORT uiPCount = ( USHORT ) hb_pcount();
USHORT uiParam;
for( uiParam = 1; uiParam <= uiPCount; uiParam++ )
{
hb_conOut( uiParam, hb_conOutAlt );
if( uiParam < uiPCount )
hb_conOutAlt( " ", 1 );
}
}
| console.c | 328 |
| HB_FUNC | QOUT(void)
HB_FUNC( QOUT )
{
hb_conOutAlt( s_szCrLf, s_iCrLfLen );
if( hb_setGetPrinter() && hb_setGetPrintHan() != FS_ERROR )
{
BYTE buf[ 256 ];
PHB_PRNPOS pPrnPos = hb_prnPos();
pPrnPos->row++;
pPrnPos->col = ( USHORT ) hb_setGetMargin();
if( pPrnPos->col )
{
if( pPrnPos->col > sizeof( buf ) )
{
BYTE * pBuf = ( BYTE * ) hb_xgrab( pPrnPos->col );
memset( pBuf, ' ', pPrnPos->col );
hb_fsWrite( hb_setGetPrintHan(), pBuf, pPrnPos->col );
hb_xfree( pBuf );
}
else
{
memset( buf, ' ', pPrnPos->col );
hb_fsWrite( hb_setGetPrintHan(), buf, pPrnPos->col );
}
}
}
HB_FUNC_EXEC( QQOUT );
}
| console.c | 341 |
| HB_FUNC | __EJECT(void)
HB_FUNC( __EJECT ) /* Ejects the current page from the printer */
{
PHB_PRNPOS pPrnPos;
if( hb_setGetPrintHan() != FS_ERROR && hb_stricmp( hb_setGetDevice(), "PRINTER" ) == 0 )
{
static const BYTE byEop[ 4 ] = { 0x0C, 0x0D, 0x00, 0x00 }; /* Buffer is 4 bytes to make CodeGuard happy */
hb_fsWrite( hb_setGetPrintHan(), byEop, 2 );
}
pPrnPos = hb_prnPos();
pPrnPos->row = pPrnPos->col = 0;
}
| console.c | 373 |
| HB_FUNC | PROW(void)
HB_FUNC( PROW ) /* Returns the current printer row position */
{
hb_retni( ( int ) hb_prnPos()->row );
}
| console.c | 387 |
| HB_FUNC | PCOL(void)
HB_FUNC( PCOL ) /* Returns the current printer row position */
{
hb_retni( ( int ) hb_prnPos()->col );
}
| console.c | 392 |
| STATIC VOID | hb_conDevPos( SHORT iRow, SHORT iCol )
static void hb_conDevPos( SHORT iRow, SHORT iCol )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conDevPos(%hd, %hd)", iRow, iCol));
/* Position printer if SET DEVICE TO PRINTER and valid printer file
otherwise position console */
if( hb_setGetPrintHan() != FS_ERROR &&
hb_stricmp( hb_setGetDevice(), "PRINTER" ) == 0 )
{
USHORT uiPRow = ( USHORT ) iRow;
USHORT uiPCol = ( USHORT ) iCol + ( USHORT ) hb_setGetMargin();
PHB_PRNPOS pPrnPos = hb_prnPos();
if( pPrnPos->row != uiPRow || pPrnPos->col != uiPCol )
{
BYTE buf[ 256 ];
int iPtr = 0;
if( pPrnPos->row != uiPRow )
{
if( ++pPrnPos->row > uiPRow )
{
memcpy( &buf[ iPtr ], "\x0C\x0D\x00\x00", 2 ); /* Source buffer is 4 bytes to make CodeGuard happy */
iPtr += 2;
pPrnPos->row = 0;
}
else
{
memcpy( &buf[ iPtr ], s_szCrLf, s_iCrLfLen );
iPtr += s_iCrLfLen;
}
while( pPrnPos->row < uiPRow )
{
if( iPtr + s_iCrLfLen > ( int ) sizeof( buf ) )
{
hb_fsWrite( hb_setGetPrintHan(), buf, ( USHORT ) iPtr );
iPtr = 0;
}
memcpy( &buf[ iPtr ], s_szCrLf, s_iCrLfLen );
iPtr += s_iCrLfLen;
++pPrnPos->row;
}
pPrnPos->col = 0;
}
else if( pPrnPos->col > uiPCol )
{
buf[ iPtr++ ] = '\x0D';
pPrnPos->col = 0;
}
while( pPrnPos->col < uiPCol )
{
if( iPtr == ( int ) sizeof( buf ) )
{
hb_fsWrite( hb_setGetPrintHan(), buf, ( USHORT ) iPtr );
iPtr = 0;
}
buf[ iPtr++ ] = ' ';
++pPrnPos->col;
}
if( iPtr )
hb_fsWrite( hb_setGetPrintHan(), buf, ( SHORT ) iPtr );
}
}
else
hb_gtSetPos( iRow, iCol );
}
| console.c | 397 |
| HB_FUNC | DEVPOS(void)
HB_FUNC( DEVPOS ) /* Sets the screen and/or printer position */
{
if( ISNUM( 1 ) && ISNUM( 2 ) )
hb_conDevPos( ( SHORT ) hb_parni( 1 ), ( SHORT ) hb_parni( 2 ) );
}
| console.c | 470 |
| HB_FUNC | SETPRC(void)
HB_FUNC( SETPRC ) /* Sets the current printer row and column positions */
{
if( hb_pcount() == 2 && ISNUM( 1 ) && ISNUM( 2 ) )
{
PHB_PRNPOS pPrnPos = hb_prnPos();
pPrnPos->row = ( USHORT ) hb_parni( 1 );
pPrnPos->col = ( USHORT ) hb_parni( 2 );
}
}
| console.c | 476 |
| HB_FUNC | DEVOUT(void)
HB_FUNC( DEVOUT ) /* writes a single value to the current device (screen or printer), but is not affected by SET ALTERNATE */
{
if( ISCHAR( 2 ) )
{
char szOldColor[ HB_CLRSTR_LEN ];
hb_gtGetColorStr( szOldColor );
hb_gtSetColorStr( hb_parc( 2 ) );
hb_conOut( 1, hb_conOutDev );
hb_gtSetColorStr( szOldColor );
}
else if( hb_pcount() >= 1 )
hb_conOut( 1, hb_conOutDev );
}
| console.c | 486 |
| HB_FUNC | DISPOUT(void)
HB_FUNC( DISPOUT ) /* writes a single value to the screen, but is not affected by SET ALTERNATE */
{
char * pszString;
ULONG ulLen;
BOOL bFreeReq;
if( ISCHAR( 2 ) )
{
char szOldColor[ HB_CLRSTR_LEN ];
hb_gtGetColorStr( szOldColor );
hb_gtSetColorStr( hb_parc( 2 ) );
pszString = hb_itemStringCon( hb_param( 1, HB_IT_ANY ), &ulLen, &bFreeReq );
hb_gtWrite( ( BYTE * ) pszString, ulLen );
if( bFreeReq )
hb_xfree( pszString );
hb_gtSetColorStr( szOldColor );
}
else if( hb_pcount() >= 1 )
{
pszString = hb_itemStringCon( hb_param( 1, HB_IT_ANY ), &ulLen, &bFreeReq );
hb_gtWrite( ( BYTE * ) pszString, ulLen );
if( bFreeReq )
hb_xfree( pszString );
}
}
| console.c | 503 |
| HB_FUNC | DISPOUTAT(void)
HB_FUNC( DISPOUTAT ) /* writes a single value to the screen at speficic position, but is not affected by SET ALTERNATE */
{
char * pszString;
ULONG ulLen;
BOOL bFreeReq;
if( ISCHAR( 4 ) )
{
char szOldColor[ HB_CLRSTR_LEN ];
hb_gtGetColorStr( szOldColor );
hb_gtSetColorStr( hb_parc( 4 ) );
pszString = hb_itemStringCon( hb_param( 3, HB_IT_ANY ), &ulLen, &bFreeReq );
hb_gtWriteAt( ( USHORT ) hb_parni( 1 ), ( USHORT ) hb_parni( 2 ), ( BYTE * ) pszString, ulLen );
if( bFreeReq )
hb_xfree( pszString );
hb_gtSetColorStr( szOldColor );
}
else if( hb_pcount() >= 3 )
{
pszString = hb_itemStringCon( hb_param( 3, HB_IT_ANY ), &ulLen, &bFreeReq );
hb_gtWriteAt( ( USHORT ) hb_parni( 1 ), ( USHORT ) hb_parni( 2 ), ( BYTE * ) pszString, ulLen );
if( bFreeReq )
hb_xfree( pszString );
}
}
| console.c | 540 |
| HB_FUNC | HB_GETSTDIN(void)
HB_FUNC( HB_GETSTDIN ) /* Return Handel for STDIN */
{
hb_retnint( ( HB_NHANDLE ) s_hFilenoStdin );
}
| console.c | 574 |
| HB_FUNC | HB_GETSTDOUT(void)
HB_FUNC( HB_GETSTDOUT ) /* Return Handel for STDOUT */
{
hb_retnint( ( HB_NHANDLE ) s_hFilenoStdout );
}
| console.c | 579 |
| HB_FUNC | HB_GETSTDERR(void)
HB_FUNC( HB_GETSTDERR ) /* Return Handel for STDERR */
{
hb_retnint( ( HB_NHANDLE ) s_hFilenoStderr );
}
| console.c | 584 |
| copyfile.c |
| Type | Function | Source | Line |
|---|
| STATIC BOOL | hb_fsCopy( char * szSource, char * szDest )
static BOOL hb_fsCopy( char * szSource, char * szDest )
{
BOOL bRetVal = FALSE;
HB_FHANDLE fhndSource;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCopy(%s, %s)", szSource, szDest));
while( ( fhndSource = hb_spOpen( ( BYTE * ) szSource, FO_READ | FO_SHARED | FO_PRIVATE ) ) == FS_ERROR )
{
USHORT uiAction = hb_errRT_BASE_Ext1( EG_OPEN, 2012, NULL, szSource, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 );
if( uiAction != E_RETRY )
break;
}
if( fhndSource != FS_ERROR )
{
HB_FHANDLE fhndDest;
while( ( fhndDest = hb_spCreate( ( BYTE * ) szDest, FC_NORMAL ) ) == FS_ERROR )
{
USHORT uiAction = hb_errRT_BASE_Ext1( EG_CREATE, 2012, NULL, szDest, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 );
if( uiAction != E_RETRY )
break;
}
if( fhndDest != FS_ERROR )
{
#if defined(HB_OS_UNIX_COMPATIBLE)
struct stat struFileInfo;
int iSuccess = fstat( fhndSource, &struFileInfo );
#endif
BYTE * buffer;
USHORT usRead;
buffer = ( BYTE * ) hb_xgrab( BUFFER_SIZE );
bRetVal = TRUE;
while( ( usRead = hb_fsRead( fhndSource, buffer, BUFFER_SIZE ) ) != 0 )
{
while( hb_fsWrite( fhndDest, buffer, usRead ) != usRead )
{
USHORT uiAction = hb_errRT_BASE_Ext1( EG_WRITE, 2016, NULL, szDest, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 );
if( uiAction != E_RETRY )
{
bRetVal = FALSE;
break;
}
}
}
hb_xfree( buffer );
#if defined(HB_OS_UNIX_COMPATIBLE)
if( iSuccess == 0 )
fchmod( fhndDest, struFileInfo.st_mode );
#endif
hb_fsClose( fhndDest );
}
hb_fsClose( fhndSource );
}
return bRetVal;
}
| copyfile.c | 64 |
| HB_FUNC | __COPYFILE(void)
HB_FUNC( __COPYFILE )
{
if( ISCHAR( 1 ) && ISCHAR( 2 ) )
{
if( ! hb_fsCopy( hb_parc( 1 ), hb_parc( 2 ) ) )
hb_retl( FALSE );
}
else
hb_errRT_BASE( EG_ARG, 2010, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); /* NOTE: Undocumented but existing Clipper Run-time error */
}
| copyfile.c | 136 |
| datec.c |
| Type | Function | Source | Line |
|---|
| CHAR * | hb_dateCMonth( int iMonth )
char * hb_dateCMonth( int iMonth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dateCMonth(%d)", iMonth));
return ( iMonth >= 1 && iMonth <= 12 ) ? ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_MONTH + iMonth - 1 ) : ( char * ) "";
}
| datec.c | 59 |
| CHAR * | hb_dateCDOW( int iDay )
char * hb_dateCDOW( int iDay )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dateCDOW(%d)", iDay));
return ( iDay >= 1 && iDay <= 7 ) ? ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_DAY + iDay - 1 ) : ( char * ) "";
}
| datec.c | 66 |
| HB_FUNC | CMONTH(void)
HB_FUNC( CMONTH )
{
PHB_ITEM pDate = hb_param( 1, HB_IT_DATE );
if( pDate )
{
int iYear, iMonth, iDay;
hb_dateDecode( hb_itemGetDL( pDate ), &iYear, &iMonth, &iDay );
hb_retc( hb_dateCMonth( iMonth ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1116, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| datec.c | 73 |
| HB_FUNC | CDOW(void)
HB_FUNC( CDOW )
{
PHB_ITEM pDate = hb_param( 1, HB_IT_DATE );
if( pDate )
{
long lDate = hb_itemGetDL( pDate );
if( lDate )
{
int iYear, iMonth, iDay;
hb_dateDecode( lDate, &iYear, &iMonth, &iDay );
hb_retc( hb_dateCDOW( hb_dateDOW( iYear, iMonth, iDay ) ) );
}
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1117, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| datec.c | 88 |
| dates.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT CHAR * | hb_dateFormat( const char * szDate, char * szFormattedDate, const char * szDateFormat )
HB_EXPORT char * hb_dateFormat( const char * szDate, char * szFormattedDate, const char * szDateFormat )
{
/*
* NOTE: szFormattedDate must point to a buffer of at least 11 bytes.
* szDateFormat must point to a buffer holding the date format to use.
*/
int format_count, digit_count, size;
HB_TRACE(HB_TR_DEBUG, ("hb_dateFormat(%s, %p, %s)", szDate, szFormattedDate, szDateFormat));
/*
* Determine the maximum size of the formatted date string
*/
size = strlen( szDateFormat );
if( size > 10 )
size = 10;
if( szDate && szFormattedDate && strlen( szDate ) == 8 ) /* A valid date is always 8 characters */
{
const char * szPtr;
int digit;
BOOL used_d, used_m, used_y;
format_count = 0;
used_d = used_m = used_y = FALSE;
szPtr = szDateFormat;
while( format_count < size )
{
digit = toupper( ( UCHAR ) *szPtr );
szPtr++;
digit_count = 1;
while( toupper( ( UCHAR ) *szPtr ) == digit && format_count < size )
{
szPtr++;
if( format_count + digit_count < size )
digit_count++;
}
switch( digit )
{
case 'D':
switch( digit_count )
{
case 4:
if( ! used_d && format_count < size )
{
/* szFormattedDate[ format_count++ ] = '0'; */
szFormattedDate[ format_count++ ] = szDate[ 6 ];
digit_count--;
}
case 3:
if( ! used_d && format_count < size )
{
/* szFormattedDate[ format_count++ ] = '0'; */
szFormattedDate[ format_count++ ] = szDate[ 6 ];
digit_count--;
}
case 2:
if( ! used_d && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 6 ];
digit_count--;
}
default:
if( ! used_d && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 7 ];
digit_count--;
}
while( digit_count-- > 0 && format_count < size )
szFormattedDate[ format_count++ ] = ( char ) digit;
}
used_d = TRUE;
break;
case 'M':
switch( digit_count )
{
case 4:
if( ! used_m && format_count < size )
{
/* szFormattedDate[ format_count++ ] = '0'; */
szFormattedDate[ format_count++ ] = szDate[ 4 ];
digit_count--;
}
case 3:
if( ! used_m && format_count < size )
{
/* szFormattedDate[ format_count++ ] = '0'; */
szFormattedDate[ format_count++ ] = szDate[ 4 ];
digit_count--;
}
case 2:
if( ! used_m && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 4 ];
digit_count--;
}
default:
if( ! used_m && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 5 ];
digit_count--;
}
while( digit_count-- > 0 && format_count < size )
szFormattedDate[ format_count++ ] = ( char ) digit;
}
used_m = TRUE;
break;
case 'Y':
switch( digit_count )
{
case 4:
if( ! used_y && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 0 ];
digit_count--;
}
case 3:
if( ! used_y && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 1 ];
digit_count--;
}
case 2:
if( ! used_y && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 2 ];
digit_count--;
}
default:
if( ! used_y && format_count < size )
{
szFormattedDate[ format_count++ ] = szDate[ 3 ];
digit_count--;
}
while( digit_count-- > 0 && format_count < size )
szFormattedDate[ format_count++ ] = ( char ) digit;
}
used_y = TRUE;
break;
default:
while( digit_count-- > 0 && format_count < size )
szFormattedDate[ format_count++ ] = ( char ) digit;
}
}
}
else
{
/* Not a valid date string, so return a blank date with separators */
format_count = size; /* size is either 8 or 10 */
hb_strncpy( szFormattedDate, szDateFormat, size );
for( digit_count = 0; digit_count < size; digit_count++ )
{
switch( szFormattedDate[ digit_count ] )
{
case 'D':
case 'd':
case 'M':
case 'm':
case 'Y':
case 'y':
szFormattedDate[ digit_count ] = ' ';
}
}
}
szFormattedDate[ format_count ] = '\0';
return szFormattedDate;
}
| dates.c | 59 |
| HB_EXPORT LONG | hb_dateUnformat( const char * szDate, const char * szDateFormat )
HB_EXPORT long hb_dateUnformat( const char * szDate, const char * szDateFormat )
{
int d_value = 0, m_value = 0, y_value = 0;
if( szDate )
{
int d_pos = 0, m_pos = 0, y_pos = 0;
int count, digit, non_digit, size;
if( ! szDateFormat )
szDateFormat = hb_setGetDateFormat();
size = strlen( szDateFormat );
for( count = 0; count < size; count++ )
{
switch( szDateFormat[ count ] )
{
case 'D':
case 'd':
if( d_pos == 0 )
{
if( m_pos == 0 && y_pos == 0 )
d_pos = 1;
else if( m_pos == 0 || y_pos == 0 )
d_pos = 2;
else
d_pos = 3;
}
break;
case 'M':
case 'm':
if( m_pos == 0 )
{
if( d_pos == 0 && y_pos == 0 )
m_pos = 1;
else if( d_pos == 0 || y_pos == 0 )
m_pos = 2;
else
m_pos = 3;
}
break;
case 'Y':
case 'y':
if( y_pos == 0 )
{
if( m_pos == 0 && d_pos == 0 )
y_pos = 1;
else if( m_pos == 0 || d_pos == 0 )
y_pos = 2;
else
y_pos = 3;
}
}
}
/* If there are non-digits at the start of the date field,
they are not to be treated as date field separators */
non_digit = 1;
size = strlen( szDate );
for( count = 0; count < size; count++ )
{
digit = szDate[ count ];
if( isdigit( digit ) )
{
/* Process the digit for the current date field */
if( d_pos == 1 )
d_value = ( d_value * 10 ) + digit - '0';
else if( m_pos == 1 )
m_value = ( m_value * 10 ) + digit - '0';
else if( y_pos == 1 )
y_value = ( y_value * 10 ) + digit - '0';
/* Treat the next non-digit as a date field separator */
non_digit = 0;
}
else if( digit != ' ' )
{
/* Process the non-digit */
if( non_digit++ == 0 )
{
/* Only move to the next date field on the first
consecutive non-digit that is encountered */
d_pos--;
m_pos--;
y_pos--;
}
}
}
if( y_value >= 0 && y_value < 100 )
{
count = hb_setGetEpoch();
digit = count / 100;
count %= 100;
if( y_value >= count )
y_value += ( digit * 100 );
else
y_value += ( ( digit * 100 ) + 100 );
}
}
return hb_dateEncode( y_value, m_value, d_value );
}
| dates.c | 237 |
| dateshb.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | CTOD(void)
HB_FUNC( CTOD )
{
if( ISCHAR( 1 ) )
hb_retdl( hb_dateUnformat( hb_parc( 1 ), hb_setGetDateFormat() ) );
else
hb_errRT_BASE_SubstR( EG_ARG, 1119, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| dateshb.c | 82 |
| HB_FUNC | DTOC(void)
HB_FUNC( DTOC )
{
if( ISDATE( 1 ) )
{
char szDate[ 9 ];
char szFormatted[ 11 ];
hb_retc( hb_dateFormat( hb_pardsbuff( szDate, 1 ), szFormatted, hb_setGetDateFormat() ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1118, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| dateshb.c | 90 |
| HB_FUNC | DTOS(void)
HB_FUNC( DTOS )
{
if( ISDATE( 1 ) )
{
char szDate[ 9 ];
hb_retc( hb_pardsbuff( szDate, 1 ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1120, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| dateshb.c | 103 |
| HB_FUNC | HB_STOD(void)
HB_FUNC( HB_STOD )
{
PHB_ITEM pDateString = hb_param( 1, HB_IT_STRING );
hb_retds( hb_itemGetCLen( pDateString ) >= 7 ? hb_itemGetCPtr( pDateString ) : NULL );
}
| dateshb.c | 117 |
| HB_FUNC | YEAR(void)
HB_FUNC( YEAR )
{
PHB_ITEM pDate = hb_param( 1, HB_IT_DATE );
if( pDate )
{
int iYear, iMonth, iDay;
hb_dateDecode( hb_itemGetDL( pDate ), &iYear, &iMonth, &iDay );
hb_retnilen( iYear, 5 );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1112, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| dateshb.c | 124 |
| HB_FUNC | MONTH(void)
HB_FUNC( MONTH )
{
PHB_ITEM pDate = hb_param( 1, HB_IT_DATE );
if( pDate )
{
int iYear, iMonth, iDay;
hb_dateDecode( hb_itemGetDL( pDate ), &iYear, &iMonth, &iDay );
hb_retnilen( iMonth, 3 );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1113, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| dateshb.c | 140 |
| HB_FUNC | DAY(void)
HB_FUNC( DAY )
{
PHB_ITEM pDate = hb_param( 1, HB_IT_DATE );
if( pDate )
{
int iYear, iMonth, iDay;
hb_dateDecode( hb_itemGetDL( pDate ), &iYear, &iMonth, &iDay );
hb_retnilen( iDay, 3 );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1114, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| dateshb.c | 156 |
| HB_FUNC | TIME(void)
HB_FUNC( TIME )
{
char szResult[ 9 ];
hb_dateTimeStr( szResult );
hb_retclen( szResult, 8 );
}
| dateshb.c | 172 |
| HB_FUNC | DATE(void)
HB_FUNC( DATE )
{
int iYear, iMonth, iDay;
hb_dateToday( &iYear, &iMonth, &iDay );
hb_retd( iYear, iMonth, iDay );
}
| dateshb.c | 179 |
| HB_FUNC | DOW(void)
HB_FUNC( DOW )
{
PHB_ITEM pDate = hb_param( 1, HB_IT_DATE );
if( pDate )
{
hb_retnilen( hb_dateJulianDOW( hb_itemGetDL( pDate ) ), 3 );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1115, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| dateshb.c | 186 |
| datesx.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | STOD(void)
HB_FUNC( STOD )
{
PHB_ITEM pDateString = hb_param( 1, HB_IT_STRING );
hb_retds( hb_itemGetCLen( pDateString ) >= 7 ? hb_itemGetCPtr( pDateString ) : NULL );
}
| datesx.c | 61 |
| defpath.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | __DEFPATH(void)
HB_FUNC( __DEFPATH )
{
char buffer[ _POSIX_PATH_MAX + 2 ];
char * szDefault;
int size = 0;
szDefault = hb_setGetDefault();
if( szDefault )
{
/* Leave enough space to append a path delimiter */
hb_strncpy( buffer, szDefault, sizeof( buffer ) - 1 );
size = strlen( buffer );
}
HB_TRACE(HB_TR_INFO, ("HB_DEFPATH: buffer is |%s|, size is %d, last char is |%c|", buffer, size, buffer[ size - 1]));
HB_TRACE(HB_TR_INFO, ("HB_DEFPATH: HB_OS_PATH_DELIM_CHR is |%c| and HB_OS_PATH_LIST_SEP_CHR is |%c|", HB_OS_PATH_DELIM_CHR, HB_OS_PATH_LIST_SEP_CHR));
/* If the path is not empty and it doesn't end with a drive or path
delimiter, then add the appropriate separator. Use ':' if the size
of the path is 1 and the list separator is not ':', otherwise use
the path delimiter. This allows the use of a drive letter delimiter
for DOS compatible operating systems while preventing it from being
with a Unix compatible OS. */
#ifdef HB_OS_HAS_DRIVE_LETTER
if( size && buffer[ size - 1 ] != HB_OS_PATH_DELIM_CHR &&
buffer[ size - 1 ] != HB_OS_DRIVE_DELIM_CHR )
{
if( size == 1 )
buffer[ size++ ] = HB_OS_DRIVE_DELIM_CHR;
else
buffer[ size++ ] = HB_OS_PATH_DELIM_CHR;
}
#else
if( size && buffer[ size - 1 ] != HB_OS_PATH_DELIM_CHR )
buffer[ size++ ] = HB_OS_PATH_DELIM_CHR;
#endif
hb_retclen( buffer, size );
}
| defpath.c | 56 |
| defpathu.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DEFPATH(void)
HB_FUNC( DEFPATH )
{
HB_FUNC_EXEC( __DEFPATH );
}
| defpathu.c | 59 |
| descend.c |
| Type | Function | Source | Line |
|---|
| VOID | hb_strDescend( char * szStringTo, const char * szStringFrom, ULONG ulLen )
void hb_strDescend( char * szStringTo, const char * szStringFrom, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strDescend(%s, %s, %lu)", szStringTo, szStringFrom, ulLen));
if( ulLen == 1 && szStringFrom[ 0 ] == '\0' )
szStringTo[ 0 ] = '\0';
else
{
for(; ulLen--; szStringTo++, szStringFrom++ )
*szStringTo = ( char ) ( 256 - *szStringFrom );
}
}
| descend.c | 56 |
| HB_FUNC | DESCEND(void)
HB_FUNC( DESCEND )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem )
{
if( HB_IS_STRING( pItem ) )
{
ULONG ulLen = hb_itemGetCLen( pItem );
if( ulLen > 0 )
{
char * szBuffer = ( char * ) hb_xgrab( ulLen + 1 );
hb_strDescend( szBuffer, hb_itemGetCPtr( pItem ), ulLen );
hb_retclen_buffer( szBuffer, ulLen );
}
else
hb_retc( NULL );
}
else if( HB_IS_DATE( pItem ) )
hb_retnl( 5231808 - hb_itemGetDL( pItem ) );
else if( HB_IS_NUMERIC( pItem ) )
hb_retnd( -1 * hb_itemGetND( pItem ) );
else if( HB_IS_LOGICAL( pItem ) )
hb_retl( ! hb_itemGetL( pItem ) );
}
}
| descend.c | 69 |
| dirdrive.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DIRCHANGE(void)
HB_FUNC( DIRCHANGE )
{
if( ISCHAR( 1 ) )
hb_retni( hb_fsChDir( ( BYTE * ) hb_parc( 1 ) ) ? 0 : hb_fsError() );
else
hb_retni( -1 );
}
| dirdrive.c | 62 |
| HB_FUNC | MAKEDIR(void)
HB_FUNC( MAKEDIR )
{
if( ISCHAR( 1 ) )
hb_retni( hb_fsMkDir( ( BYTE * ) hb_parc( 1 ) ) ? 0 : hb_fsError() );
else
hb_retni( -1 );
}
| dirdrive.c | 73 |
| HB_FUNC | DIRREMOVE(void)
HB_FUNC( DIRREMOVE )
{
if( ISCHAR( 1 ) )
hb_retni( hb_fsRmDir( ( BYTE * ) hb_parc( 1 ) ) ? 0 : hb_fsError() );
else
hb_retni( -1 );
}
| dirdrive.c | 81 |
| HB_FUNC | ISDISK(void)
HB_FUNC( ISDISK )
{
hb_retl( ( ISCHAR( 1 ) && hb_parclen( 1 ) > 0 ) ?
hb_fsIsDrv( ( BYTE )( toupper( *hb_parc( 1 ) ) - 'A' ) ) == 0 :
FALSE );
}
| dirdrive.c | 93 |
| HB_FUNC | DISKCHANGE(void)
HB_FUNC( DISKCHANGE )
{
hb_retl( ( ISCHAR( 1 ) && hb_parclen( 1 ) > 0 ) ?
hb_fsChDrv( ( BYTE )( toupper( *hb_parc( 1 ) ) - 'A' ) ) == 0 :
FALSE );
}
| dirdrive.c | 100 |
| HB_FUNC | DISKNAME(void)
HB_FUNC( DISKNAME )
{
char szDrive[ 1 ];
szDrive[ 0 ] = ( ( char ) hb_fsCurDrv() ) + 'A';
hb_retclen( szDrive, 1 );
}
| dirdrive.c | 107 |
| direct.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DIRECTORY(void)
HB_FUNC( DIRECTORY )
{
char * szDirSpec = hb_parc( 1 );
char * szAttributes = hb_parc( 2 );
BOOL fFree = FALSE;
ULONG ulMask;
PHB_ITEM pDir = hb_itemArrayNew( 0 );
PHB_FFIND ffind;
/* Get the passed attributes and convert them to Harbour Flags */
ulMask = HB_FA_ARCHIVE
| HB_FA_READONLY
| HB_FA_DEVICE
| HB_FA_TEMPORARY
| HB_FA_SPARSE
| HB_FA_REPARSE
| HB_FA_COMPRESSED
| HB_FA_OFFLINE
| HB_FA_NOTINDEXED
| HB_FA_ENCRYPTED
| HB_FA_VOLCOMP;
if( szAttributes && *szAttributes )
{
if( ( ulMask |= hb_fsAttrEncode( szAttributes ) ) & HB_FA_LABEL )
{
/* NOTE: This is Clipper Doc compatible. (not operationally) */
ulMask = HB_FA_LABEL;
}
}
if( szDirSpec && *szDirSpec )
{
szDirSpec = ( char * ) hb_fsNameConv( ( BYTE * ) szDirSpec, &fFree );
if( *szDirSpec )
{
/* CA-Cl*pper compatible behavior - add all file mask when
* last character is directory or drive separator
*/
int iLen = strlen( szDirSpec ) - 1;
#ifdef HB_OS_HAS_DRIVE_LETTER
if( szDirSpec[ iLen ] == HB_OS_PATH_DELIM_CHR ||
szDirSpec[ iLen ] == HB_OS_DRIVE_DELIM_CHR )
#else
if( szDirSpec[ iLen ] == HB_OS_PATH_DELIM_CHR )
#endif
{
if( fFree )
{
char * szTemp = hb_xstrcpy( NULL, szDirSpec, HB_OS_ALLFILE_MASK, NULL );
hb_xfree( szDirSpec );
szDirSpec = szTemp;
}
else
{
szDirSpec = hb_xstrcpy( NULL, szDirSpec, HB_OS_ALLFILE_MASK, NULL );
fFree = TRUE;
}
}
}
else
{
if( fFree )
{
hb_xfree( szDirSpec );
fFree = FALSE;
}
szDirSpec = ( char * ) HB_OS_ALLFILE_MASK;
}
}
else
szDirSpec = ( char * ) HB_OS_ALLFILE_MASK;
/* Get the file list */
if( ( ffind = hb_fsFindFirst( szDirSpec, ulMask ) ) != NULL )
{
PHB_ITEM pSubarray = hb_itemNew( NULL );
do
{
char buffer[ 32 ];
hb_arrayNew( pSubarray, F_LEN );
hb_arraySetC ( pSubarray, F_NAME, ffind->szName );
hb_arraySetNInt( pSubarray, F_SIZE, ffind->size );
hb_arraySetDL ( pSubarray, F_DATE, ffind->lDate );
hb_arraySetC ( pSubarray, F_TIME, ffind->szTime );
hb_arraySetC ( pSubarray, F_ATTR, hb_fsAttrDecode( ffind->attr, buffer ) );
/* Don't exit when array limit is reached */
hb_arrayAddForward( pDir, pSubarray );
}
while( hb_fsFindNext( ffind ) );
hb_itemRelease( pSubarray );
hb_fsFindClose( ffind );
}
if( fFree )
hb_xfree( szDirSpec );
hb_itemReturnRelease( pDir );
}
| direct.c | 106 |
| diskspac.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DISKSPACE(void)
HB_FUNC( DISKSPACE )
{
double dSpace = 0.0;
BOOL bError;
#if defined(HB_OS_DOS)
{
USHORT uiDrive = ISNUM( 1 ) ? hb_parni( 1 ) : 0;
union REGS regs;
regs.HB_XREGS.dx = uiDrive;
regs.h.ah = 0x36;
HB_DOS_INT86( 0x21, ®s, ®s );
bError = regs.HB_XREGS.ax == 0xFFFF;
if( !bError )
dSpace = ( double ) regs.HB_XREGS.bx *
( double ) regs.HB_XREGS.ax *
( double ) regs.HB_XREGS.cx;
}
#elif defined(HB_OS_WIN_32)
{
#if defined(_MSC_VER) || defined(__LCC__) || \
( defined(__GNUC__) && !defined(__RSXNT__) )
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).LowPart + \
( double ) (v).HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#else
/* NOTE: Borland doesn't seem to deal with the un-named
struct that is part of ULARGE_INTEGER
[pt] */
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).u.LowPart + \
( double ) (v).u.HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#endif
typedef BOOL ( WINAPI * P_GDFSE )( LPCSTR, PULARGE_INTEGER,
PULARGE_INTEGER, PULARGE_INTEGER );
ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes;
USHORT uiParam = ( USHORT ) hb_parni( 1 );
USHORT uiDrive = uiParam == 0 ? hb_fsCurDrv() + 1 : uiParam;
UINT uiErrMode = SetErrorMode( SEM_FAILCRITICALERRORS );
#if defined(HB_WINCE)
TCHAR lpPath[ 4 ];
lpPath[ 0 ] = ( TCHAR ) uiDrive + 'A' - 1;
lpPath[ 1 ] = ':';
lpPath[ 2 ] = '\\';
lpPath[ 3 ] = '\0';
bError = !GetDiskFreeSpaceEx( lpPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
if( !bError )
dSpace = HB_GET_LARGE_UINT( i64FreeBytesToCaller );
#else
char szPath[ 4 ];
P_GDFSE pGetDiskFreeSpaceEx = ( P_GDFSE )
GetProcAddress( GetModuleHandleA( "kernel32.dll" ),
"GetDiskFreeSpaceExA" );
szPath[ 0 ] = ( char ) uiDrive + 'A' - 1;
szPath[ 1 ] = ':';
szPath[ 2 ] = '\\';
szPath[ 3 ] = '\0';
if( pGetDiskFreeSpaceEx )
{
bError = !pGetDiskFreeSpaceEx( szPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
if( !bError )
dSpace = HB_GET_LARGE_UINT( i64FreeBytesToCaller );
}
else
{
DWORD dwSectorsPerCluster;
DWORD dwBytesPerSector;
DWORD dwNumberOfFreeClusters;
DWORD dwTotalNumberOfClusters;
bError = !GetDiskFreeSpaceA( szPath,
&dwSectorsPerCluster,
&dwBytesPerSector,
&dwNumberOfFreeClusters,
&dwTotalNumberOfClusters );
if( !bError )
dSpace = ( double ) dwNumberOfFreeClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
}
#endif
SetErrorMode( uiErrMode );
}
#elif defined(HB_OS_OS2)
{
USHORT uiDrive = ISNUM( 1 ) ? hb_parni( 1 ) : 0;
struct _FSALLOCATE fsa;
/* Query level 1 info from filesystem */
bError = DosQueryFSInfo( uiDrive, 1, &fsa, sizeof( fsa ) ) != 0;
if( !bError )
dSpace = ( double ) fsa.cUnitAvail *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
}
#elif defined(HB_OS_UNIX)
{
char * szName = hb_parc( 1 );
BOOL fFree = FALSE;
if( !szName )
szName = ( char * ) "/";
else
szName = ( char * ) hb_fsNameConv( ( BYTE * ) szName, &fFree );
{
#if defined(__WATCOMC__) || defined(__CEGCC__)
struct stat st;
bError = stat( szName, &st) != 0;
if( !bError )
dSpace = ( double ) st.st_blocks * ( double ) st.st_blksize;
#else
struct statvfs st;
bError = statvfs( szName, &st ) != 0;
if( !bError )
{
if( getuid() == 0 )
dSpace = ( double ) st.f_bfree * ( double ) st.f_bsize;
else
dSpace = ( double ) st.f_bavail * ( double ) st.f_bsize;
}
#endif
}
if( fFree )
hb_xfree( szName );
}
#else
bError = FALSE;
#endif
if( bError )
hb_errRT_BASE_Ext1( EG_OPEN, 2018, NULL, NULL, 0, EF_CANDEFAULT, HB_ERR_ARGS_BASEPARAMS );
hb_retnlen( dSpace, -1, 0 );
}
| diskspac.c | 77 |
| disksphb.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_DISKSPACE(void)
HB_FUNC( HB_DISKSPACE )
{
char szPathBuf[ 4 ];
char * szPath = hb_parc( 1 );
USHORT uiType = ISNUM( 2 ) ? ( USHORT ) hb_parni( 2 ) : HB_DISK_AVAIL;
double dSpace = 0.0;
if( uiType > HB_DISK_TOTAL )
uiType = HB_DISK_AVAIL;
if( !szPath )
{
#ifdef HB_OS_HAS_DRIVE_LETTER
if( ISNUM( 1 ) )
{
szPathBuf[ 0 ] = ( char ) hb_parni( 1 ) + 'A' - 1;
szPathBuf[ 1 ] = HB_OS_DRIVE_DELIM_CHR;
szPathBuf[ 2 ] = HB_OS_PATH_DELIM_CHR;
szPathBuf[ 3 ] = '\0';
}
else
#endif
{
szPathBuf[ 0 ] = HB_OS_PATH_DELIM_CHR;
szPathBuf[ 1 ] = '\0';
}
szPath = szPathBuf;
}
#if defined(HB_OS_DOS)
{
USHORT uiDrive = szPath[ 1 ] != HB_OS_DRIVE_DELIM_CHR ? 0 :
( szPath[ 0 ] >= 'A' && szPath[ 0 ] <= 'Z' ?
szPath[ 0 ] - 'A' + 1 :
( szPath[ 0 ] >= 'a' && szPath[ 0 ] <= 'z' ?
szPath[ 0 ] - 'a' + 1 : 0 ) );
for( ;; )
{
union REGS regs;
regs.HB_XREGS.dx = uiDrive;
regs.h.ah = 0x36;
HB_DOS_INT86( 0x21, ®s, ®s );
if( regs.HB_XREGS.ax != 0xFFFF )
{
USHORT uiClusterTotal = regs.HB_XREGS.dx;
USHORT uiClusterFree = regs.HB_XREGS.bx;
USHORT uiSecPerCluster = regs.HB_XREGS.ax;
USHORT uiSectorSize = regs.HB_XREGS.cx;
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) uiClusterFree *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) uiClusterTotal *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) uiClusterFree *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
break;
}
}
else
{
if( hb_errRT_BASE_Ext1( EG_OPEN, 2018, NULL, NULL, 0, ( EF_CANDEFAULT | EF_CANRETRY ), HB_ERR_ARGS_BASEPARAMS ) == E_RETRY )
continue;
}
break;
}
}
#elif defined(HB_OS_WIN_32)
{
#if defined(_MSC_VER) || defined(__LCC__) || \
( defined(__GNUC__) && !defined(__RSXNT__) )
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).LowPart + \
( double ) (v).HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#else
/* NOTE: Borland doesn't seem to deal with the un-named
struct that is part of ULARGE_INTEGER
[pt] */
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).u.LowPart + \
( double ) (v).u.HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#endif
typedef BOOL ( WINAPI * P_GDFSE )( LPCSTR, PULARGE_INTEGER,
PULARGE_INTEGER, PULARGE_INTEGER );
for( ;; )
{
ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes;
UINT uiErrMode = SetErrorMode( SEM_FAILCRITICALERRORS );
BOOL fResult;
#if defined(HB_WINCE)
LPTSTR lpPath = HB_TCHAR_CONVTO( szPath );
fResult = GetDiskFreeSpaceEx( lpPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
hb_fsSetIOError( fResult, 0 );
HB_TCHAR_FREE( lpPath );
if( fResult )
{
switch( uiType )
{
case HB_DISK_AVAIL:
dSpace = HB_GET_LARGE_UINT( i64FreeBytesToCaller );
break;
case HB_DISK_FREE:
dSpace = HB_GET_LARGE_UINT( i64FreeBytes );
break;
case HB_DISK_TOTAL:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes );
break;
case HB_DISK_USED:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes ) -
HB_GET_LARGE_UINT( i64FreeBytes );
break;
}
}
#else
P_GDFSE pGetDiskFreeSpaceEx = ( P_GDFSE )
GetProcAddress( GetModuleHandleA( "kernel32.dll" ),
"GetDiskFreeSpaceExA" );
if( pGetDiskFreeSpaceEx )
{
fResult = pGetDiskFreeSpaceEx( szPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
switch( uiType )
{
case HB_DISK_AVAIL:
dSpace = HB_GET_LARGE_UINT( i64FreeBytesToCaller );
break;
case HB_DISK_FREE:
dSpace = HB_GET_LARGE_UINT( i64FreeBytes );
break;
case HB_DISK_TOTAL:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes );
break;
case HB_DISK_USED:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes ) -
HB_GET_LARGE_UINT( i64FreeBytes );
break;
}
}
}
else
{
DWORD dwSectorsPerCluster;
DWORD dwBytesPerSector;
DWORD dwNumberOfFreeClusters;
DWORD dwTotalNumberOfClusters;
fResult = GetDiskFreeSpaceA( szPath,
&dwSectorsPerCluster,
&dwBytesPerSector,
&dwNumberOfFreeClusters,
&dwTotalNumberOfClusters );
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) dwNumberOfFreeClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) dwTotalNumberOfClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) dwNumberOfFreeClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
break;
}
}
}
#endif
SetErrorMode( uiErrMode );
break;
}
}
#elif defined(HB_OS_OS2)
{
struct _FSALLOCATE fsa;
USHORT rc;
USHORT uiDrive = szPath[ 1 ] != HB_OS_DRIVE_DELIM_CHR ? 0 :
( szPath[ 0 ] >= 'A' && szPath[ 0 ] <= 'Z' ?
szPath[ 0 ] - 'A' + 1 :
( szPath[ 0 ] >= 'a' && szPath[ 0 ] <= 'z' ?
szPath[ 0 ] - 'a' + 1 : 0 ) );
/* Query level 1 info from filesystem */
while( ( rc = DosQueryFSInfo( uiDrive, 1, &fsa, sizeof( fsa ) ) ) != 0 )
{
if( hb_errRT_BASE_Ext1( EG_OPEN, 2018, NULL, NULL, 0, (EF_CANDEFAULT | EF_CANRETRY), HB_ERR_ARGS_BASEPARAMS ) != E_RETRY )
break;
}
if( rc == 0 )
{
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) fsa.cUnitAvail *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) fsa.cUnit *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) fsa.cUnitAvail *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
break;
}
hb_fsSetIOError( TRUE, 0 );
}
else
hb_fsSetIOError( FALSE, 0 );
}
#elif defined(HB_OS_UNIX) && !( defined(__WATCOMC__) || defined(__CEGCC__) )
{
struct statvfs sf;
BOOL fFree = FALSE;
szPath = ( char * ) hb_fsNameConv( ( BYTE * ) szPath, &fFree );
if( statvfs( szPath, &sf ) == 0 )
{
switch( uiType )
{
case HB_DISK_AVAIL:
dSpace = ( double ) sf.f_bavail * ( double ) sf.f_bsize;
break;
case HB_DISK_FREE:
dSpace = ( double ) sf.f_bfree * ( double ) sf.f_bsize;
break;
case HB_DISK_USED:
dSpace = ( double ) ( sf.f_blocks - sf.f_bfree ) *
( double ) sf.f_bsize;
break;
case HB_DISK_TOTAL:
dSpace = ( double ) sf.f_blocks * ( double ) sf.f_bsize;
break;
}
hb_fsSetIOError( TRUE, 0 );
}
else
hb_fsSetIOError( FALSE, 0 );
if( fFree )
hb_xfree( szPath );
}
#else
{
HB_SYMBOL_UNUSED( szPath );
HB_SYMBOL_UNUSED( uiType );
}
#endif
hb_retnlen( dSpace, -1, 0 );
}
| disksphb.c | 69 |
| do.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DO(void)
HB_FUNC( DO )
{
USHORT uiPCount = ( USHORT ) hb_pcount();
if( uiPCount > 0 )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( hb_itemGetCPtr( pItem ) );
if( pDynSym )
{
hb_vmPushDynSym( pDynSym );
hb_vmPushNil();
}
else
{
hb_errRT_BASE( EG_NOFUNC, 1001, NULL, hb_itemGetCPtr( pItem ), HB_ERR_ARGS_BASEPARAMS );
return;
}
}
else if( HB_IS_BLOCK( pItem ) )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pItem );
}
else if( HB_IS_SYMBOL( pItem ) )
{
hb_vmPush( pItem );
hb_vmPushNil();
}
else
uiPCount = 0;
}
if( uiPCount > 0 )
{
USHORT uiParam;
for( uiParam = 2; uiParam <= uiPCount; ++uiParam )
hb_vmPush( hb_stackItemFromBase( uiParam ) );
hb_vmDo( ( USHORT ) ( uiPCount - 1 ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| do.c | 66 |
| empty.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | EMPTY(void)
HB_FUNC( EMPTY )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
PHB_SYMB pSym;
switch( hb_itemType( pItem ) )
{
case HB_IT_ARRAY:
hb_retl( hb_arrayLen( pItem ) == 0 );
break;
case HB_IT_HASH:
hb_retl( hb_hashLen( pItem ) == 0 );
break;
case HB_IT_STRING:
case HB_IT_MEMO:
hb_retl( hb_strEmpty( hb_itemGetCPtr( pItem ), hb_itemGetCLen( pItem ) ) );
break;
case HB_IT_INTEGER:
hb_retl( hb_itemGetNI( pItem ) == 0 );
break;
case HB_IT_LONG:
hb_retl( hb_itemGetNInt( pItem ) == 0 );
break;
case HB_IT_DOUBLE:
hb_retl( hb_itemGetND( pItem ) == 0.0 );
break;
case HB_IT_DATE:
hb_retl( hb_itemGetDL( pItem ) == 0 );
break;
case HB_IT_LOGICAL:
hb_retl( ! hb_itemGetL( pItem ) );
break;
case HB_IT_BLOCK:
hb_retl( FALSE );
break;
case HB_IT_POINTER:
hb_retl( hb_itemGetPtr( pItem ) == NULL );
break;
case HB_IT_SYMBOL:
pSym = hb_itemGetSymbol( pItem );
hb_retl( pSym == NULL || pSym->value.pFunPtr == NULL );
break;
default:
hb_retl( TRUE );
break;
}
}
| empty.c | 56 |
| errorapi.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_errorDataRelease( void * Cargo )
static void hb_errorDataRelease( void * Cargo )
{
PHB_ERRDATA pErrData = ( PHB_ERRDATA ) Cargo;
hb_itemRelease( pErrData->errorBlock );
}
static HB_TSD_NEW( s_errData, sizeof( HB_ERRDATA ), NULL, hb_errorDataRelease );
| errorapi.c | 129 |
| STATIC BOOL | hb_errGetNumCode( int * piValue, const char * szOperation )
static BOOL hb_errGetNumCode( int * piValue, const char * szOperation )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_NUMERIC );
if( pItem )
*piValue = hb_itemGetNI( pItem );
else
{
pItem = hb_errRT_BASE_Subst( EG_ARG, 0, NULL, szOperation,
HB_ERR_ARGS_BASEPARAMS );
if( !pItem )
{
*piValue = 0;
return FALSE;
}
if( !HB_IS_NUMERIC( pItem ) )
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
*piValue = hb_itemGetNI( pItem );
hb_itemRelease( pItem );
}
return TRUE;
}
| errorapi.c | 139 |
| HB_FUNC_STATIC | CARGO(void)
HB_FUNC_STATIC( CARGO )
{
hb_itemReturn( hb_errGetCargo( hb_stackSelfItem() ) );
}
| errorapi.c | 166 |
| HB_FUNC_STATIC | _CARGO(void)
HB_FUNC_STATIC( _CARGO )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem )
hb_errPutCargo( hb_stackSelfItem(), pItem );
hb_itemReturn( pItem );
}
| errorapi.c | 171 |
| HB_FUNC_STATIC | ARGS(void)
HB_FUNC_STATIC( ARGS )
{
hb_itemReturn( hb_errGetArgs( hb_stackSelfItem() ) );
}
| errorapi.c | 182 |
| HB_FUNC_STATIC | _ARGS(void)
HB_FUNC_STATIC( _ARGS )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ARRAY );
if( pItem )
hb_errPutArgsArray( hb_stackSelfItem(), pItem );
hb_itemReturn( pItem );
}
| errorapi.c | 187 |
| HB_FUNC_STATIC | CANDEFAULT(void)
HB_FUNC_STATIC( CANDEFAULT )
{
hb_retl( ( hb_errGetFlags( hb_stackSelfItem() ) & EF_CANDEFAULT ) != 0 );
}
| errorapi.c | 198 |
| HB_FUNC_STATIC | _CANDEFAULT(void)
HB_FUNC_STATIC( _CANDEFAULT )
{
if( ISLOG( 1 ) )
{
PHB_ITEM pError = hb_stackSelfItem();
BOOL fCan = hb_parl( 1 );
if( fCan )
hb_errPutFlags( pError, ( USHORT ) ( hb_errGetFlags( pError ) | EF_CANDEFAULT ) );
else
hb_errPutFlags( pError, ( USHORT ) ( hb_errGetFlags( pError ) & ~EF_CANDEFAULT ) );
hb_retl( fCan );
}
}
| errorapi.c | 203 |
| HB_FUNC_STATIC | CANRETRY(void)
HB_FUNC_STATIC( CANRETRY )
{
hb_retl( ( hb_errGetFlags( hb_stackSelfItem() ) & EF_CANRETRY ) != 0 );
}
| errorapi.c | 220 |
| HB_FUNC_STATIC | _CANRETRY(void)
HB_FUNC_STATIC( _CANRETRY )
{
if( ISLOG( 1 ) )
{
PHB_ITEM pError = hb_stackSelfItem();
BOOL fCan = hb_parl( 1 );
if( fCan )
hb_errPutFlags( pError, ( USHORT ) ( hb_errGetFlags( pError ) | EF_CANRETRY ) );
else
hb_errPutFlags( pError, ( USHORT ) ( hb_errGetFlags( pError ) & ~EF_CANRETRY ) );
hb_retl( fCan );
}
}
| errorapi.c | 225 |
| HB_FUNC_STATIC | CANSUBST(void)
HB_FUNC_STATIC( CANSUBST )
{
hb_retl( ( hb_errGetFlags( hb_stackSelfItem() ) & EF_CANSUBSTITUTE ) != 0 );
}
| errorapi.c | 242 |
| HB_FUNC_STATIC | _CANSUBST(void)
HB_FUNC_STATIC( _CANSUBST )
{
if( ISLOG( 1 ) )
{
PHB_ITEM pError = hb_stackSelfItem();
BOOL fCan = hb_parl( 1 );
if( fCan )
hb_errPutFlags( pError, ( USHORT ) ( hb_errGetFlags( pError ) | EF_CANSUBSTITUTE ) );
else
hb_errPutFlags( pError, ( USHORT ) ( hb_errGetFlags( pError ) & ~EF_CANSUBSTITUTE ) );
hb_retl( fCan );
}
}
| errorapi.c | 247 |
| HB_FUNC_STATIC | DESCRIPTION(void)
HB_FUNC_STATIC( DESCRIPTION )
{
hb_retc( hb_errGetDescription( hb_stackSelfItem() ) );
}
| errorapi.c | 264 |
| HB_FUNC_STATIC | _DESCRIPTION(void)
HB_FUNC_STATIC( _DESCRIPTION )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem && HB_IS_STRING( pItem ) )
hb_errPutDescription( hb_stackSelfItem(), hb_itemGetCPtr( pItem ) );
hb_itemReturn( pItem );
}
| errorapi.c | 269 |
| HB_FUNC_STATIC | FILENAME(void)
HB_FUNC_STATIC( FILENAME )
{
hb_retc( hb_errGetFileName( hb_stackSelfItem() ) );
}
| errorapi.c | 280 |
| HB_FUNC_STATIC | _FILENAME(void)
HB_FUNC_STATIC( _FILENAME )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem && HB_IS_STRING( pItem ) )
hb_errPutFileName( hb_stackSelfItem(), hb_itemGetCPtr( pItem ) );
hb_itemReturn( pItem );
}
| errorapi.c | 285 |
| HB_FUNC_STATIC | OPERATION(void)
HB_FUNC_STATIC( OPERATION )
{
hb_retc( hb_errGetOperation( hb_stackSelfItem() ) );
}
| errorapi.c | 296 |
| HB_FUNC_STATIC | _OPERATION(void)
HB_FUNC_STATIC( _OPERATION )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem && HB_IS_STRING( pItem ) )
hb_errPutOperation( hb_stackSelfItem(), hb_itemGetCPtr( pItem ) );
hb_itemReturn( pItem );
}
| errorapi.c | 301 |
| HB_FUNC_STATIC | SUBSYSTEM(void)
HB_FUNC_STATIC( SUBSYSTEM )
{
hb_retc( hb_errGetSubSystem( hb_stackSelfItem() ) );
}
| errorapi.c | 312 |
| HB_FUNC_STATIC | _SUBSYSTEM(void)
HB_FUNC_STATIC( _SUBSYSTEM )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem && HB_IS_STRING( pItem ) )
hb_errPutSubSystem( hb_stackSelfItem(), hb_itemGetCPtr( pItem ) );
hb_itemReturn( pItem );
}
| errorapi.c | 317 |
| HB_FUNC_STATIC | GENCODE(void)
HB_FUNC_STATIC( GENCODE )
{
hb_retni( hb_errGetGenCode( hb_stackSelfItem() ) );
}
| errorapi.c | 328 |
| HB_FUNC_STATIC | _GENCODE(void)
HB_FUNC_STATIC( _GENCODE )
{
int iValue;
if( hb_errGetNumCode( &iValue, "GENCODE" ) )
{
hb_errPutGenCode( hb_stackSelfItem(), ( USHORT ) iValue );
hb_errPutDescription( hb_stackSelfItem(),
hb_langDGetErrorDesc( iValue ) );
}
hb_retni( iValue );
}
| errorapi.c | 333 |
| HB_FUNC_STATIC | OSCODE(void)
HB_FUNC_STATIC( OSCODE )
{
hb_retni( hb_errGetOsCode( hb_stackSelfItem() ) );
}
| errorapi.c | 348 |
| HB_FUNC_STATIC | _OSCODE(void)
HB_FUNC_STATIC( _OSCODE )
{
int iValue;
if( hb_errGetNumCode( &iValue, "OSCODE" ) )
hb_errPutOsCode( hb_stackSelfItem(), ( USHORT ) iValue );
hb_retni( iValue );
}
| errorapi.c | 353 |
| HB_FUNC_STATIC | SUBCODE(void)
HB_FUNC_STATIC( SUBCODE )
{
hb_retni( hb_errGetSubCode( hb_stackSelfItem() ) );
}
| errorapi.c | 364 |
| HB_FUNC_STATIC | _SUBCODE(void)
HB_FUNC_STATIC( _SUBCODE )
{
int iValue;
if( hb_errGetNumCode( &iValue, "SUBCODE" ) )
hb_errPutSubCode( hb_stackSelfItem(), ( USHORT ) iValue );
hb_retni( iValue );
}
| errorapi.c | 369 |
| HB_FUNC_STATIC | SEVERITY(void)
HB_FUNC_STATIC( SEVERITY )
{
hb_retni( hb_errGetSeverity( hb_stackSelfItem() ) );
}
| errorapi.c | 380 |
| HB_FUNC_STATIC | _SEVERITY(void)
HB_FUNC_STATIC( _SEVERITY )
{
int iValue;
if( hb_errGetNumCode( &iValue, "SEVERITY" ) )
hb_errPutSeverity( hb_stackSelfItem(), ( USHORT ) iValue );
hb_retni( iValue );
}
| errorapi.c | 385 |
| HB_FUNC_STATIC | TRIES(void)
HB_FUNC_STATIC( TRIES )
{
hb_retni( hb_errGetTries( hb_stackSelfItem() ) );
}
| errorapi.c | 396 |
| HB_FUNC_STATIC | _TRIES(void)
HB_FUNC_STATIC( _TRIES )
{
int iValue;
if( hb_errGetNumCode( &iValue, "TRIES" ) )
hb_errPutTries( hb_stackSelfItem(), ( USHORT ) iValue );
hb_retni( iValue );
}
| errorapi.c | 401 |
| STATIC USHORT | hb_errClassCreate( void )
static USHORT hb_errClassCreate( void )
{
USHORT usClassH = hb_clsCreate( HB_TERROR_IVARCOUNT, "ERROR" );
hb_clsAdd( usClassH, "ARGS" , HB_FUNCNAME( ARGS ) );
hb_clsAdd( usClassH, "_ARGS" , HB_FUNCNAME( _ARGS ) );
hb_clsAdd( usClassH, "CANDEFAULT" , HB_FUNCNAME( CANDEFAULT ) );
hb_clsAdd( usClassH, "_CANDEFAULT" , HB_FUNCNAME( _CANDEFAULT ) );
hb_clsAdd( usClassH, "CANRETRY" , HB_FUNCNAME( CANRETRY ) );
hb_clsAdd( usClassH, "_CANRETRY" , HB_FUNCNAME( _CANRETRY ) );
hb_clsAdd( usClassH, "CANSUBSTITUTE" , HB_FUNCNAME( CANSUBST ) );
hb_clsAdd( usClassH, "_CANSUBSTITUTE", HB_FUNCNAME( _CANSUBST ) );
hb_clsAdd( usClassH, "CARGO" , HB_FUNCNAME( CARGO ) );
hb_clsAdd( usClassH, "_CARGO" , HB_FUNCNAME( _CARGO ) );
hb_clsAdd( usClassH, "DESCRIPTION" , HB_FUNCNAME( DESCRIPTION ) );
hb_clsAdd( usClassH, "_DESCRIPTION" , HB_FUNCNAME( _DESCRIPTION ) );
hb_clsAdd( usClassH, "FILENAME" , HB_FUNCNAME( FILENAME ) );
hb_clsAdd( usClassH, "_FILENAME" , HB_FUNCNAME( _FILENAME ) );
hb_clsAdd( usClassH, "GENCODE" , HB_FUNCNAME( GENCODE ) );
hb_clsAdd( usClassH, "_GENCODE" , HB_FUNCNAME( _GENCODE ) );
hb_clsAdd( usClassH, "OPERATION" , HB_FUNCNAME( OPERATION ) );
hb_clsAdd( usClassH, "_OPERATION" , HB_FUNCNAME( _OPERATION ) );
hb_clsAdd( usClassH, "OSCODE" , HB_FUNCNAME( OSCODE ) );
hb_clsAdd( usClassH, "_OSCODE" , HB_FUNCNAME( _OSCODE ) );
hb_clsAdd( usClassH, "SEVERITY" , HB_FUNCNAME( SEVERITY ) );
hb_clsAdd( usClassH, "_SEVERITY" , HB_FUNCNAME( _SEVERITY ) );
hb_clsAdd( usClassH, "SUBCODE" , HB_FUNCNAME( SUBCODE ) );
hb_clsAdd( usClassH, "_SUBCODE" , HB_FUNCNAME( _SUBCODE ) );
hb_clsAdd( usClassH, "SUBSYSTEM" , HB_FUNCNAME( SUBSYSTEM ) );
hb_clsAdd( usClassH, "_SUBSYSTEM" , HB_FUNCNAME( _SUBSYSTEM ) );
hb_clsAdd( usClassH, "TRIES" , HB_FUNCNAME( TRIES ) );
hb_clsAdd( usClassH, "_TRIES" , HB_FUNCNAME( _TRIES ) );
return usClassH;
}
| errorapi.c | 412 |
| HB_FUNC | ERRORNEW(void)
HB_FUNC( ERRORNEW )
{
hb_itemReturnRelease( hb_errNew() );
}
| errorapi.c | 448 |
| HB_FUNC | __ERRINHANDLER(void)
HB_FUNC( __ERRINHANDLER )
{
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
}
| errorapi.c | 456 |
| HB_FUNC | ERRORBLOCK(void)
HB_FUNC( ERRORBLOCK )
{
PHB_ITEM pNewErrorBlock = hb_param( 1, HB_IT_BLOCK );
PHB_ITEM pErrorBlock = hb_errorBlock();
hb_itemReturn( pErrorBlock );
if( pNewErrorBlock )
{
hb_itemCopy( pErrorBlock, pNewErrorBlock );
}
}
| errorapi.c | 461 |
| PHB_ITEM | hb_errorBlock( void )
PHB_ITEM hb_errorBlock( void )
{
PHB_ERRDATA pErrData = ( PHB_ERRDATA ) hb_stackGetTSD( &s_errData );
if( !pErrData->errorBlock )
pErrData->errorBlock = hb_itemNew( NULL );
return pErrData->errorBlock;
}
| errorapi.c | 473 |
| HB_ERROR_INFO_PTR | hb_errorHandler( HB_ERROR_INFO_PTR pNewHandler )
HB_ERROR_INFO_PTR hb_errorHandler( HB_ERROR_INFO_PTR pNewHandler )
{
PHB_ERRDATA pErrData = ( PHB_ERRDATA ) hb_stackGetTSD( &s_errData );
HB_ERROR_INFO_PTR pOld = pErrData->errorHandler;
if( pNewHandler )
pNewHandler->Previous = pErrData->errorHandler;
pErrData->errorHandler = pNewHandler;
return pOld;
}
| errorapi.c | 483 |
| HB_FUNC | DOSERROR(void)
HB_FUNC( DOSERROR )
{
PHB_ERRDATA pErrData = ( PHB_ERRDATA ) hb_stackGetTSD( &s_errData );
hb_retni( pErrData->uiErrorDOS );
if( ISNUM( 1 ) )
pErrData->uiErrorDOS = ( USHORT ) hb_parni( 1 );
}
| errorapi.c | 500 |
| VOID | hb_errInit( void )
void hb_errInit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errInit()"));
/* error function */
hb_dynsymNew( &s_symErrorNew );
/* Create error class and base object */
s_pError = hb_itemNew( NULL );
hb_clsAssociate( hb_errClassCreate() );
hb_itemMove( s_pError, hb_stackReturnItem() );
}
| errorapi.c | 510 |
| VOID | hb_errExit( void )
void hb_errExit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errExit()"));
hb_itemRelease( s_pError );
s_pError = NULL;
}
| errorapi.c | 523 |
| PHB_ITEM | hb_errNew( void )
PHB_ITEM hb_errNew( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errNew()"));
if( !s_pError || !HB_IS_OBJECT( s_pError ) )
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
return hb_arrayClone( s_pError );
}
| errorapi.c | 531 |
| USHORT | hb_errLaunch( PHB_ITEM pError )
USHORT hb_errLaunch( PHB_ITEM pError )
{
USHORT uiAction = E_DEFAULT; /* Needed to avoid GCC -O2 warning */
HB_TRACE(HB_TR_DEBUG, ("hb_errLaunch(%p)", pError));
if( pError )
{
PHB_ERRDATA pErrData = ( PHB_ERRDATA ) hb_stackGetTSD( &s_errData );
PHB_ITEM pResult;
/* Check if we have a valid error handler */
if( !pErrData->errorBlock || hb_itemType( pErrData->errorBlock ) != HB_IT_BLOCK )
hb_errInternal( HB_EI_ERRNOBLOCK, NULL, NULL, NULL );
/* Check if the error launcher was called too many times recursively */
if( pErrData->iLaunchCount == HB_ERROR_LAUNCH_MAX )
hb_errInternal( HB_EI_ERRTOOMANY, NULL, NULL, NULL );
/* Launch the error handler: "lResult := EVAL( ErrorBlock(), oError )" */
pErrData->iLaunchCount++;
/* set DOSERROR() to last OS error code */
pErrData->uiErrorDOS = hb_errGetOsCode( pError );
if( pErrData->errorHandler )
{
/* there is a low-level error handler defined - use it instead
* of normal Harbour-level one
*/
pErrData->errorHandler->Error = pError;
pErrData->errorHandler->ErrorBlock = pErrData->errorBlock;
pResult = ( pErrData->errorHandler->Func )( pErrData->errorHandler );
pErrData->errorHandler->Error = NULL;
}
else
pResult = hb_itemDo( pErrData->errorBlock, 1, pError );
pErrData->iLaunchCount--;
/* Check results */
if( hb_vmRequestQuery() != 0 )
{
if( pResult )
hb_itemRelease( pResult );
uiAction = E_BREAK;
}
else if( pResult )
{
BOOL bFailure = FALSE;
USHORT uiFlags = hb_errGetFlags( pError );
/* If the error block didn't return a logical value, */
/* or the canSubstitute flag has been set, consider it as a failure */
if( hb_itemType( pResult ) != HB_IT_LOGICAL || ( uiFlags & EF_CANSUBSTITUTE ) )
bFailure = TRUE;
else
{
uiAction = hb_itemGetL( pResult ) ? E_RETRY : E_DEFAULT;
if( ( uiAction == E_DEFAULT && !( uiFlags & EF_CANDEFAULT ) ) ||
( uiAction == E_RETRY && !( uiFlags & EF_CANRETRY ) ) )
bFailure = TRUE;
}
hb_itemRelease( pResult );
if( bFailure )
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
/* Add one try to the counter. */
if( uiAction == E_RETRY )
hb_errPutTries( pError, ( USHORT ) ( hb_errGetTries( pError ) + 1 ) );
}
else
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
}
else
uiAction = E_RETRY; /* Clipper does this, undocumented */
return uiAction;
}
/* This error launcher should be used in those situations, where the error
handler is expected to return a value to be substituted as the result of
a failed operation. [vszakats] */
| errorapi.c | 541 |
| PHB_ITEM | hb_errLaunchSubst( PHB_ITEM pError )
PHB_ITEM hb_errLaunchSubst( PHB_ITEM pError )
{
PHB_ITEM pResult;
HB_TRACE(HB_TR_DEBUG, ("hb_errLaunchSubst(%p)", pError));
if( pError )
{
PHB_ERRDATA pErrData = ( PHB_ERRDATA ) hb_stackGetTSD( &s_errData );
/* Check if we have a valid error handler */
if( !pErrData->errorBlock || hb_itemType( pErrData->errorBlock ) != HB_IT_BLOCK )
hb_errInternal( HB_EI_ERRNOBLOCK, NULL, NULL, NULL );
/* Check if the error launcher was called too many times recursively */
if( pErrData->iLaunchCount == HB_ERROR_LAUNCH_MAX )
hb_errInternal( HB_EI_ERRTOOMANY, NULL, NULL, NULL );
/* Launch the error handler: "xResult := EVAL( ErrorBlock(), oError )" */
pErrData->iLaunchCount++;
/* set DOSERROR() to last OS error code */
pErrData->uiErrorDOS = hb_errGetOsCode( pError );
if( pErrData->errorHandler )
{
/* there is a low-level error handler defined - use it instead
* of normal Harbour-level one
*/
pErrData->errorHandler->Error = pError;
pErrData->errorHandler->ErrorBlock = pErrData->errorBlock;
pResult = ( pErrData->errorHandler->Func )( pErrData->errorHandler );
pErrData->errorHandler->Error = NULL;
}
else
pResult = hb_itemDo( pErrData->errorBlock, 1, pError );
pErrData->iLaunchCount--;
/* Check results */
if( hb_vmRequestQuery() != 0 )
{
if( pResult )
hb_itemRelease( pResult );
pResult = NULL;
}
else
{
/* If the canSubstitute flag has not been set,
consider it as a failure. */
if( ! ( hb_errGetFlags( pError ) & EF_CANSUBSTITUTE ) )
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
}
}
else
pResult = hb_itemNew( NULL );
return pResult;
}
| errorapi.c | 635 |
| VOID | hb_errRelease( PHB_ITEM pError )
void hb_errRelease( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errRelease(%p)", pError));
/* NOTE: NULL pointer is checked by hb_itemRelease() [vszakats] */
hb_itemRelease( pError );
}
| errorapi.c | 695 |
| PHB_ITEM | hb_errGetCargo( PHB_ITEM pError )
PHB_ITEM hb_errGetCargo( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetCargo(%p)", pError));
return hb_arrayGetItemPtr( pError, HB_TERROR_CARGO );
}
| errorapi.c | 703 |
| PHB_ITEM | hb_errPutCargo( PHB_ITEM pError, PHB_ITEM pCargo )
PHB_ITEM hb_errPutCargo( PHB_ITEM pError, PHB_ITEM pCargo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutCargo(%p, %p)", pError, pCargo));
hb_arraySet( pError, HB_TERROR_CARGO, pCargo );
return pError;
}
| errorapi.c | 710 |
| PHB_ITEM | hb_errGetArgs( PHB_ITEM pError )
PHB_ITEM hb_errGetArgs( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetArgs(%p)", pError));
return hb_arrayGetItemPtr( pError, HB_TERROR_ARGS );
}
| errorapi.c | 719 |
| PHB_ITEM | hb_errPutArgsArray( PHB_ITEM pError, PHB_ITEM pArgs )
PHB_ITEM hb_errPutArgsArray( PHB_ITEM pError, PHB_ITEM pArgs )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutArgsArray(%p, %p)", pError, pArgs));
hb_arraySet( pError, HB_TERROR_ARGS, pArgs );
return pError;
}
| errorapi.c | 726 |
| CHAR * | hb_errGetDescription( PHB_ITEM pError )
char * hb_errGetDescription( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetDescription(%p)", pError));
return hb_arrayGetCPtr( pError, HB_TERROR_DESCRIPTION );
}
| errorapi.c | 735 |
| PHB_ITEM | hb_errPutDescription( PHB_ITEM pError, const char * szDescription )
PHB_ITEM hb_errPutDescription( PHB_ITEM pError, const char * szDescription )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutDescription(%p, %s)", pError, szDescription));
hb_arraySetC( pError, HB_TERROR_DESCRIPTION, szDescription );
return pError;
}
| errorapi.c | 742 |
| CHAR * | hb_errGetFileName( PHB_ITEM pError )
char * hb_errGetFileName( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetFileName(%p)", pError));
return hb_arrayGetCPtr( pError, HB_TERROR_FILENAME );
}
| errorapi.c | 751 |
| PHB_ITEM | hb_errPutFileName( PHB_ITEM pError, const char * szFileName )
PHB_ITEM hb_errPutFileName( PHB_ITEM pError, const char * szFileName )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutFileName(%p, %s)", pError, szFileName));
hb_arraySetC( pError, HB_TERROR_FILENAME, szFileName );
return pError;
}
| errorapi.c | 758 |
| USHORT | hb_errGetGenCode( PHB_ITEM pError )
USHORT hb_errGetGenCode( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetGenCode(%p)", pError));
return ( USHORT ) hb_arrayGetNI( pError, HB_TERROR_GENCODE );
}
| errorapi.c | 767 |
| PHB_ITEM | hb_errPutGenCode( PHB_ITEM pError, USHORT uiGenCode )
PHB_ITEM hb_errPutGenCode( PHB_ITEM pError, USHORT uiGenCode )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutGenCode(%p, %hu)", pError, uiGenCode));
hb_arraySetNI( pError, HB_TERROR_GENCODE, uiGenCode );
return pError;
}
| errorapi.c | 774 |
| CHAR * | hb_errGetOperation( PHB_ITEM pError )
char * hb_errGetOperation( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetOperation(%p)", pError));
return hb_arrayGetCPtr( pError, HB_TERROR_OPERATION );
}
| errorapi.c | 783 |
| PHB_ITEM | hb_errPutOperation( PHB_ITEM pError, const char * szOperation )
PHB_ITEM hb_errPutOperation( PHB_ITEM pError, const char * szOperation )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutOperation(%p, %s)", pError, szOperation));
if( szOperation == HB_ERR_FUNCNAME )
{
PHB_SYMB pSym = hb_itemGetSymbol( hb_stackBaseItem() );
if( pSym )
szOperation = pSym->szName;
}
hb_arraySetC( pError, HB_TERROR_OPERATION, szOperation );
return pError;
}
| errorapi.c | 790 |
| USHORT | hb_errGetOsCode( PHB_ITEM pError )
USHORT hb_errGetOsCode( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetOsCode(%p)", pError));
return ( USHORT ) hb_arrayGetNI( pError, HB_TERROR_OSCODE );
}
| errorapi.c | 806 |
| PHB_ITEM | hb_errPutOsCode( PHB_ITEM pError, USHORT uiOsCode )
PHB_ITEM hb_errPutOsCode( PHB_ITEM pError, USHORT uiOsCode )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutOsCode(%p, %hu)", pError, uiOsCode));
hb_arraySetNI( pError, HB_TERROR_OSCODE, uiOsCode );
return pError;
}
| errorapi.c | 813 |
| USHORT | hb_errGetSeverity( PHB_ITEM pError )
USHORT hb_errGetSeverity( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetSeverity(%p)", pError));
return ( USHORT ) hb_arrayGetNI( pError, HB_TERROR_SEVERITY );
}
| errorapi.c | 822 |
| PHB_ITEM | hb_errPutSeverity( PHB_ITEM pError, USHORT uiSeverity )
PHB_ITEM hb_errPutSeverity( PHB_ITEM pError, USHORT uiSeverity )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutSeverity(%p, %hu)", pError, uiSeverity));
hb_arraySetNI( pError, HB_TERROR_SEVERITY, uiSeverity );
return pError;
}
| errorapi.c | 829 |
| USHORT | hb_errGetSubCode( PHB_ITEM pError )
USHORT hb_errGetSubCode( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetSubCode(%p)", pError));
return ( USHORT ) hb_arrayGetNI( pError, HB_TERROR_SUBCODE );
}
| errorapi.c | 838 |
| PHB_ITEM | hb_errPutSubCode( PHB_ITEM pError, USHORT uiSubCode )
PHB_ITEM hb_errPutSubCode( PHB_ITEM pError, USHORT uiSubCode )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutSubCode(%p, %hu)", pError, uiSubCode));
hb_arraySetNI( pError, HB_TERROR_SUBCODE, uiSubCode );
return pError;
}
| errorapi.c | 845 |
| CHAR * | hb_errGetSubSystem( PHB_ITEM pError )
char * hb_errGetSubSystem( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetSubSytem(%p)", pError));
return hb_arrayGetCPtr( pError, HB_TERROR_SUBSYSTEM );
}
| errorapi.c | 854 |
| PHB_ITEM | hb_errPutSubSystem( PHB_ITEM pError, const char * szSubSystem )
PHB_ITEM hb_errPutSubSystem( PHB_ITEM pError, const char * szSubSystem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutSubSytem(%p, %s)", pError, szSubSystem));
hb_arraySetC( pError, HB_TERROR_SUBSYSTEM, szSubSystem );
return pError;
}
| errorapi.c | 861 |
| USHORT | hb_errGetTries( PHB_ITEM pError )
USHORT hb_errGetTries( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetTries(%p)", pError));
return ( USHORT ) hb_arrayGetNI( pError, HB_TERROR_TRIES );
}
| errorapi.c | 870 |
| PHB_ITEM | hb_errPutTries( PHB_ITEM pError, USHORT uiTries )
PHB_ITEM hb_errPutTries( PHB_ITEM pError, USHORT uiTries )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutTries(%p, %hu)", pError, uiTries));
hb_arraySetNI( pError, HB_TERROR_TRIES, uiTries );
return pError;
}
| errorapi.c | 877 |
| USHORT | hb_errGetFlags( PHB_ITEM pError )
USHORT hb_errGetFlags( PHB_ITEM pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errGetFlags(%p)", pError));
return ( USHORT ) hb_arrayGetNI( pError, HB_TERROR_FLAGS );
}
| errorapi.c | 886 |
| PHB_ITEM | hb_errPutFlags( PHB_ITEM pError, USHORT uiFlags )
PHB_ITEM hb_errPutFlags( PHB_ITEM pError, USHORT uiFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_errPutFlags(%p, %hu)", pError, uiFlags));
uiFlags &= EF_CANRETRY | EF_CANSUBSTITUTE | EF_CANDEFAULT;
hb_arraySetNI( pError, HB_TERROR_FLAGS, uiFlags );
return pError;
}
| errorapi.c | 893 |
| PHB_ITEM | hb_errPutArgs( PHB_ITEM pError, ULONG ulArgCount, ... )
PHB_ITEM hb_errPutArgs( PHB_ITEM pError, ULONG ulArgCount, ... )
{
PHB_ITEM pArray;
ULONG ulArgPos;
va_list va;
HB_TRACE(HB_TR_DEBUG, ("hb_errPutArgs(%p, %hu, ...)", pError, ulArgCount));
pArray = hb_itemArrayNew( ulArgCount );
/* Build the array from the passed arguments. */
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
hb_itemArrayPut( pArray, ulArgPos, va_arg( va, PHB_ITEM ) );
va_end( va );
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
return pError;
}
| errorapi.c | 903 |
| PHB_ITEM | hb_errRT_New( USHORT uiSeverity, const char * szSubSystem, ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiOsCode, USHORT uiFlags )
PHB_ITEM hb_errRT_New(
USHORT uiSeverity,
const char * szSubSystem,
ULONG ulGenCode,
ULONG ulSubCode,
const char * szDescription,
const char * szOperation,
USHORT uiOsCode,
USHORT uiFlags )
{
PHB_ITEM pError = hb_errNew();
hb_errPutSeverity( pError, uiSeverity );
hb_errPutSubSystem( pError, szSubSystem ? szSubSystem : HB_ERR_SS_BASE );
hb_errPutGenCode( pError, ( USHORT ) ulGenCode );
hb_errPutSubCode( pError, ( USHORT ) ulSubCode );
hb_errPutDescription( pError, szDescription ? szDescription : ( const char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ERRDESC + ulGenCode ) );
hb_errPutOperation( pError, szOperation ? szOperation : "" );
hb_errPutOsCode( pError, uiOsCode );
hb_errPutFlags( pError, uiFlags );
return pError;
}
| errorapi.c | 931 |
| PHB_ITEM | hb_errRT_New_Subst( USHORT uiSeverity, const char * szSubSystem, ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiOsCode, USHORT uiFlags )
PHB_ITEM hb_errRT_New_Subst(
USHORT uiSeverity,
const char * szSubSystem,
ULONG ulGenCode,
ULONG ulSubCode,
const char * szDescription,
const char * szOperation,
USHORT uiOsCode,
USHORT uiFlags )
{
PHB_ITEM pError = hb_errNew();
hb_errPutSeverity( pError, uiSeverity );
hb_errPutSubSystem( pError, szSubSystem ? szSubSystem : HB_ERR_SS_BASE );
hb_errPutGenCode( pError, ( USHORT ) ulGenCode );
hb_errPutSubCode( pError, ( USHORT ) ulSubCode );
hb_errPutDescription( pError, szDescription ? szDescription : ( const char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ERRDESC + ulGenCode ) );
hb_errPutOperation( pError, szOperation ? szOperation : "" );
hb_errPutOsCode( pError, uiOsCode );
hb_errPutFlags( pError, ( USHORT ) ( uiFlags | EF_CANSUBSTITUTE ) );
return pError;
}
| errorapi.c | 955 |
| PHB_ITEM | hb_errRT_SubstParams( const char *szSubSystem, ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation )
PHB_ITEM hb_errRT_SubstParams( const char *szSubSystem, ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation )
{
PHB_ITEM pRetVal;
PHB_ITEM pError;
PHB_ITEM pArray;
HB_TRACE_STEALTH( HB_TR_DEBUG, ( "hb_errRT_SubstParams()") );
pError = hb_errRT_New_Subst( ES_ERROR, szSubSystem ? szSubSystem : HB_ERR_SS_BASE,
ulGenCode, ulSubCode, szDescription, szOperation, 0, EF_NONE );
pArray = hb_arrayBaseParams();
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
/* Ok, launch... */
pRetVal = hb_errLaunchSubst( pError );
hb_itemRelease( pError );
return pRetVal;
}
| errorapi.c | 979 |
| HB_FUNC | __ERRRT_BASE(void)
HB_FUNC( __ERRRT_BASE )
{
hb_errRT_BASE( ( ULONG ) hb_parnl( 1 ),
( ULONG ) hb_parnl( 2 ),
hb_parc( 3 ),
hb_parc( 4 ),
( USHORT ) ( hb_pcount() > 5 && hb_parni( 5 ) > 0 ? 1 : 0 ),
hb_param( 6, HB_IT_ANY ) );
}
| errorapi.c | 1007 |
| HB_FUNC | __ERRRT_SBASE(void)
HB_FUNC( __ERRRT_SBASE )
{
hb_errRT_BASE_SubstR( ( ULONG ) hb_parnl( 1 ),
( ULONG ) hb_parnl( 2 ),
hb_parc( 3 ),
hb_parc( 4 ),
( USHORT ) ( hb_pcount() > 5 && hb_parni( 5 ) > 0 ? 1 : 0 ),
hb_param( 6, HB_IT_ANY ) );
}
| errorapi.c | 1017 |
| USHORT | hb_errRT_BASE( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... )
USHORT hb_errRT_BASE( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... )
{
USHORT uiAction;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
ULONG ulArgPos;
/* I replaced EF_CANRETRY with EF_NONE for Clipper compatibility
* If it's wrong and I missed sth please fix me, Druzus.
*/
pError = hb_errRT_New( ES_ERROR, HB_ERR_SS_BASE, ulGenCode, ulSubCode, szDescription, szOperation, 0, EF_NONE /* EF_CANRETRY */ );
/* Build the array from the passed arguments. */
if( ulArgCount == 0 )
{
pArray = NULL;
}
else if( ulArgCount == HB_ERR_ARGS_BASEPARAMS )
{
if( hb_pcount() == 0 )
pArray = NULL;
else
pArray = hb_arrayBaseParams();
}
else if( ulArgCount == HB_ERR_ARGS_SELFPARAMS )
{
pArray = hb_arraySelfParams();
}
else
{
pArray = hb_itemArrayNew( ulArgCount );
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
{
PHB_ITEM pArg = va_arg( va, PHB_ITEM );
if( pArg )
hb_itemArrayPut( pArray, ulArgPos, pArg );
}
va_end( va );
}
if( pArray )
{
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
}
/* Ok, launch... */
uiAction = hb_errLaunch( pError );
/* Release. */
hb_errRelease( pError );
return uiAction;
}
| errorapi.c | 1027 |
| USHORT | hb_errRT_BASE_Ext1( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiOsCode, USHORT uiFlags, ULONG ulArgCount, ... )
USHORT hb_errRT_BASE_Ext1( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiOsCode, USHORT uiFlags, ULONG ulArgCount, ... )
{
USHORT uiAction;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
ULONG ulArgPos;
pError = hb_errRT_New( ES_ERROR, HB_ERR_SS_BASE, ulGenCode, ulSubCode, szDescription, szOperation, uiOsCode, uiFlags );
/* Build the array from the passed arguments. */
if( ulArgCount == 0 )
{
pArray = NULL;
}
else if( ulArgCount == HB_ERR_ARGS_BASEPARAMS )
{
if( hb_pcount() == 0 )
pArray = NULL;
else
pArray = hb_arrayBaseParams();
}
else if( ulArgCount == HB_ERR_ARGS_SELFPARAMS )
{
pArray = hb_arraySelfParams();
}
else
{
pArray = hb_itemArrayNew( ulArgCount );
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
{
PHB_ITEM pArg = va_arg( va, PHB_ITEM );
if( pArg )
hb_itemArrayPut( pArray, ulArgPos, pArg );
}
va_end( va );
}
if( pArray )
{
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
}
/* Ok, launch... */
uiAction = hb_errLaunch( pError );
hb_errRelease( pError );
return uiAction;
}
| errorapi.c | 1088 |
| PHB_ITEM | hb_errRT_BASE_Subst( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... )
PHB_ITEM hb_errRT_BASE_Subst( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... )
{
PHB_ITEM pRetVal;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
ULONG ulArgPos;
pError = hb_errRT_New_Subst( ES_ERROR, HB_ERR_SS_BASE, ulGenCode, ulSubCode, szDescription, szOperation, 0, EF_NONE );
/* Build the array from the passed arguments. */
if( ulArgCount == 0 )
{
pArray = NULL;
}
else if( ulArgCount == HB_ERR_ARGS_BASEPARAMS )
{
if( hb_pcount() == 0 )
pArray = NULL;
else
pArray = hb_arrayBaseParams();
}
else if( ulArgCount == HB_ERR_ARGS_SELFPARAMS )
{
pArray = hb_arraySelfParams();
}
else
{
pArray = hb_itemArrayNew( ulArgCount );
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
{
PHB_ITEM pArg = va_arg( va, PHB_ITEM );
if( pArg )
hb_itemArrayPut( pArray, ulArgPos, pArg );
}
va_end( va );
}
if( pArray )
{
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
}
/* Ok, launch... */
pRetVal = hb_errLaunchSubst( pError );
hb_errRelease( pError );
return pRetVal;
}
| errorapi.c | 1145 |
| VOID | hb_errRT_BASE_SubstR( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... )
void hb_errRT_BASE_SubstR( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... )
{
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
ULONG ulArgPos;
pError = hb_errRT_New_Subst( ES_ERROR, HB_ERR_SS_BASE, ulGenCode, ulSubCode, szDescription, szOperation, 0, EF_NONE );
/* Build the array from the passed arguments. */
if( ulArgCount == 0 )
{
pArray = NULL;
}
else if( ulArgCount == HB_ERR_ARGS_BASEPARAMS )
{
if( hb_pcount() == 0 )
pArray = NULL;
else
pArray = hb_arrayBaseParams();
}
else if( ulArgCount == HB_ERR_ARGS_SELFPARAMS )
{
pArray = hb_arraySelfParams();
}
else
{
pArray = hb_itemArrayNew( ulArgCount );
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
{
PHB_ITEM pArg = va_arg( va, PHB_ITEM );
if( pArg )
hb_itemArrayPut( pArray, ulArgPos, pArg );
}
va_end( va );
}
if( pArray )
{
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
}
/* Ok, launch... */
hb_itemReturnRelease( hb_errLaunchSubst( pError ) );
hb_errRelease( pError );
}
| errorapi.c | 1202 |
| USHORT | hb_errRT_TERM( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiOSCode, USHORT uiFlags )
USHORT hb_errRT_TERM( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiOSCode, USHORT uiFlags )
{
USHORT uiAction;
PHB_ITEM pError =
hb_errRT_New( ES_ERROR, HB_ERR_SS_TERMINAL, ulGenCode, ulSubCode, szDescription, szOperation, uiOSCode, uiFlags );
uiAction = hb_errLaunch( pError );
hb_errRelease( pError );
return uiAction;
}
| errorapi.c | 1255 |
| USHORT | hb_errRT_DBCMD( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation )
USHORT hb_errRT_DBCMD( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation )
{
USHORT uiAction;
PHB_ITEM pError =
hb_errRT_New( ES_ERROR, HB_ERR_SS_DBCMD, ulGenCode, ulSubCode, szDescription, szOperation, 0, EF_NONE );
uiAction = hb_errLaunch( pError );
hb_errRelease( pError );
return uiAction;
}
| errorapi.c | 1268 |
| USHORT | hb_errRT_DBCMD_Ext( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiFlags )
USHORT hb_errRT_DBCMD_Ext( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, USHORT uiFlags )
{
USHORT uiAction;
PHB_ITEM pError;
pError = hb_errRT_New( ES_ERROR, HB_ERR_SS_DBCMD, ulGenCode, ulSubCode, (const char *)szDescription, (const char *)szOperation, 0, uiFlags );
uiAction = hb_errLaunch( pError );
hb_itemRelease( pError );
return uiAction;
}
| errorapi.c | 1281 |
| errorapu.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | ERRORINHAN(void)
HB_FUNC( ERRORINHAN )
{
HB_FUNC_EXEC( __ERRINHANDLER )
}
| errorapu.c | 59 |
| HB_FUNC | ERRORINHANDLER(void)
HB_FUNC( ERRORINHANDLER )
{
HB_FUNC_EXEC( __ERRINHANDLER )
}
| errorapu.c | 64 |
| errorint.c |
| Type | Function | Source | Line |
|---|
| VOID | hb_errInternal( ULONG ulIntCode, const char * szText, const char * szPar1, const char * szPar2 )
void hb_errInternal( ULONG ulIntCode, const char * szText, const char * szPar1, const char * szPar2 )
{
char buffer[ 8192 ];
char file[ _POSIX_PATH_MAX + 1 ];
const char * szFile;
USHORT uiLine;
int iLevel;
FILE * hLog;
BOOL fLang;
HB_TRACE(HB_TR_DEBUG, ("hb_errInternal(%lu, %s, %s, %s)", ulIntCode, szText, szPar1, szPar2));
if( szPar1 == NULL )
szPar1 = "";
if( szPar2 == NULL )
szPar2 = "";
fLang = ( hb_langID() != NULL );
szFile = hb_setGetCPtr( HB_SET_HBOUTLOG );
if( !szFile )
szFile = "hb_out.log";
hLog = hb_fopen( szFile, "a+" );
if( hLog )
{
char szTime[ 9 ];
int iYear, iMonth, iDay;
hb_dateToday( &iYear, &iMonth, &iDay );
hb_dateTimeStr( szTime );
fprintf( hLog, HB_I_("Application Internal Error - %s\n"), hb_cmdargARGV()[0] );
fprintf( hLog, HB_I_("Terminated at: %04d.%02d.%02d %s\n"), iYear, iMonth, iDay, szTime );
if( *hb_setGetCPtr( HB_SET_HBOUTLOGINFO ) )
fprintf( hLog, HB_I_("Info: %s\n"), hb_setGetCPtr( HB_SET_HBOUTLOGINFO ) );
}
hb_conOutErr( hb_conNewLine(), 0 );
if( fLang )
snprintf( buffer, sizeof( buffer ), ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ERRINTR ), ulIntCode );
else
snprintf( buffer, sizeof( buffer ), "Unrecoverable error %lu: ", ulIntCode );
hb_conOutErr( buffer, 0 );
if( hLog )
fwrite( buffer, sizeof( buffer[ 0 ] ), strlen( buffer ), hLog );
if( szText )
snprintf( buffer, sizeof( buffer ), szText, szPar1, szPar2 );
else if( fLang )
snprintf( buffer, sizeof( buffer ), ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ERRINTR + ulIntCode - 9000 ), szPar1, szPar2 );
else
buffer[ 0 ] = '\0';
hb_conOutErr( buffer, 0 );
hb_conOutErr( hb_conNewLine(), 0 );
if( hLog )
fprintf( hLog, "%s\n", buffer );
iLevel = 0;
while( hb_procinfo( iLevel++, buffer, &uiLine, file ) )
{
char msg[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 32 ];
snprintf( msg, sizeof( msg ), HB_I_("Called from %s(%hu)%s%s\n"), buffer, uiLine, *file ? HB_I_(" in ") : "", file );
hb_conOutErr( msg, 0 );
if( hLog )
fwrite( msg, sizeof( msg[ 0 ] ), strlen( msg ), hLog );
}
if( hLog )
{
fprintf( hLog, "------------------------------------------------------------------------\n");
fclose( hLog );
}
/* release console settings */
hb_conRelease();
if( hb_cmdargCheck( "ERRGPF" ) )
{
int *pGPF = NULL;
*pGPF = 0;
*(--pGPF) = 0;
}
exit( EXIT_FAILURE );
}
| errorint.c | 62 |
| file.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT BOOL | hb_fsFile( BYTE * pFilename )
HB_EXPORT BOOL hb_fsFile( BYTE * pFilename )
{
PHB_FFIND ffind;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsFile(%s)", ( char * ) pFilename));
pFilename = hb_fsNameConv( pFilename, &fFree );
if( ( ffind = hb_fsFindFirst( ( char * ) pFilename, HB_FA_ALL ) ) != NULL )
{
hb_fsFindClose( ffind );
if( fFree )
hb_xfree( pFilename );
return TRUE;
}
if( fFree )
hb_xfree( pFilename );
return FALSE;
}
| file.c | 56 |
| HB_EXPORT BOOL | hb_fsIsDirectory( BYTE * pFilename )
HB_EXPORT BOOL hb_fsIsDirectory( BYTE * pFilename )
{
BOOL bResult = FALSE, fFree;
PHB_FFIND ffind;
int iLen;
HB_TRACE(HB_TR_DEBUG, ("hb_fsIsDirectory(%s)", ( char * ) pFilename));
pFilename = hb_fsNameConv( pFilename, &fFree );
iLen = strlen( ( char * ) pFilename );
while( iLen && strchr( HB_OS_PATH_DELIM_CHR_LIST, pFilename[ iLen - 1 ] ) )
--iLen;
if( pFilename[ iLen ] )
{
if( fFree )
pFilename[ iLen ] = '\0';
else
{
pFilename = ( BYTE * ) hb_strndup( ( char * ) pFilename, iLen );
fFree = TRUE;
}
}
if( iLen && iLen <= _POSIX_PATH_MAX )
{
if( ( ffind = hb_fsFindFirst( ( char * ) pFilename, HB_FA_DIRECTORY ) ) != NULL )
{
if( ( ffind->attr & HB_FA_DIRECTORY ) == HB_FA_DIRECTORY )
bResult = TRUE;
hb_fsFindClose( ffind );
}
}
if( fFree )
hb_xfree( pFilename );
return bResult;
}
| file.c | 79 |
| filebuf.c |
| Type | Function | Source | Line |
|---|
| VOID | hb_fileDsp( PHB_FILE pFile, const char * szMsg )
void hb_fileDsp( PHB_FILE pFile, const char * szMsg )
{
UINT uiPos = 0;
printf( "\r\n[%s][", szMsg );
while( uiPos < pFile->uiLocks )
{
PHB_FLOCK pLock = &pFile->pLocks[ uiPos ];
printf( "%lld:%lld ", pLock->start, pLock->len );
++uiPos;
}
printf( "]" );
fflush(stdout);
}
| filebuf.c | 99 |
| STATIC PHB_FILE | hb_fileFind( ULONG device, ULONG inode )
static PHB_FILE hb_fileFind( ULONG device, ULONG inode )
{
if( s_openFiles && ( device || inode ) )
{
PHB_FILE pFile = s_openFiles;
do
{
if( pFile->device == device && pFile->inode == inode )
return pFile;
pFile = pFile->pNext;
}
while( s_openFiles != pFile );
}
return NULL;
}
| filebuf.c | 113 |
| STATIC PHB_FILE | hb_fileNew( HB_FHANDLE hFile, BOOL fShared, ULONG device, ULONG inode, BOOL fBind )
static PHB_FILE hb_fileNew( HB_FHANDLE hFile, BOOL fShared,
ULONG device, ULONG inode, BOOL fBind )
{
PHB_FILE pFile = hb_fileFind( device, inode );
if( !pFile )
{
pFile = ( PHB_FILE ) hb_xgrab( sizeof( HB_FILE ) );
memset( pFile, 0, sizeof( HB_FILE ) );
pFile->device = device;
pFile->inode = inode;
pFile->hFile = hFile;
pFile->shared = fShared;
if( fBind )
{
if( s_openFiles )
{
pFile->pNext = s_openFiles;
pFile->pPrev = s_openFiles->pPrev;
pFile->pPrev->pNext = pFile;
s_openFiles->pPrev = pFile;
}
else
s_openFiles = pFile->pNext = pFile->pPrev = pFile;
}
}
pFile->used++;
return pFile;
}
| filebuf.c | 129 |
| STATIC UINT | hb_fileFindOffset( PHB_FILE pFile, HB_FOFFSET ulOffset )
static UINT hb_fileFindOffset( PHB_FILE pFile, HB_FOFFSET ulOffset )
{
UINT uiFirst, uiLast, uiMiddle;
uiFirst = 0;
uiLast = pFile->uiLocks;
uiMiddle = uiLast >> 1;
while( uiFirst < uiLast )
{
HB_FOFFSET ulEnd = pFile->pLocks[ uiMiddle ].start +
pFile->pLocks[ uiMiddle ].len;
if( ulEnd <= ulOffset )
uiFirst = uiMiddle + 1;
else
uiLast = uiMiddle;
uiMiddle = ( uiFirst + uiLast ) >> 1;
}
return uiMiddle;
}
| filebuf.c | 161 |
| STATIC VOID | hb_fileInsertLock( PHB_FILE pFile, UINT uiPos, HB_FOFFSET ulStart, HB_FOFFSET ulLen )
static void hb_fileInsertLock( PHB_FILE pFile, UINT uiPos,
HB_FOFFSET ulStart, HB_FOFFSET ulLen )
{
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 );
}
pFile->uiLocks++;
memmove( &pFile->pLocks[ uiPos + 1 ], &pFile->pLocks[ uiPos ],
( pFile->uiLocks - uiPos ) * sizeof( HB_FLOCK ) );
pFile->pLocks[ uiPos ].start = ulStart;
pFile->pLocks[ uiPos ].len = ulLen;
}
| filebuf.c | 183 |
| STATIC VOID | hb_fileDeleteLock( PHB_FILE pFile, UINT uiPos )
static void hb_fileDeleteLock( PHB_FILE pFile, 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 );
}
}
| filebuf.c | 201 |
| STATIC BOOL | hb_fileSetLock( PHB_FILE pFile, BOOL * pfLockFS, HB_FOFFSET ulStart, HB_FOFFSET ulLen )
static BOOL hb_fileSetLock( PHB_FILE pFile, BOOL * pfLockFS,
HB_FOFFSET ulStart, HB_FOFFSET ulLen )
{
BOOL fLJoin, fRJoin;
UINT uiPos;
uiPos = hb_fileFindOffset( pFile, ulStart );
fLJoin = fRJoin = FALSE;
if( uiPos < pFile->uiLocks )
{
PHB_FLOCK pLock = &pFile->pLocks[ uiPos ];
if( ulStart + ulLen > pLock->start )
return FALSE;
if( ulStart + ulLen == pLock->start )
fRJoin = TRUE;
}
if( uiPos > 0 )
{
PHB_FLOCK pLock = &pFile->pLocks[ uiPos - 1 ];
if( pLock->start + pLock->len == ulStart )
fLJoin = TRUE;
}
if( fLJoin )
{
if( fRJoin )
{
pFile->pLocks[ uiPos - 1 ].len += ulLen + pFile->pLocks[ uiPos ].len;
hb_fileDeleteLock( pFile, uiPos );
}
else
pFile->pLocks[ uiPos - 1 ].len += ulLen;
}
else if( fRJoin )
{
pFile->pLocks[ uiPos ].start -= ulLen;
pFile->pLocks[ uiPos ].len += ulLen;
}
else
hb_fileInsertLock( pFile, uiPos, ulStart, ulLen );
if( pFile->shared )
* pfLockFS = TRUE;
return TRUE;
}
| filebuf.c | 214 |
| STATIC BOOL | hb_fileUnlock( PHB_FILE pFile, BOOL * pfLockFS, HB_FOFFSET ulStart, HB_FOFFSET ulLen )
static BOOL hb_fileUnlock( PHB_FILE pFile, BOOL * pfLockFS,
HB_FOFFSET ulStart, HB_FOFFSET ulLen )
{
BOOL fResult = FALSE;
UINT uiPos;
uiPos = hb_fileFindOffset( pFile, ulStart );
if( uiPos < pFile->uiLocks )
{
PHB_FLOCK pLock = &pFile->pLocks[ uiPos ];
if( ulStart >= pLock->start &&
ulStart + ulLen <= pLock->start + pLock->len )
{
if( ulStart == pLock->start )
{
if( ulLen == pLock->len )
hb_fileDeleteLock( pFile, uiPos );
else
{
pLock->start += ulLen;
pLock->len -= ulLen;
}
}
else if( ulStart + ulLen == pLock->start + pLock->len )
pLock->len -= ulLen;
else
{
hb_fileInsertLock( pFile, uiPos + 1, ulStart + ulLen,
pLock->start + pLock->len - ulStart - ulLen );
pLock->len = ulStart - pLock->start;
}
if( pFile->shared )
* pfLockFS = TRUE;
fResult = TRUE;
}
}
return fResult;
}
| filebuf.c | 259 |
| PHB_FILE | hb_fileExtOpen( BYTE * pFilename, BYTE * pDefExt, USHORT uiExFlags, BYTE * pPaths, PHB_ITEM pError )
PHB_FILE hb_fileExtOpen( BYTE * pFilename, BYTE * pDefExt,
USHORT uiExFlags, BYTE * pPaths,
PHB_ITEM pError )
{
PHB_FILE pFile = NULL;
#if defined( HB_OS_UNIX )
struct stat statbuf;
BOOL fResult;
#endif
BOOL fShared;
HB_FHANDLE hFile;
BYTE * pszFile;
fShared = ( uiExFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE ) ) == 0;
pszFile = hb_fsExtName( pFilename, pDefExt, uiExFlags, pPaths );
#if defined( HB_OS_UNIX )
hb_vmUnlock();
fResult = stat( ( char * ) pszFile, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( fResult )
{
hb_threadEnterCriticalSection( &s_fileMtx );
pFile = hb_fileFind( statbuf.st_dev, statbuf.st_ino );
if( pFile )
{
if( !fShared || ! pFile->shared || ( uiExFlags & FXO_TRUNCATE ) != 0 )
fResult = FALSE;
else
pFile->used++;
}
hb_threadLeaveCriticalSection( &s_fileMtx );
}
if( pFile )
{
if( !fResult )
{
hb_fsSetError( ( uiExFlags & FXO_TRUNCATE ) ? 5 : 32 );
pFile = NULL;
}
else if( uiExFlags & FXO_COPYNAME )
hb_strncpy( ( char * ) pFilename, ( char * ) pszFile, _POSIX_PATH_MAX );
if( pError )
{
hb_errPutFileName( pError, ( char * ) pszFile );
if( !fResult )
{
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutGenCode( pError, ( USHORT ) ( ( uiExFlags & FXO_TRUNCATE ) ? EG_CREATE : EG_OPEN ) );
}
}
}
else
#endif
{
hFile = hb_fsExtOpen( pFilename, pDefExt, uiExFlags, pPaths, pError );
if( hFile != FS_ERROR )
{
ULONG device = 0, inode = 0;
#if defined( HB_OS_UNIX )
hb_vmUnlock();
if( fstat( hFile, &statbuf ) == 0 )
{
device = ( ULONG ) statbuf.st_dev;
inode = ( ULONG ) statbuf.st_ino;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
#endif
hb_threadEnterCriticalSection( &s_fileMtx );
pFile = hb_fileNew( hFile, fShared, device, inode, TRUE );
hb_threadLeaveCriticalSection( &s_fileMtx );
if( pFile->hFile != hFile )
hb_fsClose( hFile );
}
}
hb_xfree( pszFile );
return pFile;
}
| filebuf.c | 302 |
| VOID | hb_fileClose( PHB_FILE pFile )
void hb_fileClose( PHB_FILE pFile )
{
HB_FHANDLE hFile = FS_ERROR;
hb_threadEnterCriticalSection( &s_fileMtx );
if( --pFile->used == 0 )
{
if( pFile->pNext )
{
pFile->pPrev->pNext = pFile->pNext;
pFile->pNext->pPrev = pFile->pPrev;
if( pFile == s_openFiles )
{
s_openFiles = pFile->pNext;
if( pFile == s_openFiles )
s_openFiles = NULL;
}
}
hFile = pFile->hFile;
if( pFile->pLocks )
hb_xfree( pFile->pLocks );
hb_xfree( pFile );
}
hb_threadLeaveCriticalSection( &s_fileMtx );
if( hFile != FS_ERROR )
hb_fsClose( hFile );
}
| filebuf.c | 390 |
| BOOL | hb_fileLock( PHB_FILE pFile, HB_FOFFSET ulStart, HB_FOFFSET ulLen, int iType )
BOOL hb_fileLock( PHB_FILE pFile, HB_FOFFSET ulStart, HB_FOFFSET ulLen,
int iType )
{
BOOL fResult, fLockFS = FALSE;
if( ( iType & FL_MASK ) == FL_UNLOCK )
{
hb_threadEnterCriticalSection( &s_fileMtx );
fResult = hb_fileUnlock( pFile, &fLockFS, ulStart, ulLen );
hb_threadLeaveCriticalSection( &s_fileMtx );
if( fLockFS )
hb_fsLockLarge( pFile->hFile, ulStart, ulLen, iType );
}
else
{
hb_threadEnterCriticalSection( &s_fileMtx );
fResult = hb_fileSetLock( pFile, &fLockFS, ulStart, ulLen );
hb_threadLeaveCriticalSection( &s_fileMtx );
if( fLockFS )
{
fResult = hb_fsLockLarge( pFile->hFile, ulStart, ulLen, iType );
if( !fResult )
{
hb_threadEnterCriticalSection( &s_fileMtx );
hb_fileUnlock( pFile, &fLockFS, ulStart, ulLen );
hb_threadLeaveCriticalSection( &s_fileMtx );
}
}
}
return fResult;
}
| filebuf.c | 424 |
| ULONG | hb_fileReadAt( PHB_FILE pFile, BYTE * buffer, ULONG ulSize, HB_FOFFSET llOffset )
ULONG hb_fileReadAt( PHB_FILE pFile, BYTE * buffer, ULONG ulSize,
HB_FOFFSET llOffset )
{
return hb_fsReadAt( pFile->hFile, buffer, ulSize, llOffset );
}
| filebuf.c | 457 |
| ULONG | hb_fileWriteAt( PHB_FILE pFile, const BYTE * buffer, ULONG ulSize, HB_FOFFSET llOffset )
ULONG hb_fileWriteAt( PHB_FILE pFile, const BYTE * buffer, ULONG ulSize,
HB_FOFFSET llOffset )
{
return hb_fsWriteAt( pFile->hFile, buffer, ulSize, llOffset );
}
| filebuf.c | 463 |
| BOOL | hb_fileTruncAt( PHB_FILE pFile, HB_FOFFSET llOffset )
BOOL hb_fileTruncAt( PHB_FILE pFile, HB_FOFFSET llOffset )
{
return hb_fsTruncAt( pFile->hFile, llOffset );
}
| filebuf.c | 469 |
| HB_FOFFSET | hb_fileSize( PHB_FILE pFile )
HB_FOFFSET hb_fileSize( PHB_FILE pFile )
{
return hb_fsSeekLarge( pFile->hFile, 0, FS_END );
}
| filebuf.c | 474 |
| VOID | hb_fileCommit( PHB_FILE pFile )
void hb_fileCommit( PHB_FILE pFile )
{
hb_fsCommit( pFile->hFile );
}
| filebuf.c | 479 |
| HB_FHANDLE | hb_fileHandle( PHB_FILE pFile )
HB_FHANDLE hb_fileHandle( PHB_FILE pFile )
{
return pFile ? pFile->hFile : FS_ERROR;
}
| filebuf.c | 484 |
| PHB_FILE | hb_fileCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName )
PHB_FILE hb_fileCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix,
ULONG ulAttr, BYTE * pszName )
{
PHB_FILE pFile = NULL;
HB_FHANDLE hFile;
hFile = hb_fsCreateTemp( pszDir, pszPrefix, ulAttr, pszName );
if( hFile != FS_ERROR )
pFile = hb_fileNew( hFile, FALSE, 0, 0, FALSE );
return pFile;
}
| filebuf.c | 489 |
| filehb.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | FILE(void)
HB_FUNC( FILE )
{
BYTE * szFile = ( BYTE * ) hb_parc( 1 );
hb_retl( szFile ? hb_spFile( szFile, NULL ) : FALSE );
}
| filehb.c | 67 |
| filesys.c |
| Type | Function | Source | Line |
|---|
| STATIC HANDLE | DosToWinHandle( HB_FHANDLE fHandle )
static HANDLE DosToWinHandle( HB_FHANDLE fHandle )
{
if( fHandle == ( HB_FHANDLE ) 0 )
return GetStdHandle( STD_INPUT_HANDLE );
else if( fHandle == ( HB_FHANDLE ) 1 )
return GetStdHandle( STD_OUTPUT_HANDLE );
else if( fHandle == ( HB_FHANDLE ) 2 )
return GetStdHandle( STD_ERROR_HANDLE) ;
else
return ( HANDLE ) fHandle;
}
| filesys.c | 311 |
| STATIC VOID | convert_open_flags( BOOL fCreate, ULONG ulAttr, USHORT uiFlags, DWORD *dwMode, DWORD *dwShare, DWORD *dwCreat, DWORD *dwAttr )
static void convert_open_flags( BOOL fCreate, ULONG ulAttr, USHORT uiFlags,
DWORD *dwMode, DWORD *dwShare,
DWORD *dwCreat, DWORD *dwAttr )
{
if( fCreate )
{
*dwCreat = CREATE_ALWAYS;
*dwMode = GENERIC_READ | GENERIC_WRITE;
}
else
{
if( uiFlags & FO_CREAT )
{
if( uiFlags & FO_EXCL )
*dwCreat = CREATE_NEW;
else if( uiFlags & FO_TRUNC )
*dwCreat = CREATE_ALWAYS;
else
*dwCreat = OPEN_ALWAYS;
}
else if( uiFlags & FO_TRUNC )
{
*dwCreat = TRUNCATE_EXISTING;
}
else
{
*dwCreat = OPEN_EXISTING;
}
*dwMode = 0;
switch( uiFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) )
{
case FO_READWRITE:
*dwMode |= GENERIC_READ | GENERIC_WRITE;
break;
case FO_WRITE:
*dwMode |= GENERIC_WRITE;
break;
case FO_READ:
*dwMode |= GENERIC_READ;
break;
}
}
/* shared flags */
switch( uiFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE | FO_DENYNONE ) )
{
case FO_DENYREAD:
*dwShare = FILE_SHARE_WRITE;
break;
case FO_DENYWRITE:
*dwShare = FILE_SHARE_READ;
break;
case FO_EXCLUSIVE:
*dwShare = 0;
break;
default:
*dwShare = FILE_SHARE_WRITE | FILE_SHARE_READ;
break;
}
/* file attributes flags */
if( ulAttr == FC_NORMAL )
{
*dwAttr = FILE_ATTRIBUTE_NORMAL;
}
else
{
*dwAttr = FILE_ATTRIBUTE_ARCHIVE;
if( ulAttr & FC_READONLY )
*dwAttr |= FILE_ATTRIBUTE_READONLY;
if( ulAttr & FC_HIDDEN )
*dwAttr |= FILE_ATTRIBUTE_HIDDEN;
if( ulAttr & FC_SYSTEM )
*dwAttr |= FILE_ATTRIBUTE_SYSTEM;
}
}
| filesys.c | 326 |
| STATIC VOID | convert_open_flags( BOOL fCreate, ULONG ulAttr, USHORT uiFlags, int *flags, unsigned *mode, int *share, int *attr )
static void convert_open_flags( BOOL fCreate, ULONG ulAttr, USHORT uiFlags,
int *flags, unsigned *mode,
int *share, int *attr )
{
HB_TRACE(HB_TR_DEBUG, ("convert_open_flags(%d, %lu, %hu, %p, %p, %p, %p)", fCreate, ulAttr, uiFlags, flags, mode, share, attr));
/* file access mode */
#if defined( HB_OS_UNIX )
*mode = HB_FA_POSIX_ATTR( ulAttr );
if( *mode == 0 )
{
*mode = ( ulAttr & FC_HIDDEN ) ? S_IRUSR : ( S_IRUSR | S_IRGRP | S_IROTH );
if( !( ulAttr & FC_READONLY ) )
{
if( *mode & S_IRUSR ) *mode |= S_IWUSR;
if( *mode & S_IRGRP ) *mode |= S_IWGRP;
if( *mode & S_IROTH ) *mode |= S_IWOTH;
}
if( ulAttr & FC_SYSTEM )
{
if( *mode & S_IRUSR ) *mode |= S_IXUSR;
if( *mode & S_IRGRP ) *mode |= S_IXGRP;
if( *mode & S_IROTH ) *mode |= S_IXOTH;
}
}
#else
*mode = S_IREAD |
( ( ulAttr & FC_READONLY ) ? 0 : S_IWRITE ) |
( ( ulAttr & FC_SYSTEM ) ? S_IEXEC : 0 );
#endif
/* dos file attributes */
#if defined( HB_FS_DOSATTR )
if( ulAttr == FC_NORMAL )
{
*attr = _A_NORMAL;
}
else
{
*attr = _A_ARCH;
if( ulAttr & FC_READONLY )
*attr |= _A_READONLY;
if( ulAttr & FC_HIDDEN )
*attr |= _A_HIDDEN;
if( ulAttr & FC_SYSTEM )
*attr |= _A_SYSTEM;
}
#else
*attr = 0;
#endif
if( fCreate )
{
*flags = O_RDWR | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE |
( ( uiFlags & FO_EXCL ) ? O_EXCL : 0 );
}
else
{
*attr = 0;
*flags = O_BINARY | O_LARGEFILE;
switch( uiFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) )
{
case FO_READ:
*flags |= O_RDONLY;
break;
case FO_WRITE:
*flags |= O_WRONLY;
break;
case FO_READWRITE:
*flags |= O_RDWR;
break;
default:
/* this should not happen and it's here to force default OS behavior */
*flags |= ( O_RDONLY | O_WRONLY | O_RDWR );
break;
}
if( uiFlags & FO_CREAT ) *flags |= O_CREAT;
if( uiFlags & FO_TRUNC ) *flags |= O_TRUNC;
if( uiFlags & FO_EXCL ) *flags |= O_EXCL;
}
/* shared flags (HB_FS_SOPEN) */
#if defined( _MSC_VER ) || defined( __DMC__ )
if( ( uiFlags & FO_DENYREAD ) == FO_DENYREAD )
*share = _SH_DENYRD;
else if( uiFlags & FO_EXCLUSIVE )
*share = _SH_DENYRW;
else if( uiFlags & FO_DENYWRITE )
*share = _SH_DENYWR;
else if( uiFlags & FO_DENYNONE )
*share = _SH_DENYNO;
else
*share = _SH_COMPAT;
#elif !defined( HB_OS_UNIX )
if( ( uiFlags & FO_DENYREAD ) == FO_DENYREAD )
*share = SH_DENYRD;
else if( uiFlags & FO_EXCLUSIVE )
*share = SH_DENYRW;
else if( uiFlags & FO_DENYWRITE )
*share = SH_DENYWR;
else if( uiFlags & FO_DENYNONE )
*share = SH_DENYNO;
else
*share = SH_COMPAT;
#else
*share = 0;
#endif
HB_TRACE(HB_TR_INFO, ("convert_open_flags: flags=0x%04x, mode=0x%04x, share=0x%04x, attr=0x%04x", *flags, *mode, *share, *attr));
}
| filesys.c | 406 |
| STATIC USHORT | convert_seek_flags( USHORT uiFlags )
static USHORT convert_seek_flags( USHORT uiFlags )
{
/* by default FS_SET is set */
USHORT result_flags = SEEK_SET;
HB_TRACE(HB_TR_DEBUG, ("convert_seek_flags(%hu)", uiFlags));
if( uiFlags & FS_RELATIVE )
result_flags = SEEK_CUR;
if( uiFlags & FS_END )
result_flags = SEEK_END;
return result_flags;
}
| filesys.c | 520 |
| HB_EXPORT HB_FHANDLE | hb_fsGetOsHandle( HB_FHANDLE hFileHandle )
HB_EXPORT HB_FHANDLE hb_fsGetOsHandle( HB_FHANDLE hFileHandle )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsGetOsHandle(%p)", hFileHandle));
#if defined(HB_WIN32_IO)
return ( HB_FHANDLE ) DosToWinHandle( hFileHandle );
#else
return hFileHandle;
#endif
}
| filesys.c | 543 |
| HB_EXPORT HB_FHANDLE | hb_fsPOpen( BYTE * pFilename, BYTE * pMode )
HB_EXPORT HB_FHANDLE hb_fsPOpen( BYTE * pFilename, BYTE * pMode )
{
HB_FHANDLE hFileHandle = FS_ERROR;
HB_TRACE(HB_TR_DEBUG, ("hb_fsPOpen(%p, %s)", pFilename, pMode));
#if defined(HB_OS_UNIX_COMPATIBLE) && !defined(__CYGWIN__)
{
HB_FHANDLE hPipeHandle[2], hNullHandle;
pid_t pid;
BYTE * pbyTmp;
BOOL bRead;
ULONG ulLen;
int iMaxFD;
ulLen = strlen( ( char * ) pFilename );
if( pMode && ( *pMode == 'r' || *pMode == 'w' ) )
bRead = ( *pMode == 'r' );
else
{
if( pFilename[0] == '|' )
bRead = FALSE;
else if( pFilename[ ulLen - 1 ] == '|' )
bRead = TRUE;
else
bRead = FALSE;
}
if( pFilename[0] == '|' )
{
++pFilename;
--ulLen;
}
if( pFilename[ ulLen - 1 ] == '|' )
{
pbyTmp = ( BYTE * ) hb_strdup( ( char * ) pFilename );
pbyTmp[--ulLen] = 0;
pFilename = pbyTmp;
} else
pbyTmp = NULL;
hb_vmUnlock();
if( pipe( hPipeHandle ) == 0 ) {
if( ( pid = fork() ) != -1 ) {
if( pid != 0 ) {
if( bRead ) {
close( hPipeHandle[ 1 ] );
hFileHandle = hPipeHandle[ 0 ];
} else {
close( hPipeHandle[ 0 ] );
hFileHandle = hPipeHandle[ 1 ];
}
} else {
char * argv[4];
argv[0] = ( char * ) "sh";
argv[1] = ( char * ) "-c";
argv[2] = ( char * ) pFilename;
argv[3] = ( char * ) 0;
hNullHandle = open( "/dev/null", O_RDWR );
if( bRead ) {
close( hPipeHandle[ 0 ] );
dup2( hPipeHandle[ 1 ], 1 );
dup2( hNullHandle, 0 );
dup2( hNullHandle, 2 );
} else {
close( hPipeHandle[ 1 ] );
dup2( hPipeHandle[ 0 ], 0 );
dup2( hNullHandle, 1 );
dup2( hNullHandle, 2 );
}
iMaxFD = sysconf( _SC_OPEN_MAX );
if( iMaxFD < 3 )
iMaxFD = 1024;
for( hNullHandle = 3; hNullHandle < iMaxFD; ++hNullHandle )
close( hNullHandle );
setuid( getuid() );
setgid( getgid() );
execve( "/bin/sh", argv, environ );
exit(1);
}
}
else
{
close( hPipeHandle[0] );
close( hPipeHandle[1] );
}
}
hb_fsSetIOError( hFileHandle != FS_ERROR, 0 );
hb_vmLock();
if( pbyTmp )
hb_xfree( pbyTmp );
}
#else
HB_SYMBOL_UNUSED( pFilename );
HB_SYMBOL_UNUSED( pMode );
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return hFileHandle;
}
| filesys.c | 554 |
| HB_EXPORT HB_FHANDLE | hb_fsOpen( BYTE * pFilename, USHORT uiFlags )
HB_EXPORT HB_FHANDLE hb_fsOpen( BYTE * pFilename, USHORT uiFlags )
{
HB_FHANDLE hFileHandle;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsOpen(%p, %hu)", pFilename, uiFlags));
pFilename = hb_fsNameConv( pFilename, &fFree );
#if defined(HB_WIN32_IO)
{
DWORD dwMode, dwShare, dwCreat, dwAttr;
HANDLE hFile;
convert_open_flags( FALSE, FC_NORMAL, uiFlags, &dwMode, &dwShare, &dwCreat, &dwAttr );
hb_vmUnlock();
hFile = ( HANDLE ) CreateFileA( ( char * ) pFilename, dwMode, dwShare,
NULL, dwCreat, dwAttr, NULL );
hb_fsSetIOError( hFile != ( HANDLE ) INVALID_HANDLE_VALUE, 0 );
hb_vmLock();
hFileHandle = ( HB_FHANDLE ) hFile;
}
#elif defined(HB_FS_FILE_IO)
{
int flags, share, attr;
unsigned mode;
convert_open_flags( FALSE, FC_NORMAL, uiFlags, &flags, &mode, &share, &attr );
hb_vmUnlock();
#if defined(_MSC_VER) || defined(__DMC__)
if( share )
hFileHandle = _sopen( ( char * ) pFilename, flags, share, mode );
else
hFileHandle = _open( ( char * ) pFilename, flags, mode );
#elif defined(HB_FS_SOPEN)
if( share )
hFileHandle = sopen( ( char * ) pFilename, flags, share, mode );
else
hFileHandle = open( ( char * ) pFilename, flags, mode );
#else
hFileHandle = open( ( char * ) pFilename, flags | share, mode );
#endif
hb_fsSetIOError( hFileHandle != FS_ERROR, 0 );
hb_vmLock();
}
#else
hFileHandle = FS_ERROR;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFree )
hb_xfree( pFilename );
return hFileHandle;
}
| filesys.c | 659 |
| HB_EXPORT HB_FHANDLE | hb_fsCreate( BYTE * pFilename, ULONG ulAttr )
HB_EXPORT HB_FHANDLE hb_fsCreate( BYTE * pFilename, ULONG ulAttr )
{
HB_FHANDLE hFileHandle;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCreate(%p, %lu)", pFilename, ulAttr));
pFilename = hb_fsNameConv( pFilename, &fFree );
#if defined(HB_WIN32_IO)
{
DWORD dwMode, dwShare, dwCreat, dwAttr;
HANDLE hFile;
convert_open_flags( TRUE, ulAttr, FO_EXCLUSIVE, &dwMode, &dwShare, &dwCreat, &dwAttr );
hb_vmUnlock();
hFile = ( HANDLE ) CreateFileA( ( char * ) pFilename, dwMode, dwShare,
NULL, dwCreat, dwAttr, NULL );
hb_fsSetIOError( hFile != ( HANDLE ) INVALID_HANDLE_VALUE, 0 );
hb_vmLock();
hFileHandle = ( HB_FHANDLE ) hFile;
}
#elif defined(HB_FS_FILE_IO)
{
int flags, share, attr;
unsigned mode;
convert_open_flags( TRUE, ulAttr, FO_EXCLUSIVE, &flags, &mode, &share, &attr );
hb_vmUnlock();
#if defined(HB_FS_DOSCREAT)
hFileHandle = _creat( ( char * ) pFilename, attr );
#elif defined(HB_FS_SOPEN)
hFileHandle = open( ( char * ) pFilename, flags, mode );
#else
hFileHandle = open( ( char * ) pFilename, flags | share, mode );
#endif
hb_fsSetIOError( hFileHandle != FS_ERROR, 0 );
hb_vmLock();
}
#else
hFileHandle = FS_ERROR;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFree )
hb_xfree( pFilename );
return hFileHandle;
}
| filesys.c | 719 |
| HB_EXPORT HB_FHANDLE | hb_fsCreateEx( BYTE * pFilename, ULONG ulAttr, USHORT uiFlags )
HB_EXPORT HB_FHANDLE hb_fsCreateEx( BYTE * pFilename, ULONG ulAttr, USHORT uiFlags )
{
HB_FHANDLE hFileHandle;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCreateEx(%p, %lu, %hu)", pFilename, ulAttr, uiFlags));
pFilename = hb_fsNameConv( pFilename, &fFree );
#if defined( HB_WIN32_IO )
{
DWORD dwMode, dwShare, dwCreat, dwAttr;
HANDLE hFile;
convert_open_flags( TRUE, ulAttr, uiFlags, &dwMode, &dwShare, &dwCreat, &dwAttr );
hb_vmUnlock();
hFile = ( HANDLE ) CreateFileA( ( char * ) pFilename, dwMode, dwShare,
NULL, dwCreat, dwAttr, NULL );
hb_fsSetIOError( hFile != ( HANDLE ) INVALID_HANDLE_VALUE, 0 );
hb_vmLock();
hFileHandle = ( HB_FHANDLE ) hFile;
}
#elif defined(HB_FS_FILE_IO)
{
int flags, share, attr;
unsigned mode;
convert_open_flags( TRUE, ulAttr, uiFlags, &flags, &mode, &share, &attr );
hb_vmUnlock();
#if defined(HB_FS_SOPEN)
hFileHandle = open( ( char * ) pFilename, flags, mode );
#else
hFileHandle = open( ( char * ) pFilename, flags | share, mode );
#endif
hb_fsSetIOError( hFileHandle != FS_ERROR, 0 );
hb_vmLock();
}
#else
hFileHandle = FS_ERROR;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFree )
hb_xfree( pFilename );
return hFileHandle;
}
| filesys.c | 779 |
| HB_EXPORT VOID | hb_fsClose( HB_FHANDLE hFileHandle )
HB_EXPORT void hb_fsClose( HB_FHANDLE hFileHandle )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsClose(%p)", hFileHandle));
#if defined(HB_FS_FILE_IO)
hb_vmUnlock();
#if defined(HB_WIN32_IO)
hb_fsSetIOError( CloseHandle( DosToWinHandle( hFileHandle ) ), 0 );
#else
hb_fsSetIOError( close( hFileHandle ) == 0, 0 );
#endif
hb_vmLock();
#else
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
}
| filesys.c | 831 |
| HB_EXPORT BOOL | hb_fsSetDevMode( HB_FHANDLE hFileHandle, USHORT uiDevMode )
HB_EXPORT BOOL hb_fsSetDevMode( HB_FHANDLE hFileHandle, USHORT uiDevMode )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsSetDevMode(%p, %hu)", hFileHandle, uiDevMode));
/* TODO: HB_WIN32_IO support */
#if defined(__BORLANDC__) || defined(__IBMCPP__) || defined(__DJGPP__) || \
defined(__CYGWIN__) || defined(__WATCOMC__) || defined(HB_OS_OS2)
{
int iRet = 0;
#if defined(HB_WIN32_IO)
if( hFileHandle > 2 )
iRet = -1;
else
#endif
switch( uiDevMode )
{
case FD_BINARY:
iRet = setmode( hFileHandle, O_BINARY );
break;
case FD_TEXT:
iRet = setmode( hFileHandle, O_TEXT );
break;
}
hb_fsSetIOError( iRet != -1, 0 );
return iRet != -1;
}
#elif ( defined(_MSC_VER) || defined(__MINGW32__) || defined(__DMC__) ) && \
!defined(HB_WINCE)
{
int iRet = 0;
#if defined(HB_WIN32_IO)
if( ( HB_NHANDLE ) hFileHandle > 2 )
iRet = -1;
else
#endif
switch( uiDevMode )
{
case FD_BINARY:
iRet = _setmode( ( HB_NHANDLE ) hFileHandle, _O_BINARY );
break;
case FD_TEXT:
iRet = _setmode( ( HB_NHANDLE ) hFileHandle, _O_TEXT );
break;
}
hb_fsSetIOError( iRet != -1, 0 );
return iRet != -1;
}
#elif defined( HB_OS_UNIX ) || defined( HB_WINCE )
HB_SYMBOL_UNUSED( hFileHandle );
if( uiDevMode == FD_TEXT )
{
hb_fsSetError( ( USHORT ) FS_ERROR );
return FALSE;
}
hb_fsSetError( 0 );
return TRUE;
#else
hb_fsSetError( ( USHORT ) FS_ERROR );
return FALSE;
#endif
}
| filesys.c | 852 |
| HB_EXPORT BOOL | hb_fsGetFileTime( BYTE * pszFileName, LONG * plJulian, LONG * plMillisec )
HB_EXPORT BOOL hb_fsGetFileTime( BYTE * pszFileName, LONG * plJulian, LONG * plMillisec )
{
BOOL fResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsGetFileTime(%s, %p, %p)", pszFileName, plJulian, plMillisec));
fResult = FALSE;
#if defined( HB_WIN32_IO )
{
HB_FHANDLE hFile = hb_fsOpen( pszFileName, FO_READ | FO_SHARED );
if( hFile != FS_ERROR )
{
FILETIME ft, local_ft;
SYSTEMTIME st;
hb_vmUnlock();
if( GetFileTime( DosToWinHandle( hFile ), NULL, NULL, &ft ) &&
FileTimeToLocalFileTime( &ft, &local_ft ) &&
FileTimeToSystemTime( &local_ft, &st ) )
{
*plJulian = hb_dateEncode( st.wYear, st.wMonth, st.wDay );
*plMillisec = hb_timeStampEncode( st.wHour, st.wMinute, st.wSecond, st.wMilliseconds );
fResult = TRUE;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
hb_fsClose( hFile );
}
}
#elif defined( HB_OS_UNIX ) || defined( HB_OS_OS2 ) || defined( HB_OS_DOS ) || defined( __GNUC__ )
{
struct stat sStat;
BOOL fFree;
pszFileName = hb_fsNameConv( pszFileName, &fFree );
hb_vmUnlock();
if( stat( ( char * ) pszFileName, &sStat ) == 0 )
{
time_t ftime;
struct tm * ft;
ftime = sStat.st_mtime;
ft = localtime( &ftime );
*plJulian = hb_dateEncode( ft->tm_year + 1900, ft->tm_mon + 1, ft->tm_mday );
*plMillisec = hb_timeStampEncode( ft->tm_hour, ft->tm_min, ft->tm_sec, 0 );
fResult = TRUE;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( fFree )
hb_xfree( pszFileName );
}
#else
{
int TODO; /* TODO: for given platform */
HB_SYMBOL_UNUSED( pszFileName );
HB_SYMBOL_UNUSED( plJulian );
HB_SYMBOL_UNUSED( plMillisec );
}
#endif
return fResult;
}
| filesys.c | 929 |
| HB_EXPORT BOOL | hb_fsGetAttr( BYTE * pszFileName, ULONG * pulAttr )
HB_EXPORT BOOL hb_fsGetAttr( BYTE * pszFileName, ULONG * pulAttr )
{
BOOL fResult;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsGetAttr(%s, %p)", pszFileName, pulAttr));
fResult = FALSE;
pszFileName = hb_fsNameConv( pszFileName, &fFree );
#if defined( HB_OS_WIN_32 )
{
DWORD dwAttr;
hb_vmUnlock();
dwAttr = GetFileAttributesA( ( char * ) pszFileName );
if( dwAttr != INVALID_FILE_ATTRIBUTES )
{
*pulAttr = hb_fsAttrFromRaw( dwAttr );
fResult = TRUE;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
}
#elif defined( HB_OS_DOS )
hb_vmUnlock();
{
#if defined( __DJGPP__ ) || defined(__BORLANDC__)
int attr = _chmod( ( char * ) pszFileName, 0, 0 );
if( attr != -1 )
#else
unsigned int attr = 0;
if( _dos_getfileattr( ( char * ) pszFileName, &attr ) == 0 )
#endif
{
*pulAttr = hb_fsAttrFromRaw( attr );
fResult = TRUE;
}
hb_fsSetIOError( fResult, 0 );
}
hb_vmLock();
#elif defined( HB_OS_OS2 )
{
FILESTATUS3 fs3;
APIRET ulrc;
hb_vmUnlock();
ulrc = DosQueryPathInfo( ( PSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) );
if( ulrc == NO_ERROR )
{
*pulAttr = hb_fsAttrFromRaw( fs3.attrFile );
fResult = TRUE;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
}
#elif defined( HB_OS_UNIX )
{
struct stat sStat;
hb_vmUnlock();
if( stat( ( char * ) pszFileName, &sStat ) == 0 )
{
*pulAttr = hb_fsAttrFromRaw( sStat.st_mode );
fResult = TRUE;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
}
#else
{
int TODO; /* TODO: for given platform */
HB_SYMBOL_UNUSED( pszFileName );
HB_SYMBOL_UNUSED( pulAttr );
}
#endif
if( fFree )
hb_xfree( pszFileName );
return fResult;
}
| filesys.c | 1001 |
| HB_EXPORT BOOL | hb_fsSetFileTime( BYTE * pszFileName, LONG lJulian, LONG lMillisec )
HB_EXPORT BOOL hb_fsSetFileTime( BYTE * pszFileName, LONG lJulian, LONG lMillisec )
{
BOOL fResult;
int iYear, iMonth, iDay;
int iHour, iMinute, iSecond, iMSec;
HB_TRACE(HB_TR_DEBUG, ("hb_fsSetFileTime(%s, %ld, %ld)", pszFileName, lJulian, lMillisec));
hb_dateDecode( lJulian, &iYear, &iMonth, &iDay );
hb_timeStampDecode( lMillisec, &iHour, &iMinute, &iSecond, &iMSec );
#if defined( HB_OS_WIN_32 ) && !defined( __CYGWIN__ )
{
HB_FHANDLE hFile = hb_fsOpen( pszFileName, FO_READWRITE | FO_SHARED );
fResult = hFile != FS_ERROR;
if( fResult )
{
FILETIME ft, local_ft;
SYSTEMTIME st;
hb_vmUnlock();
if( lJulian <= 0 || lMillisec < 0 )
GetLocalTime( &st );
else
memset( &st, 0, sizeof( st ) );
if( lJulian > 0 )
{
st.wYear = ( WORD ) iYear;
st.wMonth = ( WORD ) iMonth;
st.wDay = ( WORD ) iDay;
}
if( lMillisec >= 0 )
{
st.wHour = ( WORD ) iHour;
st.wMinute = ( WORD ) iMinute;
st.wSecond = ( WORD ) iSecond;
st.wMilliseconds = ( WORD ) iMSec;
}
SystemTimeToFileTime( &st, &local_ft );
LocalFileTimeToFileTime( &local_ft, &ft );
fResult = SetFileTime( DosToWinHandle( hFile ), NULL, &ft, &ft ) != 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
hb_fsClose( hFile );
}
}
#elif defined( HB_OS_OS2 )
{
FILESTATUS3 fs3;
APIRET ulrc;
BOOL fFree;
pszFileName = hb_fsNameConv( pszFileName, &fFree );
hb_vmUnlock();
ulrc = DosQueryPathInfo( ( PSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) );
if( ulrc == NO_ERROR )
{
FDATE fdate;
FTIME ftime;
if( lJulian <= 0 || lMillisec < 0 )
{
DATETIME dt;
DosGetDateTime( &dt );
fdate.year = dt.year - 1980;
fdate.month = dt.month;
fdate.day = dt.day;
ftime.hours = dt.hours;
ftime.minutes = dt.minutes;
ftime.twosecs = dt.seconds / 2;
}
if( lJulian > 0 )
{
fdate.year = iYear - 1980;
fdate.month = iMonth;
fdate.day = iDay;
}
if( lMillisec >= 0 )
{
ftime.hours = iHour;
ftime.minutes = iMinute;
ftime.twosecs = iSecond / 2;
}
fs3.fdateCreation = fs3.fdateLastAccess = fs3.fdateLastWrite = fdate;
fs3.ftimeCreation = fs3.ftimeLastAccess = fs3.ftimeLastWrite = ftime;
ulrc = DosSetPathInfo( ( PSZ ) pszFileName, FIL_STANDARD,
&fs3, sizeof( fs3 ), DSPI_WRTTHRU );
}
fResult = ulrc == NO_ERROR;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( fFree )
hb_xfree( pszFileName );
}
#elif defined( HB_OS_UNIX_COMPATIBLE ) || defined( HB_OS_DOS )
{
BOOL fFree;
pszFileName = hb_fsNameConv( pszFileName, &fFree );
hb_vmUnlock();
if( lJulian <= 0 && lMillisec )
{
fResult = utime( ( char * ) pszFileName, NULL ) == 0;
}
else
{
struct utimbuf buf;
struct tm new_value;
time_t tim;
if( lJulian <= 0 || lMillisec < 0 )
{
time_t current_time;
current_time = time( NULL );
# if _POSIX_C_SOURCE < 199506L || defined( HB_OS_DARWIN_5 )
new_value = *localtime( ¤t_time );
# else
localtime_r( ¤t_time, &new_value );
# endif
}
else
memset( &new_value, 0, sizeof( new_value ) );
if( lJulian > 0 )
{
new_value.tm_year = iYear - 1900;
new_value.tm_mon = iMonth - 1;
new_value.tm_mday = iDay;
}
if( lMillisec >= 0 )
{
new_value.tm_hour = iHour;
new_value.tm_min = iMinute;
new_value.tm_sec = iSecond;
}
tim = mktime( &new_value );
# if _POSIX_C_SOURCE < 199506L || defined( HB_OS_DARWIN_5 )
new_value = *gmtime( &tim );
# else
gmtime_r( &tim, &new_value );
# endif
buf.actime = buf.modtime = mktime( &new_value );
fResult = utime( ( char * ) pszFileName, &buf ) == 0;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( fFree )
hb_xfree( pszFileName );
}
#else
{
int TODO; /* To force warning */
fResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
}
#endif
return fResult;
}
| filesys.c | 1086 |
| HB_EXPORT BOOL | hb_fsSetAttr( BYTE * pszFileName, ULONG ulAttr )
HB_EXPORT BOOL hb_fsSetAttr( BYTE * pszFileName, ULONG ulAttr )
{
BOOL fResult;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsSetAttr(%s, %lu)", pszFileName, ulAttr));
pszFileName = hb_fsNameConv( pszFileName, &fFree );
#if defined( HB_OS_WIN_32 )
{
DWORD dwFlags = FILE_ATTRIBUTE_ARCHIVE;
if( ulAttr & HB_FA_READONLY )
dwFlags |= FILE_ATTRIBUTE_READONLY;
if( ulAttr & HB_FA_HIDDEN )
dwFlags |= FILE_ATTRIBUTE_HIDDEN;
if( ulAttr & HB_FA_SYSTEM )
dwFlags |= FILE_ATTRIBUTE_SYSTEM;
if( ulAttr & HB_FA_NORMAL )
dwFlags |= FILE_ATTRIBUTE_NORMAL;
hb_vmUnlock();
fResult = SetFileAttributesA( ( char * ) pszFileName, dwFlags );
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
}
#elif defined( HB_OS_OS2 )
{
FILESTATUS3 fs3;
APIRET ulrc;
ULONG ulOsAttr = FILE_NORMAL;
if( ulAttr & HB_FA_READONLY )
ulOsAttr |= FILE_READONLY;
if( ulAttr & HB_FA_HIDDEN )
ulOsAttr |= FILE_HIDDEN;
if( ulAttr & HB_FA_SYSTEM )
ulOsAttr |= FILE_SYSTEM;
if( ulAttr & HB_FA_ARCHIVE )
ulOsAttr |= FILE_ARCHIVED;
hb_vmUnlock();
ulrc = DosQueryPathInfo( ( PSZ ) pszFileName, FIL_STANDARD, &fs3, sizeof( fs3 ) );
if( ulrc == NO_ERROR )
{
fs3.attrFile = ulOsAttr;
ulrc = DosSetPathInfo( ( PSZ ) pszFileName, FIL_STANDARD,
&fs3, sizeof( fs3 ), DSPI_WRTTHRU );
}
fResult = ulrc == NO_ERROR;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
}
#elif defined( HB_OS_DOS )
ulAttr &= ~( HB_FA_ARCHIVE | HB_FA_HIDDEN | HB_FA_READONLY | HB_FA_SYSTEM );
hb_vmUnlock();
# if defined( __DJGPP__ ) || defined( __BORLANDC__ )
fResult = _chmod( ( char * ) pszFileName, 1, ulAttr ) != -1;
# else
fResult = _dos_setfileattr( ( char * ) pszFileName, ulAttr ) != -1;
# endif
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
#elif defined( HB_OS_UNIX_COMPATIBLE )
{
int iAttr = HB_FA_POSIX_ATTR( ulAttr );
if( iAttr == 0 )
{
iAttr = ( ulAttr & HB_FA_HIDDEN ) ? S_IRUSR : ( S_IRUSR | S_IRGRP | S_IROTH );
if( !( ulAttr & HB_FA_READONLY ) )
{
if( iAttr & S_IRUSR ) iAttr |= S_IWUSR;
if( iAttr & S_IRGRP ) iAttr |= S_IWGRP;
if( iAttr & S_IROTH ) iAttr |= S_IWOTH;
}
if( ulAttr & HB_FA_SYSTEM )
{
if( iAttr & S_IRUSR ) iAttr |= S_IXUSR;
if( iAttr & S_IRGRP ) iAttr |= S_IXGRP;
if( iAttr & S_IROTH ) iAttr |= S_IXOTH;
}
}
hb_vmUnlock();
fResult = chmod( ( char * ) pszFileName, iAttr ) != -1;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
}
#else
{
int TODO; /* To force warning */
fResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
}
#endif
if( fFree )
hb_xfree( pszFileName );
return fResult;
}
| filesys.c | 1255 |
| HB_EXPORT USHORT | hb_fsRead( HB_FHANDLE hFileHandle, BYTE * pBuff, USHORT uiCount )
HB_EXPORT USHORT hb_fsRead( HB_FHANDLE hFileHandle, BYTE * pBuff, USHORT uiCount )
{
USHORT uiRead;
HB_TRACE(HB_TR_DEBUG, ("hb_fsRead(%p, %p, %hu)", hFileHandle, pBuff, uiCount));
#if defined(HB_FS_FILE_IO)
#if defined(HB_WIN32_IO)
{
DWORD dwRead ;
BOOL fResult;
hb_vmUnlock();
fResult = ReadFile( DosToWinHandle( hFileHandle ), pBuff, ( DWORD ) uiCount, &dwRead, NULL );
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
uiRead = fResult ? ( USHORT ) dwRead : 0;
}
#else
hb_vmUnlock();
uiRead = read( hFileHandle, pBuff, uiCount );
hb_fsSetIOError( uiRead != ( USHORT ) -1, 0 );
hb_vmLock();
#endif
if( uiRead == ( USHORT ) -1 )
uiRead = 0;
#else
uiRead = 0;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return uiRead;
}
| filesys.c | 1359 |
| HB_EXPORT USHORT | hb_fsWrite( HB_FHANDLE hFileHandle, const BYTE * pBuff, USHORT uiCount )
HB_EXPORT USHORT hb_fsWrite( HB_FHANDLE hFileHandle, const BYTE * pBuff, USHORT uiCount )
{
USHORT uiWritten;
HB_TRACE(HB_TR_DEBUG, ("hb_fsWrite(%p, %p, %hu)", hFileHandle, pBuff, uiCount));
#if defined(HB_FS_FILE_IO)
#if defined(HB_WIN32_IO)
{
DWORD dwWritten = 0;
BOOL fResult;
hb_vmUnlock();
if( uiCount )
{
fResult = WriteFile( DosToWinHandle( hFileHandle ), pBuff, uiCount, &dwWritten, NULL );
}
else
{
dwWritten = 0;
fResult = SetEndOfFile( DosToWinHandle( hFileHandle ) );
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
uiWritten = fResult ? ( USHORT ) dwWritten : 0;
}
#else
if( uiCount )
{
hb_vmUnlock();
uiWritten = write( hFileHandle, pBuff, uiCount );
hb_fsSetIOError( uiWritten != ( USHORT ) -1, 0 );
if( uiWritten == ( USHORT ) -1 )
uiWritten = 0;
hb_vmLock();
}
else
{
hb_vmUnlock();
#if defined(HB_USE_LARGEFILE64)
hb_fsSetIOError( ftruncate64( hFileHandle, lseek64( hFileHandle, 0L, SEEK_CUR ) ) != -1, 0 );
#else
hb_fsSetIOError( ftruncate( hFileHandle, lseek( hFileHandle, 0L, SEEK_CUR ) ) != -1, 0 );
#endif
uiWritten = 0;
hb_vmLock();
}
#endif
#else
uiWritten = 0;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return uiWritten;
}
| filesys.c | 1399 |
| HB_EXPORT ULONG | hb_fsReadLarge( HB_FHANDLE hFileHandle, BYTE * pBuff, ULONG ulCount )
HB_EXPORT ULONG hb_fsReadLarge( HB_FHANDLE hFileHandle, BYTE * pBuff, ULONG ulCount )
{
ULONG ulRead;
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadLarge(%p, %p, %lu)", hFileHandle, pBuff, ulCount));
#if defined(HB_FS_FILE_IO)
#if defined(HB_WIN32_IO)
{
hb_vmUnlock();
hb_fsSetIOError( ReadFile( DosToWinHandle( hFileHandle ),
pBuff, ulCount, &ulRead, NULL ), 0 );
hb_vmLock();
}
#elif defined(HB_FS_LARGE_OPTIMIZED)
{
hb_vmUnlock();
ulRead = read( hFileHandle, pBuff, ulCount );
hb_fsSetIOError( ulRead != (ULONG) -1, 0 );
if( ulRead == ( ULONG ) -1 )
ulRead = 0;
hb_vmLock();
}
#else
{
ULONG ulLeftToRead = ulCount;
USHORT uiToRead;
USHORT uiRead;
BYTE * pPtr = pBuff;
ulRead = 0;
hb_vmUnlock();
while( ulLeftToRead )
{
/* Determine how much to read this time */
if( ulLeftToRead > ( ULONG ) INT_MAX )
{
uiToRead = INT_MAX;
ulLeftToRead -= ( ULONG ) uiToRead;
}
else
{
uiToRead = ( USHORT ) ulLeftToRead;
ulLeftToRead = 0;
}
uiRead = read( hFileHandle, pPtr, uiToRead );
/* -1 on bad hFileHandle
0 on disk full
*/
if( uiRead == 0 )
break;
if( uiRead == ( USHORT ) -1 )
{
uiRead = 0;
break;
}
ulRead += ( ULONG ) uiRead;
pPtr += uiRead;
}
hb_fsSetIOError( ulLeftToRead == 0, 0 );
hb_vmLock();
}
#endif
#else
ulRead = 0;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return ulRead;
}
| filesys.c | 1459 |
| HB_EXPORT ULONG | hb_fsWriteLarge( HB_FHANDLE hFileHandle, const BYTE * pBuff, ULONG ulCount )
HB_EXPORT ULONG hb_fsWriteLarge( HB_FHANDLE hFileHandle, const BYTE * pBuff, ULONG ulCount )
{
ULONG ulWritten;
HB_TRACE(HB_TR_DEBUG, ("hb_fsWriteLarge(%p, %p, %lu)", hFileHandle, pBuff, ulCount));
#if defined(HB_FS_FILE_IO)
#if defined(HB_WIN32_IO)
{
ulWritten = 0;
hb_vmUnlock();
if( ulCount )
{
hb_fsSetIOError( WriteFile( DosToWinHandle( hFileHandle), pBuff, ulCount, &ulWritten, NULL ), 0 );
}
else
{
hb_fsSetIOError( SetEndOfFile( DosToWinHandle( hFileHandle ) ), 0 );
}
hb_vmLock();
}
#else
if( ulCount )
#if defined(HB_FS_LARGE_OPTIMIZED)
{
hb_vmUnlock();
ulWritten = write( hFileHandle, pBuff, ulCount );
hb_fsSetIOError( ulWritten != ( ULONG ) -1, 0 );
if( ulWritten == ( ULONG ) -1 )
ulWritten = 0;
hb_vmLock();
}
#else
{
ULONG ulLeftToWrite = ulCount;
USHORT uiToWrite;
USHORT uiWritten;
BYTE * pPtr = ( BYTE * ) pBuff;
ulWritten = 0;
hb_vmUnlock();
while( ulLeftToWrite )
{
/* Determine how much to write this time */
if( ulLeftToWrite > ( ULONG ) INT_MAX )
{
uiToWrite = INT_MAX;
ulLeftToWrite -= ( ULONG ) uiToWrite;
}
else
{
uiToWrite = ( USHORT ) ulLeftToWrite;
ulLeftToWrite = 0;
}
uiWritten = write( hFileHandle, pPtr, uiToWrite );
/* -1 on bad hFileHandle
0 on disk full
*/
if( uiWritten == 0 )
break;
if( uiWritten == ( USHORT ) -1 )
{
uiWritten = 0;
break;
}
ulWritten += ( ULONG ) uiWritten;
pPtr += uiWritten;
}
hb_fsSetIOError( ulLeftToWrite == 0, 0 );
hb_vmLock();
}
#endif
else
{
hb_vmUnlock();
#if defined(HB_USE_LARGEFILE64)
hb_fsSetIOError( ftruncate64( hFileHandle, lseek64( hFileHandle, 0L, SEEK_CUR ) ) != -1, 0 );
#else
hb_fsSetIOError( ftruncate( hFileHandle, lseek( hFileHandle, 0L, SEEK_CUR ) ) != -1, 0 );
#endif
ulWritten = 0;
hb_vmLock();
}
#endif
#else
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return ulWritten;
}
| filesys.c | 1539 |
| HB_EXPORT ULONG | hb_fsReadAt( HB_FHANDLE hFileHandle, BYTE * pBuff, ULONG ulCount, HB_FOFFSET llOffset )
HB_EXPORT ULONG hb_fsReadAt( HB_FHANDLE hFileHandle, BYTE * pBuff, ULONG ulCount, HB_FOFFSET llOffset )
{
ULONG ulRead;
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadAt(%p, %p, %lu, " PFHL ")", hFileHandle, pBuff, ulCount, llOffset));
#if defined(HB_FS_FILE_IO)
#if defined(HB_WIN32_IO)
{
OVERLAPPED Overlapped;
hb_vmUnlock();
memset( &Overlapped, 0, sizeof( Overlapped ) );
Overlapped.Offset = ( DWORD ) ( llOffset & 0xFFFFFFFF ),
Overlapped.OffsetHigh = ( DWORD ) ( llOffset >> 32 ),
hb_fsSetIOError( ReadFile( DosToWinHandle( hFileHandle ),
pBuff, ulCount, &ulRead, &Overlapped ), 0 );
hb_vmLock();
}
#elif defined(HB_OS_UNIX)
{
hb_vmUnlock();
#if defined(HB_USE_LARGEFILE64)
ulRead = pread64( hFileHandle, pBuff, ulCount, llOffset );
#else
ulRead = pread( hFileHandle, pBuff, ulCount, llOffset );
#endif
hb_fsSetIOError( ulRead != (ULONG) -1, 0 );
if( ulRead == ( ULONG ) -1 )
ulRead = 0;
hb_vmLock();
}
#else
{
hb_vmUnlock();
/* TOFIX: this is not atom operation. It has to be fixed for RDD
* file access with shared file handles in aliased work areas
*/
if( hb_fsSeekLarge( hFileHandle, llOffset, FS_SET ) == llOffset )
ulRead = hb_fsReadLarge( hFileHandle, pBuff, ulCount );
else
ulRead = 0;
hb_vmLock();
}
#endif
#else
ulRead = 0;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return ulRead;
}
| filesys.c | 1641 |
| HB_EXPORT ULONG | hb_fsWriteAt( HB_FHANDLE hFileHandle, const BYTE * pBuff, ULONG ulCount, HB_FOFFSET llOffset )
HB_EXPORT ULONG hb_fsWriteAt( HB_FHANDLE hFileHandle, const BYTE * pBuff, ULONG ulCount, HB_FOFFSET llOffset )
{
ULONG ulWritten;
HB_TRACE(HB_TR_DEBUG, ("hb_fsWriteAt(%p, %p, %lu, " PFHL ")", hFileHandle, pBuff, ulCount, llOffset));
#if defined(HB_FS_FILE_IO)
#if defined(HB_WIN32_IO)
{
OVERLAPPED Overlapped;
hb_vmUnlock();
memset( &Overlapped, 0, sizeof( Overlapped ) );
Overlapped.Offset = ( DWORD ) ( llOffset & 0xFFFFFFFF ),
Overlapped.OffsetHigh = ( DWORD ) ( llOffset >> 32 ),
hb_fsSetIOError( WriteFile( DosToWinHandle( hFileHandle ),
pBuff, ulCount, &ulWritten, &Overlapped ), 0 );
hb_vmLock();
}
#elif defined(HB_OS_UNIX)
{
hb_vmUnlock();
#if defined(HB_USE_LARGEFILE64)
ulWritten = pwrite64( hFileHandle, pBuff, ulCount, llOffset );
#else
ulWritten = pwrite( hFileHandle, pBuff, ulCount, llOffset );
#endif
hb_fsSetIOError( ulWritten != (ULONG) -1, 0 );
if( ulWritten == ( ULONG ) -1 )
ulWritten = 0;
hb_vmLock();
}
#else
{
hb_vmUnlock();
/* TOFIX: this is not atom operation. It has to be fixed for RDD
* file access with shared file handles in aliased work areas
*/
if( hb_fsSeekLarge( hFileHandle, llOffset, FS_SET ) == llOffset )
ulWritten = hb_fsWriteLarge( hFileHandle, pBuff, ulCount );
else
ulWritten = 0;
hb_vmLock();
}
#endif
#else
ulWritten = 0;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return ulWritten;
}
| filesys.c | 1697 |
| HB_EXPORT BOOL | hb_fsTruncAt( HB_FHANDLE hFileHandle, HB_FOFFSET llOffset )
HB_EXPORT BOOL hb_fsTruncAt( HB_FHANDLE hFileHandle, HB_FOFFSET llOffset )
{
BOOL fResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadAt(%p," PFHL ")", hFileHandle, llOffset));
#if defined(HB_FS_FILE_IO)
hb_vmUnlock();
#if defined(HB_WIN32_IO)
{
ULONG ulOffsetLow = ( ULONG ) ( llOffset & ULONG_MAX ),
ulOffsetHigh = ( ULONG ) ( llOffset >> 32 );
/* This is not atom operation anyhow if someone want to truncate
* file then he has to made necessary synchronizations in upper level
* code. We have such situation in our RDD drivers and for us such
* version is enough. [druzus]
*/
ulOffsetLow = SetFilePointer( DosToWinHandle( hFileHandle ),
ulOffsetLow, ( PLONG ) &ulOffsetHigh,
( DWORD ) SEEK_SET );
if( ( ( ( HB_FOFFSET ) ulOffsetHigh << 32 ) | ulOffsetLow ) == llOffset )
fResult = SetEndOfFile( DosToWinHandle( hFileHandle ) );
else
fResult = FALSE;
}
#elif defined(HB_USE_LARGEFILE64)
fResult = ftruncate64( hFileHandle, llOffset ) != -1;
#else
fResult = ftruncate( hFileHandle, llOffset ) != -1;
#endif
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
#else
fResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return fResult;
}
| filesys.c | 1753 |
| HB_EXPORT VOID | hb_fsCommit( HB_FHANDLE hFileHandle )
HB_EXPORT void hb_fsCommit( HB_FHANDLE hFileHandle )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsCommit(%p)", hFileHandle));
#if defined(HB_OS_WIN_32)
{
hb_vmUnlock();
#if defined(HB_WIN32_IO)
hb_fsSetIOError( FlushFileBuffers( ( HANDLE ) DosToWinHandle( hFileHandle ) ), 0 );
#else
#if defined(__WATCOMC__)
hb_fsSetIOError( fsync( hFileHandle ) == 0, 0 );
#else
hb_fsSetIOError( _commit( hFileHandle ) == 0, 0 );
#endif
#endif
hb_vmLock();
}
#elif defined(HB_OS_OS2)
{
hb_vmUnlock();
hb_fsSetIOError( DosResetBuffer( hFileHandle ) == 0, 0 );
hb_vmLock();
}
#elif defined(HB_OS_UNIX)
/* NOTE: close() functions releases all lock regardles if it is an
* original or duplicated file handle
*/
hb_vmUnlock();
#if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO + 0 > 0
/* faster - flushes data buffers only, without updating directory info
*/
hb_fsSetIOError( fdatasync( hFileHandle ) == 0, 0 );
#else
/* slower - flushes all file data buffers and i-node info
*/
hb_fsSetIOError( fsync( hFileHandle ) == 0, 0 );
#endif
hb_vmLock();
#elif defined(__WATCOMC__)
hb_vmUnlock();
hb_fsSetIOError( fsync( hFileHandle ) == 0, 0 );
hb_vmLock();
#elif defined(HB_FS_FILE_IO) && !defined(HB_OS_OS2) && !defined(HB_OS_UNIX)
/* This hack is very dangerous. POSIX standard define that if _ANY_
file handle is closed all locks set by the process on the file
pointed by this descriptor are removed. It doesn't matter they
were done using different descriptor. It means that we now clean
all locks on hFileHandle with the code below if the OS is POSIX
compilant. I vote to disable it.
*/
{
int dup_handle;
BOOL fResult = FALSE;
hb_vmUnlock();
dup_handle = dup( hFileHandle );
if( dup_handle != -1 )
{
close( dup_handle );
fResult = TRUE;
}
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
}
#else
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
}
| filesys.c | 1798 |
| HB_EXPORT BOOL | hb_fsLock( HB_FHANDLE hFileHandle, ULONG ulStart, ULONG ulLength, USHORT uiMode )
HB_EXPORT BOOL hb_fsLock( HB_FHANDLE hFileHandle, ULONG ulStart,
ULONG ulLength, USHORT uiMode )
{
BOOL bResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsLock(%p, %lu, %lu, %hu)", hFileHandle, ulStart, ulLength, uiMode));
#if defined(HB_WIN32_IO)
hb_vmUnlock();
switch( uiMode & FL_MASK )
{
case FL_LOCK:
{
if( hb_iswinnt() )
{
OVERLAPPED sOlap ;
DWORD dwFlags ;
memset( &sOlap, 0, sizeof( OVERLAPPED ) ) ;
sOlap.Offset = ( ULONG ) ulStart ;
dwFlags = ( uiMode & FLX_SHARED ) ? 0 : LOCKFILE_EXCLUSIVE_LOCK ;
if( !s_fUseWaitLocks || !( uiMode & FLX_WAIT ) )
{
dwFlags |= LOCKFILE_FAIL_IMMEDIATELY ;
}
bResult = LockFileEx( DosToWinHandle( hFileHandle ), dwFlags, 0, ulLength, 0, &sOlap );
}
else
{
bResult = LockFile( DosToWinHandle( hFileHandle ), ulStart, 0, ulLength,0 );
}
break;
}
case FL_UNLOCK:
{
if( hb_iswinnt() )
{
OVERLAPPED sOlap ;
memset( &sOlap, 0, sizeof( OVERLAPPED ) ) ;
sOlap.Offset = ( ULONG ) ulStart ;
bResult = UnlockFileEx( DosToWinHandle( hFileHandle ), 0, ulLength,0, &sOlap );
}
else
{
bResult = UnlockFile( DosToWinHandle( hFileHandle ), ulStart, 0, ulLength,0 );
}
break;
}
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#elif defined(HB_OS_OS2)
{
struct _FILELOCK fl, ful;
hb_vmUnlock();
switch( uiMode & FL_MASK )
{
case FL_LOCK:
fl.lOffset = ulStart;
fl.lRange = ulLength;
ful.lOffset = 0;
ful.lRange = 0;
/* lock region, 2 seconds timeout, exclusive access - no atomic */
bResult = ( DosSetFileLocks( hFileHandle, &ful, &fl, 2000L, 0L ) == 0 );
break;
case FL_UNLOCK:
fl.lOffset = 0;
fl.lRange = 0;
ful.lOffset = ulStart;
ful.lRange = ulLength;
/* unlock region, 2 seconds timeout, exclusive access - no atomic */
bResult = ( DosSetFileLocks( hFileHandle, &ful, &fl, 2000L, 0L ) == 0 );
break;
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
}
#elif defined(_MSC_VER) || defined(__DMC__)
{
ULONG ulOldPos;
hb_vmUnlock();
ulOldPos = lseek( hFileHandle, 0L, SEEK_CUR );
lseek( hFileHandle, ulStart, SEEK_SET );
switch( uiMode & FL_MASK )
{
case FL_LOCK:
bResult = ( locking( hFileHandle, _LK_NBLCK, ulLength ) == 0 );
break;
case FL_UNLOCK:
bResult = ( locking( hFileHandle, _LK_UNLCK, ulLength ) == 0 );
break;
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
lseek( hFileHandle, ulOldPos, SEEK_SET );
}
#elif defined(__MINGW32__)
{
ULONG ulOldPos;
hb_vmUnlock();
ulOldPos = lseek( hFileHandle, 0L, SEEK_CUR );
lseek( hFileHandle, ulStart, SEEK_SET );
switch( uiMode & FL_MASK )
{
case FL_LOCK:
bResult = ( _locking( hFileHandle, _LK_LOCK, ulLength ) == 0 );
break;
case FL_UNLOCK:
bResult = ( _locking( hFileHandle, _LK_UNLCK, ulLength ) == 0 );
break;
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
lseek( hFileHandle, ulOldPos, SEEK_SET );
}
#elif defined(HB_OS_UNIX)
{
/* TODO: check for append locks (SEEK_END)
*/
struct flock lock_info;
hb_vmUnlock();
switch( uiMode & FL_MASK )
{
case FL_LOCK:
lock_info.l_type = (uiMode & FLX_SHARED) ? F_RDLCK : F_WRLCK;
lock_info.l_start = ulStart;
lock_info.l_len = ulLength;
lock_info.l_whence = SEEK_SET; /* start from the beginning of the file */
lock_info.l_pid = getpid();
bResult = ( fcntl( hFileHandle,
(uiMode & FLX_WAIT) ? F_SETLKW: F_SETLK,
&lock_info ) >= 0 );
break;
case FL_UNLOCK:
lock_info.l_type = F_UNLCK; /* unlock */
lock_info.l_start = ulStart;
lock_info.l_len = ulLength;
lock_info.l_whence = SEEK_SET;
lock_info.l_pid = getpid();
bResult = ( fcntl( hFileHandle, F_SETLK, &lock_info ) >= 0 );
break;
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
}
#elif defined(HAVE_POSIX_IO) && !defined(__IBMCPP__) && ( !defined(__GNUC__) || defined(__DJGPP__) )
hb_vmUnlock();
switch( uiMode & FL_MASK )
{
case FL_LOCK:
bResult = ( lock( hFileHandle, ulStart, ulLength ) == 0 );
break;
case FL_UNLOCK:
bResult = ( unlock( hFileHandle, ulStart, ulLength ) == 0 );
break;
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#else
bResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return bResult;
}
| filesys.c | 1879 |
| HB_EXPORT BOOL | hb_fsLockLarge( HB_FHANDLE hFileHandle, HB_FOFFSET ulStart, HB_FOFFSET ulLength, USHORT uiMode )
HB_EXPORT BOOL hb_fsLockLarge( HB_FHANDLE hFileHandle, HB_FOFFSET ulStart,
HB_FOFFSET ulLength, USHORT uiMode )
{
BOOL bResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsLockLarge(%p, %" PFHL "u, %" PFHL "u, %hu)", hFileHandle, ulStart, ulLength, uiMode));
#if defined(HB_WIN32_IO)
{
DWORD dwOffsetLo = ( DWORD ) ( ulStart & 0xFFFFFFFF ),
dwOffsetHi = ( DWORD ) ( ulStart >> 32 ),
dwLengthLo = ( DWORD ) ( ulLength & 0xFFFFFFFF ),
dwLengthHi = ( DWORD ) ( ulLength >> 32 );
hb_vmUnlock();
switch( uiMode & FL_MASK )
{
case FL_LOCK:
if( hb_iswinnt() )
{
OVERLAPPED sOlap ;
DWORD dwFlags ;
dwFlags = ( ( uiMode & FLX_SHARED ) ? 0 : LOCKFILE_EXCLUSIVE_LOCK );
if( !s_fUseWaitLocks || !( uiMode & FLX_WAIT ) )
{
dwFlags |= LOCKFILE_FAIL_IMMEDIATELY ;
}
memset( &sOlap, 0, sizeof( OVERLAPPED ) );
sOlap.Offset = dwOffsetLo;
sOlap.OffsetHigh = dwOffsetHi;
bResult = LockFileEx( DosToWinHandle( hFileHandle ), dwFlags, 0,
dwLengthLo, dwLengthHi, &sOlap );
}
else
{
bResult = LockFile( DosToWinHandle( hFileHandle ),
dwOffsetLo, dwOffsetHi,
dwLengthLo, dwLengthHi );
}
break;
case FL_UNLOCK:
if( hb_iswinnt() )
{
OVERLAPPED sOlap ;
memset( &sOlap, 0, sizeof( OVERLAPPED ) );
sOlap.Offset = dwOffsetLo;
sOlap.OffsetHigh = dwOffsetHi;
bResult = UnlockFileEx( DosToWinHandle( hFileHandle ), 0,
dwLengthLo, dwLengthHi, &sOlap );
}
else
{
bResult = UnlockFile( DosToWinHandle( hFileHandle ),
dwOffsetLo, dwOffsetHi,
dwLengthLo, dwLengthHi );
}
break;
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
}
#elif defined(HB_USE_LARGEFILE64)
{
struct flock64 lock_info;
hb_vmUnlock();
switch( uiMode & FL_MASK )
{
case FL_LOCK:
lock_info.l_type = (uiMode & FLX_SHARED) ? F_RDLCK : F_WRLCK;
lock_info.l_start = ulStart;
lock_info.l_len = ulLength;
lock_info.l_whence = SEEK_SET; /* start from the beginning of the file */
lock_info.l_pid = getpid();
bResult = ( fcntl( hFileHandle,
(uiMode & FLX_WAIT) ? F_SETLKW64: F_SETLK64,
&lock_info ) != -1 );
break;
case FL_UNLOCK:
lock_info.l_type = F_UNLCK; /* unlock */
lock_info.l_start = ulStart;
lock_info.l_len = ulLength;
lock_info.l_whence = SEEK_SET;
lock_info.l_pid = getpid();
bResult = ( fcntl( hFileHandle, F_SETLK64, &lock_info ) != -1 );
break;
default:
bResult = FALSE;
}
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
}
#else
bResult = hb_fsLock( hFileHandle, (ULONG) ulStart, (ULONG) ulLength, uiMode );
#endif
return bResult;
}
| filesys.c | 2083 |
| HB_EXPORT ULONG | hb_fsSeek( HB_FHANDLE hFileHandle, LONG lOffset, USHORT uiFlags )
HB_EXPORT ULONG hb_fsSeek( HB_FHANDLE hFileHandle, LONG lOffset, USHORT uiFlags )
{
ULONG ulPos;
HB_TRACE(HB_TR_DEBUG, ("hb_fsSeek(%p, %ld, %hu)", hFileHandle, lOffset, uiFlags));
#if defined(HB_FS_FILE_IO)
{
USHORT Flags = convert_seek_flags( uiFlags );
hb_vmUnlock();
#if defined(HB_OS_OS2)
{
APIRET ret;
/* This DOS hack creates 2GB file size limit, Druzus */
if( lOffset < 0 && Flags == SEEK_SET )
{
ret = 1;
hb_fsSetError( 25 ); /* 'Seek Error' */
}
else
{
ret = DosSetFilePtr( hFileHandle, lOffset, Flags, &ulPos );
/* TODO: what we should do with this error code? Is it DOS compatible? */
hb_fsSetError( ( USHORT ) ret );
}
if( ret != 0 )
{
/* FIXME: it should work if DosSetFilePtr is lseek compatible
but maybe OS2 has DosGetFilePtr too, if not then remove this
comment, Druzus */
if( DosSetFilePtr( hFileHandle, 0, SEEK_CUR, &ulPos ) != 0 )
{
ulPos = 0;
}
}
}
#elif defined(HB_WIN32_IO)
/* This DOS hack creates 2GB file size limit, Druzus */
if( lOffset < 0 && Flags == SEEK_SET )
{
ulPos = (ULONG) INVALID_SET_FILE_POINTER;
hb_fsSetError( 25 ); /* 'Seek Error' */
}
else
{
ulPos = (DWORD) SetFilePointer( DosToWinHandle( hFileHandle ), lOffset, NULL, ( DWORD ) Flags );
hb_fsSetIOError( (DWORD) ulPos != INVALID_SET_FILE_POINTER, 0 );
}
if( (DWORD) ulPos == INVALID_SET_FILE_POINTER )
{
ulPos = (DWORD) SetFilePointer( DosToWinHandle( hFileHandle ), 0, NULL, SEEK_CUR );
}
#else
/* This DOS hack creates 2GB file size limit, Druzus */
if( lOffset < 0 && Flags == SEEK_SET )
{
ulPos = (ULONG) -1;
hb_fsSetError( 25 ); /* 'Seek Error' */
}
else
{
ulPos = lseek( hFileHandle, lOffset, Flags );
hb_fsSetIOError( ulPos != (ULONG) -1, 0 );
}
if( ulPos == (ULONG) -1 )
{
ulPos = lseek( hFileHandle, 0L, SEEK_CUR );
if( ulPos == (ULONG) -1 )
{
ulPos = 0;
}
}
#endif
hb_vmLock();
}
#else
hb_fsSetError( 25 );
ulPos = 0;
#endif
return ulPos;
}
| filesys.c | 2197 |
| HB_EXPORT HB_FOFFSET | hb_fsSeekLarge( HB_FHANDLE hFileHandle, HB_FOFFSET llOffset, USHORT uiFlags )
HB_EXPORT HB_FOFFSET hb_fsSeekLarge( HB_FHANDLE hFileHandle, HB_FOFFSET llOffset, USHORT uiFlags )
{
HB_FOFFSET llPos;
HB_TRACE(HB_TR_DEBUG, ("hb_fsSeekLarge(%p, %" PFHL "u, %hu)", hFileHandle, llOffset, uiFlags));
#if defined(HB_WIN32_IO)
{
USHORT Flags = convert_seek_flags( uiFlags );
ULONG ulOffsetLow = ( ULONG ) ( llOffset & ULONG_MAX ),
ulOffsetHigh = ( ULONG ) ( llOffset >> 32 );
hb_vmUnlock();
if( llOffset < 0 && Flags == SEEK_SET )
{
llPos = ( HB_FOFFSET ) INVALID_SET_FILE_POINTER;
hb_fsSetError( 25 ); /* 'Seek Error' */
}
else
{
ulOffsetLow = SetFilePointer( DosToWinHandle( hFileHandle ),
ulOffsetLow, (PLONG) &ulOffsetHigh,
( DWORD ) Flags );
llPos = ( ( HB_FOFFSET ) ulOffsetHigh << 32 ) | ulOffsetLow;
hb_fsSetIOError( llPos != ( HB_FOFFSET ) INVALID_SET_FILE_POINTER, 0 );
}
if( llPos == ( HB_FOFFSET ) INVALID_SET_FILE_POINTER )
{
ulOffsetHigh = 0;
ulOffsetLow = SetFilePointer( DosToWinHandle( hFileHandle ),
0, (PLONG) &ulOffsetHigh, SEEK_CUR );
llPos = ( ( HB_FOFFSET ) ulOffsetHigh << 32 ) | ulOffsetLow;
}
hb_vmLock();
}
#elif defined(HB_USE_LARGEFILE64)
{
USHORT Flags = convert_seek_flags( uiFlags );
hb_vmUnlock();
if( llOffset < 0 && Flags == SEEK_SET )
{
llPos = (HB_FOFFSET) -1;
hb_fsSetError( 25 ); /* 'Seek Error' */
}
else
{
llPos = lseek64( hFileHandle, llOffset, Flags );
hb_fsSetIOError( llPos != (HB_FOFFSET) -1, 0 );
}
if( llPos == (HB_FOFFSET) -1 )
{
llPos = lseek64( hFileHandle, 0L, SEEK_CUR );
}
hb_vmLock();
}
#else
llPos = (HB_FOFFSET) hb_fsSeek( hFileHandle, (LONG) llOffset, uiFlags );
#endif
return llPos;
}
| filesys.c | 2283 |
| HB_EXPORT ULONG | hb_fsTell( HB_FHANDLE hFileHandle )
HB_EXPORT ULONG hb_fsTell( HB_FHANDLE hFileHandle )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsTell(%p)", hFileHandle));
return hb_fsSeek( hFileHandle, 0, FS_RELATIVE );
}
| filesys.c | 2349 |
| HB_EXPORT BOOL | hb_fsDelete( BYTE * pFilename )
HB_EXPORT BOOL hb_fsDelete( BYTE * pFilename )
{
BOOL bResult;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsDelete(%s)", (char*) pFilename));
pFilename = hb_fsNameConv( pFilename, &fFree );
#if defined(HB_OS_WIN_32)
hb_vmUnlock();
bResult = DeleteFileA( ( char * ) pFilename );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#elif defined(HB_FS_FILE_IO)
hb_vmUnlock();
bResult = ( remove( ( char * ) pFilename ) == 0 );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#else
bResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFree )
hb_xfree( pFilename );
return bResult;
}
| filesys.c | 2356 |
| HB_EXPORT BOOL | hb_fsRename( BYTE * pOldName, BYTE * pNewName )
HB_EXPORT BOOL hb_fsRename( BYTE * pOldName, BYTE * pNewName )
{
BOOL bResult;
BOOL fFreeOld, fFreeNew;
HB_TRACE(HB_TR_DEBUG, ("hb_fsRename(%s, %s)", (char*) pOldName, (char*) pNewName));
pOldName = hb_fsNameConv( pOldName, &fFreeOld );
pNewName = hb_fsNameConv( pNewName, &fFreeNew );
#if defined(HB_OS_WIN_32)
hb_vmUnlock();
bResult = MoveFileA( ( char * ) pOldName, ( char * ) pNewName );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#elif defined(HB_FS_FILE_IO)
hb_vmUnlock();
bResult = ( rename( ( char * ) pOldName, ( char * ) pNewName ) == 0 );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#else
bResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFreeOld )
hb_xfree( pOldName );
if( fFreeNew )
hb_xfree( pNewName );
return bResult;
}
| filesys.c | 2392 |
| HB_EXPORT BOOL | hb_fsMkDir( BYTE * pDirname )
HB_EXPORT BOOL hb_fsMkDir( BYTE * pDirname )
{
BOOL bResult;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsMkDir(%s)", (char*) pDirname));
pDirname = hb_fsNameConv( pDirname, &fFree );
HB_TRACE(HB_TR_DEBUG, ("hb_fsMkDir(%s)", (char*) pDirname));
#if defined(HB_OS_WIN_32)
hb_vmUnlock();
bResult = CreateDirectoryA( ( char * ) pDirname, NULL );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#elif defined(HAVE_POSIX_IO) || defined(__MINGW32__)
hb_vmUnlock();
# if ! defined(HB_OS_UNIX) && \
( defined(__WATCOMC__) || defined(__BORLANDC__) || \
defined(__IBMCPP__) || defined(__MINGW32__) )
bResult = ( mkdir( ( char * ) pDirname ) == 0 );
# else
bResult = ( mkdir( ( char * ) pDirname, S_IRWXU | S_IRWXG | S_IRWXO ) == 0 );
# endif
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#else
bResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFree )
hb_xfree( pDirname );
return bResult;
}
| filesys.c | 2431 |
| HB_EXPORT BOOL | hb_fsChDir( BYTE * pDirname )
HB_EXPORT BOOL hb_fsChDir( BYTE * pDirname )
{
BOOL bResult;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsChDir(%s)", (char*) pDirname));
pDirname = hb_fsNameConv( pDirname, &fFree );
#if defined(HB_OS_WIN_32)
hb_vmUnlock();
bResult = SetCurrentDirectoryA( ( char * ) pDirname );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#elif defined(HAVE_POSIX_IO) || defined(__MINGW32__)
hb_vmUnlock();
bResult = ( chdir( ( char * ) pDirname ) == 0 );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#else
bResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFree )
hb_xfree( pDirname );
return bResult;
}
| filesys.c | 2475 |
| HB_EXPORT BOOL | hb_fsRmDir( BYTE * pDirname )
HB_EXPORT BOOL hb_fsRmDir( BYTE * pDirname )
{
BOOL bResult;
BOOL fFree;
HB_TRACE(HB_TR_DEBUG, ("hb_fsRmDir(%s)", (char*) pDirname));
pDirname = hb_fsNameConv( pDirname, &fFree );
#if defined(HB_OS_WIN_32)
hb_vmUnlock();
bResult = RemoveDirectoryA( ( char * ) pDirname );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#elif defined(HAVE_POSIX_IO) || defined(__MINGW32__)
hb_vmUnlock();
bResult = ( rmdir( ( char * ) pDirname ) == 0 );
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#else
bResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
if( fFree )
hb_xfree( pDirname );
return bResult;
}
| filesys.c | 2511 |
| HB_EXPORT BYTE * | hb_fsCurDir( USHORT uiDrive )
HB_EXPORT BYTE * hb_fsCurDir( USHORT uiDrive )
{
BYTE * pbyDirBuffer;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCurDir(%hu)", uiDrive));
pbyDirBuffer = hb_stackDirBuffer();
hb_fsCurDirBuff( uiDrive, pbyDirBuffer, _POSIX_PATH_MAX + 1 );
return ( BYTE * ) pbyDirBuffer;
}
| filesys.c | 2550 |
| HB_EXPORT USHORT | hb_fsCurDirBuff( USHORT uiDrive, BYTE * pbyBuffer, ULONG ulLen )
HB_EXPORT USHORT hb_fsCurDirBuff( USHORT uiDrive, BYTE * pbyBuffer, ULONG ulLen )
{
USHORT uiCurDrv = uiDrive, usError;
BOOL fResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCurDirBuff(%hu)", uiDrive));
pbyBuffer[ 0 ] = '\0';
/*
* do not cover this code by HB_OS_HAS_DRIVE_LETTER macro
* It will allow us to add drive emulation in hb_fsCurDrv()/hb_fsChDrv()
* and hb_fsNameConv()
*/
#if !defined(HB_OS_OS2) && !defined(__MINGW32__)
if( uiDrive )
{
uiCurDrv = hb_fsCurDrv() + 1;
if( uiDrive != uiCurDrv )
hb_fsChDrv( ( BYTE ) ( uiDrive - 1 ) );
}
#endif
#if defined(HB_OS_WIN_32)
hb_vmUnlock();
fResult = GetCurrentDirectoryA( ulLen, ( char * ) pbyBuffer );
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
#elif defined(HB_OS_OS2)
hb_vmUnlock();
fResult = ( _getcwd1( (char *) pbyBuffer, uiDrive + 'A' - 1 ) == 0 );
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
#elif defined(HAVE_POSIX_IO)
hb_vmUnlock();
fResult = ( getcwd( ( char * ) pbyBuffer, ulLen ) != NULL );
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
#elif defined(__MINGW32__)
hb_vmUnlock();
fResult = ( _getdcwd( uiDrive, pbyBuffer, ulLen ) != NULL );
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
#else
fResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
usError = hb_fsError();
if( uiDrive != uiCurDrv )
{
hb_fsChDrv( ( BYTE ) ( uiCurDrv - 1 ) );
hb_fsSetError( usError );
}
pbyBuffer[ ulLen - 1 ] = '\0';
if( usError == 0 && pbyBuffer[ 0 ] )
{
BYTE * pbyStart = pbyBuffer;
/* Strip the leading drive spec, and leading backslash if there's one. */
/* NOTE: A trailing underscore is not returned on this platform,
so we don't need to strip it. [vszakats] */
ulLen = strlen( ( char * ) pbyBuffer );
#if defined(HB_OS_HAS_DRIVE_LETTER)
if( pbyStart[ 1 ] == HB_OS_DRIVE_DELIM_CHR )
{
pbyStart += 2;
ulLen -= 2;
}
#endif
if( strchr( HB_OS_PATH_DELIM_CHR_LIST, pbyStart[ 0 ] ) )
{
pbyStart++;
ulLen--;
}
/* Strip the trailing (back)slash if there's one */
if( ulLen && strchr( HB_OS_PATH_DELIM_CHR_LIST, pbyStart[ ulLen - 1 ] ) )
ulLen--;
if( ulLen && pbyBuffer != pbyStart )
memmove( pbyBuffer, pbyStart, ulLen );
pbyBuffer[ ulLen ] = '\0';
}
return usError;
}
| filesys.c | 2565 |
| HB_EXPORT USHORT | hb_fsChDrv( BYTE nDrive )
HB_EXPORT USHORT hb_fsChDrv( BYTE nDrive )
{
USHORT uiResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsChDrv(%d)", (int) nDrive));
#if defined(HB_OS_HAS_DRIVE_LETTER)
{
/* 'unsigned int' _have to_ be used in Watcom */
UINT uiSave, uiNewDrive;
hb_vmUnlock();
HB_FS_GETDRIVE( uiSave );
HB_FS_SETDRIVE( nDrive );
HB_FS_GETDRIVE( uiNewDrive );
if( ( UINT ) nDrive == uiNewDrive )
{
uiResult = 0;
hb_fsSetError( 0 );
}
else
{
HB_FS_SETDRIVE( uiSave );
uiResult = ( USHORT ) FS_ERROR;
hb_fsSetError( ( USHORT ) FS_ERROR );
}
hb_vmLock();
}
#else
HB_SYMBOL_UNUSED( nDrive );
uiResult = ( USHORT ) FS_ERROR;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return uiResult;
}
| filesys.c | 2671 |
| HB_EXPORT USHORT | hb_fsIsDrv( BYTE nDrive )
HB_EXPORT USHORT hb_fsIsDrv( BYTE nDrive )
{
USHORT uiResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsIsDrv(%d)", (int) nDrive));
#if defined(HB_OS_WIN_32) && !defined(HB_WINCE)
{
char buffer[ 4 ];
UINT type;
buffer[ 0 ] = nDrive + 'A';
buffer[ 1 ] = ':';
buffer[ 2 ] = '\\';
buffer[ 3 ] = '\0';
hb_vmUnlock();
type = GetDriveTypeA( ( LPCSTR ) buffer );
hb_vmLock();
uiResult = ( type == DRIVE_UNKNOWN || type == DRIVE_NO_ROOT_DIR ) ? F_ERROR : 0;
hb_fsSetError( 0 );
}
#elif defined(HB_OS_HAS_DRIVE_LETTER)
{
/* 'unsigned int' _have to_ be used in Watcom
*/
UINT uiSave, uiNewDrive;
hb_vmUnlock();
HB_FS_GETDRIVE( uiSave );
HB_FS_SETDRIVE( nDrive );
HB_FS_GETDRIVE( uiNewDrive );
if( ( UINT ) nDrive != uiNewDrive )
{
uiResult = ( USHORT ) FS_ERROR;
hb_fsSetError( ( USHORT ) FS_ERROR );
}
else
{
uiResult = 0;
hb_fsSetError( 0 );
}
HB_FS_SETDRIVE( uiSave );
hb_vmLock();
}
#else
HB_SYMBOL_UNUSED( nDrive );
uiResult = ( USHORT ) FS_ERROR;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return uiResult;
}
| filesys.c | 2719 |
| HB_EXPORT BOOL | hb_fsIsDevice( HB_FHANDLE hFileHandle )
HB_EXPORT BOOL hb_fsIsDevice( HB_FHANDLE hFileHandle )
{
BOOL bResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsIsDevice(%p)", hFileHandle));
#if defined(HB_OS_WIN_32)
hb_vmUnlock();
bResult = GetFileType( DosToWinHandle( hFileHandle ) ) == FILE_TYPE_CHAR;
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#elif defined(HB_FS_FILE_IO)
hb_vmUnlock();
#if defined( _MSC_VER ) || defined( __MINGW32__ )
bResult = _isatty( hFileHandle ) != 0;
#else
bResult = isatty( hFileHandle ) != 0;
#endif
hb_fsSetIOError( bResult, 0 );
hb_vmLock();
#else
bResult = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
HB_SYMBOL_UNUSED( hFileHandle );
#endif
return bResult;
}
| filesys.c | 2777 |
| HB_EXPORT BYTE | hb_fsCurDrv( void )
HB_EXPORT BYTE hb_fsCurDrv( void )
{
UINT uiResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsCurDrv()"));
#if defined(HB_OS_HAS_DRIVE_LETTER)
hb_vmUnlock();
HB_FS_GETDRIVE( uiResult );
hb_vmLock();
#else
uiResult = 0;
hb_fsSetError( ( USHORT ) FS_ERROR );
#endif
return ( BYTE ) uiResult; /* Return the drive number, base 0. */
}
| filesys.c | 2814 |
| HB_EXPORT BYTE * | hb_fsExtName( BYTE * pFilename, BYTE * pDefExt, USHORT uiExFlags, BYTE * pPaths )
HB_EXPORT BYTE * hb_fsExtName( BYTE * pFilename, BYTE * pDefExt,
USHORT uiExFlags, BYTE * pPaths )
{
HB_PATHNAMES * pNextPath;
PHB_FNAME pFilepath;
BOOL fIsFile = FALSE;
BYTE * szPath;
szPath = ( BYTE * ) hb_xgrab( _POSIX_PATH_MAX + 1 );
pFilepath = hb_fsFNameSplit( ( char * ) pFilename );
if( pDefExt && ( ( uiExFlags & FXO_FORCEEXT ) || !pFilepath->szExtension ) )
{
pFilepath->szExtension = ( char * ) pDefExt;
}
if( pFilepath->szPath )
{
hb_fsFNameMerge( ( char * ) szPath, pFilepath );
}
else if( uiExFlags & FXO_DEFAULTS )
{
char * szDefault = hb_setGetDefault();
if( szDefault )
{
pFilepath->szPath = szDefault;
hb_fsFNameMerge( ( char * ) szPath, pFilepath );
fIsFile = hb_fsFile( szPath );
}
if( !fIsFile && hb_setGetPath() )
{
pNextPath = hb_setGetFirstSetPath();
while( !fIsFile && pNextPath )
{
pFilepath->szPath = pNextPath->szPath;
hb_fsFNameMerge( ( char * ) szPath, pFilepath );
fIsFile = hb_fsFile( szPath );
pNextPath = pNextPath->pNext;
}
}
if( !fIsFile )
{
pFilepath->szPath = szDefault ? szDefault : NULL;
hb_fsFNameMerge( ( char * ) szPath, pFilepath );
}
}
else if( pPaths && *pPaths )
{
HB_PATHNAMES * pSearchPath = NULL;
hb_fsAddSearchPath( ( char * ) pPaths, &pSearchPath );
pNextPath = pSearchPath;
while( !fIsFile && pNextPath )
{
pFilepath->szPath = pNextPath->szPath;
hb_fsFNameMerge( ( char * ) szPath, pFilepath );
fIsFile = hb_fsFile( szPath );
pNextPath = pNextPath->pNext;
}
hb_fsFreeSearchPath( pSearchPath );
if( !fIsFile )
{
pFilepath->szPath = NULL;
hb_fsFNameMerge( ( char * ) szPath, pFilepath );
}
}
else
{
hb_fsFNameMerge( ( char * ) szPath, pFilepath );
}
hb_xfree( pFilepath );
return szPath;
}
| filesys.c | 2836 |
| HB_EXPORT HB_FHANDLE | hb_fsExtOpen( BYTE * pFilename, BYTE * pDefExt, USHORT uiExFlags, BYTE * pPaths, PHB_ITEM pError )
HB_EXPORT HB_FHANDLE hb_fsExtOpen( BYTE * pFilename, BYTE * pDefExt,
USHORT uiExFlags, BYTE * pPaths,
PHB_ITEM pError )
{
HB_FHANDLE hFile;
USHORT uiFlags;
BYTE * szPath;
HB_TRACE(HB_TR_DEBUG, ("hb_fsExtOpen(%s, %s, %hu, %p, %p)", pFilename, pDefExt, uiExFlags, pPaths, pError));
#if 0
#define FXO_TRUNCATE 0x0100 /* Create (truncate if exists) */
#define FXO_APPEND 0x0200 /* Create (append if exists) */
#define FXO_UNIQUE 0x0400 /* Create unique file FO_EXCL ??? */
#define FXO_FORCEEXT 0x0800 /* Force default extension */
#define FXO_DEFAULTS 0x1000 /* Use SET command defaults */
#define FXO_DEVICERAW 0x2000 /* Open devices in raw mode */
/* Harbour extension */
#define FXO_SHARELOCK 0x4000 /* emulate DOS SH_DENY* mode in POSIX OS */
#define FXO_COPYNAME 0x8000 /* copy final szPath into pFilename */
hb_errGetFileName( pError );
#endif
szPath = hb_fsExtName( pFilename, pDefExt, uiExFlags, pPaths );
uiFlags = uiExFlags & 0xff;
if( uiExFlags & ( FXO_TRUNCATE | FXO_APPEND | FXO_UNIQUE ) )
{
uiFlags |= FO_CREAT;
if( uiExFlags & FXO_UNIQUE )
uiFlags |= FO_EXCL;
#if !defined( HB_USE_SHARELOCKS )
else if( uiExFlags & FXO_TRUNCATE )
uiFlags |= FO_TRUNC;
#endif
}
hFile = hb_fsOpen( szPath, uiFlags );
#if defined( HB_USE_SHARELOCKS )
if( hFile != FS_ERROR && uiExFlags & FXO_SHARELOCK )
{
#if defined( HB_USE_BSDLOCKS )
int iLock;
if( ( uiFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) ) == FO_READ ||
( uiFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE ) ) == 0 )
iLock = LOCK_SH | LOCK_NB;
else
iLock = LOCK_EX | LOCK_NB;
hb_vmUnlock();
iLock = flock( hFile, iLock );
hb_vmLock();
if( iLock != 0 )
#else
USHORT uiLock;
if( ( uiFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) ) == FO_READ ||
( uiFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE ) ) == 0 )
uiLock = FL_LOCK | FLX_SHARED;
else
uiLock = FL_LOCK | FLX_EXCLUSIVE;
if( !hb_fsLockLarge( hFile, HB_SHARELOCK_POS, HB_SHARELOCK_SIZE, uiLock ) )
#endif
{
hb_fsClose( hFile );
hFile = FS_ERROR;
/*
* fix for neterr() support and Clipper compatibility,
* should be revised with a better multi platform solution.
*/
hb_fsSetError( ( uiExFlags & FXO_TRUNCATE ) ? 5 : 32 );
}
else if( uiExFlags & FXO_TRUNCATE )
{
/* truncate the file only if properly locked */
hb_fsSeek( hFile, 0, FS_SET );
hb_fsWrite( hFile, NULL, 0 );
if( hb_fsError() != 0 )
{
hb_fsClose( hFile );
hFile = FS_ERROR;
hb_fsSetError( 5 );
}
}
}
#elif 1
/*
* Temporary fix for neterr() support and Clipper compatibility,
* should be revised with a better solution.
*/
if( ( uiExFlags & ( FXO_TRUNCATE | FXO_APPEND | FXO_UNIQUE ) ) == 0 &&
hb_fsError() == 5 )
{
hb_fsSetError( 32 );
}
#endif
if( pError )
{
hb_errPutFileName( pError, ( char * ) szPath );
if( hFile == FS_ERROR )
{
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutGenCode( pError, ( USHORT ) ( ( uiExFlags & FXO_TRUNCATE ) ? EG_CREATE : EG_OPEN ) );
}
}
if( uiExFlags & FXO_COPYNAME && hFile != FS_ERROR )
hb_strncpy( ( char * ) pFilename, ( char * ) szPath, _POSIX_PATH_MAX );
hb_xfree( szPath );
return hFile;
}
| filesys.c | 2914 |
| HB_EXPORT BOOL | hb_fsEof( HB_FHANDLE hFileHandle )
HB_EXPORT BOOL hb_fsEof( HB_FHANDLE hFileHandle )
{
BOOL fResult;
hb_vmUnlock();
#if defined(__DJGPP__) || defined(__CYGWIN__) || \
defined(HB_WIN32_IO) || defined(HB_WINCE) || \
defined(HB_OS_UNIX_COMPATIBLE)
{
HB_FOFFSET curPos;
HB_FOFFSET endPos;
HB_FOFFSET newPos;
curPos = hb_fsSeekLarge( hFileHandle, 0L, SEEK_CUR );
if( curPos != -1 )
{
endPos = hb_fsSeekLarge( hFileHandle, 0L, SEEK_END );
newPos = hb_fsSeekLarge( hFileHandle, curPos, SEEK_SET );
fResult = ( endPos != -1 && newPos == curPos );
}
else
{
endPos = -1;
fResult = FALSE;
}
hb_fsSetIOError( fResult, 0 );
fResult = !fResult || curPos == endPos;
}
#else
fResult = eof( hFileHandle ) != 0;
hb_fsSetIOError( fResult, 0 );
#endif
hb_vmLock();
return fResult;
}
| filesys.c | 3029 |
| HB_EXPORT BYTE * | hb_fsNameConv( BYTE * szFileName, BOOL * pfFree )
HB_EXPORT BYTE * hb_fsNameConv( BYTE * szFileName, BOOL * pfFree )
{
int iFileCase, iDirCase;
char cDirSep;
BOOL fTrim;
/*
Convert file and dir case. The allowed SET options are:
LOWER - Convert all caracters of file to lower
UPPER - Convert all caracters of file to upper
MIXED - Leave as is
The allowed environment options are:
FILECASE - define the case of file
DIRCASE - define the case of path
DIRSEPARATOR - define separator of path (Ex. "/")
TRIMFILENAME - strip trailing and leading spaces (also from extension)
*/
fTrim = hb_setGetTrimFileName();
cDirSep = hb_setGetDirSeparator();
iFileCase = hb_setGetFileCase();
iDirCase = hb_setGetDirCase();
if( fTrim || cDirSep != HB_OS_PATH_DELIM_CHR ||
iFileCase != HB_SET_CASE_MIXED || iDirCase != HB_SET_CASE_MIXED )
{
PHB_FNAME pFileName;
ULONG ulLen;
if( pfFree )
{
BYTE * szNew = ( BYTE * ) hb_xgrab( _POSIX_PATH_MAX + 1 );
hb_strncpy( ( char * ) szNew, ( char * ) szFileName, _POSIX_PATH_MAX );
szFileName = szNew;
*pfFree = TRUE;
}
if( cDirSep != HB_OS_PATH_DELIM_CHR )
{
BYTE *p = szFileName;
while( *p )
{
if( *p == cDirSep )
*p = HB_OS_PATH_DELIM_CHR;
p++;
}
}
pFileName = hb_fsFNameSplit( ( char * ) szFileName );
/* strip trailing and leading spaces */
if( fTrim )
{
if( pFileName->szName )
{
ulLen = strlen( pFileName->szName );
ulLen = hb_strRTrimLen( pFileName->szName, ulLen, FALSE );
pFileName->szName = hb_strLTrim( pFileName->szName, &ulLen );
( ( char * ) pFileName->szName )[ulLen] = '\0';
}
if( pFileName->szExtension )
{
ulLen = strlen( pFileName->szExtension );
ulLen = hb_strRTrimLen( pFileName->szExtension, ulLen, FALSE );
pFileName->szExtension = hb_strLTrim( pFileName->szExtension, &ulLen );
( ( char * ) pFileName->szExtension )[ulLen] = '\0';
}
}
/* FILECASE */
if( iFileCase == HB_SET_CASE_LOWER )
{
if( pFileName->szName )
hb_strLower( ( char * ) pFileName->szName, strlen( pFileName->szName ) );
if( pFileName->szExtension )
hb_strLower( ( char * ) pFileName->szExtension, strlen( pFileName->szExtension ) );
}
else if( iFileCase == HB_SET_CASE_UPPER )
{
if( pFileName->szName )
hb_strUpper( ( char * ) pFileName->szName, strlen( pFileName->szName ) );
if( pFileName->szExtension )
hb_strUpper( ( char * ) pFileName->szExtension, strlen( pFileName->szExtension ) );
}
/* DIRCASE */
if( pFileName->szPath )
{
if( iDirCase == HB_SET_CASE_LOWER )
hb_strLower( ( char * ) pFileName->szPath, strlen( pFileName->szPath ) );
else if( iDirCase == HB_SET_CASE_UPPER )
hb_strUpper( ( char * ) pFileName->szPath, strlen( pFileName->szPath ) );
}
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_xfree( pFileName );
}
else if( pfFree )
*pfFree = FALSE;
return szFileName;
}
| filesys.c | 3068 |
| HB_EXPORT BYTE * | hb_fileNameConv( char * szFileName )
HB_EXPORT BYTE * hb_fileNameConv( char * szFileName )
{
BOOL fFree;
BYTE * szNew;
szNew = hb_fsNameConv( ( BYTE * ) szFileName, &fFree );
if( fFree )
{
hb_strncpy( szFileName, ( char * ) szNew, strlen( szFileName ) );
hb_xfree( szNew );
}
return ( BYTE * ) szFileName;
}
| filesys.c | 3173 |
| HB_EXPORT BOOL | hb_fsDisableWaitLocks( int iSet )
HB_EXPORT BOOL hb_fsDisableWaitLocks( int iSet )
{
BOOL fRetVal = s_fUseWaitLocks;
if( iSet >= 0 )
{
s_fUseWaitLocks = ( iSet == 0 );
}
return fRetVal;
}
| filesys.c | 3190 |
| HB_FUNC | HB_DISABLEWAITLOCKS(void)
HB_FUNC( HB_DISABLEWAITLOCKS )
{
hb_retl( hb_fsDisableWaitLocks( ISLOG( 1 ) ? ( hb_parl( 1 ) ? 1 : 0 ) : -1 ) );
}
| filesys.c | 3202 |
| fkmax.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | FKMAX(void)
HB_FUNC( FKMAX )
{
hb_retni( 40 ); /* IBM specific */
}
| fkmax.c | 58 |
| HB_FUNC | FKLABEL(void)
HB_FUNC( FKLABEL )
{
PHB_ITEM pPar1 = hb_param( 1, HB_IT_NUMERIC );
if( pPar1 )
{
USHORT uiFKey = ( USHORT ) hb_itemGetNI( pPar1 );
if( uiFKey > 0 && uiFKey <= 40 )
{
char szName[ 4 ];
snprintf( szName, sizeof( szName ), "F%i", uiFKey );
hb_retc( szName );
return;
}
}
hb_retc_null();
}
| fkmax.c | 65 |
| fnsplit.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_FNAMESPLIT(void)
HB_FUNC( HB_FNAMESPLIT )
{
if( ISCHAR( 1 ) )
{
PHB_FNAME pFileName = hb_fsFNameSplit( hb_parc( 1 ) );
hb_storc( pFileName->szPath, 2 );
hb_storc( pFileName->szName, 3 );
hb_storc( pFileName->szExtension, 4 );
hb_storc( pFileName->szDrive, 5 );
hb_xfree( pFileName );
}
}
| fnsplit.c | 56 |
| HB_FUNC | HB_FNAMEMERGE(void)
HB_FUNC( HB_FNAMEMERGE )
{
HB_FNAME pFileName;
char szFileName[ _POSIX_PATH_MAX + 1 ];
pFileName.szPath = hb_parc( 1 );
pFileName.szName = hb_parc( 2 );
pFileName.szExtension = hb_parc( 3 );
pFileName.szDrive = hb_parc( 4 );
hb_retc( hb_fsFNameMerge( szFileName, &pFileName ) );
}
| fnsplit.c | 71 |
| fserror.c |
| Type | Function | Source | Line |
|---|
| STATIC INT | hb_errnoToDosError( int ErrCode )
static int hb_errnoToDosError( int ErrCode )
{
int iResult;
#if defined(__BORLANDC__)
/* These C compilers use DOS error codes in errno */
iResult = ErrCode;
#else
switch( ErrCode )
{
#if defined( ENMFILE )
case ENMFILE:
#endif
case ENOENT:
iResult = 2; /* File not found */
break;
#if defined( ENOTDIR )
case ENOTDIR:
iResult = 3; /* Path not found */
break;
#endif
#if defined( ENFILE )
case ENFILE:
#endif
case EMFILE:
iResult = 4; /* Too many open files */
break;
case EACCES:
#if defined( ETXTBSY )
case ETXTBSY:
#endif
iResult = 5; /* Access denied */
break;
case EBADF:
iResult = 6; /* Invalid handle */
break;
case ENOMEM:
iResult = 8; /* Insufficient memory */
break;
#if defined( EFAULT )
case EFAULT:
iResult = 9; /* Invalid memory block address */
break;
#endif
case EINVAL:
iResult = 13; /* Invalid data */
break;
#if defined( EROFS )
case EROFS:
iResult = 19; /* Attempt to write on write-protected diskette */
break;
#endif
#if defined( ESPIPE )
case ESPIPE:
iResult = 25; /* Seek error */
break;
#endif
#if defined( ENOSPC )
case ENOSPC:
iResult = 29; /* Write fault */
break;
#endif
case EPIPE:
iResult = 29; /* Write fault */
break;
case EEXIST:
iResult = 32; /* Sharing violation */
break;
case EAGAIN:
iResult = 33; /* Lock violation */
break;
default:
iResult = ErrCode;
break;
}
#endif
return iResult;
}
| fserror.c | 66 |
| STATIC INT | hb_WinToDosError( ULONG ulError )
static int hb_WinToDosError( ULONG ulError )
{
int iResult;
switch( ulError )
{
case ERROR_ALREADY_EXISTS:
iResult = 5;
break;
case ERROR_FILE_NOT_FOUND:
iResult = 2;
break;
case ERROR_PATH_NOT_FOUND:
iResult = 3;
break;
case ERROR_TOO_MANY_OPEN_FILES:
iResult = 4;
break;
case ERROR_INVALID_HANDLE:
iResult = 6;
break;
default:
iResult = ( int ) ulError;
break;
}
return iResult;
}
| fserror.c | 148 |
| HB_EXPORT USHORT | hb_fsGetFError( void )
HB_EXPORT USHORT hb_fsGetFError( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsGetFError()"));
return hb_stackIOErrors()->uiFError;
}
| fserror.c | 179 |
| HB_EXPORT USHORT | hb_fsError( void )
HB_EXPORT USHORT hb_fsError( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsError()"));
return hb_stackIOErrors()->uiErrorLast;
}
| fserror.c | 187 |
| HB_EXPORT USHORT | hb_fsOsError( void )
HB_EXPORT USHORT hb_fsOsError( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsOsError()"));
return hb_stackIOErrors()->uiOsErrorLast;
}
| fserror.c | 195 |
| HB_EXPORT VOID | hb_fsSetFError( USHORT uiError )
HB_EXPORT void hb_fsSetFError( USHORT uiError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_fsSetFError(%hu)", uiError));
hb_stackIOErrors()->uiFError = uiError;
}
| fserror.c | 203 |
| HB_EXPORT VOID | hb_fsSetError( USHORT uiError )
HB_EXPORT void hb_fsSetError( USHORT uiError )
{
PHB_IOERRORS pIOErrors;
HB_TRACE(HB_TR_DEBUG, ("hb_fsSetError(%hu)", uiError));
pIOErrors = hb_stackIOErrors();
/* TODO: untranslate uiError into errno */
pIOErrors->uiOsErrorLast = pIOErrors->uiErrorLast = uiError;
}
| fserror.c | 211 |
| HB_EXPORT VOID | hb_fsSetIOError( BOOL fResult, USHORT uiOperation )
HB_EXPORT void hb_fsSetIOError( BOOL fResult, USHORT uiOperation )
{
USHORT uiOsErrorLast, uiErrorLast;
PHB_IOERRORS pIOErrors;
/* TODO: implement it */
HB_SYMBOL_UNUSED( uiOperation );
if( fResult )
{
uiOsErrorLast = uiErrorLast = 0;
}
else
{
#if defined(HB_WIN32_IO) || defined(HB_OS_WIN_32)
uiOsErrorLast = ( USHORT ) GetLastError();
uiErrorLast = ( USHORT ) hb_WinToDosError( uiOsErrorLast );
#elif defined(_MSC_VER) || defined(__DMC__)
#ifdef __XCC__
extern unsigned long _doserrno;
extern void __cdecl _dosmaperr( unsigned long oserrno );
_dosmaperr( GetLastError() );
#endif
if( _doserrno != 0 )
{
uiOsErrorLast = uiErrorLast = _doserrno;
}
else
{
uiOsErrorLast = errno;
uiErrorLast = hb_errnoToDosError( errno );
}
#else
uiOsErrorLast = errno;
uiErrorLast = hb_errnoToDosError( uiOsErrorLast );
#endif
}
pIOErrors = hb_stackIOErrors();
pIOErrors->uiOsErrorLast = uiOsErrorLast;
pIOErrors->uiErrorLast = uiErrorLast;
}
| fserror.c | 223 |
| fssize.c |
| Type | Function | Source | Line |
|---|
| HB_FOFFSET | hb_fsFSize( BYTE * pszFileName, BOOL bUseDirEntry )
HB_FOFFSET hb_fsFSize( BYTE * pszFileName, BOOL bUseDirEntry )
{
if( bUseDirEntry )
{
#if defined(HB_WINCE)
BOOL fFree;
PHB_FFIND ffind;
pszFileName = hb_fsNameConv( pszFileName, &fFree );
ffind = hb_fsFindFirst( ( char * ) pszFileName, HB_FA_ALL );
if( fFree )
hb_xfree( pszFileName );
hb_fsSetIOError( ffind != NULL, 0 );
if( ffind )
{
HB_FOFFSET size = ffind->size;
hb_fsFindClose( ffind );
return size;
}
#elif defined( HB_USE_LARGEFILE64 )
BOOL fResult, fFree;
struct stat64 statbuf;
pszFileName = hb_fsNameConv( pszFileName, &fFree );
hb_vmUnlock();
fResult = stat64( ( char * ) pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( fFree )
hb_xfree( pszFileName );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#else
BOOL fResult, fFree;
struct stat statbuf;
pszFileName = hb_fsNameConv( pszFileName, &fFree );
hb_vmUnlock();
fResult = stat( ( char * ) pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( fFree )
hb_xfree( pszFileName );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#endif
}
else
{
HB_FHANDLE hFileHandle = hb_fsOpen( pszFileName, 0 );
if( hFileHandle != FS_ERROR )
{
HB_FOFFSET ulPos;
ulPos = hb_fsSeekLarge( hFileHandle, 0, SEEK_END );
hb_fsClose( hFileHandle );
return ulPos;
}
}
return 0;
}
| fssize.c | 81 |
| HB_FUNC | HB_FSIZE(void)
HB_FUNC( HB_FSIZE )
{
hb_retnint( ISCHAR( 1 ) ? hb_fsFSize( ( BYTE * ) hb_parc( 1 ),
ISLOG( 2 ) ? hb_parl( 2 ) : TRUE ) : 0 );
}
| fssize.c | 141 |
| fstemp.c |
| Type | Function | Source | Line |
|---|
| STATIC BOOL | hb_fsTempName( BYTE * pszBuffer, const BYTE * pszDir, const BYTE * pszPrefix )
static BOOL hb_fsTempName( BYTE * pszBuffer, const BYTE * pszDir, const BYTE * pszPrefix )
{
BOOL fResult;
hb_vmUnlock();
#if defined(HB_WIN32_IO)
{
char cTempDir[ _POSIX_PATH_MAX + 1 ];
if( pszDir && pszDir[ 0 ] != '\0' )
hb_strncpy( ( char * ) cTempDir, ( const char * ) pszDir, sizeof( cTempDir ) - 1 );
else
{
if( ! GetTempPathA( ( DWORD ) _POSIX_PATH_MAX + 1, cTempDir ) )
{
hb_fsSetIOError( FALSE, 0 );
return FALSE;
}
}
cTempDir[ _POSIX_PATH_MAX ] = '\0';
fResult = GetTempFileNameA( ( LPCSTR ) cTempDir, pszPrefix ? ( LPCSTR ) pszPrefix : ( LPCSTR ) "hb", 0, ( LPSTR ) pszBuffer );
}
#else
/* TODO: Implement these: */
HB_SYMBOL_UNUSED( pszDir );
HB_SYMBOL_UNUSED( pszPrefix );
/* TOFIX: The spec says to reserve L_tmpnam number of characters for the
passed buffer. It will be needed to fix _POSIX_PATH_MAX to be
at least this large. */
pszBuffer[ 0 ] = '\0';
fResult = ( tmpnam( ( char * ) pszBuffer ) != NULL );
#endif
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
return fResult;
}
| fstemp.c | 69 |
| HB_EXPORT HB_FHANDLE | hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName )
HB_EXPORT HB_FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName )
{
USHORT nAttemptLeft = 999;
while( --nAttemptLeft )
{
if( hb_fsTempName( pszName, pszDir, pszPrefix ) )
{
HB_FHANDLE fhnd = hb_fsCreateEx( pszName, ulAttr, FO_EXCLUSIVE | FO_EXCL );
/* This function may fail, if the generated filename got
used between generation and the file creation. */
if( fhnd != FS_ERROR )
return fhnd;
}
else
{
/* Don't attempt to retry if the filename generator is
failing for some reason. */
break;
}
}
return FS_ERROR;
}
| fstemp.c | 116 |
| STATIC BOOL | fsGetTempDirByCase( BYTE *pszName, const char *pszTempDir )
static BOOL fsGetTempDirByCase( BYTE *pszName, const char *pszTempDir )
{
BOOL fOK = FALSE;
if( pszTempDir && *pszTempDir != '\0' )
{
hb_strncpy( ( char * ) pszName, ( char * ) pszTempDir, _POSIX_PATH_MAX );
switch( hb_setGetDirCase() )
{
case HB_SET_CASE_LOWER:
hb_strLower( ( char * ) pszName, strlen( ( char * ) pszName ) );
fOK = strcmp( ( char * ) pszName, pszTempDir ) == 0;
break;
case HB_SET_CASE_UPPER:
hb_strUpper( ( char * ) pszName, strlen( ( char * ) pszName ) );
fOK = strcmp( ( char * ) pszName, pszTempDir ) == 0;
break;
default:
fOK = TRUE;
break;
}
}
return fOK;
}
| fstemp.c | 146 |
| HB_EXPORT HB_FHANDLE | hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName )
HB_EXPORT HB_FHANDLE hb_fsCreateTemp( const BYTE * pszDir, const BYTE * pszPrefix, ULONG ulAttr, BYTE * pszName )
{
/* less attemps */
int iAttemptLeft = 99, iLen;
HB_FHANDLE fd;
do
{
pszName[ 0 ] = '\0';
if( pszDir && pszDir[ 0 ] != '\0' )
{
hb_strncpy( ( char * ) pszName, ( char * ) pszDir, _POSIX_PATH_MAX );
}
else
{
char * pszTmpDir = hb_getenv( "TMPDIR" );
if( !fsGetTempDirByCase( pszName, pszTmpDir ) )
{
#ifdef P_tmpdir
if( !fsGetTempDirByCase( pszName, P_tmpdir ) )
#endif
{
pszName[ 0 ] = '.';
pszName[ 1 ] = '\0';
}
}
if( pszTmpDir )
hb_xfree( pszTmpDir );
}
if( pszName[0] != '\0' )
{
int len;
len = strlen( ( char * ) pszName );
pszName[ len ] = ( BYTE ) HB_OS_PATH_DELIM_CHR;
pszName[ len + 1 ] = '\0';
}
if( pszPrefix )
hb_strncat( ( char * ) pszName, ( char * ) pszPrefix, _POSIX_PATH_MAX );
iLen = ( int ) strlen( ( char * ) pszName );
if( iLen > _POSIX_PATH_MAX - 6 )
return FS_ERROR;
#if !defined(__WATCOMC__) && ( defined( HB_OS_LINUX ) || defined( HB_OS_BSD ) )
if( hb_setGetFileCase() != HB_SET_CASE_LOWER &&
hb_setGetFileCase() != HB_SET_CASE_UPPER &&
hb_setGetDirCase() != HB_SET_CASE_LOWER &&
hb_setGetDirCase() != HB_SET_CASE_UPPER )
{
hb_strncat( ( char * ) pszName, "XXXXXX", _POSIX_PATH_MAX );
hb_vmUnlock();
fd = ( HB_FHANDLE ) mkstemp( ( char * ) pszName );
hb_fsSetIOError( fd != ( HB_FHANDLE ) -1, 0 );
hb_vmLock();
}
else
#endif
{
int i, n;
double d = hb_random_num(), x;
for( i = 0; i < 6; i++ )
{
d = d * 36;
n = ( int ) d;
d = modf( d, &x );
pszName[ iLen++ ] = n + ( n > 9 ? 'a' - 10 : '0' );
}
hb_fsNameConv( pszName, NULL );
fd = hb_fsCreateEx( pszName, ulAttr, FO_EXCLUSIVE | FO_EXCL );
}
if( fd != ( HB_FHANDLE ) FS_ERROR )
return fd;
}
while( --iAttemptLeft );
return FS_ERROR;
}
| fstemp.c | 172 |
| HB_FUNC | HB_FTEMPCREATE(void)
HB_FUNC( HB_FTEMPCREATE )
{
BYTE szName[ _POSIX_PATH_MAX + 1 ];
hb_retnint( ( HB_NHANDLE ) hb_fsCreateTemp( ( BYTE * ) hb_parc( 1 ),
( BYTE * ) hb_parc( 2 ),
( ULONG ) ( ISNUM( 3 ) ? ( ULONG ) hb_parnl( 3 ) : FC_NORMAL ),
szName ) );
hb_storc( ( char *) szName, 4 );
}
| fstemp.c | 258 |
| gete.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | GETENV(void)
HB_FUNC( GETENV )
{
PHB_ITEM pName = hb_param( 1, HB_IT_STRING );
#ifdef HB_EXTENSION
if( pName )
#else
if( pName && hb_pcount() == 1 )
#endif
{
char * pszName = hb_itemGetC( pName );
ULONG ulName = strlen( pszName );
ULONG ulPos;
/* strip the '=' or else it will clear the variable! */
for( ulPos = 0; ulPos < ulName; ulPos++ )
{
if( pszName[ ulPos ] == '=' )
{
pszName[ ulPos ] = '\0';
break;
}
}
if( pszName[ 0 ] != '\0' )
{
char * szValue;
/* NOTE: Convert the envvar name to uppercase. This is required for
DOS and OS/2 systems. [vszakats] */
#if defined(HB_OS_DOS) || defined(HB_OS_OS2)
hb_strupr( pszName );
#endif
szValue = hb_getenv( pszName );
if( szValue && szValue[ 0 ] != '\0' )
hb_retc_buffer( szValue );
else
{
if( szValue )
hb_xfree( szValue );
#ifdef HB_EXTENSION
hb_retc( hb_parc( 2 ) );
#else
hb_retc( NULL );
#endif
}
}
else
hb_retc( NULL );
hb_itemFreeC( pszName );
}
else
hb_retc( NULL );
}
| gete.c | 71 |
| HB_FUNC | GETE(void)
HB_FUNC( GETE )
{
HB_FUNC_EXEC( GETENV );
}
| gete.c | 132 |
| HB_FUNC | HB_GETENV(void)
HB_FUNC( HB_GETENV )
{
PHB_ITEM pName = hb_param( 1, HB_IT_STRING );
if( pName )
{
char * pszName = hb_itemGetC( pName );
ULONG ulName = strlen( pszName );
ULONG ulPos;
/* strip the '=' or else it will clear the variable! */
for( ulPos = 0; ulPos < ulName; ulPos++ )
{
if( pszName[ ulPos ] == '=' )
{
pszName[ ulPos ] = '\0';
break;
}
}
if( pszName[ 0 ] != '\0' )
{
char * szValue;
/* NOTE: Convert the envvar name to uppercase. This is required for
DOS and OS/2 systems. [vszakats] */
#if defined(HB_OS_DOS) || defined(HB_OS_OS2)
hb_strupr( pszName );
#endif
szValue = hb_getenv( pszName );
if( szValue && szValue[ 0 ] != '\0' )
hb_retc_buffer( szValue );
else
{
if( szValue )
hb_xfree( szValue );
hb_retc( hb_parc( 2 ) );
}
}
else
hb_retc( NULL );
hb_itemFreeC( pszName );
}
else
hb_retc( NULL );
}
| gete.c | 141 |
| gt.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DISPBEGIN(void)
HB_FUNC( DISPBEGIN )
{
hb_gtDispBegin();
}
| gt.c | 56 |
| HB_FUNC | DISPEND(void)
HB_FUNC( DISPEND )
{
hb_gtDispEnd();
}
| gt.c | 61 |
| HB_FUNC | DISPCOUNT(void)
HB_FUNC( DISPCOUNT )
{
hb_retni( hb_gtDispCount() );
}
| gt.c | 66 |
| gtapi.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT ERRCODE | hb_gtInit( HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
HB_EXPORT ERRCODE hb_gtInit( HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtInit()"));
hb_gtStartupInit();
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
HB_GTSELF_SETCOLORSTR( pGT, hb_setGetColor() );
HB_GTSELF_SETCURSORSTYLE( pGT, SC_NORMAL );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
}
if( hb_cmdargCheck( "INFO" ) )
{
if( pGT )
hb_conOutErr( HB_GTSELF_VERSION( pGT, 1 ), 0 );
hb_conOutErr( hb_conNewLine(), 0 );
}
return SUCCESS;
}
| gtapi.c | 89 |
| HB_EXPORT ERRCODE | hb_gtExit( void )
HB_EXPORT ERRCODE hb_gtExit( void )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtExit()"));
pGT = hb_gt_Base();
if( pGT )
{
while( HB_GTSELF_DISPCOUNT( pGT ) )
HB_GTSELF_DISPEND( pGT );
HB_GTSELF_FLUSH( pGT );
HB_GTSELF_EXIT( pGT );
hb_gt_BaseFree( pGT );
}
hb_gtUnLoad();
return SUCCESS;
}
| gtapi.c | 117 |
| HB_EXPORT INT | hb_gtReadKey( int iEventMask )
HB_EXPORT int hb_gtReadKey( int iEventMask )
{
int iKey = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtReadKey(%d)", iEventMask));
pGT = hb_gt_Base();
if( pGT )
{
iKey = HB_GTSELF_READKEY( pGT, iEventMask );
hb_gt_BaseFree( pGT );
}
return iKey;
}
| gtapi.c | 139 |
| HB_EXPORT ERRCODE | hb_gtBox( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right, BYTE * pbyFrame )
HB_EXPORT ERRCODE hb_gtBox( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right, BYTE * pbyFrame )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtBox(%hd, %hd, %hd, %hd, %p)", Top, Left, Bottom, Right, pbyFrame));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_BOX( pGT, Top, Left, Bottom, Right, pbyFrame, HB_GTSELF_GETCOLOR( pGT ) );
HB_GTSELF_SETPOS( pGT, Top + 1, Left + 1 );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 155 |
| HB_EXPORT ERRCODE | hb_gtBoxD( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right )
HB_EXPORT ERRCODE hb_gtBoxD( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtBoxD(%hd, %hd, %hd, %hd)", Top, Left, Bottom, Right));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_BOXD( pGT, Top, Left, Bottom, Right, ( BYTE * ) _B_DOUBLE, HB_GTSELF_GETCOLOR( pGT ) );
HB_GTSELF_SETPOS( pGT, Top + 1, Left + 1 );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 173 |
| HB_EXPORT ERRCODE | hb_gtBoxS( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right )
HB_EXPORT ERRCODE hb_gtBoxS( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtBoxS(%hd, %hd, %hd, %hd)", Top, Left, Bottom, Right));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_BOXD( pGT, Top, Left, Bottom, Right, ( BYTE * ) _B_SINGLE, HB_GTSELF_GETCOLOR( pGT ) );
HB_GTSELF_SETPOS( pGT, Top + 1, Left + 1 );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 191 |
| HB_EXPORT ERRCODE | hb_gtColorSelect( USHORT uiColorIndex )
HB_EXPORT ERRCODE hb_gtColorSelect( USHORT uiColorIndex )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtColorSelect(%hu)", uiColorIndex));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_COLORSELECT( pGT, uiColorIndex );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 209 |
| HB_EXPORT ERRCODE | hb_gtDispBegin( void )
HB_EXPORT ERRCODE hb_gtDispBegin( void )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtDispBegin()"));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_DISPBEGIN( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 225 |
| HB_EXPORT USHORT | hb_gtDispCount( void )
HB_EXPORT USHORT hb_gtDispCount( void )
{
USHORT uiCount = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtDispCount()"));
pGT = hb_gt_Base();
if( pGT )
{
uiCount = HB_GTSELF_DISPCOUNT( pGT );
hb_gt_BaseFree( pGT );
}
return uiCount;
}
| gtapi.c | 241 |
| HB_EXPORT ERRCODE | hb_gtDispEnd( void )
HB_EXPORT ERRCODE hb_gtDispEnd( void )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtDispEnd()"));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_DISPEND( pGT );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 257 |
| HB_EXPORT ERRCODE | hb_gtPreExt( void )
HB_EXPORT ERRCODE hb_gtPreExt( void )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtPreExt()"));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_PREEXT( pGT ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 274 |
| HB_EXPORT ERRCODE | hb_gtPostExt( void )
HB_EXPORT ERRCODE hb_gtPostExt( void )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtPostExt()"));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_POSTEXT( pGT ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 291 |
| HB_EXPORT ERRCODE | hb_gtGetColorStr( char * pszColorString )
HB_EXPORT ERRCODE hb_gtGetColorStr( char * pszColorString )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetColorStr(%s)", pszColorString));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_GETCOLORSTR( pGT, pszColorString );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
pszColorString[0] = '\0';
return FAILURE;
}
| gtapi.c | 313 |
| HB_EXPORT INT | hb_gtColorToN( char * szColorString )
HB_EXPORT int hb_gtColorToN( char * szColorString )
{
int iColor = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtColorToN(%s)", szColorString));
pGT = hb_gt_Base();
if( pGT )
{
iColor = HB_GTSELF_COLORNUM( pGT, szColorString );
hb_gt_BaseFree( pGT );
}
return iColor;
}
| gtapi.c | 330 |
| HB_EXPORT ERRCODE | hb_gtColorsToString( int * pColors, int iColorCount, char * pszColorString, int iBufSize )
HB_EXPORT ERRCODE hb_gtColorsToString( int * pColors, int iColorCount, char * pszColorString, int iBufSize )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtColorsToString(%p, %d, %p, %d)", pColors, iColorCount, pszColorString, iBufSize));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_COLORSTOSTRING( pGT, pColors, iColorCount, pszColorString, iBufSize );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
pszColorString[0] = '\0';
return FAILURE;
}
| gtapi.c | 346 |
| HB_EXPORT ERRCODE | hb_gtSetColorStr( const char * szColorString )
HB_EXPORT ERRCODE hb_gtSetColorStr( const char * szColorString )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetColorStr(%s)", szColorString));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETCOLORSTR( pGT, szColorString );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 363 |
| HB_EXPORT ERRCODE | hb_gtGetCursor( USHORT * uipCursorStyle )
HB_EXPORT ERRCODE hb_gtGetCursor( USHORT * uipCursorStyle )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetCursor(%p)", uipCursorStyle));
pGT = hb_gt_Base();
if( pGT )
{
*uipCursorStyle = HB_GTSELF_GETCURSORSTYLE( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
*uipCursorStyle = SC_NONE;
return FAILURE;
}
| gtapi.c | 379 |
| HB_EXPORT ERRCODE | hb_gtSetCursor( USHORT uiCursorStyle )
HB_EXPORT ERRCODE hb_gtSetCursor( USHORT uiCursorStyle )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetCursor(%hu)", uiCursorStyle));
if( uiCursorStyle <= SC_SPECIAL2 )
{
PHB_GT pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETCURSORSTYLE( pGT, uiCursorStyle );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
}
return FAILURE;
}
| gtapi.c | 396 |
| HB_EXPORT ERRCODE | hb_gtGetPos( SHORT * piRow, SHORT * piCol )
HB_EXPORT ERRCODE hb_gtGetPos( SHORT * piRow, SHORT * piCol )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetPos(%p, %p)", piRow, piCol));
pGT = hb_gt_Base();
if( pGT )
{
int iRow, iCol;
HB_GTSELF_GETPOS( pGT, &iRow, &iCol );
*piRow = ( SHORT ) iRow;
*piCol = ( SHORT ) iCol;
hb_gt_BaseFree( pGT );
return SUCCESS;
}
*piRow = *piCol = 0;
return FAILURE;
}
| gtapi.c | 414 |
| HB_EXPORT ERRCODE | hb_gtSetPos( SHORT iRow, SHORT iCol )
HB_EXPORT ERRCODE hb_gtSetPos( SHORT iRow, SHORT iCol )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetPos(%hd, %hd)", iRow, iCol));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETPOS( pGT, iRow, iCol );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 438 |
| HB_EXPORT USHORT | hb_gtMaxCol( void )
HB_EXPORT USHORT hb_gtMaxCol( void )
{
USHORT uiMaxCol = 79;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtMaxCol()"));
pGT = hb_gt_Base();
if( pGT )
{
uiMaxCol = HB_GTSELF_MAXCOL( pGT );
hb_gt_BaseFree( pGT );
}
return uiMaxCol;
}
| gtapi.c | 455 |
| HB_EXPORT USHORT | hb_gtMaxRow( void )
HB_EXPORT USHORT hb_gtMaxRow( void )
{
USHORT uiMaxRow = 24;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtMaxRow()"));
pGT = hb_gt_Base();
if( pGT )
{
uiMaxRow = HB_GTSELF_MAXROW( pGT );
hb_gt_BaseFree( pGT );
}
return uiMaxRow;
}
| gtapi.c | 471 |
| HB_EXPORT ERRCODE | hb_gtScrDim( USHORT * uipHeight, USHORT * uipWidth )
HB_EXPORT ERRCODE hb_gtScrDim( USHORT * uipHeight, USHORT * uipWidth )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtScrDim(%p, %p)", uipHeight, uipWidth));
pGT = hb_gt_Base();
if( pGT )
{
int iHeight, iWidth;
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
*uipHeight = ( USHORT ) iHeight;
*uipWidth = ( USHORT ) iWidth;
hb_gt_BaseFree( pGT );
return SUCCESS;
}
*uipHeight = *uipWidth = 0;
return FAILURE;
}
| gtapi.c | 487 |
| HB_EXPORT ERRCODE | hb_gtSetSnowFlag( BOOL fNoSnow )
HB_EXPORT ERRCODE hb_gtSetSnowFlag( BOOL fNoSnow )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetSnowFlag(%d)", (int) fNoSnow));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETSNOWFLAG( pGT, fNoSnow );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 508 |
| HB_EXPORT ERRCODE | hb_gtRectSize( int iTop, int iLeft, int iBottom, int iRight, ULONG * pulBuffSize )
HB_EXPORT ERRCODE hb_gtRectSize( int iTop, int iLeft, int iBottom, int iRight, ULONG * pulBuffSize )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtRectSize(%d, %d, %d, %d, %p)", iTop, iLeft, iBottom, iRight, pulBuffSize));
pGT = hb_gt_Base();
if( pGT )
{
*pulBuffSize = HB_GTSELF_RECTSIZE( pGT, iTop, iLeft, iBottom, iRight );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
*pulBuffSize = 0;
return FAILURE;
}
| gtapi.c | 524 |
| HB_EXPORT BOOL | hb_gtIsColor( void )
HB_EXPORT BOOL hb_gtIsColor( void )
{
BOOL fColor = TRUE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtIsColor()"));
pGT = hb_gt_Base();
if( pGT )
{
fColor = HB_GTSELF_ISCOLOR( pGT );
hb_gt_BaseFree( pGT );
}
return fColor;
}
| gtapi.c | 541 |
| HB_EXPORT ERRCODE | hb_gtRepChar( USHORT uiRow, USHORT uiCol, BYTE byChar, USHORT uiCount )
HB_EXPORT ERRCODE hb_gtRepChar( USHORT uiRow, USHORT uiCol, BYTE byChar, USHORT uiCount )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtRepChar(%hu, %hu, %d, %hu)", uiRow, uiCol, (int) byChar, uiCount));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_REPLICATE( pGT, uiRow, uiCol, HB_GTSELF_GETCOLOR( pGT ), 0,
byChar, uiCount );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 557 |
| HB_EXPORT ERRCODE | hb_gtSave( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, void * pScrBuff )
HB_EXPORT ERRCODE hb_gtSave( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, void * pScrBuff )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSave(%hu, %hu, %hu, %hu, %p)", uiTop, uiLeft, uiBottom, uiRight, pScrBuff));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SAVE( pGT, uiTop, uiLeft, uiBottom, uiRight, ( BYTE * ) pScrBuff );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 575 |
| HB_EXPORT ERRCODE | hb_gtRest( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, void * pScrBuff )
HB_EXPORT ERRCODE hb_gtRest( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, void * pScrBuff )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtRest(%hu, %hu, %hu, %hu, %p)", uiTop, uiLeft, uiBottom, uiRight, pScrBuff));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_REST( pGT, uiTop, uiLeft, uiBottom, uiRight, ( BYTE * ) pScrBuff );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 591 |
| HB_EXPORT ERRCODE | hb_gtGetChar( USHORT uiRow, USHORT uiCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar )
HB_EXPORT ERRCODE hb_gtGetChar( USHORT uiRow, USHORT uiCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetChar(%hu, %hu, %p, %p, %p)", uiRow, uiCol, pbColor, pbAttr, pusChar));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_GETCHAR( pGT, uiRow, uiCol, pbColor, pbAttr, pusChar ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 608 |
| HB_EXPORT ERRCODE | hb_gtPutChar( USHORT uiRow, USHORT uiCol, BYTE bColor, BYTE bAttr, USHORT usChar )
HB_EXPORT ERRCODE hb_gtPutChar( USHORT uiRow, USHORT uiCol, BYTE bColor, BYTE bAttr, USHORT usChar )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtPutChar(%hu, %hu, %hu, %hu, %hu)", uiRow, uiCol, bColor, bAttr, usChar));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_PUTCHAR( pGT, uiRow, uiCol, bColor, bAttr, usChar ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 625 |
| HB_EXPORT ERRCODE | hb_gtBeginWrite( void )
HB_EXPORT ERRCODE hb_gtBeginWrite( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gtBeginWrite()"));
/* Do nothing in Harbour */
return SUCCESS;
}
| gtapi.c | 642 |
| HB_EXPORT ERRCODE | hb_gtEndWrite( void )
HB_EXPORT ERRCODE hb_gtEndWrite( void )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtEndWrite()"));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 651 |
| HB_EXPORT ERRCODE | hb_gtGetBlink( BOOL * bpBlink )
HB_EXPORT ERRCODE hb_gtGetBlink( BOOL * bpBlink )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetBlink(%p)", bpBlink));
pGT = hb_gt_Base();
if( pGT )
{
*bpBlink = HB_GTSELF_GETBLINK( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
*bpBlink = 0;
return FAILURE;
}
| gtapi.c | 667 |
| HB_EXPORT ERRCODE | hb_gtSetBlink( BOOL fBlink )
HB_EXPORT ERRCODE hb_gtSetBlink( BOOL fBlink )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetBlink(%d)", (int) fBlink));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETBLINK( pGT, fBlink );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 684 |
| HB_EXPORT ERRCODE | hb_gtSetMode( USHORT uiRows, USHORT uiCols )
HB_EXPORT ERRCODE hb_gtSetMode( USHORT uiRows, USHORT uiCols )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetMode(%hu, %hu)", uiRows, uiCols));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_SETMODE( pGT, uiRows, uiCols ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 700 |
| HB_EXPORT ERRCODE | hb_gtWriteAt( USHORT uiRow, USHORT uiCol, BYTE * pStr, ULONG ulLength )
HB_EXPORT ERRCODE hb_gtWriteAt( USHORT uiRow, USHORT uiCol, BYTE * pStr, ULONG ulLength )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteAt(%hu, %hu, %p, %lu)", uiRow, uiCol, pStr, ulLength));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_WRITEAT( pGT, uiRow, uiCol, pStr, ulLength );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 717 |
| HB_EXPORT ERRCODE | hb_gtWrite( BYTE * pStr, ULONG ulLength )
HB_EXPORT ERRCODE hb_gtWrite( BYTE * pStr, ULONG ulLength )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtWrite(%p, %lu)", pStr, ulLength));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_WRITE( pGT, pStr, ulLength );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 734 |
| HB_EXPORT ERRCODE | hb_gtWriteCon( BYTE * pStr, ULONG ulLength )
HB_EXPORT ERRCODE hb_gtWriteCon( BYTE * pStr, ULONG ulLength )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteCon(%p, %lu)", pStr, ulLength));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_WRITECON( pGT, pStr, ulLength );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 751 |
| HB_EXPORT ERRCODE | hb_gtScroll( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, SHORT iRows, SHORT iCols )
HB_EXPORT ERRCODE hb_gtScroll( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, SHORT iRows, SHORT iCols )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gtScroll(%hu, %hu, %hu, %hu, %hd, %hd)", uiTop, uiLeft, uiBottom, uiRight, iRows, iCols));
if( uiTop <= uiBottom && uiLeft <= uiRight )
{
PHB_GT pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SCROLL( pGT, uiTop, uiLeft, uiBottom, uiRight,
HB_GTSELF_GETCOLOR( pGT ), ' ', iRows, iCols );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
}
return FAILURE;
}
| gtapi.c | 768 |
| HB_EXPORT ERRCODE | hb_gtScrollUp( USHORT uiRows )
HB_EXPORT ERRCODE hb_gtScrollUp( USHORT uiRows )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gtScrollUp(%hd)", uiRows));
if( uiRows != 0 )
{
PHB_GT pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SCROLLUP( pGT, uiRows, HB_GTSELF_GETCOLOR( pGT ), ' ' );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
}
return FAILURE;
}
| gtapi.c | 787 |
| HB_EXPORT ERRCODE | hb_gtDrawShadow( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, BYTE byAttr )
HB_EXPORT ERRCODE hb_gtDrawShadow( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, BYTE byAttr )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtDrawShadow(%hu, %hu, %hu, %hu, %d)", uiTop, uiLeft, uiBottom, uiRight, (int) byAttr));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_DRAWSHADOW( pGT, uiTop, uiLeft, uiBottom, uiRight, byAttr );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 805 |
| HB_EXPORT ERRCODE | hb_gtTone( double dFrequency, double dDuration )
HB_EXPORT ERRCODE hb_gtTone( double dFrequency, double dDuration )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtTone(%lf, %lf)", dFrequency, dDuration));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_TONE( pGT, dFrequency, dDuration );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 822 |
| HB_EXPORT CONST CHAR * | hb_gtVersion( int iType )
HB_EXPORT const char * hb_gtVersion( int iType )
{
const char * szVersion = "";
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtVersion(%d)",iType));
pGT = hb_gt_Base();
if( pGT )
{
szVersion = HB_GTSELF_VERSION( pGT, iType );
hb_gt_BaseFree( pGT );
}
return szVersion;
}
| gtapi.c | 838 |
| HB_EXPORT ERRCODE | hb_gtSetAttribute( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, BYTE byAttr )
HB_EXPORT ERRCODE hb_gtSetAttribute( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, BYTE byAttr )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetAttribute(%hu, %hu, %hu, %hu, %d)", uiTop, uiLeft, uiBottom, uiRight, (int) byAttr));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETATTRIBUTE( pGT, uiTop, uiLeft, uiBottom, uiRight, byAttr );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 854 |
| HB_EXPORT ERRCODE | hb_gtSuspend( void )
HB_EXPORT ERRCODE hb_gtSuspend( void )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSuspend()"));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_SUSPEND( pGT ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 871 |
| HB_EXPORT ERRCODE | hb_gtResume( void )
HB_EXPORT ERRCODE hb_gtResume( void )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtResume()"));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_RESUME( pGT ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 889 |
| HB_EXPORT ERRCODE | hb_gtOutStd( BYTE * pbyStr, ULONG ulLen )
HB_EXPORT ERRCODE hb_gtOutStd( BYTE * pbyStr, ULONG ulLen )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtOutStd(%p, %lu)", pbyStr, ulLen));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_OUTSTD( pGT, pbyStr, ulLen );
hb_gt_BaseFree( pGT );
}
else
hb_fsWriteLarge( ( HB_FHANDLE ) HB_STDOUT_HANDLE, pbyStr, ulLen );
return SUCCESS;
}
| gtapi.c | 906 |
| HB_EXPORT ERRCODE | hb_gtOutErr( BYTE * pbyStr, ULONG ulLen )
HB_EXPORT ERRCODE hb_gtOutErr( BYTE * pbyStr, ULONG ulLen )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtOutErr(%p, %lu)", pbyStr, ulLen));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_OUTERR( pGT, pbyStr, ulLen );
hb_gt_BaseFree( pGT );
}
else
hb_fsWriteLarge( ( HB_FHANDLE ) HB_STDERR_HANDLE, pbyStr, ulLen );
return SUCCESS;
}
| gtapi.c | 924 |
| HB_EXPORT ERRCODE | hb_gtSetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox )
HB_EXPORT ERRCODE hb_gtSetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetDispCP(%s, %s, %d)", pszTermCDP, pszHostCDP, fBox));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 942 |
| HB_EXPORT ERRCODE | hb_gtSetKeyCP( char * pszTermCDP, char * pszHostCDP )
HB_EXPORT ERRCODE hb_gtSetKeyCP( char * pszTermCDP, char * pszHostCDP )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetKeyCP(%s, %s)", pszTermCDP, pszHostCDP));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_SETKEYCP( pGT, pszTermCDP, pszHostCDP ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 959 |
| HB_EXPORT ERRCODE | hb_gtInfo( int iType, PHB_GT_INFO pInfo )
HB_EXPORT ERRCODE hb_gtInfo( int iType, PHB_GT_INFO pInfo )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtInfo(%d, %p)", iType, pInfo));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_INFO( pGT, iType, pInfo ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 976 |
| HB_EXPORT INT | hb_gtAlert( PHB_ITEM pMessage, PHB_ITEM pOptions, int iClrNorm, int iClrHigh, double dDelay )
HB_EXPORT int hb_gtAlert( PHB_ITEM pMessage, PHB_ITEM pOptions,
int iClrNorm, int iClrHigh, double dDelay )
{
int iResult = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtAlert(%p, %p, %d, %d, %f)", pMessage, pOptions, iClrNorm, iClrHigh, dDelay));
pGT = hb_gt_Base();
if( pGT )
{
iResult = HB_GTSELF_ALERT( pGT, pMessage, pOptions, iClrNorm,
iClrHigh, dDelay );
hb_gt_BaseFree( pGT );
}
return iResult;
}
| gtapi.c | 993 |
| HB_EXPORT INT | hb_gtSetFlag( int iType, int iNewValue )
HB_EXPORT int hb_gtSetFlag( int iType, int iNewValue )
{
int iFlag = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetFlag(%d, %d)", iType, iNewValue));
pGT = hb_gt_Base();
if( pGT )
{
iFlag = HB_GTSELF_SETFLAG( pGT, iType, iNewValue );
hb_gt_BaseFree( pGT );
}
return iFlag;
}
| gtapi.c | 1011 |
| HB_EXPORT INT | hb_gtGetCurrColor( void )
HB_EXPORT int hb_gtGetCurrColor( void )
{
int iColor = 0x07;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetCurrColor()"));
pGT = hb_gt_Base();
if( pGT )
{
iColor = HB_GTSELF_GETCOLOR( pGT );
hb_gt_BaseFree( pGT );
}
return iColor;
}
| gtapi.c | 1027 |
| HB_EXPORT INT | hb_gtGetClearColor( void )
HB_EXPORT int hb_gtGetClearColor( void )
{
int iColor = 0x07;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetClearColor()"));
pGT = hb_gt_Base();
if( pGT )
{
iColor = HB_GTSELF_GETCLEARCOLOR( pGT );
hb_gt_BaseFree( pGT );
}
return iColor;
}
| gtapi.c | 1043 |
| HB_EXPORT ERRCODE | hb_gtSetClearColor( int iColor )
HB_EXPORT ERRCODE hb_gtSetClearColor( int iColor )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetClearColor(%d)", iColor));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETCLEARCOLOR( pGT, iColor );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 1059 |
| HB_EXPORT INT | hb_gtGetClearChar( void )
HB_EXPORT int hb_gtGetClearChar( void )
{
int iChar = ' ';
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetClearChar()"));
pGT = hb_gt_Base();
if( pGT )
{
iChar = HB_GTSELF_GETCLEARCHAR( pGT );
hb_gt_BaseFree( pGT );
}
return iChar;
}
| gtapi.c | 1075 |
| HB_EXPORT ERRCODE | hb_gtSetClearChar( int iChar )
HB_EXPORT ERRCODE hb_gtSetClearChar( int iChar )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtSetClearChar(%d)", iChar));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SETCLEARCHAR( pGT, iChar );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 1091 |
| HB_EXPORT ERRCODE | hb_gtGetScrChar( int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar )
HB_EXPORT ERRCODE hb_gtGetScrChar( int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtScrGetChar(%d, %d, %p, %p, %p)", iRow, iCol, pbColor, pbAttr, pusChar));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, pbColor, pbAttr, pusChar ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 1107 |
| HB_EXPORT ERRCODE | hb_gtPutScrChar( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar )
HB_EXPORT ERRCODE hb_gtPutScrChar( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar )
{
ERRCODE errCode = FAILURE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtPutScrChar(%d, %d, %d, %d, %hu)", iRow, iCol, bColor, bAttr, usChar));
pGT = hb_gt_Base();
if( pGT )
{
if( HB_GTSELF_PUTSCRCHAR( pGT, iRow, iCol, bColor, bAttr, usChar ) )
errCode = SUCCESS;
hb_gt_BaseFree( pGT );
}
return errCode;
}
| gtapi.c | 1124 |
| HB_EXPORT ERRCODE | hb_gtFlush( void )
HB_EXPORT ERRCODE hb_gtFlush( void )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtFlush()"));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 1141 |
| HB_EXPORT ERRCODE | hb_gtGetPosEx( int * piRow, int * piCol )
HB_EXPORT ERRCODE hb_gtGetPosEx( int * piRow, int * piCol )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGetPosEx(%p, %p)", piRow, piCol));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_GETPOS( pGT, piRow, piCol );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
*piRow = *piCol = 0;
return FAILURE;
}
| gtapi.c | 1157 |
| HB_EXPORT ERRCODE | hb_gtScrollEx( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols )
HB_EXPORT ERRCODE hb_gtScrollEx( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gtScrollEx(%d, %d, %d, %d, %d, %hd, %d, %d)", iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols));
if( iTop <= iBottom && iLeft <= iRight )
{
PHB_GT pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_SCROLL( pGT, iTop, iLeft, iBottom, iRight,
bColor, bChar, iRows, iCols );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
}
return FAILURE;
}
| gtapi.c | 1174 |
| HB_EXPORT ERRCODE | hb_gtBoxEx( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor )
HB_EXPORT ERRCODE hb_gtBoxEx( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtBoxEx(%d, %d, %d, %d, %p, %d)", iTop, iLeft, iBottom, iRight, pbyFrame, bColor));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_BOX( pGT, iTop, iLeft, iBottom, iRight, pbyFrame, bColor );
HB_GTSELF_SETPOS( pGT, iTop + 1, iLeft + 1 );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 1193 |
| HB_EXPORT INT | hb_gtGfxPrimitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor )
HB_EXPORT int hb_gtGfxPrimitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor )
{
PHB_GT pGT;
int iResult = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGfxText(%d, %d, %d, %d, %d, %d)", iType, iTop, iLeft, iBottom, iRight, iColor));
pGT = hb_gt_Base();
if( pGT )
{
iResult = HB_GTSELF_GFXPRIMITIVE( pGT, iType, iTop, iLeft, iBottom, iRight, iColor );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
}
return iResult;
}
| gtapi.c | 1211 |
| HB_EXPORT ERRCODE | hb_gtGfxText( int iTop, int iLeft, char * cBuf, int iColor, int iSize, int iWidth )
HB_EXPORT ERRCODE hb_gtGfxText( int iTop, int iLeft, char * cBuf, int iColor, int iSize, int iWidth )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtGfxText(%d, %d, %s, %d, %d, %d)", iTop, iLeft, cBuf, iColor, iSize, iWidth));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_GFXTEXT( pGT, iTop, iLeft, cBuf, iColor, iSize, iWidth );
HB_GTSELF_FLUSH( pGT );
hb_gt_BaseFree( pGT );
return SUCCESS;
}
return FAILURE;
}
| gtapi.c | 1228 |
| gtapiu.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT VOID | hb_gtWCreate( HB_GT_RECT * rect, HB_GT_WND ** wnd )
HB_EXPORT void hb_gtWCreate( HB_GT_RECT * rect, HB_GT_WND ** wnd )
{
/* TODO: */
HB_SYMBOL_UNUSED( rect );
HB_SYMBOL_UNUSED( wnd );
}
| gtapiu.c | 55 |
| HB_EXPORT VOID | hb_gtWDestroy( HB_GT_WND * wnd )
HB_EXPORT void hb_gtWDestroy( HB_GT_WND * wnd )
{
/* TODO: */
HB_SYMBOL_UNUSED( wnd );
}
| gtapiu.c | 63 |
| HB_EXPORT BOOL | hb_gtWFlash( void )
HB_EXPORT BOOL hb_gtWFlash( void )
{
/* TODO: */
return FALSE;
}
| gtapiu.c | 70 |
| HB_EXPORT VOID | hb_gtWApp( HB_GT_WND ** wnd )
HB_EXPORT void hb_gtWApp( HB_GT_WND ** wnd )
{
/* TODO: */
HB_SYMBOL_UNUSED( wnd );
}
| gtapiu.c | 77 |
| HB_EXPORT VOID | hb_gtWCurrent( HB_GT_WND * wnd )
HB_EXPORT void hb_gtWCurrent( HB_GT_WND * wnd )
{
/* TODO: */
HB_SYMBOL_UNUSED( wnd );
}
| gtapiu.c | 84 |
| HB_EXPORT VOID | hb_gtWPos( HB_GT_WND * wnd, HB_GT_RECT * rect )
HB_EXPORT void hb_gtWPos( HB_GT_WND * wnd, HB_GT_RECT * rect )
{
/* TODO: */
HB_SYMBOL_UNUSED( wnd );
HB_SYMBOL_UNUSED( rect );
}
| gtapiu.c | 91 |
| HB_EXPORT BOOL | hb_gtWVis( HB_GT_WND * wnd, USHORT uiStatus )
HB_EXPORT BOOL hb_gtWVis( HB_GT_WND * wnd, USHORT uiStatus )
{
/* TODO: */
HB_SYMBOL_UNUSED( wnd );
HB_SYMBOL_UNUSED( uiStatus );
return FALSE;
}
| gtapiu.c | 99 |
| HB_EXPORT USHORT | hb_gtSLR( HB_GT_SLR * pSLR )
HB_EXPORT USHORT hb_gtSLR( HB_GT_SLR * pSLR ) /* System Level Request */
{
/* Do nothing in Harbour, since the low-level GT API is
implemented with a different method than in CA-Cl*pper. */
HB_SYMBOL_UNUSED( pSLR );
return 1;
}
| gtapiu.c | 109 |
| HB_EXPORT USHORT | hb_gtModalRead( void * dummy )
HB_EXPORT USHORT hb_gtModalRead( void * dummy )
{
/* TODO: */
HB_SYMBOL_UNUSED( dummy );
return 1;
}
| gtapiu.c | 119 |
| HB_EXPORT USHORT | hb_gtFlushCursor( void )
HB_EXPORT USHORT hb_gtFlushCursor( void )
{
/* TODO: */
return 1;
}
| gtapiu.c | 128 |
| HB_EXPORT USHORT | hb_gtSetColor( HB_GT_RGB * color )
HB_EXPORT USHORT hb_gtSetColor( HB_GT_RGB * color )
{
/* TODO: */
HB_SYMBOL_UNUSED( color );
return 1;
}
| gtapiu.c | 135 |
| HB_EXPORT USHORT | hb_gtGetColor( HB_GT_RGB * color )
HB_EXPORT USHORT hb_gtGetColor( HB_GT_RGB * color )
{
/* TODO: */
HB_SYMBOL_UNUSED( color );
return 1;
}
| gtapiu.c | 144 |
| HB_EXPORT USHORT | hb_gtSetBorder( HB_GT_RGB * color )
HB_EXPORT USHORT hb_gtSetBorder( HB_GT_RGB * color )
{
/* TODO: */
HB_SYMBOL_UNUSED( color );
return 1;
}
| gtapiu.c | 153 |
| gtchrmap.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | chrmap_init( int *piTransTbl )
static void chrmap_init( int *piTransTbl )
{
int i;
for( i = 0; i < 256; ++i )
piTransTbl[i] = HB_CHRMAP( i < 128 ? 1 : 0, i );
piTransTbl[155] = HB_CHRMAP( 1, '.' );
}
| gtchrmap.c | 67 |
| STATIC VOID | chrmap_dotctrl( int *piTransTbl )
static void chrmap_dotctrl( int *piTransTbl )
{
int i;
for( i = 0; i < 32; ++i )
piTransTbl[i] = piTransTbl[i+128] = HB_CHRMAP( 1, '.' );
}
| gtchrmap.c | 77 |
| STATIC VOID | chrmap_ascictrl( int *piTransTbl )
static void chrmap_ascictrl( int *piTransTbl )
{
piTransTbl[04] = HB_CHRMAP( 1, '#' );
piTransTbl[16] = HB_CHRMAP( 1, '>' );
piTransTbl[17] = HB_CHRMAP( 1, '<' );
piTransTbl[30] = HB_CHRMAP( 1, '^' );
piTransTbl[31] = HB_CHRMAP( 1, 'v' );
piTransTbl[24] = HB_CHRMAP( 1, '^' );
piTransTbl[25] = HB_CHRMAP( 1, 'v' );
piTransTbl[26] = HB_CHRMAP( 1, '>' );
piTransTbl[27] = HB_CHRMAP( 1, '<' );
}
| gtchrmap.c | 85 |
| STATIC VOID | chrmap_acscbox( int *piTransTbl )
static void chrmap_acscbox( int *piTransTbl )
{
piTransTbl[ 04] = HB_CHRMAP( 5, '`' ); /* ACS_DIAMOND */
piTransTbl[ 16] = HB_CHRMAP( 5, '+' ); /* ACS_RARROW */
piTransTbl[ 17] = HB_CHRMAP( 5, ',' ); /* ACS_LARROW */
piTransTbl[ 24] = HB_CHRMAP( 5, '-' ); /* ACS_UARROW */
piTransTbl[ 25] = HB_CHRMAP( 5, '.' ); /* ACS_DARROW */
piTransTbl[ 26] = HB_CHRMAP( 5, '+' ); /* ACS_RARROW */
piTransTbl[ 27] = HB_CHRMAP( 5, ',' ); /* ACS_LARROW */
piTransTbl[ 30] = HB_CHRMAP( 5, '-' ); /* ACS_UARROW */
piTransTbl[ 31] = HB_CHRMAP( 5, '.' ); /* ACS_DARROW */
piTransTbl[176] = HB_CHRMAP( 5, 'h' ); /* ACS_BOARD */
piTransTbl[177] = HB_CHRMAP( 5, 'a' ); /* ACS_CKBOARD */
piTransTbl[178] = HB_CHRMAP( 5, '0' ); /* ACS_BLOCK */
piTransTbl[179] = HB_CHRMAP( 5, 'x' ); /* ACS_VLINE */
piTransTbl[180] = HB_CHRMAP( 5, 'u' ); /* ACS_RTEE */
piTransTbl[181] = HB_CHRMAP( 5, 'u' ); /* ACS_RTEE */
piTransTbl[182] = HB_CHRMAP( 5, 'u' ); /* ACS_RTEE */
piTransTbl[183] = HB_CHRMAP( 5, 'k' ); /* ACS_URCORNER */
piTransTbl[184] = HB_CHRMAP( 5, 'k' ); /* ACS_URCORNER */
piTransTbl[185] = HB_CHRMAP( 5, 'u' ); /* ACS_RTEE */
piTransTbl[186] = HB_CHRMAP( 5, 'x' ); /* ACS_VLINE */
piTransTbl[187] = HB_CHRMAP( 5, 'k' ); /* ACS_URCORNER */
piTransTbl[188] = HB_CHRMAP( 5, 'j' ); /* ACS_LRCORNER */
piTransTbl[189] = HB_CHRMAP( 5, 'j' ); /* ACS_LRCORNER */
piTransTbl[190] = HB_CHRMAP( 5, 'j' ); /* ACS_LRCORNER */
piTransTbl[191] = HB_CHRMAP( 5, 'k' ); /* ACS_URCORNER */
piTransTbl[192] = HB_CHRMAP( 5, 'm' ); /* ACS_LLCORNER */
piTransTbl[193] = HB_CHRMAP( 5, 'v' ); /* ACS_BTEE */
piTransTbl[194] = HB_CHRMAP( 5, 'w' ); /* ACS_TTEE */
piTransTbl[195] = HB_CHRMAP( 5, 't' ); /* ACS_LTEE */
piTransTbl[196] = HB_CHRMAP( 5, 'q' ); /* ACS_HLINE */
piTransTbl[197] = HB_CHRMAP( 5, 'n' ); /* ACS_PLUS */
piTransTbl[198] = HB_CHRMAP( 5, 't' ); /* ACS_LTEE */
piTransTbl[199] = HB_CHRMAP( 5, 't' ); /* ACS_LTEE */
piTransTbl[200] = HB_CHRMAP( 5, 'm' ); /* ACS_LLCORNER */
piTransTbl[201] = HB_CHRMAP( 5, 'l' ); /* ACS_ULCORNER */
piTransTbl[202] = HB_CHRMAP( 5, 'v' ); /* ACS_BTEE */
piTransTbl[203] = HB_CHRMAP( 5, 'w' ); /* ACS_TTEE */
piTransTbl[204] = HB_CHRMAP( 5, 't' ); /* ACS_LTEE */
piTransTbl[205] = HB_CHRMAP( 5, 'q' ); /* ACS_HLINE */
piTransTbl[206] = HB_CHRMAP( 5, 'n' ); /* ACS_PLUS */
piTransTbl[207] = HB_CHRMAP( 5, 'v' ); /* ACS_BTEE */
piTransTbl[208] = HB_CHRMAP( 5, 'v' ); /* ACS_BTEE */
piTransTbl[209] = HB_CHRMAP( 5, 'w' ); /* ACS_TTEE */
piTransTbl[210] = HB_CHRMAP( 5, 'w' ); /* ACS_TTEE */
piTransTbl[211] = HB_CHRMAP( 5, 'm' ); /* ACS_LLCORNER */
piTransTbl[212] = HB_CHRMAP( 5, 'm' ); /* ACS_LLCORNER */
piTransTbl[213] = HB_CHRMAP( 5, 'l' ); /* ACS_ULCORNER */
piTransTbl[214] = HB_CHRMAP( 5, 'l' ); /* ACS_ULCORNER */
piTransTbl[215] = HB_CHRMAP( 5, 'n' ); /* ACS_PLUS */
piTransTbl[216] = HB_CHRMAP( 5, 'n' ); /* ACS_PLUS */
piTransTbl[217] = HB_CHRMAP( 5, 'j' ); /* ACS_LRCORNER */
piTransTbl[218] = HB_CHRMAP( 5, 'l' ); /* ACS_ULCORNER */
#if 0
piTransTbl[219] = HB_CHRMAP( 5, '`' ); /* ACS_DIAMOND */
piTransTbl[220] = HB_CHRMAP( 5, '`' ); /* ACS_DIAMOND */
piTransTbl[221] = HB_CHRMAP( 5, '`' ); /* ACS_DIAMOND */
piTransTbl[222] = HB_CHRMAP( 5, '`' ); /* ACS_DIAMOND */
piTransTbl[223] = HB_CHRMAP( 5, '`' ); /* ACS_DIAMOND */
#endif
}
| gtchrmap.c | 98 |
| STATIC VOID | skip_blank( char **buf )
static void skip_blank( char **buf )
{
while( **buf != '\0' && **buf == ' ' )
++(*buf);
}
| gtchrmap.c | 163 |
| STATIC INT | get_val( char **buf )
static int get_val( char **buf )
{
int n = -1;
char c;
if( (*buf)[0] == '\'' && (*buf)[1] != '\0' && (*buf)[2] == '\'' )
{
n = (*buf)[1] & 0xff;
*buf+=3;
}
else if( (*buf)[0] == '0' && ((*buf)[1] == 'x' || (*buf)[1] == 'X') )
{
n = 0;
*buf+=2;
for(; (**buf >= '0' && **buf <= '9') ||
(**buf >= 'A' && **buf <= 'F') ||
(**buf >= 'a' && **buf <= 'f'); (*buf)++ )
{
c = **buf | 0x20;
n = (n << 4) + c - (c > '9' ? ('a' - 10) : '0');
}
}
else if( **buf >= '0' && **buf <= '9' )
{
n = 0;
for(; (**buf >= '0' && **buf <= '9'); (*buf)++ )
n = n * 10 + (**buf - '0');
}
return n > 0xff ? -1 : n;
}
| gtchrmap.c | 169 |
| STATIC INT | parse_line( char *buf, int *from, int *to, char *op, int *val, int *mod )
static int parse_line( char *buf, int *from, int *to, char *op, int *val, int *mod )
{
char *s, *s2;
int ret = 0, ina = 0;
s = buf;
while( *s != '\0' )
{
switch( *s )
{
case '\t':
*s = ' ';
break;
case '\'':
ina ^= 1;
if( ina )
++s;
break;
case '\n':
case '\r':
case '#':
*s = '\0';
break;
}
if( *s != '\0' )
++s;
}
s = buf;
skip_blank( &s );
if( *s == '@' )
{
++s;
s2 = buf;
while( *s != '\0' && *s != ' ' )
*s2++ = *s++;
*s2 = '\0';
ret = strlen( buf ) > 0 ? 2 : -1;
}
else if( *s != '\0' )
{
ret = *from = *to = *val = *mod = -1;
*op = '=';
*from = get_val( &s );
if( *from >= 0 )
{
if( *s == '-' )
{
++s;
*to = get_val( &s );
}
else
*to = *from;
}
if( *to >= 0 && *s == ':' && s[1] == ' ' )
{
++s;
skip_blank( &s );
if( *s == '*' && (s[1] == '+' || s[1] == '-' || s[1] == '&' ||
s[1] == '|' || s[1] == '^' || s[1] == '=' ||
s[1] == ' ') )
{
*op = s[1];
s+=2;
}
*val = *op == ' ' ? 0 : get_val( &s );
if( *val >= 0 )
{
skip_blank( &s );
*mod = get_val( &s );
skip_blank( &s );
if( *mod >=0 && *mod <= 5 && *s == '\0' )
ret = 1;
}
}
}
return ret;
}
| gtchrmap.c | 200 |
| STATIC INT | chrmap_parse( FILE *fp, const char *pszTerm, int *nTransTbl, const char *pszFile )
static int chrmap_parse( FILE *fp, const char *pszTerm, int *nTransTbl, const char *pszFile )
{
int line = 0, from = 0, to = 0, val = 0, mod = 0, i, n;
char buf[256], *s, op = 0;
int isTerm = 0;
fpos_t pos;
fgetpos( fp, &pos );
fseek( fp, 0, SEEK_SET );
while( !feof( fp ) && isTerm < 2 )
{
++line;
if( fgets( buf, sizeof( buf ), fp ) != NULL )
{
n = 0;
if( *buf == ':' )
{
if( isTerm == 1 )
isTerm = 2;
else
{
*buf = '|';
s = buf;
while( *s != '\0' && *s != ' ' && *s != '\t' &&
*s != '\n' && *s != '\r' )
++s;
*s = '\0';
s = buf;
i = strlen( pszTerm );
while( isTerm == 0 && ( s = strstr( s + 1, pszTerm ) ) != NULL )
{
if( *(s-1) == '|' &&
( s[i] == '|' || s[i] == '\0' ) )
isTerm = 1;
}
}
}
else if( isTerm == 1 )
{
n = parse_line( buf, &from, &to, &op, &val, &mod );
}
if( n == 2 )
{
chrmap_parse( fp, buf, nTransTbl, pszFile );
}
else if( n == 1 )
{
/* printf("line: %3d\tfrom=%d, to=%d, op='%c', val=%d, mod=%d\n", line, from, to, op, val, mod); */
for( i = from; i <= to; ++i )
{
switch( op )
{
case '|':
nTransTbl[i] = ( i | val );
break;
case '&':
nTransTbl[i] = ( i & val );
break;
case '^':
nTransTbl[i] = ( i ^ val );
break;
case '+':
nTransTbl[i] = ( i + val ) & 0xff;
break;
case '-':
nTransTbl[i] = ( i - val ) & 0xff;
break;
case '=':
nTransTbl[i] = val;
break;
case '*':
case ' ':
default:
nTransTbl[i] = i;
break;
}
nTransTbl[i] |= mod << 16;
}
}
else if( n == -1 )
{
fprintf( stderr, "file: %s, parse error at line: %d\n", pszFile, line );
}
}
}
fsetpos( fp, &pos );
return isTerm;
}
| gtchrmap.c | 282 |
| STATIC INT | hb_gt_chrmapread( const char *pszFile, const char *pszTerm, int *nTransTbl )
static int hb_gt_chrmapread( const char *pszFile, const char *pszTerm, int *nTransTbl )
{
FILE *fp;
char buf[256], *ptr, *pTerm;
int isTerm = -1;
fp = hb_fopen( pszFile, "r" );
if( fp != NULL )
{
hb_strncpy( buf, pszTerm, sizeof( buf ) - 1 );
isTerm = 0;
pTerm = buf;
while( pTerm )
{
if( ( ptr = strchr( pTerm, '/' ) ) != NULL )
*ptr++ = '\0';
if( *pTerm )
if( chrmap_parse( fp, pTerm, nTransTbl, pszFile ) > 0 )
isTerm = 1;
pTerm = ptr;
}
fclose( fp );
}
return isTerm;
}
| gtchrmap.c | 375 |
| INT | hb_gt_chrmapinit( int *piTransTbl, const char *pszTerm, BOOL fSetACSC )
int hb_gt_chrmapinit( int *piTransTbl, const char *pszTerm, BOOL fSetACSC )
{
char *pszFree = NULL, *pszFile, szFile[ _POSIX_PATH_MAX + 1 ];
int nRet = -1;
chrmap_init( piTransTbl );
if( pszTerm == NULL || *pszTerm == '\0' )
pszTerm = pszFree = hb_getenv("HB_TERM");
if( pszTerm == NULL || *pszTerm == '\0' )
{
if( pszFree )
hb_xfree( pszFree );
pszTerm = pszFree = hb_getenv("TERM");
}
if( pszTerm != NULL && *pszTerm != '\0' )
{
pszFile = hb_getenv( "HB_CHARMAP" );
if( pszFile != NULL && *pszFile != '\0' )
nRet = hb_gt_chrmapread( pszFile, pszTerm, piTransTbl );
if( nRet == -1 )
{
if( pszFile )
hb_xfree( pszFile );
pszFile = hb_getenv( "HB_ROOT" );
if( pszFile != NULL && sizeof( szFile ) >
strlen( pszFile ) + strlen( hb_gt_szCharMapFileDefault ) )
{
hb_strncpy( szFile, pszFile, sizeof( szFile ) - 1 );
hb_strncat( szFile, hb_gt_szCharMapFileDefault, sizeof( szFile ) - 1 );
nRet = hb_gt_chrmapread( szFile, pszTerm, piTransTbl );
}
}
if( pszFile )
hb_xfree( pszFile );
if( nRet == -1 )
nRet = hb_gt_chrmapread( hb_gt_szCharMapFileDefault, pszTerm, piTransTbl );
}
if( pszFree )
hb_xfree( pszFree );
if( nRet == -1 )
{
chrmap_dotctrl( piTransTbl );
if( fSetACSC )
chrmap_acscbox( piTransTbl );
else
chrmap_ascictrl( piTransTbl );
}
return nRet;
}
| gtchrmap.c | 404 |
| gtclip.c |
| Type | Function | Source | Line |
|---|
| BOOL | hb_gt_setClipboard( char * szClipData, ULONG ulLen )
BOOL hb_gt_setClipboard( char * szClipData, ULONG ulLen )
{
hb_threadEnterCriticalSection( &s_clipMtx );
if( s_ulClipboardLen )
hb_xfree( s_szClipboardData );
s_ulClipboardLen = ulLen;
if( ulLen )
{
s_szClipboardData = ( char * ) hb_xgrab( s_ulClipboardLen + 1 );
memcpy( s_szClipboardData, szClipData, s_ulClipboardLen );
s_szClipboardData[ s_ulClipboardLen ] = '\0';
}
hb_threadLeaveCriticalSection( &s_clipMtx );
return TRUE;
}
| gtclip.c | 74 |
| BOOL | hb_gt_getClipboard( char ** pszClipData, ULONG *pulLen )
BOOL hb_gt_getClipboard( char ** pszClipData, ULONG *pulLen )
{
hb_threadEnterCriticalSection( &s_clipMtx );
*pszClipData = NULL;
*pulLen = s_ulClipboardLen;
if( s_ulClipboardLen )
{
*pszClipData = ( char * ) hb_xgrab( s_ulClipboardLen + 1 );
memcpy( *pszClipData, s_szClipboardData, s_ulClipboardLen );
( *pszClipData )[ s_ulClipboardLen ] = '\0';
}
hb_threadLeaveCriticalSection( &s_clipMtx );
return s_ulClipboardLen != 0;
}
| gtclip.c | 93 |
| BOOL | hb_gt_w32_setClipboard( UINT uFormat, char * szClipData, ULONG ulLen )
BOOL hb_gt_w32_setClipboard( UINT uFormat, char * szClipData, ULONG ulLen )
{
BOOL fResult = FALSE;
if( OpenClipboard( NULL ) )
{
HGLOBAL hglbCopy;
EmptyClipboard();
/* Allocate a global memory object for the text. */
hglbCopy = GlobalAlloc( GMEM_MOVEABLE, uFormat == CF_UNICODETEXT ? ( ulLen + 1 ) * sizeof( wchar_t ) : ulLen + 1 );
if( hglbCopy )
{
/* Lock the handle and copy the text to the buffer. */
LPTSTR lptstrCopy = ( LPTSTR ) GlobalLock( hglbCopy );
if( lptstrCopy )
{
if( uFormat == CF_UNICODETEXT )
{
hb_mbtowcset( ( LPWSTR ) lptstrCopy, szClipData, ulLen );
* ( ( ( LPWSTR ) lptstrCopy ) + ulLen ) = L'\0';
}
else
{
memcpy( lptstrCopy, szClipData, ulLen );
lptstrCopy[ ulLen ] = '\0';
}
fResult = TRUE;
}
GlobalUnlock( hglbCopy );
/* Place the handle on the clipboard. */
SetClipboardData( uFormat, hglbCopy );
}
CloseClipboard();
}
return fResult;
}
| gtclip.c | 113 |
| BOOL | hb_gt_w32_getClipboard( UINT uFormat, char ** pszClipData, ULONG *pulLen )
BOOL hb_gt_w32_getClipboard( UINT uFormat, char ** pszClipData, ULONG *pulLen )
{
*pulLen = 0;
*pszClipData = NULL;
if( IsClipboardFormatAvailable( uFormat ) && OpenClipboard( NULL ) )
{
HGLOBAL hglb = GetClipboardData( uFormat );
if( hglb )
{
LPTSTR lptstr = ( LPTSTR ) GlobalLock( hglb );
if( lptstr )
{
switch( uFormat )
{
case CF_UNICODETEXT:
*pulLen = wcslen( ( LPWSTR ) lptstr );
if( *pulLen )
*pszClipData = hb_wctomb( ( LPWSTR ) lptstr );
break;
case CF_OEMTEXT:
case CF_TEXT:
*pulLen = strlen( ( char * ) lptstr );
if( *pulLen )
{
*pszClipData = ( char * ) hb_xgrab( *pulLen + 1 );
memcpy( *pszClipData, lptstr, *pulLen );
( *pszClipData )[ *pulLen ] = '\0';
}
break;
default:
*pulLen = GlobalSize( hglb );
if( *pulLen )
{
*pszClipData = ( char * ) hb_xgrab( *pulLen + 1 );
memcpy( *pszClipData, lptstr, *pulLen );
( *pszClipData )[ *pulLen ] = '\0';
}
break;
}
GlobalUnlock( hglb );
}
}
CloseClipboard();
}
return *pulLen != 0;
}
| gtclip.c | 152 |
| gtfunc.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_SETDISPCP(void)
HB_FUNC( HB_SETDISPCP )
{
if( ISCHAR( 1 ) )
{
if( hb_pcount() == 2 && ISLOG( 2 ) )
hb_gtSetDispCP( hb_parc( 1 ), NULL, hb_parl( 2 ) );
else
hb_gtSetDispCP( hb_parc( 1 ), hb_parc( 2 ), hb_parl( 3 ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1089, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| gtfunc.c | 57 |
| HB_FUNC | HB_SETKEYCP(void)
HB_FUNC( HB_SETKEYCP )
{
if( ISCHAR( 1 ) )
hb_gtSetKeyCP( hb_parc( 1 ), hb_parc( 2 ) );
else
hb_errRT_BASE_SubstR( EG_ARG, 1089, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| gtfunc.c | 70 |
| HB_FUNC | HB_SETTERMCP(void)
HB_FUNC( HB_SETTERMCP )
{
if( ISCHAR( 1 ) )
{
if( hb_pcount() == 2 && ISLOG( 2 ) )
{
hb_gtSetDispCP( hb_parc( 1 ), NULL, hb_parl( 2 ) );
hb_gtSetKeyCP( hb_parc( 1 ), NULL );
}
else
{
hb_gtSetDispCP( hb_parc( 1 ), hb_parc( 2 ), hb_parl( 3 ) );
hb_gtSetKeyCP( hb_parc( 1 ), hb_parc( 2 ) );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1089, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| gtfunc.c | 78 |
| HB_FUNC | HB_GTINFO(void)
HB_FUNC( HB_GTINFO )
{
if( ISNUM( 1 ) )
{
HB_GT_INFO gtInfo;
gtInfo.pNewVal = hb_param( 2, HB_IT_ANY );
gtInfo.pNewVal2 = hb_param( 3, HB_IT_ANY );
gtInfo.pResult = NULL;
hb_gtInfo( hb_parni( 1 ), >Info );
if( gtInfo.pResult )
hb_itemReturnRelease( gtInfo.pResult );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| gtfunc.c | 97 |
| HB_FUNC | HB_GTVERSION(void)
HB_FUNC( HB_GTVERSION )
{
hb_retc( hb_gtVersion( hb_parni( 1 ) ) );
}
| gtfunc.c | 115 |
| HB_FUNC | HB_GTALERT(void)
HB_FUNC( HB_GTALERT )
{
hb_retni( hb_gtAlert( hb_param( 1, HB_IT_ANY ),
hb_param( 2, HB_IT_ANY ),
ISCHAR( 3 ) ? hb_gtColorToN( hb_parc( 3 ) ) : hb_parni( 3 ) /* iClrNorm */,
ISCHAR( 4 ) ? hb_gtColorToN( hb_parc( 4 ) ) : hb_parni( 4 ) /* iClrHigh */,
hb_parnd( 5 ) ) );
}
| gtfunc.c | 120 |
| HB_FUNC | HB_GFXPRIMITIVE(void)
HB_FUNC( HB_GFXPRIMITIVE )
{
hb_retni( hb_gtGfxPrimitive( hb_parni( 1 ) /* nType */,
hb_parni( 2 ) /* nTop */,
hb_parni( 3 ) /* nLeft */,
hb_parni( 4 ) /* nBottom */,
hb_parni( 5 ) /* nRight */,
hb_parni( 6 ) /* nColor */ ) );
}
| gtfunc.c | 129 |
| HB_FUNC | HB_GFXTEXT(void)
HB_FUNC( HB_GFXTEXT )
{
hb_gtGfxText( hb_parni( 1 ) /* nTop */,
hb_parni( 2 ) /* nLeft */,
hb_parc( 3 ) /* cText */,
hb_parni( 4 ) /* nColor */,
hb_parni( 5 ) /* nSize */,
hb_parni( 6 ) /* nWidth */ );
}
| gtfunc.c | 139 |
| gtkbstat.c |
| Type | Function | Source | Line |
|---|
| INT | hb_gt_w32_getKbdState( void )
int hb_gt_w32_getKbdState( void )
{
BYTE kbState[256];
int iKbdState = 0;
GetKeyboardState( kbState );
if( kbState[VK_SHIFT ] & 0x80 ) iKbdState |= HB_GTI_KBD_SHIFT;
if( kbState[VK_CONTROL ] & 0x80 ) iKbdState |= HB_GTI_KBD_CTRL;
if( kbState[VK_MENU ] & 0x80 ) iKbdState |= HB_GTI_KBD_ALT;
if( kbState[VK_LWIN ] & 0x80 ) iKbdState |= HB_GTI_KBD_LWIN;
if( kbState[VK_RWIN ] & 0x80 ) iKbdState |= HB_GTI_KBD_RWIN;
if( kbState[VK_APPS ] & 0x80 ) iKbdState |= HB_GTI_KBD_MENU;
if( kbState[VK_SCROLL ] & 0x01 ) iKbdState |= HB_GTI_KBD_SCROLOCK;
if( kbState[VK_NUMLOCK ] & 0x01 ) iKbdState |= HB_GTI_KBD_NUMLOCK;
if( kbState[VK_CAPITAL ] & 0x01 ) iKbdState |= HB_GTI_KBD_CAPSLOCK;
if( kbState[VK_INSERT ] & 0x01 ) iKbdState |= HB_GTI_KBD_INSERT;
return iKbdState;
}
| gtkbstat.c | 61 |
| VOID | hb_gt_w32_setKbdState( int iKbdState )
void hb_gt_w32_setKbdState( int iKbdState )
{
BYTE kbState[256];
GetKeyboardState( kbState );
kbState[VK_SHIFT ] = ( iKbdState & HB_GTI_KBD_SHIFT ) ? 0x80 : 0;
kbState[VK_CONTROL] = ( iKbdState & HB_GTI_KBD_CTRL ) ? 0x80 : 0;
kbState[VK_MENU ] = ( iKbdState & HB_GTI_KBD_ALT ) ? 0x80 : 0;
kbState[VK_LWIN ] = ( iKbdState & HB_GTI_KBD_LWIN ) ? 0x80 : 0;
kbState[VK_RWIN ] = ( iKbdState & HB_GTI_KBD_RWIN ) ? 0x80 : 0;
kbState[VK_APPS ] = ( iKbdState & HB_GTI_KBD_MENU ) ? 0x80 : 0;
kbState[VK_SCROLL ] = ( iKbdState & HB_GTI_KBD_SCROLOCK ) ? 0x01 : 0;
kbState[VK_NUMLOCK] = ( iKbdState & HB_GTI_KBD_NUMLOCK ) ? 0x01 : 0;
kbState[VK_CAPITAL] = ( iKbdState & HB_GTI_KBD_CAPSLOCK ) ? 0x01 : 0;
kbState[VK_INSERT ] = ( iKbdState & HB_GTI_KBD_INSERT ) ? 0x01 : 0;
SetKeyboardState( kbState );
}
| gtkbstat.c | 82 |
| gtkeycod.c |
| Type | Function | Source | Line |
|---|
| INT | hb_gt_dos_keyCodeTranslate( int iKey )
int hb_gt_dos_keyCodeTranslate( int iKey )
{
/* Perform key translations */
switch( iKey )
{
case -1: /* No key available */
iKey = 0;
break;
case 328: /* Up arrow */
iKey = K_UP;
break;
case 336: /* Down arrow */
iKey = K_DOWN;
break;
case 331: /* Left arrow */
iKey = K_LEFT;
break;
case 333: /* Right arrow */
iKey = K_RIGHT;
break;
case 327: /* Home */
iKey = K_HOME;
break;
case 335: /* End */
iKey = K_END;
break;
case 329: /* Page Up */
iKey = K_PGUP;
break;
case 337: /* Page Down */
iKey = K_PGDN;
break;
case 371: /* Ctrl + Left arrow */
iKey = K_CTRL_LEFT;
break;
case 372: /* Ctrl + Right arrow */
iKey = K_CTRL_RIGHT;
break;
case 375: /* Ctrl + Home */
iKey = K_CTRL_HOME;
break;
case 373: /* Ctrl + End */
iKey = K_CTRL_END;
break;
case 388: /* Ctrl + Page Up */
iKey = K_CTRL_PGUP;
break;
case 374: /* Ctrl + Page Down */
iKey = K_CTRL_PGDN;
break;
case 338: /* Insert */
iKey = K_INS;
break;
case 339: /* Delete */
iKey = K_DEL;
break;
case 315: /* F1 */
iKey = K_F1;
break;
case 316: /* F2 */
case 317: /* F3 */
case 318: /* F4 */
case 319: /* F5 */
case 320: /* F6 */
case 321: /* F7 */
case 322: /* F8 */
case 323: /* F9 */
case 324: /* F10 */
iKey = 315 - iKey;
break;
case 340: /* Shift + F1 */
case 341: /* Shift + F2 */
case 342: /* Shift + F3 */
case 343: /* Shift + F4 */
case 344: /* Shift + F5 */
case 345: /* Shift + F6 */
case 346: /* Shift + F7 */
case 347: /* Shift + F8 */
case 348: /* Shift + F9 */
case 349: /* Shift + F10 */
case 350: /* Ctrl + F1 */
case 351: /* Ctrl + F2 */
case 352: /* Ctrl + F3 */
case 353: /* Ctrl + F4 */
case 354: /* Ctrl + F5 */
case 355: /* Ctrl + F6 */
case 356: /* Ctrl + F7 */
case 357: /* Ctrl + F8 */
case 358: /* Ctrl + F9 */
case 359: /* Ctrl + F10 */
case 360: /* Alt + F1 */
case 361: /* Alt + F2 */
case 362: /* Alt + F3 */
case 363: /* Alt + F4 */
case 364: /* Alt + F5 */
case 365: /* Alt + F6 */
case 366: /* Alt + F7 */
case 367: /* Alt + F8 */
case 368: /* Alt + F9 */
case 369: /* Alt + F10 */
iKey = 330 - iKey;
break;
case 389: /* F11 */
case 390: /* F12 */
case 391: /* Shift + F11 */
case 392: /* Shift + F12 */
case 393: /* Ctrl + F11 */
case 394: /* Ctrl + F12 */
case 395: /* Alt + F11 */
case 396: /* Alt + F12 */
iKey = 349 - iKey;
}
return iKey;
}
| gtkeycod.c | 62 |
| gtsys.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_GTSYS(void)
HB_FUNC( HB_GTSYS ) {}
| gtsys.c | 78 |
| gttone.c |
| Type | Function | Source | Line |
|---|
| STATIC INT | hb_Inp9x( USHORT usPort )
static int hb_Inp9x( USHORT usPort )
{
USHORT usVal;
HB_TRACE(HB_TR_DEBUG, ("hb_Inp9x(%hu)", usPort));
#if defined( __BORLANDC__ ) || defined(__DMC__)
_DX = usPort;
__emit__(0xEC); /* ASM IN AL, DX */
__emit__(0x32,0xE4); /* ASM XOR AH, AH */
usVal = _AX;
#elif ( defined( __XCC__ ) || defined( __POCC__ ) ) && defined( _M_IX86 )
__asm {
mov dx, usPort
xor ax, ax
in al, dx
mov usVal, ax
}
#elif defined( __MINGW32__ )
__asm__ __volatile__ ("inb %w1,%b0":"=a" (usVal):"Nd" (usPort));
#elif defined( __WATCOMC__ )
usVal = ( USHORT ) inp( usPort );
#else
usVal = ( USHORT ) _inp( usPort );
#endif
return usVal;
}
| gttone.c | 77 |
| STATIC INT | hb_Outp9x( USHORT usPort, USHORT usVal )
static int hb_Outp9x( USHORT usPort, USHORT usVal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_Outp9x(%hu, %hu)", usPort, usVal));
#if defined( __BORLANDC__ ) || defined(__DMC__)
_DX = usPort;
_AL = usVal;
__emit__(0xEE); /* ASM OUT DX, AL */
#elif ( defined( __XCC__ ) || defined( __POCC__ ) ) && defined( _M_IX86 )
__asm {
mov dx, usPort
mov ax, usVal
out dx, al
}
#elif defined( __MINGW32__ )
__asm__ __volatile__ ("outb %b0,%w1": :"a" (usVal), "Nd" (usPort));
#elif defined( __WATCOMC__ )
outp( usPort, usVal );
#else
_outp( usPort, usVal );
#endif
return usVal;
}
| gttone.c | 117 |
| STATIC VOID | hb_gt_w9xTone( double dFreq, double dDurat )
static void hb_gt_w9xTone( double dFreq, double dDurat )
{
INT uLSB,uMSB;
ULONG lAdjFreq;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_w9xtone(%lf, %lf)", dFreq, dDurat));
/* sync with internal clock with very small time period */
hb_idleSleep( 0.01 );
/* Clipper ignores Tone() requests (but delays anyway) if Frequency is
less than < 20 hz (and so should we) to maintain compatibility .. */
if( dFreq >= 20.0 )
{
/* Setup Sound Control Port Registers and timer channel 2 */
hb_Outp9x(67, 182) ;
lAdjFreq = (ULONG)( 1193180 / dFreq ) ;
if( (LONG) lAdjFreq < 0 )
uLSB = lAdjFreq + 65536;
else
uLSB = lAdjFreq % 256;
if( (LONG) lAdjFreq < 0 )
uMSB = lAdjFreq + 65536;
else
uMSB = lAdjFreq / 256;
/* set the frequency (LSB,MSB) */
hb_Outp9x(66, ( USHORT ) uLSB);
hb_Outp9x(66, ( USHORT ) uMSB);
/* Get current Port setting */
/* enable Speaker Data & Timer gate bits */
/* (00000011B is bitmask to enable sound) */
/* Turn on Speaker - sound Tone for duration.. */
hb_Outp9x(97, ( USHORT ) hb_Inp9x( 97 ) | 3);
hb_idleSleep( dDurat );
/* Read back current Port value for Reset */
/* disable Speaker Data & Timer gate bits */
/* (11111100B is bitmask to disable sound) */
/* Turn off the Speaker ! */
hb_Outp9x(97, hb_Inp9x( 97 ) & 0xFC);
}
else
{
hb_idleSleep( dDurat );
}
}
| gttone.c | 152 |
| STATIC VOID | hb_gt_wNtTone( double dFreq, double dDurat )
static void hb_gt_wNtTone( double dFreq, double dDurat )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_wNtTone(%lf, %lf)", dFreq, dDurat));
/* Clipper ignores Tone() requests (but delays anyway) if Frequency is
less than < 20 hz. Windows NT minimum is 37... */
if( dFreq >= 37.0 )
{
Beep( (ULONG) dFreq, (ULONG) ( dDurat * 1000 ) ); /* Beep wants Milliseconds */
}
else
{
hb_idleSleep( dDurat );
}
}
| gttone.c | 213 |
| VOID | hb_gt_w32_tone( double dFrequency, double dDuration )
void hb_gt_w32_tone( double dFrequency, double dDuration )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_w32_tone(%lf, %lf)", dFrequency, dDuration));
/*
* According to the Clipper NG, the duration in 'ticks' is truncated to the
* interger portion ... Depending on the platform, Harbour allows a finer
* resolution, but the minimum is 1 tick (for compatibility)
*/
/* Convert from ticks to seconds */
dDuration = ( HB_MIN( HB_MAX( 1.0, dDuration ), ULONG_MAX ) ) / 18.2;
/* keep the frequency in an acceptable range */
dFrequency = HB_MIN( HB_MAX( 0.0, dFrequency ), 32767.0 );
/* If Windows NT or NT2k, use wNtTone, which provides TONE()
reset sequence support (new) */
if( hb_iswinnt() || hb_iswince() )
{
hb_gt_wNtTone( dFrequency, dDuration );
}
else /* If Windows 95 or 98, use w9xTone for chosen C compilers */
{
#if defined( HB_ARCH_32BIT ) && !defined( _M_ARM ) && \
( defined( __BORLANDC__ ) || defined( _MSC_VER ) || \
defined( __WATCOMC__ ) || defined(__MINGW32__) )
hb_gt_w9xTone( dFrequency, dDuration );
#else
hb_gt_wNtTone( dFrequency, dDuration );
#endif
}
}
| gttone.c | 232 |
| gx.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | ISCOLOR(void)
HB_FUNC( ISCOLOR )
{
hb_retl( hb_gtIsColor() );
}
| gx.c | 67 |
| HB_FUNC | NOSNOW(void)
HB_FUNC( NOSNOW )
{
if( ISLOG( 1 ) )
hb_gtSetSnowFlag( hb_parl( 1 ) );
}
| gx.c | 72 |
| HB_FUNC | SETMODE(void)
HB_FUNC( SETMODE )
{
USHORT uiRows, uiCols;
hb_gtScrDim( &uiRows, &uiCols );
if( ISNUM( 1 ) )
uiRows = ( USHORT ) hb_parni( 1 );
if( ISNUM( 2 ) )
uiCols = ( USHORT ) hb_parni( 2 );
hb_retl( hb_gtSetMode( uiRows, uiCols ) == SUCCESS );
}
| gx.c | 78 |
| hardcr.c |
| Type | Function | Source | Line |
|---|
| STATIC CHAR * | hb_strHardCR( char * pszString, ULONG ulStringLen )
static char * hb_strHardCR( char * pszString, ULONG ulStringLen )
{
ULONG ulStringPos;
HB_TRACE(HB_TR_DEBUG, ("hb_strHardCR(%s, %lu)", pszString, ulStringLen));
for( ulStringPos = 0; ulStringPos < ulStringLen; ulStringPos++ )
{
if( pszString[ ulStringPos ] == HB_CHAR_SOFT1 &&
pszString[ ulStringPos + 1 ] == HB_CHAR_SOFT2 )
{
pszString[ ulStringPos ] = HB_CHAR_HARD1;
}
}
return pszString;
}
| hardcr.c | 56 |
| HB_FUNC | HARDCR(void)
HB_FUNC( HARDCR )
{
PHB_ITEM pString = hb_param( 1, HB_IT_STRING );
if( pString )
{
char * pszBuffer = hb_itemGetC( pString );
ULONG ulStringLen = hb_itemGetCLen( pString );
hb_retclen_buffer( hb_strHardCR( pszBuffer, ulStringLen ), ulStringLen );
}
else
hb_retc( NULL );
}
| hardcr.c | 74 |
| hbadler.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT ULONG | hb_adler32( ULONG adler, const BYTE *buf, ULONG len )
HB_EXPORT ULONG hb_adler32( ULONG adler, const BYTE *buf, ULONG len )
{
ULONG s1 = adler & 0xffff;
ULONG s2 = ( adler >> 16 ) & 0xffff;
if( buf && len )
{
do
{
int i = len < NMAX ? len : NMAX;
len -= i;
do
{
s1 += ( UCHAR ) *buf++;
s2 += s1;
}
while( --i );
s1 %= BASE;
s2 %= BASE;
}
while( len );
}
return ( s2 << 16 ) | s1;
}
| hbadler.c | 62 |
| HB_FUNC | HB_ADLER32(void)
HB_FUNC( HB_ADLER32 )
{
char * szString = hb_parc( 1 );
if( szString )
hb_retnint( hb_adler32( ( ULONG ) hb_parnl( 2 ), ( BYTE * ) szString, hb_parclen( 1 ) ) );
else
hb_errRT_BASE( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbadler.c | 88 |
| hbbit.c |
| Type | Function | Source | Line |
|---|
| STATIC BOOL | hb_numParam( int iParam, HB_LONG * plNum )
static BOOL hb_numParam( int iParam, HB_LONG * plNum )
{
if( ISNUM( iParam ) )
{
*plNum = hb_parnint( iParam );
return TRUE;
}
hb_errRT_BASE_SubstR( EG_ARG, 1089, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
*plNum = 0;
return FALSE;
}
| hbbit.c | 63 |
| HB_FUNC | HB_BITAND(void)
HB_FUNC( HB_BITAND )
{
HB_LONG lValue;
if( hb_numParam( 1, &lValue ) )
{
int iPCount = hb_pcount() - 1, i = 1;
do
{
HB_LONG lNext;
if( !hb_numParam( ++i, &lNext ) )
return;
lValue &= lNext;
}
while( --iPCount > 0 );
hb_retnint( lValue );
}
}
| hbbit.c | 75 |
| HB_FUNC | HB_BITOR(void)
HB_FUNC( HB_BITOR )
{
HB_LONG lValue;
if( hb_numParam( 1, &lValue ) )
{
int iPCount = hb_pcount() - 1, i = 1;
do
{
HB_LONG lNext;
if( !hb_numParam( ++i, &lNext ) )
return;
lValue |= lNext;
}
while( --iPCount > 0 );
hb_retnint( lValue );
}
}
| hbbit.c | 93 |
| HB_FUNC | HB_BITXOR(void)
HB_FUNC( HB_BITXOR )
{
HB_LONG lValue;
if( hb_numParam( 1, &lValue ) )
{
int iPCount = hb_pcount() - 1, i = 1;
do
{
HB_LONG lNext;
if( !hb_numParam( ++i, &lNext ) )
return;
lValue ^= lNext;
}
while( --iPCount > 0 );
hb_retnint( lValue );
}
}
| hbbit.c | 111 |
| HB_FUNC | HB_BITNOT(void)
HB_FUNC( HB_BITNOT )
{
HB_LONG lValue;
if( hb_numParam( 1, &lValue ) )
hb_retnint( ~lValue );
}
| hbbit.c | 129 |
| HB_FUNC | HB_BITTEST(void)
HB_FUNC( HB_BITTEST )
{
HB_LONG lValue, lBit;
if( hb_numParam( 1, &lValue ) && hb_numParam( 2, &lBit ) )
hb_retl( ( lValue & ( ( HB_LONG ) 1 << lBit ) ) != 0 );
}
| hbbit.c | 136 |
| HB_FUNC | HB_BITSET(void)
HB_FUNC( HB_BITSET )
{
HB_LONG lValue, lBit;
if( hb_numParam( 1, &lValue ) && hb_numParam( 2, &lBit ) )
hb_retnint( lValue | ( ( HB_LONG ) 1 << lBit ) );
}
| hbbit.c | 143 |
| HB_FUNC | HB_BITRESET(void)
HB_FUNC( HB_BITRESET )
{
HB_LONG lValue, lBit;
if( hb_numParam( 1, &lValue ) && hb_numParam( 2, &lBit ) )
hb_retnint( lValue & ( ~ ( ( HB_LONG ) 1 << lBit ) ) );
}
| hbbit.c | 150 |
| HB_FUNC | HB_BITSHIFT(void)
HB_FUNC( HB_BITSHIFT )
{
HB_LONG lValue, lBits;
if( hb_numParam( 1, &lValue ) && hb_numParam( 2, &lBits ) )
{
if( lBits < 0 )
hb_retnint( lValue >> -lBits );
else
hb_retnint( lValue << lBits );
}
}
| hbbit.c | 157 |
| hbcrc.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT ULONG | hb_crc32( ULONG crc, const BYTE *buf, ULONG len )
HB_EXPORT ULONG hb_crc32( ULONG crc, const BYTE *buf, ULONG len )
{
crc ^= 0xffffffffL;
if( buf && len )
{
do
crc = crc32_tab[ ( crc ^ *buf++ ) & 0xFF ] ^ ( crc >> 8 );
while( --len );
}
return crc ^ 0xffffffffL;
}
| hbcrc.c | 152 |
| HB_EXPORT ULONG | hb_crc16( ULONG crc, const BYTE *buf, ULONG len )
HB_EXPORT ULONG hb_crc16( ULONG crc, const BYTE *buf, ULONG len )
{
crc ^= 0xffff;
if( buf && len )
{
do
crc = crc16_tab[ ( crc ^ *buf++ ) & 0xFF ] ^ ( crc >> 8 );
while( --len );
}
return crc ^ 0xffff;
}
| hbcrc.c | 164 |
| HB_EXPORT HB_ULONG | hb_crc( HB_ULONG crc, const BYTE * buf, ULONG len, HB_ULONG poly )
HB_EXPORT HB_ULONG hb_crc( HB_ULONG crc, const BYTE * buf, ULONG len, HB_ULONG poly )
{
if( buf && len )
{
HB_ULONG mask = 1, revp = 0;
while( poly > 1 )
{
mask <<= 1;
revp <<= 1;
if( poly & 1 )
revp |= 1;
poly >>= 1;
}
crc ^= --mask;
do
{
HB_ULONG b = ( crc ^ ( UCHAR ) * buf++ ) & 0xFF;
int i = 8;
do
b = b & 1 ? revp ^ ( b >> 1 ) : b >> 1;
while( --i );
crc = b ^ ( crc >> 8 );
}
while( --len );
crc ^= mask;
}
return crc;
}
| hbcrc.c | 176 |
| HB_EXPORT HB_ULONG | hb_crcct( HB_ULONG crc, const BYTE * buf, ULONG len, HB_ULONG poly )
HB_EXPORT HB_ULONG hb_crcct( HB_ULONG crc, const BYTE * buf, ULONG len, HB_ULONG poly )
{
if( buf && len )
{
HB_ULONG mask, revp = poly;
int bits = 0;
while( revp >>= 1 )
++bits;
mask = ( HB_LONG ) 1 << ( bits - 1 );
bits -= 8;
do
{
int i = 8;
crc ^= ( HB_ULONG ) * buf++ << bits;
do
crc = crc & mask ? poly ^ ( crc << 1 ) : crc << 1;
while( --i );
}
while( --len );
crc &= ( mask << 1 ) - 1;
}
return crc;
}
| hbcrc.c | 206 |
| HB_FUNC | HB_CRC32(void)
HB_FUNC( HB_CRC32 )
{
char * szString = hb_parc( 1 );
if( szString )
hb_retnint( hb_crc32( ( ULONG ) hb_parnl( 2 ), ( BYTE * ) szString, hb_parclen( 1 ) ) );
else
hb_errRT_BASE( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbcrc.c | 231 |
| HB_FUNC | HB_CRC16(void)
HB_FUNC( HB_CRC16 )
{
char * szString = hb_parc( 1 );
if( szString )
hb_retnint( hb_crc16( ( ULONG ) hb_parnl( 2 ), ( BYTE * ) szString, hb_parclen( 1 ) ) );
else
hb_errRT_BASE( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbcrc.c | 241 |
| HB_FUNC | HB_CRC(void)
HB_FUNC( HB_CRC )
{
char * szString = hb_parc( 1 );
if( szString )
{
HB_ULONG ulPolynomial = ( HB_ULONG ) hb_parnint( 3 );
if( ulPolynomial == 0 )
ulPolynomial = 0x11021;
hb_retnint( hb_crc( ( HB_ULONG ) hb_parnint( 2 ), ( BYTE * ) szString, hb_parclen( 1 ), ulPolynomial ) );
}
else
hb_errRT_BASE( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbcrc.c | 251 |
| HB_FUNC | HB_CRCCT(void)
HB_FUNC( HB_CRCCT )
{
char * szString = hb_parc( 1 );
if( szString )
{
HB_ULONG ulPolynomial = ( HB_ULONG ) hb_parnint( 3 );
if( ulPolynomial == 0 )
ulPolynomial = 0x11021;
hb_retnint( hb_crcct( ( HB_ULONG ) hb_parnint( 2 ), ( BYTE * ) szString, hb_parclen( 1 ), ulPolynomial ) );
}
else
hb_errRT_BASE( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbcrc.c | 266 |
| hbffind.c |
| Type | Function | Source | Line |
|---|
| ULONG | hb_fsAttrFromRaw( ULONG raw_attr )
ULONG hb_fsAttrFromRaw( ULONG raw_attr )
{
ULONG ulAttr;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrFromRaw(%lu)", raw_attr));
#if defined(HB_OS_DOS)
ulAttr = 0;
if( raw_attr & FA_ARCH ) ulAttr |= HB_FA_ARCHIVE;
if( raw_attr & FA_DIREC ) ulAttr |= HB_FA_DIRECTORY;
if( raw_attr & FA_HIDDEN ) ulAttr |= HB_FA_HIDDEN;
if( raw_attr & FA_RDONLY ) ulAttr |= HB_FA_READONLY;
if( raw_attr & FA_LABEL ) ulAttr |= HB_FA_LABEL;
if( raw_attr & FA_SYSTEM ) ulAttr |= HB_FA_SYSTEM;
#elif defined(HB_OS_OS2)
ulAttr = 0;
if( raw_attr & FILE_ARCHIVED ) ulAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_DIRECTORY ) ulAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_HIDDEN ) ulAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_READONLY ) ulAttr |= HB_FA_READONLY;
if( raw_attr & FILE_SYSTEM ) ulAttr |= HB_FA_SYSTEM;
#elif defined(HB_OS_WIN_32)
ulAttr = 0;
if( raw_attr & FILE_ATTRIBUTE_ARCHIVE ) ulAttr |= HB_FA_ARCHIVE;
if( raw_attr & FILE_ATTRIBUTE_DIRECTORY ) ulAttr |= HB_FA_DIRECTORY;
if( raw_attr & FILE_ATTRIBUTE_HIDDEN ) ulAttr |= HB_FA_HIDDEN;
if( raw_attr & FILE_ATTRIBUTE_READONLY ) ulAttr |= HB_FA_READONLY;
if( raw_attr & FILE_ATTRIBUTE_SYSTEM ) ulAttr |= HB_FA_SYSTEM;
if( raw_attr & FILE_ATTRIBUTE_NORMAL ) ulAttr |= HB_FA_NORMAL;
#ifdef HB_EXTENSION
/* Note that FILE_ATTRIBUTE_NORMAL is not needed
HB_FA_DEVICE not supported
HB_FA_VOLCOMP needs to be checked */
if( raw_attr & FILE_ATTRIBUTE_ENCRYPTED ) ulAttr |= HB_FA_ENCRYPTED;
if( raw_attr & FILE_ATTRIBUTE_TEMPORARY ) ulAttr |= HB_FA_TEMPORARY;
if( raw_attr & FILE_ATTRIBUTE_SPARSE_FILE ) ulAttr |= HB_FA_SPARSE;
if( raw_attr & FILE_ATTRIBUTE_REPARSE_POINT ) ulAttr |= HB_FA_REPARSE;
if( raw_attr & FILE_ATTRIBUTE_COMPRESSED ) ulAttr |= HB_FA_COMPRESSED;
if( raw_attr & FILE_ATTRIBUTE_OFFLINE ) ulAttr |= HB_FA_OFFLINE;
/* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED */
/* not defined in some older winnt.h */
if( raw_attr & 0x00002000 ) ulAttr |= HB_FA_NOTINDEXED;
if( raw_attr & 0x00008000 ) ulAttr |= HB_FA_VOLCOMP;
#endif
#elif defined(HB_OS_UNIX)
ulAttr = ( ( raw_attr & S_IXOTH ) ? HB_FA_XOTH : 0 ) |
( ( raw_attr & S_IWOTH ) ? HB_FA_WOTH : 0 ) |
( ( raw_attr & S_IROTH ) ? HB_FA_ROTH : 0 ) |
( ( raw_attr & S_IXGRP ) ? HB_FA_XGRP : 0 ) |
( ( raw_attr & S_IWGRP ) ? HB_FA_WGRP : 0 ) |
( ( raw_attr & S_IRGRP ) ? HB_FA_RGRP : 0 ) |
( ( raw_attr & S_IXUSR ) ? HB_FA_XUSR : 0 ) |
( ( raw_attr & S_IWUSR ) ? HB_FA_WUSR : 0 ) |
( ( raw_attr & S_IRUSR ) ? HB_FA_RUSR : 0 ) |
( ( raw_attr & S_ISVTX ) ? HB_FA_SVTX : 0 ) |
( ( raw_attr & S_ISGID ) ? HB_FA_SGID : 0 ) |
( ( raw_attr & S_ISUID ) ? HB_FA_SUID : 0 );
if( S_ISREG( raw_attr ) ) ulAttr |= HB_FA_FILE;
if( S_ISDIR( raw_attr ) ) ulAttr |= HB_FA_DIRECTORY;
if( S_ISLNK( raw_attr ) ) ulAttr |= HB_FA_LINK;
if( S_ISCHR( raw_attr ) ) ulAttr |= HB_FA_CHRDEVICE;
if( S_ISBLK( raw_attr ) ) ulAttr |= HB_FA_BLKDEVICE;
if( S_ISFIFO( raw_attr ) ) ulAttr |= HB_FA_FIFO;
if( S_ISSOCK( raw_attr ) ) ulAttr |= HB_FA_SOCKET;
#else
HB_SYMBOL_UNUSED( raw_attr );
ulAttr = 0;
#endif
return ulAttr;
}
| hbffind.c | 180 |
| ULONG | hb_fsAttrToRaw( ULONG ulAttr )
ULONG hb_fsAttrToRaw( ULONG ulAttr )
{
ULONG raw_attr;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrToRaw(%lu)", ulAttr));
#if defined(HB_OS_DOS)
raw_attr = 0;
if( ulAttr & HB_FA_ARCHIVE ) raw_attr |= FA_ARCH;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= FA_DIREC;
if( ulAttr & HB_FA_HIDDEN ) raw_attr |= FA_HIDDEN;
if( ulAttr & HB_FA_READONLY ) raw_attr |= FA_RDONLY;
if( ulAttr & HB_FA_LABEL ) raw_attr |= FA_LABEL;
if( ulAttr & HB_FA_SYSTEM ) raw_attr |= FA_SYSTEM;
#elif defined(HB_OS_OS2)
raw_attr = 0;
if( ulAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ARCHIVED;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_DIRECTORY;
if( ulAttr & HB_FA_HIDDEN ) raw_attr |= FILE_HIDDEN;
if( ulAttr & HB_FA_READONLY ) raw_attr |= FILE_READONLY;
if( ulAttr & HB_FA_SYSTEM ) raw_attr |= FILE_SYSTEM;
#elif defined(HB_OS_WIN_32)
raw_attr = 0;
if( ulAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ATTRIBUTE_ARCHIVE;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_ATTRIBUTE_DIRECTORY;
if( ulAttr & HB_FA_HIDDEN ) raw_attr |= FILE_ATTRIBUTE_HIDDEN;
if( ulAttr & HB_FA_READONLY ) raw_attr |= FILE_ATTRIBUTE_READONLY;
if( ulAttr & HB_FA_SYSTEM ) raw_attr |= FILE_ATTRIBUTE_SYSTEM;
if( ulAttr & HB_FA_NORMAL ) raw_attr |= FILE_ATTRIBUTE_NORMAL;
#ifdef HB_EXTENSION
/* Note that FILE_ATTRIBUTE_NORMAL is not needed
HB_FA_DEVICE not supported
HB_FA_VOLCOMP needs to be checked */
if( ulAttr & HB_FA_ENCRYPTED ) raw_attr |= FILE_ATTRIBUTE_ENCRYPTED;
if( ulAttr & HB_FA_TEMPORARY ) raw_attr |= FILE_ATTRIBUTE_TEMPORARY;
if( ulAttr & HB_FA_SPARSE ) raw_attr |= FILE_ATTRIBUTE_SPARSE_FILE;
if( ulAttr & HB_FA_REPARSE ) raw_attr |= FILE_ATTRIBUTE_REPARSE_POINT;
if( ulAttr & HB_FA_COMPRESSED ) raw_attr |= FILE_ATTRIBUTE_COMPRESSED;
if( ulAttr & HB_FA_OFFLINE ) raw_attr |= FILE_ATTRIBUTE_OFFLINE;
if( ulAttr & HB_FA_NOTINDEXED ) raw_attr |= 0x00002000; /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED not defined in some older winnt.h */
if( ulAttr & HB_FA_VOLCOMP ) raw_attr |= 0x00008000;
#endif
#elif defined(HB_OS_UNIX)
raw_attr = HB_FA_POSIX_ATTR( ulAttr );
if( ulAttr & HB_FA_FILE ) raw_attr |= S_IFREG;
if( ulAttr & HB_FA_DIRECTORY ) raw_attr |= S_IFDIR;
if( ulAttr & HB_FA_LINK ) raw_attr |= S_IFLNK;
if( ulAttr & HB_FA_CHRDEVICE ) raw_attr |= S_IFCHR;
if( ulAttr & HB_FA_BLKDEVICE ) raw_attr |= S_IFBLK;
if( ulAttr & HB_FA_FIFO ) raw_attr |= S_IFIFO;
if( ulAttr & HB_FA_SOCKET ) raw_attr |= S_IFSOCK;
#else
HB_SYMBOL_UNUSED( ulAttr );
raw_attr = 0;
#endif
return raw_attr;
}
| hbffind.c | 264 |
| ULONG | hb_fsAttrEncode( const char * szAttr )
ULONG hb_fsAttrEncode( const char * szAttr )
{
const char * pos = szAttr;
char ch;
ULONG ulAttr = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrEncode(%p)", szAttr));
while( ( ch = ( char ) toupper( *pos ) ) != '\0' )
{
switch( ch )
{
case 'R': ulAttr |= HB_FA_READONLY; break;
case 'H': ulAttr |= HB_FA_HIDDEN; break;
case 'S': ulAttr |= HB_FA_SYSTEM; break;
case 'V': ulAttr |= HB_FA_LABEL; break;
case 'D': ulAttr |= HB_FA_DIRECTORY; break;
case 'A': ulAttr |= HB_FA_ARCHIVE; break;
#ifdef HB_EXTENSION
case 'E': ulAttr |= HB_FA_ENCRYPTED; break;
case 'T': ulAttr |= HB_FA_TEMPORARY; break;
case 'P': ulAttr |= HB_FA_SPARSE; break;
case 'L': ulAttr |= HB_FA_REPARSE; break;
case 'C': ulAttr |= HB_FA_COMPRESSED; break;
case 'O': ulAttr |= HB_FA_OFFLINE; break;
case 'X': ulAttr |= HB_FA_NOTINDEXED; break;
case 'I': ulAttr |= HB_FA_DEVICE; break;
case 'M': ulAttr |= HB_FA_VOLCOMP; break;
#endif
}
pos++;
}
return ulAttr;
}
| hbffind.c | 339 |
| CHAR * | hb_fsAttrDecode( ULONG ulAttr, char * szAttr )
char * hb_fsAttrDecode( ULONG ulAttr, char * szAttr )
{
char * ptr = szAttr;
HB_TRACE(HB_TR_DEBUG, ("hb_fsAttrDecode(%lu, %p)", ulAttr, szAttr));
/* Using the same order as CA-Cl*pper did: RHSVDA. */
if( ulAttr & HB_FA_READONLY ) *ptr++ = 'R';
if( ulAttr & HB_FA_HIDDEN ) *ptr++ = 'H';
if( ulAttr & HB_FA_SYSTEM ) *ptr++ = 'S';
if( ulAttr & HB_FA_LABEL ) *ptr++ = 'V';
if( ulAttr & HB_FA_DIRECTORY ) *ptr++ = 'D';
if( ulAttr & HB_FA_ARCHIVE ) *ptr++ = 'A';
#ifdef HB_EXTENSION
if( ulAttr & HB_FA_ENCRYPTED ) *ptr++ = 'E';
if( ulAttr & HB_FA_TEMPORARY ) *ptr++ = 'T';
if( ulAttr & HB_FA_SPARSE ) *ptr++ = 'P';
if( ulAttr & HB_FA_REPARSE ) *ptr++ = 'L';
if( ulAttr & HB_FA_COMPRESSED ) *ptr++ = 'C';
if( ulAttr & HB_FA_OFFLINE ) *ptr++ = 'O';
if( ulAttr & HB_FA_NOTINDEXED ) *ptr++ = 'X';
if( ulAttr & HB_FA_DEVICE ) *ptr++ = 'I';
if( ulAttr & HB_FA_VOLCOMP ) *ptr++ = 'M';
#endif
*ptr = '\0';
return szAttr;
}
| hbffind.c | 381 |
| STATIC BOOL | hb_fsFindNextLow( PHB_FFIND ffind )
static BOOL hb_fsFindNextLow( PHB_FFIND ffind )
{
BOOL bFound;
USHORT nYear = 0;
USHORT nMonth = 0;
USHORT nDay = 0;
USHORT nHour = 0;
USHORT nMin = 0;
USHORT nSec = 0;
ULONG raw_attr = 0;
/* Set the default values in case some platforms don't
support some of these, or they may fail on them. */
ffind->szName[ 0 ] = '\0';
ffind->size = 0;
/* Do platform dependant first/next search */
hb_vmUnlock();
#if defined(HB_OS_DOS)
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
/* Handling HB_FA_LABEL doesn't need any special tricks
under the DOS platform. */
if( ffind->bFirst )
{
ffind->bFirst = FALSE;
tzset();
#if defined(__WATCOMC__)
bFound = ( _dos_findfirst( ffind->pszFileMask, ( USHORT ) hb_fsAttrToRaw( ffind->attrmask ), &info->entry ) == 0 );
#else
bFound = ( findfirst( ffind->pszFileMask, &info->entry, ( USHORT ) hb_fsAttrToRaw( ffind->attrmask ) ) == 0 );
#endif
}
else
{
#if defined(__WATCOMC__)
bFound = ( _dos_findnext( &info->entry ) == 0 );
#else
bFound = ( findnext( &info->entry ) == 0 );
#endif
}
/* Fill Harbour found file info */
if( bFound )
{
hb_strncpy( ffind->szName, info->entry.ff_name, sizeof( ffind->szName ) - 1 );
ffind->size = info->entry.ff_fsize;
raw_attr = info->entry.ff_attrib;
{
time_t ftime;
struct tm * ft;
struct stat sStat;
stat( info->entry.ff_name, &sStat );
ftime = sStat.st_mtime;
ft = localtime( &ftime );
nYear = ft->tm_year + 1900;
nMonth = ft->tm_mon + 1;
nDay = ft->tm_mday;
nHour = ft->tm_hour;
nMin = ft->tm_min;
nSec = ft->tm_sec;
}
}
hb_fsSetIOError( bFound, 0 );
}
#elif defined(HB_OS_OS2)
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
/* TODO: HB_FA_LABEL handling */
if( ffind->bFirst )
{
ffind->bFirst = FALSE;
tzset();
info->hFindFile = HDIR_CREATE;
info->findCount = 1;
bFound = DosFindFirst( ffind->pszFileMask,
&info->hFindFile,
( LONG ) hb_fsAttrToRaw( ffind->attrmask ),
&info->entry,
sizeof( info->entry ),
&info->findCount,
FIL_STANDARD ) == NO_ERROR && info->findCount > 0;
}
else
bFound = DosFindNext( info->hFindFile,
&info->entry,
sizeof( info->entry ),
&info->findCount ) == NO_ERROR && info->findCount > 0;
/* Fill Harbour found file info */
if( bFound )
{
struct stat sStat;
stat( info->entry.achName, &sStat );
hb_strncpy( ffind->szName, info->entry.achName, sizeof( ffind->szName ) - 1 );
ffind->size = sStat.st_size;
raw_attr = info->entry.attrFile;
{
time_t ftime;
struct tm * ft;
ftime = sStat.st_mtime;
ft = localtime( &ftime );
nYear = ft->tm_year + 1900;
nMonth = ft->tm_mon + 1;
nDay = ft->tm_mday;
nHour = ft->tm_hour;
nMin = ft->tm_min;
nSec = ft->tm_sec;
}
}
hb_fsSetIOError( bFound, 0 );
}
#elif defined(HB_OS_WIN_32)
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
bFound = FALSE;
if( ffind->attrmask & HB_FA_LABEL )
{
if( ffind->bFirst )
{
ffind->bFirst = FALSE;
ffind->szName[ 0 ] = '\0';
bFound = GetVolumeInformationA( ffind->pszFileMask, ffind->szName, _POSIX_PATH_MAX, NULL, NULL, NULL, NULL, 0 );
}
}
else
{
if( ffind->bFirst )
{
ffind->bFirst = FALSE;
info->hFindFile = FindFirstFileA( ffind->pszFileMask, &info->pFindFileData );
info->dwAttr = ( DWORD ) hb_fsAttrToRaw( ffind->attrmask );
if( ( info->hFindFile != INVALID_HANDLE_VALUE ) && HB_WIN_32_MATCH() )
bFound = TRUE;
}
if( ! bFound && info->hFindFile != INVALID_HANDLE_VALUE )
{
while( FindNextFileA( info->hFindFile, &info->pFindFileData ) )
{
if( HB_WIN_32_MATCH() )
{
bFound = TRUE;
break;
}
}
}
/* Fill Harbour found file info */
if( bFound )
{
hb_strncpy( ffind->szName, info->pFindFileData.cFileName, sizeof( ffind->szName ) - 1 );
if( info->pFindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
ffind->size = 0;
else
{
#if defined(__XCC__) || __POCC__ >= 500
/* NOTE: PellesC 5.00.1 will go into an infinite loop if we don't
split this into two operations. [vszakats] */
ffind->size = ( HB_FOFFSET ) info->pFindFileData.nFileSizeLow;
ffind->size += ( HB_FOFFSET ) info->pFindFileData.nFileSizeHigh << 32;
#else
ffind->size = ( HB_FOFFSET ) info->pFindFileData.nFileSizeLow +
( ( HB_FOFFSET ) info->pFindFileData.nFileSizeHigh << 32 );
#endif
}
raw_attr = ( ULONG ) info->pFindFileData.dwFileAttributes;
/* NOTE: One of these may fail when searching on an UNC path, I
don't know yet what's the reason. [vszakats] */
{
FILETIME ft;
SYSTEMTIME time;
if( FileTimeToLocalFileTime( &info->pFindFileData.ftLastWriteTime, &ft ) &&
FileTimeToSystemTime( &ft, &time ) )
{
nYear = time.wYear;
nMonth = time.wMonth;
nDay = time.wDay;
nHour = time.wHour;
nMin = time.wMinute;
nSec = time.wSecond;
}
}
}
}
hb_fsSetIOError( bFound, 0 );
}
#elif defined(HB_OS_UNIX)
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
char dirname[ _POSIX_PATH_MAX + 1 ];
char string[ _POSIX_PATH_MAX + 1 ];
bFound = FALSE;
/* TODO: HB_FA_LABEL handling */
string[ 0 ] = '\0';
if( ffind->bFirst )
{
char * pos;
ffind->bFirst = FALSE;
dirname[ 0 ] = '\0';
info->pattern[ 0 ] = '\0';
/* hb_strncpy( string, pszFileName, sizeof( string ) - 1 ); */
hb_strncpy( string, ffind->pszFileMask, sizeof( string ) - 1 );
pos = strrchr( string, HB_OS_PATH_DELIM_CHR );
if( pos )
{
hb_strncpy( info->pattern, pos + 1, sizeof( info->pattern ) - 1 );
*( pos + 1 ) = '\0';
hb_strncpy( dirname, string, sizeof( dirname ) - 1 );
}
else
{
hb_strncpy( info->pattern, string, sizeof( info->pattern ) - 1 );
dirname[ 0 ] = '.';
dirname[ 1 ] = HB_OS_PATH_DELIM_CHR;
dirname[ 2 ] = '\0';
}
tzset();
info->dir = opendir( dirname );
hb_strncpy( info->path, dirname, sizeof( info->path ) - 1 );
}
if( info->dir && info->pattern[ 0 ] != '\0' )
{
while( ( info->entry = readdir( info->dir ) ) != NULL )
{
hb_strncpy( string, info->entry->d_name, sizeof( string ) - 1 );
if( hb_strMatchFile( string, info->pattern ) )
{
bFound = TRUE;
break;
}
}
}
/* Fill Harbour found file info */
if( bFound )
{
hb_strncpy( dirname, info->path, sizeof( dirname ) - 1 );
hb_strncat( dirname, info->entry->d_name, sizeof( dirname ) - 1 );
{
time_t ftime;
struct tm * ft;
#if defined( HB_USE_LARGEFILE64 )
struct stat64 sStat;
if( stat64( dirname, &sStat ) == 0 )
#else
struct stat sStat;
if( stat( dirname, &sStat ) == 0 )
#endif
{
hb_strncpy( ffind->szName, info->entry->d_name, sizeof( ffind->szName ) - 1 );
ffind->size = sStat.st_size;
raw_attr = sStat.st_mode;
ftime = sStat.st_mtime;
ft = localtime( &ftime );
nYear = ft->tm_year + 1900;
nMonth = ft->tm_mon + 1;
nDay = ft->tm_mday;
nHour = ft->tm_hour;
nMin = ft->tm_min;
nSec = ft->tm_sec;
}
else
bFound = FALSE;
}
}
hb_fsSetIOError( bFound, 0 );
}
#else
{
int TODO; /* TODO: for given platform */
/* HB_SYMBOL_UNUSED( ffind ); */
HB_SYMBOL_UNUSED( nYear );
HB_SYMBOL_UNUSED( nMonth );
HB_SYMBOL_UNUSED( nDay );
HB_SYMBOL_UNUSED( nHour );
HB_SYMBOL_UNUSED( nMin );
HB_SYMBOL_UNUSED( nSec );
HB_SYMBOL_UNUSED( raw_attr );
bFound = FALSE;
hb_fsSetError( ( USHORT ) FS_ERROR );
}
#endif
/* Fill common Harbour found file info */
if( bFound )
{
/* Do the conversions common for all platforms */
ffind->szName[ _POSIX_PATH_MAX ] = '\0';
ffind->attr = hb_fsAttrFromRaw( raw_attr );
ffind->lDate = hb_dateEncode( nYear, nMonth, nDay );
hb_dateStrPut( ffind->szDate, nYear, nMonth, nDay );
ffind->szDate[ 8 ] = '\0';
snprintf( ffind->szTime, sizeof( ffind->szTime ), "%02d:%02d:%02d", nHour, nMin, nSec );
}
hb_vmLock();
return bFound;
}
| hbffind.c | 415 |
| HB_EXPORT PHB_FFIND | hb_fsFindFirst( const char * pszFileMask, ULONG attrmask )
HB_EXPORT PHB_FFIND hb_fsFindFirst( const char * pszFileMask, ULONG attrmask )
{
PHB_FFIND ffind;
ffind = ( PHB_FFIND ) hb_xgrab( sizeof( HB_FFIND ) );
memset( ffind, 0, sizeof( HB_FFIND ) );
/* Allocate platform dependent file find info storage */
ffind->info = ( void * ) hb_xgrab( sizeof( HB_FFIND_INFO ) );
memset( ffind->info, 0, sizeof( HB_FFIND_INFO ) );
/* Store search parameters */
ffind->pszFileMask = pszFileMask;
ffind->attrmask = attrmask;
ffind->bFirst = TRUE;
/* Find first/next matching file */
if( hb_fsFindNext( ffind ) )
return ffind;
/* If no file found at all, free stuff allocated so far and return NULL. */
hb_fsFindClose( ffind );
return NULL;
}
| hbffind.c | 788 |
| HB_EXPORT BOOL | hb_fsFindNext( PHB_FFIND ffind )
HB_EXPORT BOOL hb_fsFindNext( PHB_FFIND ffind )
{
while( hb_fsFindNextLow( ffind ) )
{
/* Filter the result to stay MS-DOS and CA-Cl*pper compatible. */
if( !( ( ( ffind->attrmask & HB_FA_HIDDEN ) == 0 && ( ffind->attr & HB_FA_HIDDEN ) != 0 ) ||
( ( ffind->attrmask & HB_FA_SYSTEM ) == 0 && ( ffind->attr & HB_FA_SYSTEM ) != 0 ) ||
( ( ffind->attrmask & HB_FA_LABEL ) == 0 && ( ffind->attr & HB_FA_LABEL ) != 0 ) ||
( ( ffind->attrmask & HB_FA_DIRECTORY ) == 0 && ( ffind->attr & HB_FA_DIRECTORY ) != 0 ) ) )
{
return TRUE;
}
}
return FALSE;
}
| hbffind.c | 819 |
| HB_EXPORT VOID | hb_fsFindClose( PHB_FFIND ffind )
HB_EXPORT void hb_fsFindClose( PHB_FFIND ffind )
{
if( ffind )
{
/* Do platform dependant cleanup */
if( ffind->info )
{
PHB_FFIND_INFO info = ( PHB_FFIND_INFO ) ffind->info;
hb_vmUnlock();
#if defined(HB_OS_DOS)
#if defined(__DJGPP__) || defined(__BORLANDC__)
{
HB_SYMBOL_UNUSED( info );
}
#else
{
#if defined(__WATCOMC__)
_dos_findclose( &info->entry );
#else
findclose( &info->entry );
#endif
}
#endif
#elif defined(HB_OS_OS2)
{
DosFindClose( info->hFindFile );
}
#elif defined(HB_OS_WIN_32)
if( info->hFindFile != INVALID_HANDLE_VALUE )
{
FindClose( info->hFindFile );
}
#elif defined(HB_OS_UNIX)
if( info->dir )
{
closedir( info->dir );
}
#else
{
/* Intentionally do nothing */
int TODO; /* TODO: for given platform */
HB_SYMBOL_UNUSED( info );
}
#endif
hb_vmLock();
hb_xfree( ( void * ) ffind->info );
}
hb_xfree( ( void * ) ffind );
}
}
| hbffind.c | 837 |
| hbfile.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_FILEEXISTS(void)
HB_FUNC( HB_FILEEXISTS )
{
hb_retl( hb_fsFileExists( hb_parc( 1 ) ) );
}
| hbfile.c | 56 |
| HB_FUNC | HB_DIREXISTS(void)
HB_FUNC( HB_DIREXISTS )
{
hb_retl( hb_fsDirExists( hb_parc( 1 ) ) );
}
| hbfile.c | 61 |
| hbgtcore.c |
| Type | Function | Source | Line |
|---|
| PHB_GT | hb_gt_Base( void )
PHB_GT hb_gt_Base( void )
{
return s_curGT;
}
| hbgtcore.c | 80 |
| VOID | hb_gt_BaseFree( PHB_GT pGT )
void hb_gt_BaseFree( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
}
| hbgtcore.c | 85 |
| STATIC VOID | hb_gt_def_BaseInit( PHB_GT_BASE pGT )
static void hb_gt_def_BaseInit( PHB_GT_BASE pGT )
{
pGT->fVgaCell = TRUE;
pGT->fIsColor = TRUE;
pGT->fBlinking = TRUE;
pGT->fStdOutCon = FALSE;
pGT->fStdErrCon = FALSE;
pGT->iCursorShape = SC_NORMAL;
pGT->uiDispCount = 0;
pGT->uiExtCount = 0;
pGT->uiClearChar = ' ';
pGT->bClearColor = 0x07;
pGT->iHeight = 24;
pGT->iWidth = 80;
pGT->hStdIn = s_hStdIn;
pGT->hStdOut = s_hStdOut;
pGT->hStdErr = s_hStdErr;
pGT->iDoubleClickSpeed = 168; /* In milliseconds */
pGT->inkeyBuffer = pGT->defaultKeyBuffer;
pGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE;
}
| hbgtcore.c | 90 |
| STATIC VOID * | hb_gt_def_New( PHB_GT pGT )
static void * hb_gt_def_New( PHB_GT pGT )
{
ULONG ulSize, ulIndex;
USHORT usChar;
BYTE bColor, bAttr;
int i;
hb_gt_def_BaseInit( pGT );
HB_GTSELF_GETSIZE( pGT, &pGT->iHeight, &pGT->iWidth );
ulSize = ( ULONG ) pGT->iHeight * pGT->iWidth;
pGT->screenBuffer =
( PHB_SCREENCELL ) hb_xgrab( sizeof( HB_SCREENCELL ) * ulSize );
pGT->prevBuffer =
( PHB_SCREENCELL ) hb_xgrab( sizeof( HB_SCREENCELL ) * ulSize );
pGT->pLines = ( BOOL * ) hb_xgrab( sizeof( BOOL ) * pGT->iHeight );
memset( pGT->prevBuffer, 0, sizeof( HB_SCREENCELL ) * ulSize );
for( i = 0; i < pGT->iHeight; ++i )
pGT->pLines[ i ] = TRUE;
usChar = HB_GTSELF_GETCLEARCHAR( pGT );
bColor = HB_GTSELF_GETCLEARCOLOR( pGT );
bAttr = 0;
for( ulIndex = 0; ulIndex < ulSize; ++ulIndex )
{
pGT->screenBuffer[ ulIndex ].c.usChar = usChar;
pGT->screenBuffer[ ulIndex ].c.bColor = bColor;
pGT->screenBuffer[ ulIndex ].c.bAttr = bAttr;
pGT->prevBuffer[ ulIndex ].c.bAttr = HB_GT_ATTR_REFRESH;
}
return pGT;
}
| hbgtcore.c | 115 |
| STATIC VOID | hb_gt_def_Free( PHB_GT pGT )
static void hb_gt_def_Free( PHB_GT pGT )
{
if( pGT->screenBuffer )
hb_xfree( pGT->screenBuffer );
if( pGT->prevBuffer )
hb_xfree( pGT->prevBuffer );
if( pGT->pLines )
hb_xfree( pGT->pLines );
if( pGT->iColorCount > 0 )
hb_xfree( pGT->pColor );
if( pGT->pNotifierBlock )
hb_itemRelease( pGT->pNotifierBlock );
if( s_curGT == pGT )
s_curGT = NULL;
hb_xfree( pGT );
}
| hbgtcore.c | 151 |
| STATIC VOID | hb_gt_def_Init( PHB_GT pGT, HB_FHANDLE hStdIn, HB_FHANDLE hStdOut, HB_FHANDLE hStdErr )
static void hb_gt_def_Init( PHB_GT pGT, HB_FHANDLE hStdIn, HB_FHANDLE hStdOut, HB_FHANDLE hStdErr )
{
HB_GTSELF_NEW( pGT );
pGT->hStdIn = hStdIn;
pGT->hStdOut = hStdOut;
pGT->hStdErr = hStdErr;
HB_GTSELF_RESIZE( pGT, pGT->iHeight, pGT->iWidth );
HB_GTSELF_MOUSEINIT( pGT );
HB_GTSELF_MOUSEGETPOS( pGT, &pGT->iMouseLastRow, &pGT->iMouseLastCol );
}
| hbgtcore.c | 171 |
| STATIC VOID | hb_gt_def_Exit( PHB_GT pGT )
static void hb_gt_def_Exit( PHB_GT pGT )
{
HB_GTSELF_MOUSEEXIT( pGT );
HB_GTSELF_INKEYEXIT( pGT );
HB_GTSELF_FREE( pGT );
/* clear internal clipboard data */
hb_gt_setClipboard( NULL, 0 );
}
| hbgtcore.c | 184 |
| STATIC BOOL | hb_gt_def_CheckPos( PHB_GT pGT, int iRow, int iCol, long *plIndex )
static BOOL hb_gt_def_CheckPos( PHB_GT pGT, int iRow, int iCol, long *plIndex )
{
if( iRow >= 0 && iCol >= 0 )
{
int iHeight, iWidth;
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
if( iRow < iHeight && iCol < iWidth )
{
if( plIndex )
*plIndex = ( long ) iRow * iWidth + iCol;
return TRUE;
}
}
return FALSE;
}
| hbgtcore.c | 195 |
| STATIC VOID | hb_gt_def_GetPos( PHB_GT pGT, int * piRow, int * piCol )
static void hb_gt_def_GetPos( PHB_GT pGT, int * piRow, int * piCol )
{
* piRow = pGT->iRow;
* piCol = pGT->iCol;
}
| hbgtcore.c | 212 |
| STATIC VOID | hb_gt_def_SetPos( PHB_GT pGT, int iRow, int iCol )
static void hb_gt_def_SetPos( PHB_GT pGT, int iRow, int iCol )
{
pGT->iRow = iRow;
pGT->iCol = iCol;
}
| hbgtcore.c | 218 |
| STATIC INT | hb_gt_def_MaxCol( PHB_GT pGT )
static int hb_gt_def_MaxCol( PHB_GT pGT )
{
return pGT->iWidth - 1;
}
| hbgtcore.c | 224 |
| STATIC INT | hb_gt_def_MaxRow( PHB_GT pGT )
static int hb_gt_def_MaxRow( PHB_GT pGT )
{
return pGT->iHeight - 1;
}
| hbgtcore.c | 229 |
| STATIC BOOL | hb_gt_def_IsColor( PHB_GT pGT )
static BOOL hb_gt_def_IsColor( PHB_GT pGT )
{
return pGT->fIsColor;
}
| hbgtcore.c | 234 |
| STATIC VOID | hb_gt_def_GetColorStr( PHB_GT pGT, char * pszColorString )
static void hb_gt_def_GetColorStr( PHB_GT pGT, char * pszColorString )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_GetColorStr(%p,%s)", pGT, pszColorString));
HB_GTSELF_COLORSTOSTRING( pGT, pGT->pColor, pGT->iColorCount,
pszColorString, HB_CLRSTR_LEN );
}
| hbgtcore.c | 239 |
| STATIC VOID | hb_gt_def_SetColorStr( PHB_GT pGT, const char * szColorString )
static void hb_gt_def_SetColorStr( PHB_GT pGT, const char * szColorString )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_SetColorStr(%p,%s)", pGT, szColorString));
HB_GTSELF_STRINGTOCOLORS( pGT, szColorString, &pGT->pColor, &pGT->iColorCount );
pGT->iColorIndex = HB_CLR_STANDARD; /* HB_GTSELF_COLORSELECT( pGT, HB_CLR_STANDARD ); */
}
| hbgtcore.c | 251 |
| STATIC VOID | hb_gt_def_ColorSelect( PHB_GT pGT, int iColorIndex )
static void hb_gt_def_ColorSelect( PHB_GT pGT, int iColorIndex )
{
if( iColorIndex >= 0 && iColorIndex < pGT->iColorCount )
pGT->iColorIndex = iColorIndex;
}
| hbgtcore.c | 259 |
| STATIC INT | hb_gt_def_GetColor( PHB_GT pGT )
static int hb_gt_def_GetColor( PHB_GT pGT )
{
if( pGT->iColorCount )
return pGT->pColor[ pGT->iColorIndex ];
else
return HB_GTSELF_GETCLEARCOLOR( pGT );
}
| hbgtcore.c | 265 |
| STATIC VOID | hb_gt_def_GetColorData( PHB_GT pGT, int ** pColorsPtr, int * piColorCount, int * piColorIndex )
static void hb_gt_def_GetColorData( PHB_GT pGT, int ** pColorsPtr, int * piColorCount, int * piColorIndex )
{
if( pGT->iColorCount )
{
*pColorsPtr = ( int * ) hb_xgrab( pGT->iColorCount * sizeof( int ) );
memcpy( *pColorsPtr, pGT->pColor, pGT->iColorCount * sizeof( int ) );
*piColorCount = pGT->iColorCount;
*piColorIndex = pGT->iColorIndex;
}
else
{
*pColorsPtr = ( int * ) hb_xgrab( sizeof( int ) );
*pColorsPtr[ 0 ] = 0;
*piColorCount = 1;
*piColorIndex = 0;
}
}
| hbgtcore.c | 273 |
| STATIC INT | hb_gt_def_GetClearColor( PHB_GT pGT )
static int hb_gt_def_GetClearColor( PHB_GT pGT )
{
return pGT->bClearColor;
}
| hbgtcore.c | 291 |
| STATIC VOID | hb_gt_def_SetClearColor( PHB_GT pGT, int iColor )
static void hb_gt_def_SetClearColor( PHB_GT pGT, int iColor )
{
pGT->bClearColor = iColor;
}
| hbgtcore.c | 296 |
| STATIC INT | hb_gt_def_GetClearChar( PHB_GT pGT )
static int hb_gt_def_GetClearChar( PHB_GT pGT )
{
return pGT->uiClearChar;
}
| hbgtcore.c | 301 |
| STATIC VOID | hb_gt_def_SetClearChar( PHB_GT pGT, int iChar )
static void hb_gt_def_SetClearChar( PHB_GT pGT, int iChar )
{
pGT->uiClearChar = iChar;
}
| hbgtcore.c | 306 |
| STATIC CONST CHAR * | hb_gt_def_ColorDecode( const char * szColorString, int * piColor )
static const char * hb_gt_def_ColorDecode( const char * szColorString, int * piColor )
{
char c;
int nColor = 0, iCount = 0;
BOOL bFore = TRUE;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_ColorDecode(%s,%p)", szColorString, piColor));
while( ( c = *szColorString++ ) != 0 )
{
switch( c )
{
case '*':
nColor |= 0x80;
break;
case '+':
nColor |= 0x08;
break;
case '/':
if( !bFore )
nColor = ( ( nColor >> 4 ) & 0x0F07 ) | ( nColor & 0x88 );
else
bFore = FALSE;
break;
case 'b':
case 'B':
nColor |= bFore ? 0x01: 0x10;
break;
case 'g':
case 'G':
nColor |= bFore ? 0x02: 0x20;
break;
case 'r':
case 'R':
nColor |= bFore ? 0x04: 0x40;
break;
case 'w':
case 'W':
nColor |= bFore ? 0x07: 0x70;
break;
case 'n':
case 'N':
nColor &= bFore ? 0xFFF8: 0xFF8F;
break;
case 'i':
case 'I':
bFore = FALSE;
nColor &= 0x88;
nColor |= 0x70;
break;
case 'x':
case 'X':
nColor &= 0x88;
break;
case 'u':
case 'U':
if( bFore )
nColor = ( nColor & 0xF0F8 ) | 0x0801;
else
nColor = ( nColor & 0x0F8F ) | 0x8010;
break;
case ',':
* piColor = iCount == 0 ? -1 : nColor;
return szColorString;
default:
if( c >= '0' && c <= '9' )
{
int iColor = c - '0';
while( *szColorString >= '0' && *szColorString <= '9' )
iColor = iColor * 10 + ( *szColorString++ - '0' );
iColor &= 0x0f;
if( bFore )
nColor = ( nColor & 0xF0F8 ) | iColor;
else
nColor = ( nColor & 0x0F8F ) | ( iColor << 4 );
}
else
--iCount;
}
++iCount;
}
* piColor = iCount == 0 ? -1 : nColor;
return NULL;
}
| hbgtcore.c | 311 |
| STATIC INT | hb_gt_def_ColorNum( PHB_GT pGT, const char * szColorString )
static int hb_gt_def_ColorNum( PHB_GT pGT, const char * szColorString )
{
int nColor;
HB_SYMBOL_UNUSED( pGT );
hb_gt_def_ColorDecode( szColorString, &nColor );
return nColor;
}
| hbgtcore.c | 417 |
| STATIC VOID | hb_gt_def_StringToColors( PHB_GT pGT, const char * szColorString, int ** pColorsPtr, int * piColorCount )
static void hb_gt_def_StringToColors( PHB_GT pGT, const char * szColorString, int ** pColorsPtr, int * piColorCount )
{
int * pColors;
int nPos = 0;
int nColor;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_StringToColors(%p,%s,%p,%p)", pGT, szColorString, pColorsPtr, piColorCount));
HB_SYMBOL_UNUSED( pGT );
if( *piColorCount == 0 )
{
*piColorCount = HB_CLR_MAX_ + 1;
*pColorsPtr = ( int * ) hb_xgrab( *piColorCount * sizeof( int ) );
memset( *pColorsPtr, 0, *piColorCount * sizeof( int ) );
}
pColors = *pColorsPtr;
if( !szColorString || !*szColorString )
{
pColors[ HB_CLR_STANDARD ] = 0x07;
pColors[ HB_CLR_ENHANCED ] = 0x70;
pColors[ HB_CLR_BORDER ] = 0;
pColors[ HB_CLR_BACKGROUND ] = 0;
pColors[ HB_CLR_UNSELECTED ] = 0x70;
}
else do
{
szColorString = hb_gt_def_ColorDecode( szColorString, &nColor );
if( nPos == *piColorCount )
{
++*piColorCount;
pColors = *pColorsPtr = ( int * ) hb_xrealloc( pColors, *piColorCount * sizeof( int ) );
pColors[ nPos ] = 0;
}
if( nColor != -1 )
pColors[ nPos ] = nColor;
++nPos;
}
while( szColorString );
if( nPos >= HB_CLR_ENHANCED && nPos < HB_CLR_UNSELECTED &&
*piColorCount > HB_CLR_UNSELECTED )
pColors[ HB_CLR_UNSELECTED ] = pColors[ HB_CLR_ENHANCED ];
}
| hbgtcore.c | 427 |
| STATIC VOID | hb_gt_def_ColorsToString( PHB_GT pGT, int * pColors, int iColorCount, char * pszColorString, int iBufSize )
static void hb_gt_def_ColorsToString( PHB_GT pGT, int * pColors, int iColorCount, char * pszColorString, int iBufSize )
{
int iColorIndex, iPos;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_ColorsToString(%p,%p,%d,%s,%d)", pGT, pColors, iColorCount, pszColorString, iBufSize));
HB_SYMBOL_UNUSED( pGT );
/* Go on if there's space left for the largest color string plus EOF */
for( iColorIndex = iPos = 0; iColorIndex < iColorCount && iPos < iBufSize - 8; ++iColorIndex )
{
int nColor = pColors[ iColorIndex ] & 7;
int j;
if( iColorIndex > 0 )
pszColorString[ iPos++ ] = ',';
for( j = 0; j <= 1; j++ )
{
if( ( pColors[ iColorIndex ] & ( j ? 0x8000 : 0x0800 ) ) == 0 )
{
if( nColor == 7 )
pszColorString[ iPos++ ] = 'W';
else if( nColor == 0 )
pszColorString[ iPos++ ] = 'N';
else
{
if( ( nColor & 1 ) != 0 )
pszColorString[ iPos++ ] = 'B';
if( ( nColor & 2 ) != 0 )
pszColorString[ iPos++ ] = 'G';
if( ( nColor & 4 ) != 0 )
pszColorString[ iPos++ ] = 'R';
}
}
else
pszColorString[ iPos++ ] = 'U';
if( j == 0 )
{
/* NOTE: When STRICT is on, Harbour will put both the "*" and "+"
chars to the first half of the colorspec (like "W*+/B"),
which is quite ugly, otherwise it will put the "+" to the
first half and the "*" to the second (like "W+/B*"), which
is how it should be done. [vszakats] */
#ifdef HB_C52_STRICT
if( ( pColors[ iColorIndex ] & 0x80 ) != 0 )
pszColorString[ iPos++ ] = '*';
#endif
if( ( pColors[ iColorIndex ] & 0x08 ) != 0 )
pszColorString[ iPos++ ] = '+';
pszColorString[ iPos++ ] = '/';
}
#ifndef HB_C52_STRICT
else
{
if( ( pColors[ iColorIndex ] & 0x80 ) != 0 )
pszColorString[ iPos++ ] = '*';
}
#endif
nColor = ( pColors[ iColorIndex ] >> 4 ) & 7;
}
}
pszColorString[ iPos ] = '\0';
}
| hbgtcore.c | 475 |
| STATIC INT | hb_gt_def_GetCursorStyle( PHB_GT pGT )
static int hb_gt_def_GetCursorStyle( PHB_GT pGT )
{
return pGT->iCursorShape;
}
| hbgtcore.c | 547 |
| STATIC VOID | hb_gt_def_SetCursorStyle( PHB_GT pGT, int iStyle )
static void hb_gt_def_SetCursorStyle( PHB_GT pGT, int iStyle )
{
switch( iStyle )
{
case SC_NONE:
case SC_NORMAL:
case SC_INSERT:
case SC_SPECIAL1:
case SC_SPECIAL2:
pGT->iCursorShape = iStyle;
break;
default:
pGT->iCursorShape = SC_NORMAL;
break;
}
}
| hbgtcore.c | 552 |
| STATIC VOID | hb_gt_def_GetScrCursor( PHB_GT pGT, int * piRow, int * piCol, int * piStyle )
static void hb_gt_def_GetScrCursor( PHB_GT pGT, int * piRow, int * piCol, int * piStyle )
{
HB_GTSELF_GETPOS( pGT, piRow, piCol );
if( *piRow < 0 || *piCol < 0 ||
*piRow > HB_GTSELF_MAXROW( pGT ) || *piCol > HB_GTSELF_MAXCOL( pGT ) )
*piStyle = SC_NONE;
else
*piStyle = HB_GTSELF_GETCURSORSTYLE( pGT );
}
| hbgtcore.c | 569 |
| STATIC BOOL | hb_gt_def_GetBlink( PHB_GT pGT )
static BOOL hb_gt_def_GetBlink( PHB_GT pGT )
{
return pGT->fBlinking;
}
| hbgtcore.c | 579 |
| STATIC VOID | hb_gt_def_SetBlink( PHB_GT pGT, BOOL fBlink )
static void hb_gt_def_SetBlink( PHB_GT pGT, BOOL fBlink )
{
pGT->fBlinking = fBlink;
}
| hbgtcore.c | 584 |
| STATIC VOID | hb_gt_def_SetSnowFlag( PHB_GT pGT, BOOL fNoSnow )
static void hb_gt_def_SetSnowFlag( PHB_GT pGT, BOOL fNoSnow )
{
/*
* NOTE: This is a compatibility function which have to be implemented
* in low level GT driver.
* If you're running on a CGA and snow is a problem speak up!
*/
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( fNoSnow );
}
| hbgtcore.c | 589 |
| STATIC VOID | hb_gt_def_DispBegin( PHB_GT pGT )
static void hb_gt_def_DispBegin( PHB_GT pGT )
{
pGT->uiDispCount++;
}
| hbgtcore.c | 601 |
| STATIC VOID | hb_gt_def_DispEnd( PHB_GT pGT )
static void hb_gt_def_DispEnd( PHB_GT pGT )
{
if( pGT->uiDispCount > 0 )
pGT->uiDispCount--;
}
| hbgtcore.c | 606 |
| STATIC INT | hb_gt_def_DispCount( PHB_GT pGT )
static int hb_gt_def_DispCount( PHB_GT pGT )
{
return pGT->uiDispCount;
}
| hbgtcore.c | 612 |
| STATIC BOOL | hb_gt_def_PreExt( PHB_GT pGT )
static BOOL hb_gt_def_PreExt( PHB_GT pGT )
{
if( pGT->uiExtCount == 0 )
HB_GTSELF_REFRESH( pGT );
pGT->uiExtCount++;
return TRUE;
}
| hbgtcore.c | 617 |
| STATIC BOOL | hb_gt_def_PostExt( PHB_GT pGT )
static BOOL hb_gt_def_PostExt( PHB_GT pGT )
{
if( pGT->uiExtCount )
pGT->uiExtCount--;
return TRUE;
}
| hbgtcore.c | 626 |
| STATIC BOOL | hb_gt_def_Suspend( PHB_GT pGT )
static BOOL hb_gt_def_Suspend( PHB_GT pGT )
{
return HB_GTSELF_PREEXT( pGT );
}
| hbgtcore.c | 634 |
| STATIC BOOL | hb_gt_def_Resume( PHB_GT pGT )
static BOOL hb_gt_def_Resume( PHB_GT pGT )
{
return HB_GTSELF_POSTEXT( pGT );
}
| hbgtcore.c | 639 |
| STATIC VOID | hb_gt_def_OutStd( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen )
static void hb_gt_def_OutStd( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen )
{
if( ulLen )
{
if( pGT->fStdOutCon )
HB_GTSELF_WRITECON( pGT, pbyStr, ulLen );
else
{
HB_GTSELF_PREEXT( pGT );
if( pGT->fDispTrans )
{
BYTE * pbyStrBuff = ( BYTE * ) hb_xgrab( ulLen );
memcpy( pbyStrBuff, pbyStr, ulLen );
hb_cdpnTranslate( ( char * ) pbyStrBuff,
pGT->cdpHost, pGT->cdpTerm, ulLen );
hb_fsWriteLarge( pGT->hStdOut, pbyStrBuff, ulLen );
hb_xfree( pbyStrBuff );
}
else
hb_fsWriteLarge( pGT->hStdOut, pbyStr, ulLen );
HB_GTSELF_POSTEXT( pGT );
}
}
}
| hbgtcore.c | 644 |
| STATIC VOID | hb_gt_def_OutErr( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen )
static void hb_gt_def_OutErr( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen )
{
if( ulLen )
{
if( pGT->fStdErrCon )
HB_GTSELF_WRITECON( pGT, pbyStr, ulLen );
else
{
HB_GTSELF_PREEXT( pGT );
if( pGT->fDispTrans )
{
BYTE * pbyStrBuff = ( BYTE * ) hb_xgrab( ulLen );
memcpy( pbyStrBuff, pbyStr, ulLen );
hb_cdpnTranslate( ( char * ) pbyStrBuff,
pGT->cdpHost, pGT->cdpTerm, ulLen );
hb_fsWriteLarge( pGT->hStdErr, pbyStrBuff, ulLen );
hb_xfree( pbyStrBuff );
}
else
hb_fsWriteLarge( pGT->hStdErr, pbyStr, ulLen );
HB_GTSELF_POSTEXT( pGT );
}
}
}
| hbgtcore.c | 669 |
| STATIC VOID | hb_gt_def_Tone( PHB_GT pGT, double dFrequency, double dDuration )
static void hb_gt_def_Tone( PHB_GT pGT, double dFrequency, double dDuration )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( dFrequency );
/* convert Clipper (DOS) timer tick units to seconds ( x / 18.2 ) */
hb_idleSleep( dDuration / 18.2 );
}
| hbgtcore.c | 694 |
| STATIC VOID | hb_gt_def_Bell( PHB_GT pGT )
static void hb_gt_def_Bell( PHB_GT pGT )
{
HB_GTSELF_TONE( pGT, 700.0, 3.0 );
}
| hbgtcore.c | 703 |
| STATIC CONST CHAR * | hb_gt_def_Version( PHB_GT pGT, int iType )
static const char * hb_gt_def_Version( PHB_GT pGT, int iType )
{
HB_SYMBOL_UNUSED( pGT );
if( iType == 0 )
return ( char * ) "NUL";
return ( char * ) "Harbour Terminal: NULL";
}
| hbgtcore.c | 708 |
| STATIC BOOL | hb_gt_def_GetChar( PHB_GT pGT, int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar )
static BOOL hb_gt_def_GetChar( PHB_GT pGT, int iRow, int iCol,
BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar )
{
long lIndex;
if( HB_GTSELF_CHECKPOS( pGT, iRow, iCol, &lIndex ) )
{
*pusChar = pGT->screenBuffer[ lIndex ].c.usChar;
*pbColor = pGT->screenBuffer[ lIndex ].c.bColor;
*pbAttr = pGT->screenBuffer[ lIndex ].c.bAttr;
return TRUE;
}
return FALSE;
}
| hbgtcore.c | 718 |
| STATIC BOOL | hb_gt_def_PutChar( PHB_GT pGT, int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar )
static BOOL hb_gt_def_PutChar( PHB_GT pGT, int iRow, int iCol,
BYTE bColor, BYTE bAttr, USHORT usChar )
{
long lIndex;
if( HB_GTSELF_CHECKPOS( pGT, iRow, iCol, &lIndex ) )
{
pGT->screenBuffer[ lIndex ].c.usChar = usChar;
pGT->screenBuffer[ lIndex ].c.bColor = bColor;
pGT->screenBuffer[ lIndex ].c.bAttr = bAttr;
pGT->pLines[ iRow ] = TRUE;
pGT->fRefresh = TRUE;
return TRUE;
}
return FALSE;
}
| hbgtcore.c | 733 |
| STATIC VOID | hb_gt_def_PutText( PHB_GT pGT, int iRow, int iCol, BYTE bColor, BYTE * pText, ULONG ulLen )
static void hb_gt_def_PutText( PHB_GT pGT, int iRow, int iCol, BYTE bColor, BYTE * pText, ULONG ulLen )
{
while( ulLen-- )
{
if( !HB_GTSELF_PUTCHAR( pGT, iRow, iCol, bColor, 0, *pText++ ) )
break;
++iCol;
}
}
| hbgtcore.c | 750 |
| STATIC VOID | hb_gt_def_Replicate( PHB_GT pGT, int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar, ULONG ulLen )
static void hb_gt_def_Replicate( PHB_GT pGT, int iRow, int iCol, BYTE bColor,
BYTE bAttr, USHORT usChar, ULONG ulLen )
{
if( iCol < 0 )
{
if( ulLen < ( ULONG ) -iCol )
ulLen = 0;
else
ulLen += iCol;
iCol = 0;
}
while( ulLen-- )
{
if( !HB_GTSELF_PUTCHAR( pGT, iRow, iCol, bColor, bAttr, usChar ) )
break;
++iCol;
}
}
| hbgtcore.c | 760 |
| STATIC VOID | hb_gt_def_WriteAt( PHB_GT pGT, int iRow, int iCol, BYTE * pText, ULONG ulLength )
static void hb_gt_def_WriteAt( PHB_GT pGT, int iRow, int iCol, BYTE * pText, ULONG ulLength )
{
int iMaxCol = HB_GTSELF_MAXCOL( pGT );
/* Truncate the text if the cursor will end up off the right edge */
HB_GTSELF_PUTTEXT( pGT, iRow, iCol, HB_GTSELF_GETCOLOR( pGT ), pText,
HB_MIN( ulLength, ( ULONG ) ( iMaxCol - iCol + 1 ) ) );
/* Finally, save the new cursor position, even if off-screen */
HB_GTSELF_SETPOS( pGT, iRow, iCol + ( int ) ulLength );
}
| hbgtcore.c | 779 |
| STATIC VOID | hb_gt_def_Write( PHB_GT pGT, BYTE * pText, ULONG ulLength )
static void hb_gt_def_Write( PHB_GT pGT, BYTE * pText, ULONG ulLength )
{
int iRow, iCol;
HB_GTSELF_GETPOS( pGT, &iRow, &iCol );
HB_GTSELF_WRITEAT( pGT, iRow, iCol, pText, ulLength );
}
| hbgtcore.c | 791 |
| STATIC VOID | hb_gt_def_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength )
static void hb_gt_def_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength )
{
int iLen = 0;
BOOL bDisp = FALSE;
BOOL bBell = FALSE;
BOOL bNewLine = FALSE;
int iRow, iCol, iMaxRow, iMaxCol;
BYTE szString[ WRITECON_BUFFER_SIZE ];
iMaxRow = HB_GTSELF_MAXROW( pGT );
iMaxCol = HB_GTSELF_MAXCOL( pGT );
HB_GTSELF_GETPOS( pGT, &iRow, &iCol );
/* Limit the starting cursor position to maxrow(),maxcol()
on the high end, but don't limit it on the low end. */
if( iRow > iMaxRow || iCol > iMaxCol )
{
if( iRow > iMaxRow )
iRow = iMaxRow;
if( iCol > iMaxCol )
iCol = iMaxCol;
HB_GTSELF_SETPOS( pGT, iRow, iCol );
}
while( ulLength-- )
{
BYTE ch = *pText++;
switch( ch )
{
case HB_CHAR_BEL:
bDisp = bBell = TRUE;
break;
case HB_CHAR_BS:
if( iCol > 0 )
{
--iCol;
bDisp = TRUE;
}
else if( iCol == 0 && iRow > 0 )
{
iCol = iMaxCol;
--iRow;
bDisp = TRUE;
}
if( bDisp )
{
if( iLen )
szString[ iLen - 1 ] = ' ';
else
{
HB_GTSELF_SETPOS( pGT, iRow, iCol );
szString[ iLen++ ] = ' ';
}
}
break;
case HB_CHAR_LF:
iCol = 0;
if( iRow >= 0 ) ++iRow;
bDisp = TRUE;
bNewLine = TRUE;
break;
case HB_CHAR_CR:
iCol = 0;
if( *pText == HB_CHAR_LF )
{
if( iRow >= 0 ) ++iRow;
bNewLine = TRUE;
++pText;
--ulLength;
}
bDisp = TRUE;
break;
default:
++iCol;
if( iCol > iMaxCol || iCol <= 0 )
{
/* If the cursor position started off the left edge,
don't display the first character of the string */
if( iCol > 0 ) szString[ iLen++ ] = ch;
/* Always advance to the first column of the next row
when the right edge is reached or when the cursor
started off the left edge, unless the cursor is off
the top edge, in which case only change the column */
iCol = 0;
if( iRow >= 0 ) ++iRow;
bDisp = TRUE;
bNewLine = TRUE;
}
else
szString[ iLen++ ] = ch;
/* Special handling for a really wide screen or device */
if( iLen >= WRITECON_BUFFER_SIZE ) bDisp = TRUE;
}
if( bDisp || ulLength == 0 )
{
if( iLen )
HB_GTSELF_WRITE( pGT, szString, iLen );
iLen = 0;
if( iRow > iMaxRow )
{
/* Normal scroll */
HB_GTSELF_SCROLL( pGT, 0, 0, iMaxRow, iMaxCol, HB_GTSELF_GETCOLOR( pGT ),
HB_GTSELF_GETCLEARCHAR( pGT ), iRow - iMaxRow, 0 );
iRow = iMaxRow;
iCol = 0;
}
else if( iRow < 0 && bNewLine )
{
/* Special case scroll when newline
and cursor off top edge of display */
HB_GTSELF_SCROLL( pGT, 0, 0, iMaxRow, iMaxCol, HB_GTSELF_GETCOLOR( pGT ),
HB_GTSELF_GETCLEARCHAR( pGT ), 1, 0 );
}
HB_GTSELF_SETPOS( pGT, iRow, iCol );
bDisp = FALSE;
bNewLine = FALSE;
/* To emulate scrolling */
HB_GTSELF_FLUSH( pGT );
if( bBell )
{
HB_GTSELF_BELL( pGT );
bBell = FALSE;
}
}
}
}
| hbgtcore.c | 801 |
| STATIC LONG | hb_gt_def_RectSize( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
static long hb_gt_def_RectSize( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
{
int iRows, iCols;
iRows = iBottom - iTop + 1;
iCols = iRight - iLeft + 1;
if( iCols <= 0 || iRows <= 0 )
return 0;
else
return ( ( long ) iRows * iCols ) << ( pGT->fVgaCell ? 1 : 2 );
}
| hbgtcore.c | 940 |
| STATIC VOID | hb_gt_def_Save( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer )
static void hb_gt_def_Save( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE * pBuffer )
{
while( iTop <= iBottom )
{
BYTE bColor, bAttr;
USHORT usChar;
int iCol;
for( iCol = iLeft; iCol <= iRight; ++iCol )
{
if( !HB_GTSELF_GETCHAR( pGT, iTop, iCol, &bColor, &bAttr, &usChar ) )
{
usChar = HB_GTSELF_GETCLEARCHAR( pGT );
bColor = HB_GTSELF_GETCLEARCOLOR( pGT );
bAttr = 0x00;
}
if( pGT->fVgaCell )
{
*pBuffer++ = ( BYTE ) usChar;
*pBuffer++ = bColor;
}
else
{
HB_PUT_LE_UINT16( pBuffer, usChar );
pBuffer += 2;
*pBuffer++ = bColor;
*pBuffer++ = bAttr;
}
}
++iTop;
}
}
| hbgtcore.c | 953 |
| STATIC VOID | hb_gt_def_Rest( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer )
static void hb_gt_def_Rest( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE * pBuffer )
{
while( iTop <= iBottom )
{
BYTE bColor, bAttr;
USHORT usChar;
int iCol;
for( iCol = iLeft; iCol <= iRight; ++iCol )
{
if( pGT->fVgaCell )
{
usChar = *pBuffer++;
bColor = *pBuffer++;
bAttr = 0;
}
else
{
usChar = HB_GET_LE_UINT16( pBuffer );
pBuffer += 2;
bColor = *pBuffer++;
bAttr = *pBuffer++;
}
HB_GTSELF_PUTCHAR( pGT, iTop, iCol, bColor, bAttr, usChar );
}
++iTop;
}
}
| hbgtcore.c | 987 |
| STATIC VOID | hb_gt_def_SetAttribute( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor )
static void hb_gt_def_SetAttribute( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE bColor )
{
while( iTop <= iBottom )
{
BYTE bColorOld, bAttr;
USHORT usChar;
int iCol;
for( iCol = iLeft; iCol <= iRight; ++iCol )
{
if( !HB_GTSELF_GETCHAR( pGT, iTop, iCol, &bColorOld, &bAttr, &usChar ) )
break;
if( !HB_GTSELF_PUTCHAR( pGT, iTop, iCol, bColor, bAttr, usChar ) )
break;
}
++iTop;
}
}
| hbgtcore.c | 1017 |
| STATIC VOID | hb_gt_def_DrawShadow( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor )
static void hb_gt_def_DrawShadow( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE bColor )
{
int iMaxRow, iMaxCol, i;
if( iTop > iBottom )
{
i = iTop;
iTop = iBottom;
iBottom = i;
}
if( iLeft > iRight )
{
i = iLeft;
iLeft = iRight;
iRight = i;
}
iLeft += 2;
++iBottom;
iMaxRow = HB_GTSELF_MAXROW( pGT );
iMaxCol = HB_GTSELF_MAXCOL( pGT );
/* Draw the bottom edge */
if( iBottom <= iMaxRow && iLeft <= iMaxCol )
HB_GTSELF_SETATTRIBUTE( pGT, iBottom, iLeft, iBottom, HB_MIN( iRight, iMaxCol ), bColor );
++iRight;
++iTop;
/* Draw the right edge */
if( iTop <= iMaxRow && iRight <= iMaxCol )
HB_GTSELF_SETATTRIBUTE( pGT, iTop, iRight, iBottom, HB_MIN( iRight + 1, iMaxCol ), bColor );
}
| hbgtcore.c | 1037 |
| STATIC VOID | hb_gt_def_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols )
static void hb_gt_def_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE bColor, BYTE bChar, int iRows, int iCols )
{
int iColOld, iColNew, iColSize, iColClear, iClrs, iLength;
iColSize = iRight - iLeft;
iLength = iColSize + 1;
iColOld = iColNew = iLeft;
if( iCols >= 0 )
{
iColOld += iCols;
iColSize -= iCols;
iColClear = iColNew + iColSize + 1;
iClrs = iCols;
}
else
{
iColNew -= iCols;
iColSize += iCols;
iColClear = iColOld;
iClrs = -iCols;
}
if( iLength > 0 && iTop <= iBottom )
{
BYTE * pBuffer = NULL;
if( ( iRows || iCols ) && iColSize >= 0 && ( iBottom - iTop >= iRows ) )
{
ULONG ulSize = HB_GTSELF_RECTSIZE( pGT, iTop, iColOld, iTop, iColOld + iColSize );
if( ulSize )
pBuffer = ( BYTE * ) hb_xgrab( ulSize );
}
while( iTop <= iBottom )
{
int iRowPos;
if( iRows >= 0 )
iRowPos = iTop++;
else
iRowPos = iBottom--;
if( pBuffer && ( iRows == 0 ||
( iRowPos + iRows >= iTop && iRowPos + iRows <= iBottom ) ) )
{
HB_GTSELF_SAVE( pGT, iRowPos + iRows, iColOld, iRowPos + iRows, iColOld + iColSize, pBuffer );
HB_GTSELF_REST( pGT, iRowPos, iColNew, iRowPos, iColNew + iColSize, pBuffer );
if( iClrs )
HB_GTSELF_REPLICATE( pGT, iRowPos, iColClear, bColor, 0, bChar, iClrs );
}
else
HB_GTSELF_REPLICATE( pGT, iRowPos, iLeft, bColor, 0, bChar, iLength );
}
if( pBuffer )
hb_xfree( pBuffer );
}
}
| hbgtcore.c | 1073 |
| STATIC VOID | hb_gt_def_ScrollArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols )
static void hb_gt_def_ScrollArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE bColor, BYTE bChar, int iRows, int iCols )
{
if( iRows || iCols )
{
int iColNew, iColSize, iColClear, iClrs, iLength, iHeight, iWidth;
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
if( iTop < 0 )
iTop = 0;
if( iLeft < 0 )
iLeft = 0;
if( iBottom >= iHeight )
iBottom = iHeight -1;
if( iRight >= iWidth )
iRight = iWidth -1;
iColSize = iRight - iLeft;
iLength = iColSize + 1;
iColNew = iLeft;
if( iCols >= 0 )
{
iColSize -= iCols;
iColClear = iColNew + iColSize + 1;
iClrs = iCols;
}
else
{
iColClear = iColNew;
iColNew -= iCols;
iColSize += iCols;
iClrs = -iCols;
}
if( iLength > 0 )
{
long lIndex, lOffset = ( long ) iRows * iWidth + iCols;
BOOL fMove = ( iRows || iCols ) && iColSize >= 0 &&
( iBottom - iTop >= iRows );
while( iTop <= iBottom )
{
int iRowPos, i;
if( iRows >= 0 )
iRowPos = iTop++;
else
iRowPos = iBottom--;
if( fMove && ( iRows == 0 ||
( iRowPos + iRows >= iTop && iRowPos + iRows <= iBottom ) ) )
{
lIndex = ( long ) iRowPos * iWidth + iColNew;
if( lOffset < 0 )
{
for( i = 0; i <= iColSize; ++i, ++lIndex )
{
pGT->screenBuffer[ lIndex ].uiValue =
pGT->screenBuffer[ lIndex + lOffset ].uiValue;
pGT->prevBuffer[ lIndex ].uiValue =
pGT->prevBuffer[ lIndex + lOffset ].uiValue;
}
}
else
{
for( i = iColSize, lIndex += iColSize; i >= 0; --i, --lIndex )
{
pGT->screenBuffer[ lIndex ].uiValue =
pGT->screenBuffer[ lIndex + lOffset ].uiValue;
pGT->prevBuffer[ lIndex ].uiValue =
pGT->prevBuffer[ lIndex + lOffset ].uiValue;
}
}
if( iClrs )
HB_GTSELF_REPLICATE( pGT, iRowPos, iColClear, bColor, 0, bChar, iClrs );
}
else
HB_GTSELF_REPLICATE( pGT, iRowPos, iLeft, bColor, 0, bChar, iLength );
}
}
}
}
| hbgtcore.c | 1134 |
| STATIC VOID | hb_gt_def_ScrollUp( PHB_GT pGT, int iRows, BYTE bColor, BYTE bChar )
static void hb_gt_def_ScrollUp( PHB_GT pGT, int iRows, BYTE bColor, BYTE bChar )
{
if( iRows > 0 )
{
int i, j, iHeight, iWidth;
long lIndex = 0, lOffset;
BYTE bAttr = 0;
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
lOffset = ( long ) iRows * iWidth;
for( i = iRows; i < iHeight; ++i )
{
pGT->pLines[ i - iRows ] = pGT->pLines[ i ];
for( j = 0; j < iWidth; ++j )
{
pGT->screenBuffer[ lIndex ].uiValue =
pGT->screenBuffer[ lIndex + lOffset ].uiValue;
pGT->prevBuffer[ lIndex ].uiValue =
pGT->prevBuffer[ lIndex + lOffset ].uiValue;
++lIndex;
}
}
for( i = HB_MAX( 0, iHeight - iRows ); i < iHeight; ++i )
{
for( j = 0; j < iWidth; ++j )
{
pGT->screenBuffer[ lIndex ].c.usChar = bChar;
pGT->screenBuffer[ lIndex ].c.bColor = bColor;
pGT->screenBuffer[ lIndex ].c.bAttr = bAttr;
++lIndex;
}
pGT->pLines[ i ] = TRUE;
}
pGT->fRefresh = TRUE;
}
}
| hbgtcore.c | 1218 |
| STATIC VOID | hb_gt_def_Box( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor )
static void hb_gt_def_Box( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE * pbyFrame, BYTE bColor )
{
int iMaxRow, iMaxCol, iRows, iCols, iFirst, i;
if( iTop > iBottom )
{
i = iTop;
iTop = iBottom;
iBottom = i;
}
if( iLeft > iRight )
{
i = iLeft;
iLeft = iRight;
iRight = i;
}
iMaxRow = HB_GTSELF_MAXROW( pGT ), iMaxCol = HB_GTSELF_MAXCOL( pGT );
if( iTop <= iMaxRow && iLeft <= iMaxCol && iBottom >= 0 && iRight >= 0 )
{
BYTE szBox[ 10 ];
BYTE bPadCh = HB_GTSELF_GETCLEARCHAR( pGT );
if( pbyFrame )
{
for( i = 0; *pbyFrame && i < 9; ++i )
bPadCh = szBox[ i ] = *pbyFrame++;
}
else
i = 0;
while( i < 8 )
szBox[ i++ ] = bPadCh;
szBox[ i ] = '\0';
if( iTop == iBottom )
HB_GTSELF_HORIZLINE( pGT, iTop, iLeft, iRight, szBox[ 1 ], bColor );
else if( iLeft == iRight )
HB_GTSELF_VERTLINE( pGT, iLeft, iTop, iBottom, szBox[ 3 ], bColor );
else
{
BYTE bAttr = HB_GT_ATTR_BOX;
iRows = ( iBottom > iMaxRow ? iMaxRow + 1 : iBottom ) -
( iTop < 0 ? -1 : iTop ) - 1;
iCols = ( iRight > iMaxCol ? iMaxCol + 1 : iRight ) -
( iLeft < 0 ? -1 : iLeft ) - 1;
iFirst = iLeft < 0 ? 0 : iLeft + 1;
if( iTop >= 0 )
{
if( iLeft >= 0 )
HB_GTSELF_PUTCHAR( pGT, iTop, iLeft, bColor, bAttr, szBox[ 0 ] );
if( iCols )
HB_GTSELF_REPLICATE( pGT, iTop, iFirst, bColor, bAttr, szBox[ 1 ], iCols );
if( iRight <= iMaxCol )
HB_GTSELF_PUTCHAR( pGT, iTop, iFirst + iCols, bColor, bAttr, szBox[ 2 ] );
iTop++;
}
else
iTop = 0;
for( i = 0; i < iRows; ++i )
{
if( iLeft >= 0 )
HB_GTSELF_PUTCHAR( pGT, iTop + i, iLeft, bColor, bAttr, szBox[ 7 ] );
if( iCols && szBox[ 8 ] )
HB_GTSELF_REPLICATE( pGT, iTop + i, iFirst, bColor, bAttr, szBox[ 8 ], iCols );
if( iRight <= iMaxCol )
HB_GTSELF_PUTCHAR( pGT, iTop + i, iFirst + iCols, bColor, bAttr, szBox[ 3 ] );
}
if( iBottom <= iMaxRow )
{
if( iLeft >= 0 )
HB_GTSELF_PUTCHAR( pGT, iBottom, iLeft, bColor, bAttr, szBox[ 6 ] );
if( iCols )
HB_GTSELF_REPLICATE( pGT, iBottom, iFirst, bColor, bAttr, szBox[ 5 ], iCols );
if( iRight <= iMaxCol )
HB_GTSELF_PUTCHAR( pGT, iBottom, iFirst + iCols, bColor, bAttr, szBox[ 4 ] );
}
}
}
}
| hbgtcore.c | 1255 |
| STATIC VOID | hb_gt_def_BoxS( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor )
static void hb_gt_def_BoxS( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE * pbyFrame, BYTE bColor )
{
HB_GTSELF_BOX( pGT, iTop, iLeft, iBottom, iRight,
pbyFrame ? pbyFrame : ( BYTE * ) _B_SINGLE, bColor );
}
| hbgtcore.c | 1338 |
| STATIC VOID | hb_gt_def_BoxD( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor )
static void hb_gt_def_BoxD( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
BYTE * pbyFrame, BYTE bColor )
{
HB_GTSELF_BOX( pGT, iTop, iLeft, iBottom, iRight,
pbyFrame ? pbyFrame : ( BYTE * ) _B_DOUBLE, bColor );
}
| hbgtcore.c | 1345 |
| STATIC VOID | hb_gt_def_HorizLine( PHB_GT pGT, int iRow, int iLeft, int iRight, BYTE bChar, BYTE bColor )
static void hb_gt_def_HorizLine( PHB_GT pGT, int iRow, int iLeft, int iRight,
BYTE bChar, BYTE bColor )
{
int iLength, iCol;
if( iLeft <= iRight )
{
iLength = iRight - iLeft + 1;
iCol = iLeft;
}
else
{
iLength = iLeft - iRight + 1;
iCol = iRight;
}
HB_GTSELF_REPLICATE( pGT, iRow, iCol, bColor, HB_GT_ATTR_BOX, bChar, iLength );
}
| hbgtcore.c | 1352 |
| STATIC VOID | hb_gt_def_VertLine( PHB_GT pGT, int iCol, int iTop, int iBottom, BYTE bChar, BYTE bColor )
static void hb_gt_def_VertLine( PHB_GT pGT, int iCol, int iTop, int iBottom,
BYTE bChar, BYTE bColor )
{
int iLength, iRow;
if( iTop <= iBottom )
{
iLength = iBottom - iTop + 1;
iRow = iTop;
}
else
{
iLength = iTop - iBottom + 1;
iRow = iBottom;
}
if( iRow < 0 )
{
iLength += iRow;
iRow = 0;
}
while( --iLength >= 0 )
{
if( !HB_GTSELF_PUTCHAR( pGT, iRow, iCol, bColor, HB_GT_ATTR_BOX, bChar ) )
break;
++iRow;
}
}
| hbgtcore.c | 1371 |
| STATIC BOOL | hb_gt_def_SetDispCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP, BOOL fBox )
static BOOL hb_gt_def_SetDispCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP, BOOL fBox )
{
#ifndef HB_CDP_SUPPORT_OFF
if( !pszHostCDP )
pszHostCDP = hb_cdpID();
if( !pszTermCDP )
pszTermCDP = pszHostCDP;
if( pszTermCDP && pszHostCDP )
{
pGT->cdpTerm = hb_cdpFind( pszTermCDP );
pGT->cdpHost = hb_cdpFind( pszHostCDP );
pGT->fDispTrans = pGT->cdpTerm && pGT->cdpHost &&
pGT->cdpTerm != pGT->cdpHost;
return TRUE;
}
#else
HB_SYMBOL_UNUSED( pszTermCDP );
HB_SYMBOL_UNUSED( pszHostCDP );
#endif
HB_SYMBOL_UNUSED( fBox );
return FALSE;
}
| hbgtcore.c | 1401 |
| STATIC BOOL | hb_gt_def_SetKeyCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP )
static BOOL hb_gt_def_SetKeyCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( pszTermCDP );
HB_SYMBOL_UNUSED( pszHostCDP );
return FALSE;
}
| hbgtcore.c | 1426 |
| STATIC BOOL | hb_gt_def_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo )
static BOOL hb_gt_def_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo )
{
switch( iType )
{
case HB_GTI_ISGRAPHIC:
case HB_GTI_FULLSCREEN:
case HB_GTI_KBDSUPPORT:
case HB_GTI_ISCTWIN:
case HB_GTI_ISMULTIWIN:
case HB_GTI_ISUNICODE:
pInfo->pResult = hb_itemPutL( pInfo->pResult, FALSE );
break;
case HB_GTI_INPUTFD:
pInfo->pResult = hb_itemPutNInt( pInfo->pResult, ( HB_NHANDLE ) pGT->hStdIn );
break;
case HB_GTI_OUTPUTFD:
pInfo->pResult = hb_itemPutNInt( pInfo->pResult, ( HB_NHANDLE ) pGT->hStdOut );
break;
case HB_GTI_ERRORFD:
pInfo->pResult = hb_itemPutNInt( pInfo->pResult, ( HB_NHANDLE ) pGT->hStdErr );
break;
case HB_GTI_COMPATBUFFER:
pInfo->pResult = hb_itemPutL( pInfo->pResult, pGT->fVgaCell );
if( hb_itemType( pInfo->pNewVal ) & HB_IT_LOGICAL )
pGT->fVgaCell = hb_itemGetL( pInfo->pNewVal );
break;
case HB_GTI_VIEWMAXWIDTH:
pInfo->pResult = hb_itemPutNInt( pInfo->pResult, HB_GTSELF_MAXCOL( pGT ) );
break;
case HB_GTI_VIEWMAXHEIGHT:
pInfo->pResult = hb_itemPutNInt( pInfo->pResult, HB_GTSELF_MAXROW( pGT ) );
break;
case HB_GTI_NEWWIN: /* clear screen area, set default cursor shape and position */
{
/* Clear screen */
HB_GTSELF_DISPBEGIN( pGT );
HB_GTSELF_SCROLL( pGT, 0, 0, HB_GTSELF_MAXROW( pGT ), HB_GTSELF_MAXCOL( pGT ),
HB_GTSELF_GETCOLOR( pGT ), HB_GTSELF_GETCLEARCHAR( pGT ), 0, 0 );
HB_GTSELF_SETPOS( pGT, 0, 0 );
HB_GTSELF_SETCURSORSTYLE( pGT, SC_NORMAL );
HB_GTSELF_DISPEND( pGT );
HB_GTSELF_FLUSH( pGT );
/* no break; */
}
case HB_GTI_GETWIN: /* save screen buffer, cursor shape and possition */
{
int iRow, iCol;
ULONG ulSize;
if( !pInfo->pResult )
pInfo->pResult = hb_itemNew( NULL );
hb_arrayNew( pInfo->pResult, 8 );
HB_GTSELF_GETPOS( pGT, &iRow, &iCol );
hb_arraySetNI( pInfo->pResult, 1, iRow );
hb_arraySetNI( pInfo->pResult, 2, iCol );
hb_arraySetNI( pInfo->pResult, 3, HB_GTSELF_GETCURSORSTYLE( pGT ) );
hb_arraySetC ( pInfo->pResult, 4, hb_conSetColor( NULL ) );
iRow = HB_GTSELF_MAXROW( pGT );
iCol = HB_GTSELF_MAXCOL( pGT );
hb_arraySetNI( pInfo->pResult, 5, iRow );
hb_arraySetNI( pInfo->pResult, 6, iCol );
ulSize = HB_GTSELF_RECTSIZE( pGT, 0, 0, iRow, iCol );
if( ulSize )
{
BYTE * pBuffer = ( BYTE * ) hb_xgrab( ulSize + 1 );
HB_GTSELF_SAVE( pGT, 0, 0, iRow, iCol, pBuffer );
hb_arraySetCPtr( pInfo->pResult, 7, ( char * ) pBuffer, ulSize );
}
break;
}
case HB_GTI_SETWIN: /* restore screen buffer, cursor shape and possition */
if( hb_arrayLen( pInfo->pNewVal ) == 8 )
{
HB_GTSELF_DISPBEGIN( pGT );
if( hb_arrayGetCLen( pInfo->pNewVal, 7 ) > 0 )
{
HB_GTSELF_REST( pGT, 0, 0, hb_arrayGetNI( pInfo->pNewVal, 5 ),
hb_arrayGetNI( pInfo->pNewVal, 6 ),
( BYTE * ) hb_arrayGetCPtr( pInfo->pNewVal, 7 ) );
}
HB_GTSELF_SETPOS( pGT, hb_arrayGetNI( pInfo->pNewVal, 1 ),
hb_arrayGetNI( pInfo->pNewVal, 2 ) );
HB_GTSELF_SETCURSORSTYLE( pGT, hb_arrayGetNI( pInfo->pNewVal, 3 ) );
hb_conSetColor( hb_arrayGetCPtr( pInfo->pNewVal, 4 ) );
HB_GTSELF_DISPEND( pGT );
HB_GTSELF_FLUSH( pGT );
}
break;
case HB_GTI_CLIPBOARDDATA:
if( hb_itemType( pInfo->pNewVal ) & HB_IT_STRING )
{
/* set new Clipboard value */
hb_gt_setClipboard( hb_itemGetCPtr( pInfo->pNewVal ),
hb_itemGetCLen( pInfo->pNewVal ) );
}
else
{
/* get Clipboard value */
char * pszClipData;
ULONG ulLen;
if( hb_gt_getClipboard( &pszClipData, &ulLen ) )
pInfo->pResult = hb_itemPutCLPtr( pInfo->pResult, pszClipData, ulLen );
else
pInfo->pResult = hb_itemPutC( pInfo->pResult, NULL );
}
break;
case HB_GTI_NOTIFIERBLOCK:
if( pGT->pNotifierBlock )
{
hb_itemRelease( pGT->pNotifierBlock );
pGT->pNotifierBlock = NULL;
}
if( hb_itemType( pInfo->pNewVal ) & HB_IT_BLOCK )
pGT->pNotifierBlock = hb_itemNew( pInfo->pNewVal );
break;
default:
return FALSE;
}
return TRUE;
}
| hbgtcore.c | 1435 |
| STATIC INT | hb_gt_def_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions, int iClrNorm, int iClrHigh, double dDelay )
static int hb_gt_def_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions,
int iClrNorm, int iClrHigh, double dDelay )
{
int iOptions = ( int ) hb_arrayLen( pOptions );
int iRet = 0;
if( HB_IS_STRING( pMessage ) && iOptions > 0 )
{
char * szMessage = hb_itemGetCPtr( pMessage );
ULONG ulLen = hb_itemGetCLen( pMessage );
BOOL fScreen = FALSE, fKeyBoard = FALSE;
int iKey = 0, i, iDspCount, iStyle, iRows, iCols,
iRow, iCol, iTop, iLeft, iBottom, iRight, iMnuCol, iPos, iClr;
BYTE * pBuffer = NULL;
HB_GT_INFO gtInfo;
gtInfo.pNewVal = gtInfo.pResult = NULL;
HB_GTSELF_INFO( pGT, HB_GTI_FULLSCREEN, >Info );
if( gtInfo.pResult )
{
fScreen = hb_itemGetL( gtInfo.pResult );
}
HB_GTSELF_INFO( pGT, HB_GTI_KBDSUPPORT, >Info );
if( gtInfo.pResult )
{
fKeyBoard = hb_itemGetL( gtInfo.pResult );
hb_itemRelease( gtInfo.pResult );
}
HB_GTSELF_GETSIZE( pGT, &iRows, &iCols );
if( iCols <= 4 || iRows <= 4 )
fScreen = FALSE;
if( fScreen )
{
ULONG ulLines = 0, ulWidth = 0, ulCurrWidth = 0, ul = 0, ulDst = 0,
ulLast = 0, ulSpace1 = 0, ulSpace2 = 0, ulDefWidth, ulMaxWidth;
char * szMsgDsp;
ulMaxWidth = iCols - 4;
ulDefWidth = ( ulMaxWidth * 3 ) >> 2;
if( ulDefWidth == 0 )
ulDefWidth = 1;
szMsgDsp = ( char * ) hb_xgrab( ulLen + ( ulLen / ulDefWidth ) + 1 );
while( ul < ulLen )
{
if( szMessage[ ul ] == '\n' )
{
if( ulCurrWidth > ulMaxWidth )
{
ulDst = ulLast;
}
else
{
++ulLines;
if( ulCurrWidth > ulWidth )
ulWidth = ulCurrWidth;
ulCurrWidth = ulSpace1 = ulSpace2 = 0;
szMsgDsp[ ulDst++ ] = '\n';
ulLast = ulDst;
}
}
else
{
if( szMessage[ ul ] == ' ' )
{
if( ulCurrWidth <= ulDefWidth )
ulSpace1 = ul;
else if( ulCurrWidth <= ulMaxWidth && !ulSpace2 )
ulSpace2 = ul;
}
szMsgDsp[ ulDst++ ] = szMessage[ ul ];
++ulCurrWidth;
if( ulCurrWidth > ulDefWidth && ulSpace1 )
{
ulCurrWidth -= ul - ulSpace1 + 1;
ulDst -= ul - ulSpace1 + 1;
ul = ulSpace1;
++ulLines;
if( ulCurrWidth > ulWidth )
ulWidth = ulCurrWidth;
ulCurrWidth = ulSpace1 = ulSpace2 = 0;
szMsgDsp[ ulDst++ ] = '\n';
ulLast = ulDst;
}
else if( ulCurrWidth > ulMaxWidth )
{
if( ulSpace2 )
{
ulCurrWidth -= ul - ulSpace2 + 1;
ulDst -= ul - ulSpace2 + 1;
ul = ulSpace2;
++ulLines;
if( ulCurrWidth > ulWidth )
ulWidth = ulCurrWidth;
ulCurrWidth = ulSpace1 = ulSpace2 = 0;
szMsgDsp[ ulDst++ ] = '\n';
ulLast = ulDst;
}
#ifndef HB_C52_STRICT
else
{
ulCurrWidth--;
ulDst--;
ul--;
szMsgDsp[ ulDst++ ] = '\n';
ulLast = ulDst;
++ulLines;
if( ulCurrWidth > ulWidth )
ulWidth = ulCurrWidth;
ulCurrWidth = ulSpace1 = ulSpace2 = 0;
}
#endif
}
}
++ul;
}
ulLines++;
if( ulCurrWidth > ulWidth )
ulWidth = ulCurrWidth;
if( ulLines == 1 && ulWidth < ulDefWidth )
ulWidth += HB_MIN( 4, ulDefWidth - ulWidth );
ulCurrWidth = 0;
for( i = 1; i <= iOptions; ++i )
{
ulCurrWidth += hb_arrayGetCLen( pOptions, i ) + 4;
}
if( ulCurrWidth > ulMaxWidth )
ulCurrWidth = ulMaxWidth;
if( ulCurrWidth > ulWidth )
ulWidth = ulCurrWidth;
if( ( ULONG ) iRows < ulLines + 4 )
ulLines = iRows - 4;
iTop = ( iRows - ulLines - 4 ) >> 1;
iLeft = ( iCols - ulWidth - 4 ) >> 1;
iBottom = iTop + ulLines + 3;
iRight = iLeft + ulWidth + 3;
if( iClrNorm == 0 )
iClrNorm = 0x4F;
if( iClrHigh == 0 )
iClrHigh = 0x1F;
iDspCount = HB_GTSELF_DISPCOUNT( pGT );
if( iDspCount == 0 )
HB_GTSELF_DISPBEGIN( pGT );
HB_GTSELF_GETPOS( pGT, &iRow, &iCol );
iStyle = HB_GTSELF_GETCURSORSTYLE( pGT );
HB_GTSELF_SETCURSORSTYLE( pGT, SC_NONE );
ulLen = HB_GTSELF_RECTSIZE( pGT, iTop, iLeft, iBottom, iRight );
if( ulLen )
{
pBuffer = ( BYTE * ) hb_xgrab( ulLen );
HB_GTSELF_SAVE( pGT, iTop, iLeft, iBottom, iRight, pBuffer );
}
HB_GTSELF_BOXS( pGT, iTop, iLeft, iBottom, iRight, NULL, iClrNorm );
HB_GTSELF_BOXS( pGT, iTop + 1, iLeft + 1, iBottom - 1, iRight - 1, ( BYTE * ) " ", iClrNorm );
ulLast = 0;
i = iTop + 1;
for( ul = 0; ul < ulDst; ++ul )
{
if( szMsgDsp[ ul ] == '\n' )
{
if( ul > ulLast )
{
ulLen = ul - ulLast;
if( ulLen > ulWidth )
ulLen = ulWidth;
HB_GTSELF_PUTTEXT( pGT, i, iLeft + ( ( ulWidth - ulLen + 1 ) >> 1 ) + 2,
iClrNorm, ( BYTE * ) szMsgDsp + ulLast, ulLen );
}
ulLast = ul + 1;
if( ++i >= iBottom - 1 )
break;
}
}
if( ul > ulLast && i < iBottom - 1 )
{
ulLen = ul - ulLast;
if( ulLen > ulWidth )
ulLen = ulWidth;
HB_GTSELF_PUTTEXT( pGT, i, iLeft + ( ( ulWidth - ulLen + 1 ) >> 1 ) + 2,
iClrNorm, ( BYTE * ) szMsgDsp + ulLast, ulLen );
}
iPos = 1;
while( iRet == 0 )
{
HB_GTSELF_DISPBEGIN( pGT );
iMnuCol = iLeft + ( ( ulWidth - ulCurrWidth ) >> 1 ) + 3;
for( i = 1; i <= iOptions; ++i )
{
iClr = i == iPos ? iClrHigh : iClrNorm;
ulLen = hb_arrayGetCLen( pOptions, i );
HB_GTSELF_PUTTEXT( pGT, iBottom - 1, iMnuCol, iClr, ( BYTE * ) " ", 1 );
HB_GTSELF_PUTTEXT( pGT, iBottom - 1, iMnuCol + 1, iClr,
( BYTE * ) hb_arrayGetCPtr( pOptions, i ), ulLen );
HB_GTSELF_PUTTEXT( pGT, iBottom - 1, iMnuCol + 1 + ulLen, iClr, ( BYTE * ) " ", 1 );
iMnuCol += ulLen + 4;
}
while( HB_GTSELF_DISPCOUNT( pGT ) )
HB_GTSELF_DISPEND( pGT );
HB_GTSELF_REFRESH( pGT );
iKey = fKeyBoard ? HB_GTSELF_INKEYGET( pGT, TRUE, dDelay, INKEY_ALL ) : 0;
if( iKey == K_ESC )
break;
else if( iKey == K_ENTER || iKey == K_SPACE || iKey == 0 )
{
iRet = iPos;
}
else if( iKey == K_LEFT || iKey == K_SH_TAB )
{
if( --iPos == 0 )
iPos = iOptions;
dDelay = 0.0;
}
else if( iKey == K_RIGHT || iKey == K_TAB )
{
if( ++iPos > iOptions )
iPos = 1;
dDelay = 0.0;
}
#ifdef HB_COMPAT_C53
else if( iKey == K_LBUTTONDOWN )
{
int iMRow, iMCol;
HB_GTSELF_MOUSEGETPOS( pGT, &iMRow, &iMCol );
if( iMRow == iBottom - 1 )
{
iMnuCol = iLeft + ( ( ulWidth - ulCurrWidth ) >> 1 ) + 4;
for( i = 1; i <= iOptions; ++i )
{
ulLen = hb_arrayGetCLen( pOptions, i );
if( iMCol >= iMnuCol && iMCol < iMnuCol + ( int ) ulLen )
{
iRet = i;
break;
}
iMnuCol += ulLen + 4;
}
}
}
#endif
else if( iKey >= 32 && iKey <= 255 )
{
int iUp = hb_charUpper( iKey );
for( i = 1; i <= iOptions; ++i )
{
char *szValue = hb_arrayGetCPtr( pOptions, i );
if( szValue && iUp == hb_charUpper( *szValue ) )
{
iRet = i;
break;
}
}
}
}
hb_xfree( szMsgDsp );
if( pBuffer )
{
HB_GTSELF_REST( pGT, iTop, iLeft, iBottom, iRight, pBuffer );
hb_xfree( pBuffer );
}
HB_GTSELF_SETPOS( pGT, iRow, iCol );
HB_GTSELF_SETCURSORSTYLE( pGT, iStyle );
HB_GTSELF_REFRESH( pGT );
while( HB_GTSELF_DISPCOUNT( pGT ) < iDspCount )
HB_GTSELF_DISPBEGIN( pGT );
}
else
{
ULONG ul, ulStart = 0;
char *szEol = hb_conNewLine();
for( ul = 0; ul < ulLen; ++ul )
{
if( szMessage[ ul ] == '\n' )
{
if( ul > ulStart )
HB_GTSELF_WRITECON( pGT, ( BYTE * ) szMessage + ulStart, ul - ulStart );
HB_GTSELF_WRITECON( pGT, ( BYTE * ) szEol, strlen( szEol ) );
ulStart = ul + 1;
}
}
if( ul > ulStart )
HB_GTSELF_WRITECON( pGT, ( BYTE * ) szMessage + ulStart, ul - ulStart );
HB_GTSELF_WRITECON( pGT, ( BYTE * ) " (", 2 );
for( i = 1; i <= iOptions; ++i )
{
if( i > 1 )
HB_GTSELF_WRITECON( pGT, ( BYTE * ) ", ", 2 );
HB_GTSELF_WRITECON( pGT, ( BYTE * ) hb_arrayGetCPtr( pOptions, i ),
hb_arrayGetCLen( pOptions, i ) );
}
HB_GTSELF_WRITECON( pGT, ( BYTE * ) ") ", 2 );
while( iRet == 0 )
{
iKey = fKeyBoard ? HB_GTSELF_INKEYGET( pGT, TRUE, dDelay, INKEY_ALL ) : 0;
if( iKey == 0 )
iRet = 1;
else if( iKey == K_ESC )
break;
else if( iKey >= 32 && iKey <= 255 )
{
int iUp = hb_charUpper( iKey );
for( i = 1; i <= iOptions; ++i )
{
char *szValue = hb_arrayGetCPtr( pOptions, i );
if( szValue && iUp == hb_charUpper( *szValue ) )
{
iRet = i;
break;
}
}
}
}
if( iKey >= 32 && iKey <= 255 )
{
char szVal[2];
szVal[ 0 ] = ( char ) iKey;
szVal[ 1 ] = '\0';
HB_GTSELF_WRITECON( pGT, ( BYTE * ) szVal, 1 );
}
}
}
return iRet;
}
| hbgtcore.c | 1570 |
| STATIC INT | hb_gt_def_SetFlag( PHB_GT pGT, int iType, int iNewValue )
static int hb_gt_def_SetFlag( PHB_GT pGT, int iType, int iNewValue )
{
int iPrevValue = 0;
switch( iType )
{
case HB_GTI_COMPATBUFFER:
iPrevValue = pGT->fVgaCell;
pGT->fVgaCell = iNewValue != 0;
break;
case HB_GTI_STDOUTCON:
iPrevValue = pGT->fStdOutCon;
pGT->fStdOutCon = iNewValue != 0;
break;
case HB_GTI_STDERRCON:
iPrevValue = pGT->fStdErrCon;
pGT->fStdErrCon = iNewValue != 0;
break;
}
return iPrevValue;
}
| hbgtcore.c | 1903 |
| STATIC BOOL | hb_gt_def_SetMode( PHB_GT pGT, int iRows, int iCols )
static BOOL hb_gt_def_SetMode( PHB_GT pGT, int iRows, int iCols )
{
return HB_GTSELF_RESIZE( pGT, iRows, iCols );
}
| hbgtcore.c | 1928 |
| STATIC BOOL | hb_gt_def_Resize( PHB_GT pGT, int iRows, int iCols )
static BOOL hb_gt_def_Resize( PHB_GT pGT, int iRows, int iCols )
{
if( iRows > 0 && iCols > 0 && pGT->screenBuffer )
{
if( pGT->iHeight != iRows || pGT->iWidth != iCols )
{
BYTE * pBuffer = NULL;
ULONG ulLen = ( ULONG ) iRows * iCols, ulIndex;
ULONG ulSize;
int i;
ulSize = HB_GTSELF_RECTSIZE( pGT, 0, 0, iRows - 1, iCols - 1 );
if( ulSize )
{
pBuffer = ( BYTE * ) hb_xgrab( ulSize );
HB_GTSELF_SAVE( pGT, 0, 0, iRows - 1, iCols - 1, pBuffer );
}
pGT->screenBuffer =
( PHB_SCREENCELL ) hb_xrealloc( pGT->screenBuffer,
sizeof( HB_SCREENCELL ) * ulLen );
pGT->prevBuffer =
( PHB_SCREENCELL ) hb_xrealloc( pGT->prevBuffer,
sizeof( HB_SCREENCELL ) * ulLen );
pGT->pLines = ( BOOL * ) hb_xrealloc( pGT->pLines,
sizeof( BOOL ) * iRows );
memset( pGT->screenBuffer, 0, sizeof( HB_SCREENCELL ) * ulLen );
memset( pGT->prevBuffer, 0, sizeof( HB_SCREENCELL ) * ulLen );
for( i = 0; i < iRows; ++i )
pGT->pLines[ i ] = TRUE;
for( ulIndex = 0; ulIndex < ulLen; ++ulIndex )
{
pGT->screenBuffer[ ulIndex ].c.usChar = HB_GTSELF_GETCLEARCHAR( pGT );
pGT->screenBuffer[ ulIndex ].c.bColor = HB_GTSELF_GETCLEARCOLOR( pGT );
pGT->screenBuffer[ ulIndex ].c.bAttr = 0x00;
pGT->prevBuffer[ ulIndex ].c.bAttr = HB_GT_ATTR_REFRESH;
}
pGT->iHeight = iRows;
pGT->iWidth = iCols;
if( pGT->iRow >= pGT->iHeight )
pGT->iRow = pGT->iHeight - 1;
if( pGT->iCol >= pGT->iWidth )
pGT->iCol = pGT->iWidth - 1;
pGT->fRefresh = TRUE;
if( ulSize )
{
HB_GTSELF_REST( pGT, 0, 0, iRows - 1, iCols - 1, pBuffer );
hb_xfree( pBuffer );
}
}
return TRUE;
}
return FALSE;
}
| hbgtcore.c | 1933 |
| STATIC VOID | hb_gt_def_GetSize( PHB_GT pGT, int * piRows, int * piCols )
static void hb_gt_def_GetSize( PHB_GT pGT, int * piRows, int * piCols )
{
*piRows = pGT->iHeight;
*piCols = pGT->iWidth;
}
| hbgtcore.c | 1995 |
| STATIC VOID | hb_gt_def_SemiCold( PHB_GT pGT )
static void hb_gt_def_SemiCold( PHB_GT pGT )
{
int i;
for( i = 0; i < pGT->iHeight; ++i )
pGT->pLines[ i ] = FALSE;
pGT->fRefresh = FALSE;
}
| hbgtcore.c | 2001 |
| STATIC VOID | hb_gt_def_ColdArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
static void hb_gt_def_ColdArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
{
long lIndex;
int i;
if( iTop > iBottom )
{
i = iTop;
iTop = iBottom;
iBottom = i;
}
if( iLeft > iRight )
{
i = iLeft;
iLeft = iRight;
iRight = i;
}
while( iTop <= iBottom )
{
for( i = iLeft; i <= iRight; ++i )
{
if( HB_GTSELF_CHECKPOS( pGT, iTop, i, &lIndex ) )
{
pGT->screenBuffer[ lIndex ].c.bAttr &= ~HB_GT_ATTR_REFRESH;
pGT->prevBuffer[ lIndex ].uiValue = pGT->screenBuffer[ lIndex ].uiValue;
}
}
if( iLeft == 0 && iRight == pGT->iWidth - 1 )
pGT->pLines[ iTop ] = FALSE;
++iTop;
}
}
| hbgtcore.c | 2009 |
| STATIC VOID | hb_gt_def_ExposeArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
static void hb_gt_def_ExposeArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
{
long lIndex;
int i;
if( iTop > iBottom )
{
i = iTop;
iTop = iBottom;
iBottom = i;
}
if( iLeft > iRight )
{
i = iLeft;
iLeft = iRight;
iRight = i;
}
while( iTop <= iBottom )
{
for( i = iLeft; i <= iRight; ++i )
{
if( HB_GTSELF_CHECKPOS( pGT, iTop, i, &lIndex ) )
{
pGT->prevBuffer[ lIndex ].c.bAttr = HB_GT_ATTR_REFRESH;
pGT->pLines[ iTop ] = TRUE;
pGT->fRefresh = TRUE;
}
}
++iTop;
}
}
| hbgtcore.c | 2042 |
| STATIC VOID | hb_gt_def_TouchCell( PHB_GT pGT, int iRow, int iCol )
static void hb_gt_def_TouchCell( PHB_GT pGT, int iRow, int iCol )
{
long lIndex;
if( HB_GTSELF_CHECKPOS( pGT, iRow, iCol, &lIndex ) )
{
pGT->prevBuffer[ lIndex ].c.bAttr = HB_GT_ATTR_REFRESH;
pGT->pLines[ iRow ] = TRUE;
pGT->fRefresh = TRUE;
}
}
| hbgtcore.c | 2074 |
| STATIC VOID | hb_gt_def_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
static void hb_gt_def_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iRow );
HB_SYMBOL_UNUSED( iCol );
HB_SYMBOL_UNUSED( iSize );
}
| hbgtcore.c | 2086 |
| STATIC VOID | hb_gt_def_Refresh( PHB_GT pGT )
static void hb_gt_def_Refresh( PHB_GT pGT )
{
if( pGT->fRefresh )
{
int i, l, r;
long lIndex;
for( i = 0; i < pGT->iHeight; ++i )
{
if( pGT->pLines[ i ] )
{
lIndex = ( long ) i * pGT->iWidth;
for( l = 0; l < pGT->iWidth; ++l, ++lIndex )
{
if( pGT->prevBuffer[ lIndex ].uiValue !=
pGT->screenBuffer[ lIndex ].uiValue )
break;
}
if( l < pGT->iWidth )
{
lIndex = ( long ) ( i + 1 ) * pGT->iWidth - 1;
for( r = pGT->iWidth - 1; r > l; --r, --lIndex )
{
if( pGT->prevBuffer[ lIndex ].uiValue !=
pGT->screenBuffer[ lIndex ].uiValue )
break;
}
HB_GTSELF_REDRAW( pGT, i, l, r - l + 1 );
lIndex = ( long ) i * pGT->iWidth + l;
do
{
pGT->prevBuffer[ lIndex ].uiValue =
pGT->screenBuffer[ lIndex ].uiValue;
++lIndex;
}
while( ++l <= r );
}
pGT->pLines[ i ] = FALSE;
}
}
pGT->fRefresh = FALSE;
}
}
| hbgtcore.c | 2094 |
| STATIC VOID | hb_gt_def_Flush( PHB_GT pGT )
static void hb_gt_def_Flush( PHB_GT pGT )
{
if( HB_GTSELF_DISPCOUNT( pGT ) == 0 )
HB_GTSELF_REFRESH( pGT );
}
| hbgtcore.c | 2138 |
| STATIC INT | hb_gt_def_ReadKey( PHB_GT pGT, int iEventMask )
static int hb_gt_def_ReadKey( PHB_GT pGT, int iEventMask )
{
return HB_GTSELF_MOUSEREADKEY( pGT, iEventMask );
}
| hbgtcore.c | 2144 |
| STATIC INT | hb_gt_def_InkeyFilter( PHB_GT pGT, int iKey, int iEventMask )
static int hb_gt_def_InkeyFilter( PHB_GT pGT, int iKey, int iEventMask )
{
int iMask;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyFilter(%p,%d,%d)", pGT, iKey, iEventMask));
HB_SYMBOL_UNUSED( pGT );
switch( iKey )
{
case K_MOUSEMOVE:
case K_MMLEFTDOWN:
case K_MMRIGHTDOWN:
case K_MMMIDDLEDOWN:
case K_NCMOUSEMOVE:
iMask = INKEY_MOVE;
break;
case K_LBUTTONDOWN:
case K_LDBLCLK:
iMask = INKEY_LDOWN;
break;
case K_LBUTTONUP:
iMask = INKEY_LUP;
break;
case K_RBUTTONDOWN:
case K_RDBLCLK:
iMask = INKEY_RDOWN;
break;
case K_RBUTTONUP:
iMask = INKEY_RUP;
break;
case K_MBUTTONDOWN:
case K_MBUTTONUP:
case K_MDBLCLK:
iMask = INKEY_MMIDDLE;
break;
case K_MWFORWARD:
case K_MWBACKWARD:
iMask = INKEY_MWHEEL;
break;
default:
iMask = INKEY_KEYBOARD;
break;
}
if( ( iMask & iEventMask ) == 0 )
return 0;
return iKey;
}
| hbgtcore.c | 2149 |
| STATIC VOID | hb_gt_def_InkeyPop( PHB_GT pGT )
static void hb_gt_def_InkeyPop( PHB_GT pGT )
{
if( pGT->StrBuffer )
{
if( ++pGT->StrBufferPos >= pGT->StrBufferSize )
{
hb_xfree( pGT->StrBuffer );
pGT->StrBuffer = NULL;
}
}
else if( pGT->inkeyHead != pGT->inkeyTail )
{
if( ++pGT->inkeyTail >= pGT->inkeyBufferSize )
pGT->inkeyTail = 0;
}
}
| hbgtcore.c | 2201 |
| STATIC VOID | hb_gt_def_InkeyPut( PHB_GT pGT, int iKey )
static void hb_gt_def_InkeyPut( PHB_GT pGT, int iKey )
{
int iHead;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyPut(%p,%d)", pGT, iKey));
iHead = pGT->inkeyHead;
if( iKey == K_MOUSEMOVE )
{
/*
* Clipper does not store in buffer repeated mouse movement
* IMHO it's good idea to reduce unnecessary inkey buffer
* overloading so I also implemented it, [druzus]
*/
if( pGT->iLastPut == iKey && pGT->inkeyHead != pGT->inkeyTail )
return;
}
/*
* When the buffer is full new event overwrite the last one
* in the buffer - it's Clipper behavior, [druzus]
*/
pGT->inkeyBuffer[ iHead++ ] = pGT->iLastPut = iKey;
if( iHead >= pGT->inkeyBufferSize )
iHead = 0;
if( iHead != pGT->inkeyTail )
pGT->inkeyHead = iHead;
}
| hbgtcore.c | 2219 |
| STATIC VOID | hb_gt_def_InkeyIns( PHB_GT pGT, int iKey )
static void hb_gt_def_InkeyIns( PHB_GT pGT, int iKey )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyIns(%p,%d)", pGT, iKey));
if( --pGT->inkeyTail < 0 )
pGT->inkeyTail = pGT->inkeyBufferSize -1;
pGT->inkeyBuffer[ pGT->inkeyTail ] = iKey;
/* When the buffer is full new event overwrite the last one
* in the buffer. [druzus]
*/
if( pGT->inkeyHead == pGT->inkeyTail )
{
if( --pGT->inkeyHead < 0 )
pGT->inkeyHead = pGT->inkeyBufferSize -1;
}
}
| hbgtcore.c | 2251 |
| STATIC BOOL | hb_gt_def_InkeyNextCheck( PHB_GT pGT, int iEventMask, int * iKey )
static BOOL hb_gt_def_InkeyNextCheck( PHB_GT pGT, int iEventMask, int * iKey )
{
HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyNextCheck(%p,%d)", pGT, iKey) );
if( pGT->StrBuffer )
{
*iKey = pGT->StrBuffer[ pGT->StrBufferPos ];
}
else if( pGT->inkeyHead != pGT->inkeyTail )
{
*iKey = hb_gt_def_InkeyFilter( pGT, pGT->inkeyBuffer[ pGT->inkeyTail ], iEventMask );
}
else
{
return FALSE;
}
if( *iKey == 0 )
{
hb_gt_def_InkeyPop( pGT );
return FALSE;
}
return TRUE;
}
| hbgtcore.c | 2271 |
| STATIC VOID | hb_gt_def_InkeyPollDo( PHB_GT pGT )
static void hb_gt_def_InkeyPollDo( PHB_GT pGT )
{
int iKey;
HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyPollDo(%p)", pGT) );
iKey = HB_GTSELF_READKEY( pGT, INKEY_ALL );
if( iKey )
{
switch( iKey )
{
case HB_BREAK_FLAG: /* Check for Ctrl+Break */
case K_ALT_C: /* Check for normal Alt+C */
if( hb_setGetCancel() )
{
hb_vmRequestCancel(); /* Request cancellation */
return;
}
break;
case K_ALT_D: /* Check for Alt+D */
if( hb_setGetDebug() )
{
hb_vmRequestDebug(); /* Request the debugger */
return;
}
}
HB_GTSELF_INKEYPUT( pGT, iKey );
}
}
| hbgtcore.c | 2298 |
| STATIC VOID | hb_gt_def_InkeyPoll( PHB_GT pGT )
static void hb_gt_def_InkeyPoll( PHB_GT pGT )
{
HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyPoll(%p)", pGT) );
/*
* Clipper 5.3 always poll events without respecting
* _SET_TYPEAHEAD when CL5.2 only when it's non zero.
* IMHO keeping CL5.2 behavior will be more accurate for xharbour
* because it allow to control it by user what some times could be
* necessary due to different low level GT behavior on some platforms
*/
if( hb_setGetTypeAhead() )
{
hb_gt_def_InkeyPollDo( pGT );
}
}
| hbgtcore.c | 2330 |
| STATIC INT | hb_gt_def_InkeyNext( PHB_GT pGT, int iEventMask )
static int hb_gt_def_InkeyNext( PHB_GT pGT, int iEventMask )
{
int iKey = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyNext(%p,%d)", pGT, iEventMask));
HB_GTSELF_INKEYPOLL( pGT );
hb_gt_def_InkeyNextCheck( pGT, iEventMask, &iKey );
return iKey;
}
| hbgtcore.c | 2348 |
| STATIC INT | hb_gt_def_InkeyGet( PHB_GT pGT, BOOL fWait, double dSeconds, int iEventMask )
static int hb_gt_def_InkeyGet( PHB_GT pGT, BOOL fWait, double dSeconds, int iEventMask )
{
HB_ULONG end_timer;
BOOL fPop;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyGet(%p,%d,%f,%d)", pGT, (int) fWait, dSeconds, iEventMask));
/* Wait forever ?, Use fixed value 100 for strict Clipper compatibility */
if( fWait && dSeconds * 100 >= 1 )
end_timer = hb_dateMilliSeconds() + ( HB_ULONG ) ( dSeconds * 1000 );
else
end_timer = 0;
do
{
hb_gt_def_InkeyPollDo( pGT );
fPop = hb_gt_def_InkeyNextCheck( pGT, iEventMask, &pGT->inkeyLast );
if( fPop )
break;
/* immediately break if a VM request is pending. */
if( !fWait || hb_vmRequestQuery() != 0 )
return 0;
hb_idleState();
}
while( end_timer == 0 || end_timer > hb_dateMilliSeconds() );
hb_idleReset();
if( fPop )
{
hb_gt_def_InkeyPop( pGT );
return pGT->inkeyLast;
}
return 0;
}
| hbgtcore.c | 2361 |
| STATIC INT | hb_gt_def_InkeyLast( PHB_GT pGT, int iEventMask )
static int hb_gt_def_InkeyLast( PHB_GT pGT, int iEventMask )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyLast(%p,%d)", pGT, iEventMask));
HB_GTSELF_INKEYPOLL( pGT );
return hb_gt_def_InkeyFilter( pGT, pGT->inkeyLast, iEventMask );
}
| hbgtcore.c | 2402 |
| STATIC INT | hb_gt_def_InkeySetLast( PHB_GT pGT, int iKey )
static int hb_gt_def_InkeySetLast( PHB_GT pGT, int iKey )
{
int iLast;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetLast(%p,%d)", pGT, iKey));
iLast = pGT->inkeyLast;
pGT->inkeyLast = iKey;
return iLast;
}
| hbgtcore.c | 2412 |
| STATIC VOID | hb_gt_def_InkeySetText( PHB_GT pGT, const char * szText, ULONG ulLen )
static void hb_gt_def_InkeySetText( PHB_GT pGT, const char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetText(%p,%s,%lu)", pGT, szText, ulLen));
if( pGT->StrBuffer )
{
hb_xfree( pGT->StrBuffer );
pGT->StrBuffer = NULL;
}
if( szText && ulLen )
{
pGT->StrBuffer = ( BYTE * ) hb_xgrab( ulLen );
memcpy( pGT->StrBuffer, szText, ulLen );
pGT->StrBufferSize = ulLen;
pGT->StrBufferPos = 0;
}
}
| hbgtcore.c | 2425 |
| STATIC VOID | hb_gt_def_InkeyReset( PHB_GT pGT )
static void hb_gt_def_InkeyReset( PHB_GT pGT )
{
int iTypeAhead;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyReset(%p)", pGT));
if( pGT->StrBuffer )
{
hb_xfree( pGT->StrBuffer );
pGT->StrBuffer = NULL;
}
pGT->inkeyHead = 0;
pGT->inkeyTail = 0;
iTypeAhead = hb_setGetTypeAhead();
if( iTypeAhead != pGT->inkeyBufferSize )
{
if( pGT->inkeyBufferSize > HB_DEFAULT_INKEY_BUFSIZE )
hb_xfree( pGT->inkeyBuffer );
if( iTypeAhead > HB_DEFAULT_INKEY_BUFSIZE )
{
pGT->inkeyBufferSize = iTypeAhead;
pGT->inkeyBuffer = ( int * ) hb_xgrab( pGT->inkeyBufferSize * sizeof( int ) );
}
else
{
pGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE;
pGT->inkeyBuffer = pGT->defaultKeyBuffer;
}
}
}
| hbgtcore.c | 2445 |
| STATIC VOID | hb_gt_def_InkeyExit( PHB_GT pGT )
static void hb_gt_def_InkeyExit( PHB_GT pGT )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyExit(%p)", pGT));
if( pGT->StrBuffer )
{
hb_xfree( pGT->StrBuffer );
pGT->StrBuffer = NULL;
}
if( pGT->inkeyBufferSize > HB_DEFAULT_INKEY_BUFSIZE )
{
hb_xfree( pGT->inkeyBuffer );
pGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE;
pGT->inkeyBuffer = pGT->defaultKeyBuffer;
}
}
| hbgtcore.c | 2481 |
| STATIC VOID | hb_gt_def_MouseInit( PHB_GT pGT )
static void hb_gt_def_MouseInit( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
}
| hbgtcore.c | 2499 |
| STATIC VOID | hb_gt_def_MouseExit( PHB_GT pGT )
static void hb_gt_def_MouseExit( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
}
| hbgtcore.c | 2504 |
| STATIC BOOL | hb_gt_def_MouseIsPresent( PHB_GT pGT )
static BOOL hb_gt_def_MouseIsPresent( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
return FALSE;
}
| hbgtcore.c | 2509 |
| STATIC VOID | hb_gt_def_MouseShow( PHB_GT pGT )
static void hb_gt_def_MouseShow( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
}
| hbgtcore.c | 2515 |
| STATIC VOID | hb_gt_def_MouseHide( PHB_GT pGT )
static void hb_gt_def_MouseHide( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
}
| hbgtcore.c | 2520 |
| STATIC BOOL | hb_gt_def_MouseGetCursor( PHB_GT pGT )
static BOOL hb_gt_def_MouseGetCursor( PHB_GT pGT )
{
return pGT->fMouseVisible;
}
| hbgtcore.c | 2525 |
| STATIC VOID | hb_gt_def_MouseSetCursor( PHB_GT pGT, BOOL fVisible )
static void hb_gt_def_MouseSetCursor( PHB_GT pGT, BOOL fVisible )
{
if( fVisible )
{
HB_GTSELF_MOUSESHOW( pGT );
pGT->fMouseVisible = TRUE;
}
else if( pGT->fMouseVisible )
{
/*
* mouse drivers use hide counters, so repeated calls to
* HB_GTSELF_MOUSEHIDE( pGT ) will need at least the same number of
* calls to HB_GTSELF_MOUSESHOW() to make mouse cursor visible. This
* behavior is not compatible with Clipper so call to
* HB_GTSELF_MOUSEHIDE( pGT ) is guarded by pGT->fMouseVisible.
* The counter is not updated when mouse cursor is visible and
* HB_GTSELF_MOUSESHOW() is called so this behavior is enough.
* If some platform works in differ way then and this behavior
* will create problems GT driver should overload
* HB_GTSELF_MOUSESETCURSOR()/HB_GTSELF_MOUSEGETCURSOR() methods.
* [druzus]
*/
HB_GTSELF_MOUSEHIDE( pGT );
pGT->fMouseVisible = FALSE;
}
}
| hbgtcore.c | 2530 |
| STATIC INT | hb_gt_def_MouseRow( PHB_GT pGT )
static int hb_gt_def_MouseRow( PHB_GT pGT )
{
int iRow, iCol;
HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol );
return iRow;
}
| hbgtcore.c | 2557 |
| STATIC INT | hb_gt_def_MouseCol( PHB_GT pGT )
static int hb_gt_def_MouseCol( PHB_GT pGT )
{
int iRow, iCol;
HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol );
return iCol;
}
| hbgtcore.c | 2565 |
| STATIC VOID | hb_gt_def_MouseGetPos( PHB_GT pGT, int * piRow, int * piCol )
static void hb_gt_def_MouseGetPos( PHB_GT pGT, int * piRow, int * piCol )
{
HB_SYMBOL_UNUSED( pGT );
*piRow = *piCol = 0;
}
| hbgtcore.c | 2573 |
| STATIC VOID | hb_gt_def_MouseSetPos( PHB_GT pGT, int iRow, int iCol )
static void hb_gt_def_MouseSetPos( PHB_GT pGT, int iRow, int iCol )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iRow );
HB_SYMBOL_UNUSED( iCol );
}
| hbgtcore.c | 2580 |
| STATIC VOID | hb_gt_def_MouseSetBounds( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
static void hb_gt_def_MouseSetBounds( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iTop );
HB_SYMBOL_UNUSED( iLeft );
HB_SYMBOL_UNUSED( iBottom );
HB_SYMBOL_UNUSED( iRight );
}
| hbgtcore.c | 2587 |
| STATIC VOID | hb_gt_def_MouseGetBounds( PHB_GT pGT, int * piTop, int * piLeft, int * piBottom, int * piRight )
static void hb_gt_def_MouseGetBounds( PHB_GT pGT, int * piTop, int * piLeft, int * piBottom, int * piRight )
{
HB_SYMBOL_UNUSED( pGT );
*piTop = *piLeft = 0;
HB_GTSELF_GETSIZE( pGT, piBottom, piRight );
--(*piBottom);
--(*piRight);
}
typedef struct
{
int iRow;
int iCol;
int fVisible;
int iTop;
int iLeft;
int iBottom;
int iRight;
} _HB_MOUSE_STORAGE;
| hbgtcore.c | 2596 |
| STATIC INT | hb_gt_def_mouseStorageSize( PHB_GT pGT )
static int hb_gt_def_mouseStorageSize( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
return sizeof( _HB_MOUSE_STORAGE );
}
| hbgtcore.c | 2617 |
| STATIC VOID | hb_gt_def_mouseSaveState( PHB_GT pGT, BYTE * pBuffer )
static void hb_gt_def_mouseSaveState( PHB_GT pGT, BYTE * pBuffer )
{
_HB_MOUSE_STORAGE * pStore = ( _HB_MOUSE_STORAGE * ) pBuffer;
int iRow, iCol, iTop, iLeft, iBottom, iRight;
HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol );
HB_GTSELF_MOUSEGETBOUNDS( pGT, &iTop, &iLeft, &iBottom, &iRight );
pStore->iRow = iRow;
pStore->iCol = iCol;
pStore->fVisible = HB_GTSELF_MOUSEGETCURSOR( pGT );
pStore->iTop = iTop;
pStore->iLeft = iLeft;
pStore->iBottom = iBottom;
pStore->iRight = iRight;
}
| hbgtcore.c | 2624 |
| STATIC VOID | hb_gt_def_mouseRestoreState( PHB_GT pGT, BYTE * pBuffer )
static void hb_gt_def_mouseRestoreState( PHB_GT pGT, BYTE * pBuffer )
{
_HB_MOUSE_STORAGE * pStore = ( _HB_MOUSE_STORAGE * ) pBuffer;
HB_GTSELF_MOUSESETBOUNDS( pGT, pStore->iTop, pStore->iLeft, pStore->iBottom, pStore->iRight );
HB_GTSELF_MOUSESETPOS( pGT, pStore->iRow, pStore->iCol );
HB_GTSELF_MOUSESETCURSOR( pGT, pStore->fVisible );
}
| hbgtcore.c | 2641 |
| STATIC INT | hb_gt_def_mouseGetDoubleClickSpeed( PHB_GT pGT )
static int hb_gt_def_mouseGetDoubleClickSpeed( PHB_GT pGT )
{
return pGT->iDoubleClickSpeed;
}
| hbgtcore.c | 2650 |
| STATIC VOID | hb_gt_def_mouseSetDoubleClickSpeed( PHB_GT pGT, int iSpeed )
static void hb_gt_def_mouseSetDoubleClickSpeed( PHB_GT pGT, int iSpeed )
{
if( iSpeed > 0 )
pGT->iDoubleClickSpeed = iSpeed;
}
| hbgtcore.c | 2655 |
| STATIC INT | hb_gt_def_MouseCountButton( PHB_GT pGT )
static int hb_gt_def_MouseCountButton( PHB_GT pGT )
{
HB_SYMBOL_UNUSED( pGT );
return 0;
}
| hbgtcore.c | 2661 |
| STATIC BOOL | hb_gt_def_MouseButtonState( PHB_GT pGT, int iButton )
static BOOL hb_gt_def_MouseButtonState( PHB_GT pGT, int iButton )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iButton );
return FALSE;
}
| hbgtcore.c | 2668 |
| STATIC BOOL | hb_gt_def_MouseButtonPressed( PHB_GT pGT, int iButton, int * piRow, int * piCol )
static BOOL hb_gt_def_MouseButtonPressed( PHB_GT pGT, int iButton, int * piRow, int * piCol )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iButton );
HB_SYMBOL_UNUSED( piRow );
HB_SYMBOL_UNUSED( piCol );
return FALSE;
}
| hbgtcore.c | 2676 |
| STATIC BOOL | hb_gt_def_MouseButtonReleased( PHB_GT pGT, int iButton, int * piRow, int * piCol )
static BOOL hb_gt_def_MouseButtonReleased( PHB_GT pGT, int iButton, int * piRow, int * piCol )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iButton );
HB_SYMBOL_UNUSED( piRow );
HB_SYMBOL_UNUSED( piCol );
return FALSE;
}
| hbgtcore.c | 2686 |
| STATIC INT | hb_gt_def_MouseReadKey( PHB_GT pGT, int iEventMask )
static int hb_gt_def_MouseReadKey( PHB_GT pGT, int iEventMask )
{
int iKey = 0, iRow, iCol;
if( HB_GTSELF_MOUSEISPRESENT( pGT ) )
{
if( iEventMask & INKEY_LDOWN && HB_GTSELF_MOUSEBUTTONPRESSED( pGT, 0, &iRow, &iCol ) )
{
HB_ULONG timer = hb_dateMilliSeconds();
if( timer - pGT->iMouseLeftTimer <= ( HB_ULONG ) HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT ) )
iKey = K_LDBLCLK;
else
iKey = K_LBUTTONDOWN;
pGT->iMouseLeftTimer = timer;
}
else if( iEventMask & INKEY_LUP && HB_GTSELF_MOUSEBUTTONRELEASED( pGT, 0, &iRow, &iCol ) )
{
iKey = K_LBUTTONUP;
}
else if( iEventMask & INKEY_RDOWN && HB_GTSELF_MOUSEBUTTONPRESSED( pGT, 1, &iRow, &iCol ) )
{
HB_ULONG timer = hb_dateMilliSeconds();
if( timer - pGT->iMouseRightTimer <= ( HB_ULONG ) HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT ) )
iKey = K_RDBLCLK;
else
iKey = K_RBUTTONDOWN;
pGT->iMouseRightTimer = timer;
}
else if( iEventMask & INKEY_RUP && HB_GTSELF_MOUSEBUTTONRELEASED( pGT, 1, &iRow, &iCol ) )
{
iKey = K_RBUTTONUP;
}
else if( iEventMask & INKEY_MMIDDLE && HB_GTSELF_MOUSEBUTTONPRESSED( pGT, 2, &iRow, &iCol ) )
{
HB_ULONG timer = hb_dateMilliSeconds();
if( timer - pGT->iMouseMiddleTimer <= ( HB_ULONG ) HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT ) )
iKey = K_MDBLCLK;
else
iKey = K_MBUTTONDOWN;
pGT->iMouseMiddleTimer = timer;
}
else if( iEventMask & INKEY_MMIDDLE && HB_GTSELF_MOUSEBUTTONRELEASED( pGT, 2, &iRow, &iCol ) )
{
iKey = K_MBUTTONUP;
}
else if( iEventMask & INKEY_MOVE )
{
HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol );
if( iRow != pGT->iMouseLastRow || iCol != pGT->iMouseLastCol )
{
pGT->iMouseLastRow = iRow;
pGT->iMouseLastCol = iCol;
iKey = K_MOUSEMOVE;
}
}
}
return iKey;
}
| hbgtcore.c | 2696 |
| STATIC INT | hb_gt_def_GfxPrimitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor )
static int hb_gt_def_GfxPrimitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iType );
HB_SYMBOL_UNUSED( iTop );
HB_SYMBOL_UNUSED( iLeft );
HB_SYMBOL_UNUSED( iBottom );
HB_SYMBOL_UNUSED( iRight );
HB_SYMBOL_UNUSED( iColor );
return 0;
}
| hbgtcore.c | 2755 |
| STATIC VOID | hb_gt_def_GfxText( PHB_GT pGT, int iTop, int iLeft, char * szText, int iColor, int iSize, int iWidth )
static void hb_gt_def_GfxText( PHB_GT pGT, int iTop, int iLeft, char * szText, int iColor, int iSize, int iWidth )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iTop );
HB_SYMBOL_UNUSED( iLeft );
HB_SYMBOL_UNUSED( szText );
HB_SYMBOL_UNUSED( iColor );
HB_SYMBOL_UNUSED( iSize );
HB_SYMBOL_UNUSED( iWidth );
}
| hbgtcore.c | 2768 |
| STATIC VOID | hb_gt_def_WhoCares( PHB_GT pGT, void * pCargo )
static void hb_gt_def_WhoCares( PHB_GT pGT, void * pCargo )
{
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( pCargo );
}
/* ************************************************************************* */
#if defined( __GNUC__ ) && 0
static HB_GT_FUNCS s_gtCoreFunc =
{
Init : hb_gt_def_Init ,
Exit : hb_gt_def_Exit ,
New : hb_gt_def_New ,
Free : hb_gt_def_Free ,
Resize : hb_gt_def_Resize ,
SetMode : hb_gt_def_SetMode ,
GetSize : hb_gt_def_GetSize ,
SemiCold : hb_gt_def_SemiCold ,
ColdArea : hb_gt_def_ColdArea ,
ExposeArea : hb_gt_def_ExposeArea ,
ScrollArea : hb_gt_def_ScrollArea ,
TouchCell : hb_gt_def_TouchCell ,
Redraw : hb_gt_def_Redraw ,
Refresh : hb_gt_def_Refresh ,
Flush : hb_gt_def_Flush ,
MaxCol : hb_gt_def_MaxCol ,
MaxRow : hb_gt_def_MaxRow ,
CheckPos : hb_gt_def_CheckPos ,
SetPos : hb_gt_def_SetPos ,
GetPos : hb_gt_def_GetPos ,
IsColor : hb_gt_def_IsColor ,
GetColorStr : hb_gt_def_GetColorStr ,
SetColorStr : hb_gt_def_SetColorStr ,
ColorSelect : hb_gt_def_ColorSelect ,
GetColor : hb_gt_def_GetColor ,
ColorNum : hb_gt_def_ColorNum ,
ColorsToString : hb_gt_def_ColorsToString ,
StringToColors : hb_gt_def_StringToColors ,
GetColorData : hb_gt_def_GetColorData ,
GetClearColor : hb_gt_def_GetClearColor ,
SetClearColor : hb_gt_def_SetClearColor ,
GetClearChar : hb_gt_def_GetClearChar ,
SetClearChar : hb_gt_def_SetClearChar ,
GetCursorStyle : hb_gt_def_GetCursorStyle ,
SetCursorStyle : hb_gt_def_SetCursorStyle ,
GetScrCursor : hb_gt_def_GetScrCursor ,
GetScrChar : hb_gt_def_GetChar ,
PutScrChar : hb_gt_def_PutChar ,
DispBegin : hb_gt_def_DispBegin ,
DispEnd : hb_gt_def_DispEnd ,
DispCount : hb_gt_def_DispCount ,
GetChar : hb_gt_def_GetChar ,
PutChar : hb_gt_def_PutChar ,
RectSize : hb_gt_def_RectSize ,
Save : hb_gt_def_Save ,
Rest : hb_gt_def_Rest ,
PutText : hb_gt_def_PutText ,
Replicate : hb_gt_def_Replicate ,
WriteAt : hb_gt_def_WriteAt ,
Write : hb_gt_def_Write ,
WriteCon : hb_gt_def_WriteCon ,
SetAttribute : hb_gt_def_SetAttribute ,
DrawShadow : hb_gt_def_DrawShadow ,
Scroll : hb_gt_def_Scroll ,
ScrollUp : hb_gt_def_ScrollUp ,
Box : hb_gt_def_Box ,
BoxD : hb_gt_def_BoxD ,
BoxS : hb_gt_def_BoxS ,
HorizLine : hb_gt_def_HorizLine ,
VertLine : hb_gt_def_VertLine ,
GetBlink : hb_gt_def_GetBlink ,
SetBlink : hb_gt_def_SetBlink ,
SetSnowFlag : hb_gt_def_SetSnowFlag ,
Version : hb_gt_def_Version ,
Suspend : hb_gt_def_Suspend ,
Resume : hb_gt_def_Resume ,
PreExt : hb_gt_def_PreExt ,
PostExt : hb_gt_def_PostExt ,
OutStd : hb_gt_def_OutStd ,
OutErr : hb_gt_def_OutErr ,
Tone : hb_gt_def_Tone ,
Bell : hb_gt_def_Bell ,
Info : hb_gt_def_Info ,
Alert : hb_gt_def_Alert ,
SetFlag : hb_gt_def_SetFlag ,
SetDispCP : hb_gt_def_SetDispCP ,
SetKeyCP : hb_gt_def_SetKeyCP ,
ReadKey : hb_gt_def_ReadKey ,
InkeyGet : hb_gt_def_InkeyGet ,
InkeyPut : hb_gt_def_InkeyPut ,
InkeyIns : hb_gt_def_InkeyIns ,
InkeyLast : hb_gt_def_InkeyLast ,
InkeyNext : hb_gt_def_InkeyNext ,
InkeyPoll : hb_gt_def_InkeyPoll ,
InkeySetText : hb_gt_def_InkeySetText ,
InkeySetLast : hb_gt_def_InkeySetLast ,
InkeyReset : hb_gt_def_InkeyReset ,
InkeyExit : hb_gt_def_InkeyExit ,
MouseInit : hb_gt_def_MouseInit ,
MouseExit : hb_gt_def_MouseExit ,
MouseIsPresent : hb_gt_def_MouseIsPresent ,
MouseShow : hb_gt_def_MouseShow ,
MouseHide : hb_gt_def_MouseHide ,
MouseGetCursor : hb_gt_def_MouseGetCursor ,
MouseSetCursor : hb_gt_def_MouseSetCursor ,
MouseCol : hb_gt_def_MouseCol ,
MouseRow : hb_gt_def_MouseRow ,
MouseGetPos : hb_gt_def_MouseGetPos ,
MouseSetPos : hb_gt_def_MouseSetPos ,
MouseSetBounds : hb_gt_def_MouseSetBounds ,
MouseGetBounds : hb_gt_def_MouseGetBounds ,
MouseStorageSize : hb_gt_def_mouseStorageSize ,
MouseSaveState : hb_gt_def_mouseSaveState ,
MouseRestoreState : hb_gt_def_mouseRestoreState ,
MouseGetDoubleClickSpeed : hb_gt_def_mouseGetDoubleClickSpeed ,
MouseSetDoubleClickSpeed : hb_gt_def_mouseSetDoubleClickSpeed ,
MouseCountButton : hb_gt_def_MouseCountButton ,
MouseButtonState : hb_gt_def_MouseButtonState ,
MouseButtonPressed : hb_gt_def_MouseButtonPressed ,
MouseButtonReleased : hb_gt_def_MouseButtonReleased ,
MouseReadKey : hb_gt_def_MouseReadKey ,
GfxPrimitive : hb_gt_def_GfxPrimitive ,
GfxText : hb_gt_def_GfxText ,
WhoCares : hb_gt_def_WhoCares
};
#else
static HB_GT_FUNCS s_gtCoreFunc =
{
hb_gt_def_Init ,
hb_gt_def_Exit ,
hb_gt_def_New ,
hb_gt_def_Free ,
hb_gt_def_Resize ,
hb_gt_def_SetMode ,
hb_gt_def_GetSize ,
hb_gt_def_SemiCold ,
hb_gt_def_ColdArea ,
hb_gt_def_ExposeArea ,
hb_gt_def_ScrollArea ,
hb_gt_def_TouchCell ,
hb_gt_def_Redraw ,
hb_gt_def_Refresh ,
hb_gt_def_Flush ,
hb_gt_def_MaxCol ,
hb_gt_def_MaxRow ,
hb_gt_def_CheckPos ,
hb_gt_def_SetPos ,
hb_gt_def_GetPos ,
hb_gt_def_IsColor ,
hb_gt_def_GetColorStr ,
hb_gt_def_SetColorStr ,
hb_gt_def_ColorSelect ,
hb_gt_def_GetColor ,
hb_gt_def_ColorNum ,
hb_gt_def_ColorsToString ,
hb_gt_def_StringToColors ,
hb_gt_def_GetColorData ,
hb_gt_def_GetClearColor ,
hb_gt_def_SetClearColor ,
hb_gt_def_GetClearChar ,
hb_gt_def_SetClearChar ,
hb_gt_def_GetCursorStyle ,
hb_gt_def_SetCursorStyle ,
hb_gt_def_GetScrCursor ,
hb_gt_def_GetChar , /* intentionally mapped to GetScrChar */
hb_gt_def_PutChar , /* intentionally mapped to PutScrChar */
hb_gt_def_DispBegin ,
hb_gt_def_DispEnd ,
hb_gt_def_DispCount ,
hb_gt_def_GetChar ,
hb_gt_def_PutChar ,
hb_gt_def_RectSize ,
hb_gt_def_Save ,
hb_gt_def_Rest ,
hb_gt_def_PutText ,
hb_gt_def_Replicate ,
hb_gt_def_WriteAt ,
hb_gt_def_Write ,
hb_gt_def_WriteCon ,
hb_gt_def_SetAttribute ,
hb_gt_def_DrawShadow ,
hb_gt_def_Scroll ,
hb_gt_def_ScrollUp ,
hb_gt_def_Box ,
hb_gt_def_BoxD ,
hb_gt_def_BoxS ,
hb_gt_def_HorizLine ,
hb_gt_def_VertLine ,
hb_gt_def_GetBlink ,
hb_gt_def_SetBlink ,
hb_gt_def_SetSnowFlag ,
hb_gt_def_Version ,
hb_gt_def_Suspend ,
hb_gt_def_Resume ,
hb_gt_def_PreExt ,
hb_gt_def_PostExt ,
hb_gt_def_OutStd ,
hb_gt_def_OutErr ,
hb_gt_def_Tone ,
hb_gt_def_Bell ,
hb_gt_def_Info ,
hb_gt_def_Alert ,
hb_gt_def_SetFlag ,
hb_gt_def_SetDispCP ,
hb_gt_def_SetKeyCP ,
hb_gt_def_ReadKey ,
hb_gt_def_InkeyGet ,
hb_gt_def_InkeyPut ,
hb_gt_def_InkeyIns ,
hb_gt_def_InkeyLast ,
hb_gt_def_InkeyNext ,
hb_gt_def_InkeyPoll ,
hb_gt_def_InkeySetText ,
hb_gt_def_InkeySetLast ,
hb_gt_def_InkeyReset ,
hb_gt_def_InkeyExit ,
hb_gt_def_MouseInit ,
hb_gt_def_MouseExit ,
hb_gt_def_MouseIsPresent ,
hb_gt_def_MouseShow ,
hb_gt_def_MouseHide ,
hb_gt_def_MouseGetCursor ,
hb_gt_def_MouseSetCursor ,
hb_gt_def_MouseCol ,
hb_gt_def_MouseRow ,
hb_gt_def_MouseGetPos ,
hb_gt_def_MouseSetPos ,
hb_gt_def_MouseSetBounds ,
hb_gt_def_MouseGetBounds ,
hb_gt_def_mouseStorageSize ,
hb_gt_def_mouseSaveState ,
hb_gt_def_mouseRestoreState ,
hb_gt_def_mouseGetDoubleClickSpeed ,
hb_gt_def_mouseSetDoubleClickSpeed ,
hb_gt_def_MouseCountButton ,
hb_gt_def_MouseButtonState ,
hb_gt_def_MouseButtonPressed ,
hb_gt_def_MouseButtonReleased ,
hb_gt_def_MouseReadKey ,
hb_gt_def_GfxPrimitive ,
hb_gt_def_GfxText ,
hb_gt_def_WhoCares
};
#endif
/* ************************************************************************* */
static char s_gtNameBuf[ HB_GT_NAME_MAX_ + 1 ];
#if defined(HB_GT_LIB)
HB_EXPORT const char * hb_gt_szNameDefault = HB_GT_DRVNAME( HB_GT_LIB );
#elif defined(HB_WINCE)
HB_EXPORT const char * hb_gt_szNameDefault = "wvt";
#elif defined(HB_OS_WIN_32)
HB_EXPORT const char * hb_gt_szNameDefault = "win";
#elif defined(HB_OS_DOS)
HB_EXPORT const char * hb_gt_szNameDefault = "dos";
#elif defined(HB_OS_OS2)
HB_EXPORT const char * hb_gt_szNameDefault = "os2";
#elif defined(HB_OS_UNIX)
HB_EXPORT const char * hb_gt_szNameDefault = "trm";
#else
HB_EXPORT const char * hb_gt_szNameDefault = "std";
#endif
static const HB_GT_INIT * s_gtInit[ HB_GT_MAX_ ];
static int s_gtLinkOrder[ HB_GT_MAX_ ];
static int s_iGtLinkCount = 0;
static int s_iGtCount = 0;
HB_FUNC_EXTERN( HB_GTSYS );
| hbgtcore.c | 2779 |
| STATIC CONST CHAR * | hb_gt_FindDefault( void )
static const char * hb_gt_FindDefault( void )
{
char szFuncName[ 15 + HB_GT_NAME_MAX_ ];
int iPos;
for( iPos = 0; iPos < s_iGtCount; iPos++ )
{
snprintf( szFuncName, sizeof( szFuncName ),
"HB_GT_%s_DEFAULT", s_gtInit[ iPos ]->id );
if( hb_dynsymFind( szFuncName ) )
return s_gtInit[ iPos ]->id;
}
if( hb_dynsymFind( "HB_GT_NUL_DEFAULT" ) )
return "NUL";
else
return NULL;
}
| hbgtcore.c | 3052 |
| STATIC INT | hb_gt_FindEntry( const char * pszID )
static int hb_gt_FindEntry( const char * pszID )
{
int iPos;
for( iPos = 0; iPos < s_iGtCount; iPos++ )
{
if( hb_stricmp( s_gtInit[ iPos ]->id, pszID ) == 0 ||
( hb_strnicmp( pszID, "gt", 2 ) == 0 &&
hb_stricmp( s_gtInit[ iPos ]->id, pszID + 2 ) == 0 ) )
return iPos;
}
return -1;
}
| hbgtcore.c | 3071 |
| HB_EXPORT VOID | hb_gtSetDefault( const char * szGtName )
HB_EXPORT void hb_gtSetDefault( const char * szGtName )
{
hb_strncpy( s_gtNameBuf, szGtName, sizeof( s_gtNameBuf ) - 1 );
hb_gt_szNameDefault = s_gtNameBuf;
}
| hbgtcore.c | 3086 |
| HB_EXPORT BOOL | hb_gtRegister( const HB_GT_INIT * gtInit )
HB_EXPORT BOOL hb_gtRegister( const HB_GT_INIT * gtInit )
{
if( hb_gt_FindEntry( gtInit->id ) == -1 )
{
s_gtInit[ s_iGtCount++ ] = gtInit;
return TRUE;
}
return FALSE;
}
| hbgtcore.c | 3092 |
| HB_EXPORT BOOL | hb_gtLoad( const char * szGtName, PHB_GT_FUNCS pFuncTable )
HB_EXPORT BOOL hb_gtLoad( const char * szGtName, PHB_GT_FUNCS pFuncTable )
{
int iPos;
if( szGtName )
{
if( hb_stricmp( szGtName, "nul" ) == 0 || hb_stricmp( szGtName, "null" ) == 0 )
{
if( pFuncTable == NULL )
pFuncTable = &s_gtCoreFunc;
if( !s_curGT )
{
s_curGT = ( PHB_GT_BASE ) hb_xgrab( sizeof( HB_GT_BASE ) );
memset( s_curGT, 0, sizeof( HB_GT_BASE ) );
}
s_curGT->pFuncTable = pFuncTable;
return TRUE;
}
iPos = hb_gt_FindEntry( szGtName );
if( iPos != -1 )
{
if( pFuncTable == NULL )
pFuncTable = &s_gtCoreFunc;
memcpy( s_gtInit[ iPos ]->pSuperTable, pFuncTable, sizeof( HB_GT_FUNCS ) );
if( !s_gtInit[ iPos ]->init( pFuncTable ) )
{
hb_errInternal( 6001, "Screen driver initialization failure", NULL, NULL );
}
if( s_gtInit[ iPos ]->pGtId )
*s_gtInit[ iPos ]->pGtId = s_iGtLinkCount;
s_gtLinkOrder[ s_iGtLinkCount++ ] = iPos;
if( !s_curGT )
{
s_curGT = ( PHB_GT_BASE ) hb_xgrab( sizeof( HB_GT_BASE ) );
memset( s_curGT, 0, sizeof( HB_GT_BASE ) );
}
s_curGT->pFuncTable = pFuncTable;
return TRUE;
}
}
return FALSE;
}
| hbgtcore.c | 3102 |
| HB_EXPORT BOOL | hb_gtUnLoad( void )
HB_EXPORT BOOL hb_gtUnLoad( void )
{
while( s_iGtLinkCount > 0 )
{
if( --s_iGtLinkCount == 0 )
memcpy( &s_gtCoreFunc,
s_gtInit[ s_gtLinkOrder[ s_iGtLinkCount ] ]->pSuperTable,
sizeof( HB_GT_FUNCS ) );
}
return TRUE;
}
| hbgtcore.c | 3149 |
| HB_EXPORT VOID | hb_gtStartupInit( void )
HB_EXPORT void hb_gtStartupInit( void )
{
char * szGtName;
BOOL fInit;
szGtName = hb_cmdargString( "GT" );
if( szGtName )
{
fInit = hb_gtLoad( szGtName, &s_gtCoreFunc );
hb_xfree( szGtName );
if( fInit )
return;
}
szGtName = hb_getenv( "HB_GT" );
if( szGtName )
{
fInit = hb_gtLoad( szGtName, &s_gtCoreFunc );
hb_xfree( szGtName );
if( fInit )
return;
}
if( hb_gtLoad( hb_gt_FindDefault(), &s_gtCoreFunc ) )
return;
if( hb_gtLoad( hb_gt_szNameDefault, &s_gtCoreFunc ) )
return;
if( hb_dynsymFind( "HB_GT_NUL" ) ) /* GTNUL was explicitly requsted */
{
if( hb_gtLoad( "NUL", &s_gtCoreFunc ) )
return;
}
hb_errInternal( 9998, "Screen driver initialization failure", NULL, NULL );
/* force linking HB_GTSYS() */
HB_FUNC_EXEC( HB_GTSYS );
}
HB_GT_ANNOUNCE( HB_GT_NAME )
| hbgtcore.c | 3162 |
| hbhex.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_HEXTONUM(void)
HB_FUNC( HB_HEXTONUM )
{
char * szHex = hb_parc( 1 );
if( szHex )
{
HB_ULONG ulNum = 0;
while( *szHex == ' ' ) szHex++;
while( *szHex )
{
int iDigit;
char c = *szHex++;
if( c >= '0' && c <= '9' )
iDigit = c - '0';
else if( c >= 'A' && c <= 'F' )
iDigit = c - ( 'A' - 10 );
else if( c >= 'a' && c <= 'f' )
iDigit = c - ( 'a' - 10 );
else
{
ulNum = 0;
break;
}
ulNum = ( ulNum << 4 ) + iDigit;
}
hb_retnint( ulNum );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbhex.c | 57 |
| HB_FUNC | HB_NUMTOHEX(void)
HB_FUNC( HB_NUMTOHEX )
{
HB_ULONG ulNum;
int iLen;
BOOL fDefaultLen;
char ret[ 33 ];
if( ISNUM( 2 ) )
{
iLen = hb_parni( 2 );
iLen = ( iLen < 1 ) ? 1 : ( ( iLen > 32 ) ? 32 : iLen );
fDefaultLen = 0;
}
else
{
iLen = 32;
fDefaultLen = 1;
}
if( ISNUM( 1 ) )
ulNum = hb_parnint( 1 );
else if( ISPOINTER( 1 ) )
ulNum = (HB_PTRDIFF) hb_parptr( 1 );
else
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
ret[ iLen ] = '\0';
do
{
int iDigit = ( int ) ( ulNum & 0x0F );
ret[ --iLen ] = ( char ) ( iDigit + ( iDigit < 10 ? '0' : 'A' - 10 ) );
ulNum >>= 4;
}
while( fDefaultLen ? ulNum != 0 : iLen != 0 );
hb_retc( &ret[ iLen ] );
}
| hbhex.c | 89 |
| HB_FUNC | HB_STRTOHEX(void)
HB_FUNC( HB_STRTOHEX )
{
const char * szStr = hb_parc( 1 ), * szSep = "";
ULONG ulStr, ulSep = 0;
if( hb_pcount() > 1 )
{
szSep = hb_parc( 2 );
ulSep = hb_parclen( 2 );
}
if( !szStr || !szSep )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
ulStr = hb_parclen( 1 );
if( ulStr )
{
ULONG ulDest = ( ulStr << 1 ) + ( ulStr - 1 ) * ulSep;
char * szDest, * szPtr;
szPtr = szDest = ( char * ) hb_xgrab( ulDest + 1 );
do
{
UCHAR uc = ( UCHAR ) *szStr++, ud;
ud = uc >> 4;
*szPtr++ = ud + ( ud < 10 ? '0' : 'A' - 10 );
ud = uc & 0x0F;
*szPtr++ = ud + ( ud < 10 ? '0' : 'A' - 10 );
if( --ulStr && ulSep )
{
memcpy( szPtr, szSep, ulSep );
szPtr += ulSep;
}
}
while( ulStr );
hb_retclen_buffer( szDest, ulDest );
}
else
hb_retc( NULL );
}
| hbhex.c | 130 |
| HB_FUNC | HB_HEXTOSTR(void)
HB_FUNC( HB_HEXTOSTR )
{
char * szStr = hb_parc( 1 );
ULONG ulStr;
if( !szStr )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
ulStr = hb_parclen( 1 );
if( ulStr > 1 )
{
ULONG ulDest, ul;
char * szDest;
szDest = szStr;
ul = ulStr;
ulDest = 0;
do
{
char c = *szDest++;
if( ( c >= '0' && c <= '9' ) ||
( c >= 'A' && c <= 'F' ) ||
( c >= 'a' && c <= 'f' ) )
++ulDest;
}
while( --ul );
ulDest >>= 1;
if( ulDest )
{
int iVal = 0x10;
szDest = ( char * ) hb_xgrab( ulDest + 1 );
/* ul = 0; see above stop condition */
do
{
char c = *szStr++;
if( c >= '0' && c <= '9' )
iVal += c - '0';
else if( c >= 'A' && c <= 'F' )
iVal += c - ( 'A' - 10 );
else if( c >= 'a' && c <= 'f' )
iVal += c - ( 'a' - 10 );
else
continue;
if( iVal & 0x100 )
{
szDest[ul++] = ( char ) iVal & 0xff;
iVal = 0x1;
}
iVal <<= 4;
}
while( --ulStr );
hb_retclen_buffer( szDest, ulDest );
return;
}
}
hb_retc( NULL );
}
| hbhex.c | 174 |
| hbinet.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_inetLinuxSigusrHandle( int sig )
static void hb_inetLinuxSigusrHandle( int sig )
{
/* nothing to do */
HB_SYMBOL_UNUSED( sig );
}
# endif
#endif
/* JC1: we need it volatile to be minimally thread safe. */
static volatile int s_iSessions = 0;
| hbinet.c | 230 |
| STATIC BOOL | hb_inetIsOpen( HB_SOCKET_STRUCT *Socket )
static BOOL hb_inetIsOpen( HB_SOCKET_STRUCT *Socket )
{
if( Socket->com == ( HB_SOCKET_T ) -1 )
{
HB_SOCKET_SET_ERROR2( Socket, -4, "Closed socket" );
return FALSE;
}
return TRUE;
}
| hbinet.c | 241 |
| STATIC INT | hb_selectReadSocket( HB_SOCKET_STRUCT *Socket )
static int hb_selectReadSocket( HB_SOCKET_STRUCT *Socket )
{
fd_set set;
struct timeval tv;
int iResult;
hb_vmUnlock();
FD_ZERO( &set );
FD_SET(Socket->com, &set);
if( Socket->timeout == -1 )
{
iResult = select( Socket->com + 1, &set, NULL, NULL, NULL );
}
else
{
tv.tv_sec = Socket->timeout/ 1000;
tv.tv_usec = (Socket->timeout % 1000) * 1000;
iResult = select( Socket->com + 1, &set, NULL, NULL, &tv );
}
hb_vmLock();
return iResult > 0 ? FD_ISSET( Socket->com, &set ) : 0;
}
| hbinet.c | 253 |
| STATIC INT | hb_selectWriteSocket( HB_SOCKET_STRUCT *Socket )
static int hb_selectWriteSocket( HB_SOCKET_STRUCT *Socket )
{
fd_set set;
struct timeval tv;
int iResult;
hb_vmUnlock();
FD_ZERO( &set );
FD_SET(Socket->com, &set);
if( Socket->timeout == -1 )
{
iResult = select( Socket->com + 1, NULL, &set, NULL, NULL );
}
else
{
tv.tv_sec = Socket->timeout/ 1000;
tv.tv_usec = (Socket->timeout % 1000) * 1000;
iResult = select( Socket->com + 1, NULL, &set, NULL, &tv );
}
hb_vmLock();
return iResult > 0 ? FD_ISSET( Socket->com, &set ) : 0;
}
| hbinet.c | 280 |
| STATIC INT | hb_selectWriteExceptSocket( HB_SOCKET_STRUCT *Socket )
static int hb_selectWriteExceptSocket( HB_SOCKET_STRUCT *Socket )
{
fd_set set, eset;
struct timeval tv;
int iResult;
hb_vmUnlock();
FD_ZERO( &set );
FD_SET(Socket->com, &set);
FD_ZERO( &eset );
FD_SET(Socket->com, &eset);
if( Socket->timeout == -1 )
{
iResult = select( Socket->com + 1, NULL, &set, &eset, NULL );
}
else
{
tv.tv_sec = Socket->timeout/ 1000;
tv.tv_usec = (Socket->timeout % 1000) * 1000;
iResult = select(Socket->com + 1, NULL, &set, &eset, &tv);
}
hb_vmLock();
if( iResult < 0 || FD_ISSET( Socket->com, &eset) )
return 2;
else if( FD_ISSET( Socket->com, &set ) )
return 1;
else
return 0;
}
| hbinet.c | 308 |
| STATIC STRUCT HOSTENT * | hb_getHosts( char * name, HB_SOCKET_STRUCT *Socket )
static struct hostent * hb_getHosts( char * name, HB_SOCKET_STRUCT *Socket )
{
struct hostent *Host = NULL;
hb_vmUnlock();
/* TOFIX: make it MT safe */
/* let's see if name is an IP address; not necessary on Linux */
#if defined(HB_OS_WIN_32) || defined(HB_OS_OS2)
{
ULONG ulAddr;
ulAddr = inet_addr( name );
if( ulAddr == INADDR_NONE )
{
if( strcmp( "255.255.255.255", name ) == 0 )
{
Host = gethostbyaddr( (const char*) &ulAddr, sizeof( ulAddr ), AF_INET );
}
}
else
{
Host = gethostbyaddr( (const char*) &ulAddr, sizeof( ulAddr ), AF_INET );
}
}
#endif
if( Host == NULL )
{
Host = gethostbyname( name );
}
if( Host == NULL && Socket )
{
#if defined(HB_OS_WIN_32)
HB_SOCKET_SET_ERROR2( Socket, WSAGetLastError() , "Generic error in gethostbyname()" );
WSASetLastError( 0 );
#elif defined(HB_OS_OS2) || defined(HB_OS_HPUX) || defined(__WATCOMC__)
HB_SOCKET_SET_ERROR2( Socket, h_errno, "Generic error in gethostbyname()" );
#else
HB_SOCKET_SET_ERROR2( Socket, h_errno, (char *) hstrerror( h_errno ) );
#endif
}
hb_vmLock();
return Host;
}
| hbinet.c | 343 |
| STATIC VOID | hb_socketSetNonBlocking( HB_SOCKET_STRUCT *Socket )
static void hb_socketSetNonBlocking( HB_SOCKET_STRUCT *Socket )
{
#ifdef HB_OS_WIN_32
ULONG mode = 1;
ioctlsocket( Socket->com, FIONBIO, &mode );
#else
int flags = fcntl( Socket->com, F_GETFL, 0 );
if( flags != -1 )
{
flags |= O_NONBLOCK;
fcntl( Socket->com, F_SETFL, (LONG) flags );
}
#endif
}
| hbinet.c | 397 |
| STATIC VOID | hb_socketSetBlocking( HB_SOCKET_STRUCT *Socket )
static void hb_socketSetBlocking( HB_SOCKET_STRUCT *Socket )
{
#ifdef HB_OS_WIN_32
ULONG mode = 0;
ioctlsocket( Socket->com, FIONBIO, &mode );
#else
int flags = fcntl( Socket->com, F_GETFL, 0 );
if( flags != -1 )
{
flags &= ~O_NONBLOCK;
fcntl( Socket->com, F_SETFL, ( long ) flags );
}
#endif
}
| hbinet.c | 416 |
| STATIC INT | hb_socketConnect( HB_SOCKET_STRUCT *Socket )
static int hb_socketConnect( HB_SOCKET_STRUCT *Socket )
{
int iErr1;
#if ! defined(HB_OS_WIN_32)
int iErrval;
socklen_t iErrvalLen;
#endif
int iOpt = 1;
hb_vmUnlock();
setsockopt( Socket->com, SOL_SOCKET, SO_KEEPALIVE, (const char *) &iOpt , sizeof( iOpt ));
/* we'll be using a nonblocking function */
hb_socketSetNonBlocking( Socket );
iErr1 = connect( Socket->com, (struct sockaddr *) &Socket->remote, sizeof(Socket->remote) );
if( iErr1 != 0 )
{
#if defined(HB_OS_WIN_32)
if( WSAGetLastError() != WSAEWOULDBLOCK )
#else
if( errno != EINPROGRESS )
#endif
{
HB_SOCKET_SET_ERROR( Socket );
}
else
{
/* Now we wait for socket connection or timeout */
#if defined(HB_OS_WIN_32)
iErr1 = hb_selectWriteExceptSocket( Socket );
if( iErr1 == 2 )
{
HB_SOCKET_SET_ERROR2( Socket, 2, "Connection failed" );
}
else if( iErr1 == 1 )
{
/* success */
}
#else
if( hb_selectWriteSocket( Socket ) )
{
/* Connection has been completed with a failure or a success */
iErrvalLen = sizeof( iErrval );
iErr1 = getsockopt( Socket->com,
SOL_SOCKET,
SO_ERROR,
(void *) &iErrval,
&iErrvalLen
);
if( iErr1 )
{
HB_SOCKET_SET_ERROR1( Socket, iErr1 );
}
else if( iErrval )
{
HB_SOCKET_SET_ERROR1( Socket, iErrval );
}
/* Success! */
}
#endif
/* Timed out */
else
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
}
}
}
hb_socketSetBlocking( Socket );
hb_vmLock();
return Socket->errorCode == 0;
}
| hbinet.c | 433 |
| STATIC HB_GARBAGE_FUNC( | hb_inetSocketFinalize )
static HB_GARBAGE_FUNC( hb_inetSocketFinalize )
{
HB_SOCKET_STRUCT *Socket = ( HB_SOCKET_STRUCT *) Cargo;
if( Socket->com != ( HB_SOCKET_T ) -1 )
{
#if defined( HB_OS_WIN_32 )
shutdown( Socket->com, SD_BOTH );
#elif defined(HB_OS_OS2)
shutdown( Socket->com, SO_RCV_SHUTDOWN + SO_SND_SHUTDOWN );
#elif !defined(__WATCOMC__)
shutdown( Socket->com, SHUT_RDWR );
#endif
HB_INET_CLOSE( Socket->com );
Socket->com = ( HB_SOCKET_T ) -1;
}
if( Socket->caPeriodic )
{
hb_itemRelease( Socket->caPeriodic );
Socket->caPeriodic = NULL;
}
}
| hbinet.c | 513 |
| HB_FUNC | HB_INETINIT(void)
HB_FUNC( HB_INETINIT )
{
if( s_iSessions )
{
s_iSessions++;
}
else
{
#if defined(HB_OS_WIN_32)
#define HB_MKWORD( l, h ) ((WORD)(((BYTE)(l)) | (((WORD)((BYTE)(h))) << 8)))
WSADATA wsadata;
WSAStartup( HB_MKWORD(1,1), &wsadata );
#elif defined( HB_INET_LINUX_INTERRUPT )
signal( HB_INET_LINUX_INTERRUPT, hb_inetLinuxSigusrHandle );
#endif
s_iSessions = 1;
}
}
| hbinet.c | 542 |
| HB_FUNC | HB_INETCLEANUP(void)
HB_FUNC( HB_INETCLEANUP )
{
if( --s_iSessions == 0 )
{
#if defined(HB_OS_WIN_32)
WSACleanup();
#endif
}
}
| hbinet.c | 561 |
| HB_FUNC | HB_INETCREATE(void)
HB_FUNC( HB_INETCREATE )
{
PHB_ITEM pSocket = NULL;
HB_SOCKET_STRUCT *Socket;
HB_SOCKET_INIT( Socket, pSocket );
if( ISNUM( 1 ) )
Socket->timeout = hb_parni(1);
hb_itemReturnRelease( pSocket );
}
| hbinet.c | 575 |
| HB_FUNC | HB_INETCLOSE(void)
HB_FUNC( HB_INETCLOSE )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else if( Socket->com != ( HB_SOCKET_T ) -1 )
{
hb_vmUnlock();
#if defined( HB_OS_WIN_32 )
shutdown( Socket->com, SD_BOTH );
#elif defined(HB_OS_OS2)
shutdown( Socket->com, SO_RCV_SHUTDOWN + SO_SND_SHUTDOWN );
#elif !defined(__WATCOMC__)
shutdown( Socket->com, SHUT_RDWR );
#endif
hb_retni( HB_INET_CLOSE( Socket->com ) );
Socket->com = ( HB_SOCKET_T ) -1;
#ifdef HB_INET_LINUX_INTERRUPT
kill( 0, HB_INET_LINUX_INTERRUPT );
#endif
hb_vmLock();
}
else
hb_retni( -1 );
}
| hbinet.c | 586 |
| HB_FUNC | HB_INETFD(void)
HB_FUNC( HB_INETFD )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
{
hb_retnint( Socket->com );
if( ISLOG( 2 ) && hb_parl( 2 ) )
Socket->com = ( HB_SOCKET_T ) -1;
}
}
| hbinet.c | 617 |
| HB_FUNC | HB_INETSTATUS(void)
HB_FUNC( HB_INETSTATUS )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
/* TODO: hb_retni( Socket->status ); */
hb_retni( Socket->com == ( HB_SOCKET_T ) -1 ? -1 : 1 );
}
| hbinet.c | 635 |
| HB_FUNC | HB_INETERRORCODE(void)
HB_FUNC( HB_INETERRORCODE )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
hb_retni( Socket->errorCode );
}
| hbinet.c | 667 |
| HB_FUNC | HB_INETERRORDESC(void)
HB_FUNC( HB_INETERRORDESC )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
hb_retc( Socket->errorDesc );
}
| hbinet.c | 677 |
| HB_FUNC | HB_INETCLEARERROR(void)
HB_FUNC( HB_INETCLEARERROR )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
HB_SOCKET_ZERO_ERROR( Socket );
}
| hbinet.c | 690 |
| HB_FUNC | HB_INETCOUNT(void)
HB_FUNC( HB_INETCOUNT )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
hb_retni( Socket->count );
}
| hbinet.c | 701 |
| HB_FUNC | HB_INETADDRESS(void)
HB_FUNC( HB_INETADDRESS )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
char *addr;
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
{
addr = inet_ntoa( Socket->remote.sin_addr );
hb_retc( addr );
}
}
| hbinet.c | 711 |
| HB_FUNC | HB_INETPORT(void)
HB_FUNC( HB_INETPORT )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
hb_retni( ntohs( Socket->remote.sin_port ) );
}
| hbinet.c | 725 |
| HB_FUNC | HB_INETTIMEOUT(void)
HB_FUNC( HB_INETTIMEOUT )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket )
{
hb_retni( Socket->timeout );
if( ISNUM( 2 ) )
Socket->timeout = hb_parni( 2 );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbinet.c | 736 |
| HB_FUNC | HB_INETCLEARTIMEOUT(void)
HB_FUNC( HB_INETCLEARTIMEOUT )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
Socket->timeout = -1;
}
| hbinet.c | 750 |
| HB_FUNC | HB_INETTIMELIMIT(void)
HB_FUNC( HB_INETTIMELIMIT )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
{
hb_retnl( Socket->timelimit );
if( ISNUM( 2 ) )
Socket->timelimit = hb_parnl(2);
}
}
| hbinet.c | 760 |
| HB_FUNC | HB_INETCLEARTIMELIMIT(void)
HB_FUNC( HB_INETCLEARTIMELIMIT )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
Socket->timelimit = -1;
}
| hbinet.c | 774 |
| HB_FUNC | HB_INETPERIODCALLBACK(void)
HB_FUNC( HB_INETPERIODCALLBACK )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
PHB_ITEM pExec = hb_param( 2, HB_IT_ARRAY | HB_IT_BLOCK | HB_IT_SYMBOL );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
{
if( Socket->caPeriodic )
hb_itemReturn( Socket->caPeriodic );
if( pExec )
{
if( Socket->caPeriodic )
hb_itemRelease( Socket->caPeriodic );
Socket->caPeriodic = hb_itemClone( pExec );
}
}
}
| hbinet.c | 784 |
| HB_FUNC | HB_INETCLEARPERIODCALLBACK(void)
HB_FUNC( HB_INETCLEARPERIODCALLBACK )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else if( Socket->caPeriodic )
{
hb_itemRelease( Socket->caPeriodic );
Socket->caPeriodic = NULL;
}
}
| hbinet.c | 804 |
| HB_FUNC | HB_INETGETSNDBUFSIZE(void)
HB_FUNC( HB_INETGETSNDBUFSIZE )
{
HB_SOCKET_STRUCT * Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else if( !hb_inetIsOpen( Socket ) )
hb_retni( -1 );
else
{
int value;
socklen_t len = sizeof( value );
#if defined( HB_OS_WIN_32 )
getsockopt( Socket->com, SOL_SOCKET, SO_SNDBUF, ( char * ) &value, &len );
#else
getsockopt( Socket->com, SOL_SOCKET, SO_SNDBUF, ( void * ) &value, &len );
#endif
hb_retni( value );
}
}
| hbinet.c | 817 |
| HB_FUNC | HB_INETGETRCVBUFSIZE(void)
HB_FUNC( HB_INETGETRCVBUFSIZE )
{
HB_SOCKET_STRUCT * Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else if( !hb_inetIsOpen( Socket ) )
hb_retni( -1 );
else
{
int value;
socklen_t len = sizeof( value );
#if defined( HB_OS_WIN_32 )
getsockopt( Socket->com, SOL_SOCKET, SO_RCVBUF, ( char * ) &value, &len );
#else
getsockopt( Socket->com, SOL_SOCKET, SO_RCVBUF, ( void * ) &value, &len );
#endif
hb_retni( value );
}
}
| hbinet.c | 838 |
| HB_FUNC | HB_INETSETSNDBUFSIZE(void)
HB_FUNC( HB_INETSETSNDBUFSIZE )
{
HB_SOCKET_STRUCT * Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else if( !hb_inetIsOpen( Socket ) )
hb_retni( -1 );
else
{
int value = hb_parni( 2 );
#if defined( HB_OS_WIN_32 )
setsockopt( Socket->com, SOL_SOCKET, SO_SNDBUF, ( char * ) &value, sizeof( value ) );
#else
setsockopt( Socket->com, SOL_SOCKET, SO_SNDBUF, ( void * ) &value, sizeof( value ) );
#endif
hb_retni( value );
}
}
| hbinet.c | 859 |
| HB_FUNC | HB_INETSETRCVBUFSIZE(void)
HB_FUNC( HB_INETSETRCVBUFSIZE )
{
HB_SOCKET_STRUCT * Socket = HB_PARSOCKET( 1 );
if( Socket == NULL )
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else if( !hb_inetIsOpen( Socket ) )
hb_retni( -1 );
else
{
int value = hb_parni( 2 );
#if defined( HB_OS_WIN_32 )
setsockopt( Socket->com, SOL_SOCKET, SO_RCVBUF, ( char * ) &value, sizeof( value ) );
#else
setsockopt( Socket->com, SOL_SOCKET, SO_RCVBUF, ( void * ) &value, sizeof( value ) );
#endif
hb_retni( value );
}
}
| hbinet.c | 879 |
| STATIC VOID | s_inetRecvInternal( int iMode )
static void s_inetRecvInternal( int iMode )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING );
char *buffer;
int iLen, iMaxLen, iReceived;
int iTimeElapsed;
if( Socket == NULL || pBuffer == NULL || !ISBYREF( 2 ) )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
hb_retni( 0 );
return;
}
pBuffer = hb_itemUnShare( pBuffer );
buffer = hb_itemGetCPtr( pBuffer );
iLen = hb_itemGetCLen( pBuffer );
if( ISNIL( 3 ) )
{
iMaxLen = iLen;
}
else
{
iMaxLen = hb_parni( 3 );
if( iLen < iMaxLen )
iMaxLen = iLen;
}
hb_vmUnlock();
iReceived = 0;
iTimeElapsed = 0;
HB_SOCKET_ZERO_ERROR( Socket );
do
{
if( hb_selectReadSocket( Socket ) )
{
iLen = recv( Socket->com, buffer + iReceived, iMaxLen - iReceived, MSG_NOSIGNAL );
if( iLen > 0 )
iReceived += iLen;
/* Called from InetRecv()? */
if( iMode == 0 )
break;
}
else
{
/* timed out; let's see if we have to run a cb routine */
iTimeElapsed += Socket->timeout;
hb_vmLock();
/* if we have a caPeriodic, timeLimit is our REAL timeout */
if( Socket->caPeriodic )
{
hb_execFromArray( Socket->caPeriodic );
/* do we continue? */
if( ! hb_parl( -1 ) || hb_vmRequestQuery() != 0 ||
( Socket->timelimit != -1 && iTimeElapsed >= Socket->timelimit ) )
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
hb_retni( iReceived );
return;
}
/* Declare success to continue loop */
iLen = 1;
}
else /* the timeout has gone, and we have no recovery routine */
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
hb_retni( iReceived );
return;
}
hb_vmUnlock();
}
}
while( iReceived < iMaxLen && iLen > 0 );
Socket->count = iReceived;
hb_vmLock();
if( iLen == 0 )
{
HB_SOCKET_SET_ERROR2( Socket, -2, "Connection closed" );
hb_retni( iLen );
}
else if( iLen < 0 )
{
HB_SOCKET_SET_ERROR( Socket );
hb_retni( iLen );
}
else
hb_retni( iReceived );
}
| hbinet.c | 905 |
| HB_FUNC | HB_INETRECV(void)
HB_FUNC( HB_INETRECV )
{
s_inetRecvInternal( 0 );
}
| hbinet.c | 1011 |
| HB_FUNC | HB_INETRECVALL(void)
HB_FUNC( HB_INETRECVALL )
{
s_inetRecvInternal( 1 );
}
| hbinet.c | 1017 |
| STATIC VOID | s_inetRecvPattern( const char *szPattern )
static void s_inetRecvPattern( const char *szPattern )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
PHB_ITEM pResult = hb_param( 2, HB_IT_BYREF );
PHB_ITEM pMaxSize = hb_param( 3, HB_IT_NUMERIC );
PHB_ITEM pBufferSize = hb_param( 4, HB_IT_NUMERIC );
char cChar = '\0';
char * Buffer;
int iAllocated, iBufferSize, iMax;
int iLen = 0, iPatLen;
int iPos = 0, iTimeElapsed;
if( Socket == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
hb_retni( 0 );
return;
}
if( pBufferSize )
{
iBufferSize = hb_itemGetNI( pBufferSize );
}
else
{
iBufferSize = 80;
}
if( pMaxSize )
{
iMax = hb_itemGetNI( pMaxSize );
}
else
{
iMax = 0;
}
hb_vmUnlock();
HB_SOCKET_ZERO_ERROR( Socket );
Buffer = (char *) hb_xgrab( iBufferSize );
iAllocated = iBufferSize;
iTimeElapsed = 0;
iPatLen = ( int ) strlen( szPattern );
do
{
if( iPos == iAllocated - 1 )
{
iAllocated += iBufferSize;
Buffer = ( char * ) hb_xrealloc( Buffer, iAllocated );
}
if( hb_selectReadSocket( Socket ) )
iLen = recv( Socket->com, &cChar, 1, MSG_NOSIGNAL );
else
{
iTimeElapsed += Socket->timeout;
if( Socket->caPeriodic )
{
BOOL fResult;
hb_vmLock();
hb_execFromArray( Socket->caPeriodic );
fResult = hb_parl( -1 ) && hb_vmRequestQuery() == 0;
hb_vmUnlock();
/* do we continue? */
if( fResult &&
( Socket->timelimit == -1 || iTimeElapsed < Socket->timelimit ) )
{
continue;
}
}
/* this signals timeout */
iLen = -2;
}
if( iLen > 0 )
{
Buffer[ iPos++ ] = cChar;
/* verify endsequence recognition automata status */
if( iPos >= iPatLen &&
memcmp( Buffer + iPos - iPatLen, szPattern, iPatLen ) == 0 )
{
break;
}
}
else
{
break;
}
}
while( iMax == 0 || iPos < iMax );
hb_vmLock();
if( iLen <= 0 )
{
if( pResult )
{
hb_itemPutNI( pResult, iLen );
}
if( iLen == 0 )
{
HB_SOCKET_SET_ERROR2( Socket, -2, "Connection closed" );
}
else if( iLen == -2 )
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
}
else
{
HB_SOCKET_SET_ERROR( Socket );
}
hb_xfree( (void *) Buffer );
}
else
{
if( iMax == 0 || iPos < iMax )
{
iPos -= iPatLen;
Socket->count = iPos;
if( pResult )
{
hb_itemPutNI( pResult, iPos );
}
hb_retclen_buffer( Buffer, iPos );
}
else
{
HB_SOCKET_SET_ERROR2( Socket, -3, "Buffer overrun" );
if( pResult )
{
hb_itemPutNI( pResult, -2 );
}
hb_xfree( (void *) Buffer );
hb_retc( NULL );
}
}
}
| hbinet.c | 1023 |
| HB_FUNC | HB_INETRECVLINE(void)
HB_FUNC( HB_INETRECVLINE )
{
s_inetRecvPattern( "\r\n" );
}
| hbinet.c | 1179 |
| HB_FUNC | HB_INETRECVENDBLOCK(void)
HB_FUNC( HB_INETRECVENDBLOCK )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
PHB_ITEM pProto = hb_param( 2, HB_IT_ARRAY | HB_IT_STRING );
PHB_ITEM pResult = hb_param( 3, HB_IT_BYREF );
PHB_ITEM pMaxSize = hb_param( 4, HB_IT_NUMERIC );
PHB_ITEM pBufferSize = hb_param( 5, HB_IT_NUMERIC );
char cChar = '\0';
char * Buffer;
char ** Proto;
int iAllocated, iBufferSize, iMax;
int iLen;
int iPos = 0;
int iPosProto;
int iTimeElapsed = 0;
int iprotos;
int i;
int *iprotosize;
int ifindproto = 0;
BOOL bProtoFound;
if( Socket == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
if( pResult )
hb_itemPutNI( pResult, -1 );
hb_retc( NULL );
return;
}
if( pProto )
{
if( HB_IS_ARRAY( pProto ) )
{
iprotos = (int) hb_arrayLen( pProto );
if( iprotos <= 0 )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
Proto = (char**) hb_xgrab( sizeof(char*) * iprotos );
iprotosize = (int *) hb_xgrab( sizeof(int) * iprotos );
for( i = 0; i < iprotos; i++ )
{
Proto[ i ] = hb_arrayGetCPtr( pProto, i + 1 );
iprotosize[ i ] = hb_arrayGetCLen( pProto, i + 1 );
}
}
else
{
Proto = (char**) hb_xgrab( sizeof(char*) );
iprotosize = (int *) hb_xgrab( sizeof(int) );
Proto[0] = hb_itemGetCPtr( pProto );
iprotosize[0] = hb_itemGetCLen( pProto );
iprotos = 1;
}
}
else
{
Proto = (char**) hb_xgrab( sizeof(char*) );
iprotosize = (int *) hb_xgrab( sizeof(int) );
Proto[0] = (char *) "\r\n";
iprotos = 1;
iprotosize[0] = 2;
}
iBufferSize = pBufferSize ? hb_itemGetNI( pBufferSize ) : 80;
iMax = pMaxSize ? hb_itemGetNI( pMaxSize ) : 0;
hb_vmUnlock();
HB_SOCKET_ZERO_ERROR( Socket );
Buffer = (char *) hb_xgrab( iBufferSize );
iAllocated = iBufferSize;
do
{
if( iPos == iAllocated - 1 )
{
iAllocated += iBufferSize;
Buffer = ( char * ) hb_xrealloc( Buffer, iAllocated );
}
iLen = 0;
if( hb_selectReadSocket( Socket ) )
{
iLen = recv( Socket->com, &cChar, 1, MSG_NOSIGNAL );
}
else
{
iTimeElapsed += Socket->timeout;
if( Socket->caPeriodic )
{
BOOL fResult;
hb_vmLock();
hb_execFromArray( Socket->caPeriodic );
fResult = hb_parl( -1 ) && hb_vmRequestQuery() == 0;
hb_vmUnlock();
if( fResult &&
( Socket->timelimit == -1 || iTimeElapsed < Socket->timelimit ) )
{
continue;
}
}
iLen = -2;
}
if( iLen > 0 )
{
int protos;
bProtoFound = 0;
for( protos = 0; protos < iprotos; protos++ )
{
if( cChar == Proto[protos][iprotosize[protos] - 1] && iprotosize[protos] <= iPos )
{
bProtoFound = 1;
for( iPosProto = 0; iPosProto < ( iprotosize[protos] - 1 ); iPosProto++ )
{
if( Proto[protos][iPosProto] != Buffer[ ( iPos - iprotosize[protos] ) + iPosProto + 1 ] )
{
bProtoFound = 0;
break;
}
}
if(bProtoFound)
{
ifindproto = protos;
break;
}
}
}
if( bProtoFound )
break;
Buffer[ iPos++ ] = cChar;
}
else
break;
}
while( iMax == 0 || iPos < iMax );
hb_vmLock();
if( iLen <= 0 )
{
if( pResult )
{
hb_itemPutNI( pResult, iLen );
}
if( iLen == 0 )
{
HB_SOCKET_SET_ERROR2( Socket, -2, "Connection closed" );
}
else if( iLen == -2 )
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
}
else
{
HB_SOCKET_SET_ERROR( Socket );
}
hb_xfree( ( void * ) Buffer );
hb_retc( NULL );
}
else
{
if( iMax == 0 || iPos < iMax )
{
Socket->count = iPos;
if( pResult )
{
hb_itemPutNI( pResult, iPos - (iprotosize[ifindproto]-1) );
}
hb_retclen_buffer( Buffer, iPos - (iprotosize[ifindproto]-1) );
}
else
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Buffer overrun" );
if( pResult )
{
hb_itemPutNI( pResult, -2 );
}
hb_xfree( (void *) Buffer );
hb_retc( NULL );
}
}
hb_xfree( Proto );
hb_xfree( iprotosize );
}
| hbinet.c | 1184 |
| HB_FUNC | HB_INETDATAREADY(void)
HB_FUNC( HB_INETDATAREADY )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
int iVal;
fd_set rfds;
struct timeval tv = {0,0};
if( Socket == NULL || ( hb_pcount() > 1 && ! ISNUM( 2 ) ) )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
hb_retl( FALSE );
return;
}
if( ISNUM( 1 ) )
{
iVal = hb_parni( 2 );
tv.tv_sec = iVal / 1000;
tv.tv_usec = (iVal % 1000) * 1000;
}
hb_vmUnlock();
HB_SOCKET_ZERO_ERROR( Socket );
FD_ZERO(&rfds);
FD_SET(Socket->com, &rfds);
iVal = select( Socket->com + 1, &rfds, NULL, NULL, &tv );
/* Don't rely on the value of tv now! */
if( iVal < 0 )
{
HB_SOCKET_SET_ERROR( Socket );
}
hb_vmLock();
hb_retni( iVal );
}
| hbinet.c | 1395 |
| STATIC VOID | s_inetSendInternal( int iMode )
static void s_inetSendInternal( int iMode )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING );
char *Buffer;
int iLen, iSent, iSend;
if( Socket == NULL || pBuffer == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
hb_retni( 0 );
return;
}
Buffer = hb_itemGetCPtr( pBuffer );
iSend = ( int ) hb_itemGetCLen( pBuffer );
if( ISNUM( 3 ) )
{
iLen = hb_parni( 3 );
if( iLen < iSend )
iSend = iLen;
}
hb_vmUnlock();
HB_SOCKET_ZERO_ERROR( Socket );
iSent = 0;
iLen = 0;
while( iSent < iSend )
{
iLen = 0;
if( hb_selectWriteSocket( Socket ) )
iLen = send( Socket->com, Buffer + iSent, iSend - iSent, MSG_NOSIGNAL );
if( iLen > 0 )
{
iSent += iLen;
}
else if( iLen == 0 )
{
HB_SOCKET_SET_ERROR2( Socket, -1 , "Timeout" );
break;
}
else
{
HB_SOCKET_SET_ERROR( Socket );
break;
}
if( iMode == 0 )
break;
}
Socket->count = iSent;
hb_vmLock();
hb_retni( iLen > 0 ? iSent : -1 );
}
| hbinet.c | 1441 |
| HB_FUNC | HB_INETSEND(void)
HB_FUNC( HB_INETSEND )
{
s_inetSendInternal( 0 );
}
| hbinet.c | 1505 |
| HB_FUNC | HB_INETSENDALL(void)
HB_FUNC( HB_INETSENDALL )
{
s_inetSendInternal( 1 );
}
| hbinet.c | 1510 |
| HB_FUNC | HB_INETGETHOSTS(void)
HB_FUNC( HB_INETGETHOSTS )
{
char * szHost = hb_parc( 1 );
struct hostent *Host;
char ** cHosts;
int iCount = 0;
if( szHost == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
Host = hb_getHosts( szHost, NULL );
if( Host )
{
cHosts = Host->h_addr_list;
while( *cHosts )
{
iCount++;
cHosts++;
}
}
if( iCount == 0 )
hb_reta( 0 );
else
{
PHB_ITEM pHosts = hb_itemArrayNew( iCount );
iCount = 0;
cHosts = Host->h_addr_list;
while( *cHosts )
{
hb_arraySetC( pHosts, ++iCount,
inet_ntoa( *( ( struct in_addr * ) * cHosts ) ) );
cHosts++;
}
hb_itemReturnRelease( pHosts );
}
}
| hbinet.c | 1520 |
| HB_FUNC | HB_INETGETALIAS(void)
HB_FUNC( HB_INETGETALIAS )
{
char * szHost = hb_parc( 1 );
struct hostent *Host;
char ** cHosts;
int iCount = 0;
if( szHost == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
Host = hb_getHosts( szHost, NULL );
if( Host )
{
cHosts = Host->h_aliases;
while( *cHosts )
{
iCount++;
cHosts++;
}
}
if( iCount == 0 )
hb_reta( 0 );
else
{
PHB_ITEM pHosts = hb_itemArrayNew( iCount );
iCount = 0;
cHosts = Host->h_aliases;
while( *cHosts )
{
hb_arraySetC( pHosts, ++iCount,
inet_ntoa( *( ( struct in_addr * ) * cHosts ) ) );
cHosts++;
}
hb_itemReturnRelease( pHosts );
}
}
| hbinet.c | 1562 |
| HB_FUNC | HB_INETSERVER(void)
HB_FUNC( HB_INETSERVER )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 2 );
PHB_ITEM pSocket = NULL;
char * szAddress;
int iPort;
int iOpt = 1;
int iListen;
/* Parameter error checking */
if( ! ISNUM( 1 ) || ( Socket == NULL && !ISNIL( 2 ) ) )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
if( Socket )
HB_SOCKET_ZERO_ERROR( Socket );
else
HB_SOCKET_INIT( Socket, pSocket );
/* Creates comm socket */
#if defined(HB_OS_WIN_32)
Socket->com = socket( AF_INET, SOCK_STREAM, 0 );
#else
Socket->com = socket( PF_INET, SOCK_STREAM, 0 );
#endif
if( Socket->com == ( HB_SOCKET_T ) -1 )
{
HB_SOCKET_SET_ERROR( Socket );
if( pSocket )
hb_itemReturnRelease( pSocket );
else
hb_itemReturn( hb_param( 2, HB_IT_ANY ) );
return;
}
/* we'll be using only nonblocking sockets */
/* hb_socketSetNonBlocking( Socket ); */
/* Reusable socket; under unix, do not wait it is unused */
setsockopt( Socket->com, SOL_SOCKET, SO_REUSEADDR, (const char *) &iOpt, sizeof( iOpt ) );
iPort = htons( hb_parni( 1 ) );
Socket->remote.sin_family = AF_INET;
Socket->remote.sin_port = iPort;
szAddress = hb_parc( 2 );
Socket->remote.sin_addr.s_addr = szAddress ? inet_addr( szAddress ) : INADDR_ANY;
iListen = ISNUM( 3 ) ? hb_parni( 3 ) : 10;
hb_vmUnlock();
if( bind( Socket->com, (struct sockaddr *) &Socket->remote, sizeof(Socket->remote) ) )
{
HB_SOCKET_SET_ERROR( Socket );
HB_INET_CLOSE( Socket->com );
Socket->com = ( HB_SOCKET_T ) -1;
}
else if( listen( Socket->com, iListen ) )
{
HB_SOCKET_SET_ERROR( Socket );
HB_INET_CLOSE( Socket->com );
Socket->com = ( HB_SOCKET_T ) -1;
}
hb_vmLock();
if( pSocket )
hb_itemReturnRelease( pSocket );
else
hb_itemReturn( hb_param( 2, HB_IT_ANY ) );
}
| hbinet.c | 1608 |
| HB_FUNC | HB_INETACCEPT(void)
HB_FUNC( HB_INETACCEPT )
{
#if !defined(EAGAIN)
#define EAGAIN -1
#endif
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
HB_SOCKET_STRUCT *NewSocket;
HB_SOCKET_T incoming = 0;
int iError = EAGAIN;
struct sockaddr_in si_remote;
#if defined(_XOPEN_SOURCE_EXTENDED)
socklen_t Len;
#elif defined(HB_OS_WIN_32)
int Len;
#else
unsigned int Len;
#endif
if( Socket == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
return;
}
hb_vmUnlock();
Len = sizeof( struct sockaddr_in );
/*
* Accept can (and should) be asynchronously stopped by closing the
* accepting socket. this will make the wait to terminate, and the
* calling program will be notivfied through the status of the
* returned socket.
*/
HB_SOCKET_ZERO_ERROR( Socket );
/* Connection incoming */
while( iError == EAGAIN )
{
if( hb_selectReadSocket( Socket ) )
{
/* On error (e.g. async connection closed) , com will be -1 and
errno == 22 (invalid argument ) */
incoming = accept( Socket->com, (struct sockaddr *) &si_remote, &Len );
if( incoming == ( HB_SOCKET_T ) -1 )
{
#if defined(HB_OS_WIN_32)
iError = WSAGetLastError();
#else
iError = errno;
#endif
}
else
iError = 0;
}
/* Timeout expired */
else
iError = -1;
}
hb_vmLock();
if( iError == -1 )
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
}
else if( iError > 0 )
{
HB_SOCKET_SET_ERROR1( Socket, iError );
}
else
{
PHB_ITEM pSocket = NULL;
/* we'll be using only nonblocking sockets */
HB_SOCKET_INIT( NewSocket, pSocket );
memcpy( &NewSocket->remote, &si_remote, Len );
NewSocket->com = incoming;
/* hb_socketSetNonBlocking( NewSocket ); */
hb_itemReturnRelease( pSocket );
}
}
| hbinet.c | 1685 |
| HB_FUNC | HB_INETCONNECT(void)
HB_FUNC( HB_INETCONNECT )
{
char * szHost = hb_parc( 1 );
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 3 );
PHB_ITEM pSocket = NULL;
struct hostent *Host;
int iPort;
if( szHost == NULL || !ISNUM( 2 ) || ( Socket == NULL && !ISNIL( 3 ) ) )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
if( Socket )
{
if( Socket->com != ( HB_SOCKET_T ) -1 )
{
HB_INET_CLOSE( Socket->com );
Socket->com = ( HB_SOCKET_T ) -1;
}
HB_SOCKET_ZERO_ERROR( Socket );
}
else
HB_SOCKET_INIT( Socket, pSocket );
Host = hb_getHosts( szHost, Socket );
/* error had been set by get hosts */
if( Host )
{
/* Creates comm socket */
#if defined(HB_OS_WIN_32)
Socket->com = socket( AF_INET, SOCK_STREAM, 0);
#else
Socket->com = socket( PF_INET, SOCK_STREAM, 0);
#endif
if( Socket->com == ( HB_SOCKET_T ) -1 )
{
HB_SOCKET_SET_ERROR( Socket );
}
else
{
iPort = htons( hb_parni( 2 ) );
Socket->remote.sin_family = AF_INET;
Socket->remote.sin_port= iPort;
Socket->remote.sin_addr.s_addr = (*(UINT *)Host->h_addr_list[0]);
hb_socketConnect( Socket );
}
}
if( pSocket )
hb_itemReturnRelease( pSocket );
else
hb_itemReturn( hb_param( 3, HB_IT_ANY ) );
}
| hbinet.c | 1778 |
| HB_FUNC | HB_INETCONNECTIP(void)
HB_FUNC( HB_INETCONNECTIP )
{
char * szHost = hb_parc( 1 );
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 3 );
PHB_ITEM pSocket = NULL;
int iPort = hb_parni( 2 );
if( szHost == NULL || iPort == 0 || ( Socket == NULL && !ISNIL( 3 ) ) )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
if( Socket )
{
if( Socket->com != ( HB_SOCKET_T ) -1 )
{
HB_INET_CLOSE( Socket->com );
Socket->com = ( HB_SOCKET_T ) -1;
}
HB_SOCKET_ZERO_ERROR( Socket );
}
else
{
HB_SOCKET_INIT( Socket, pSocket );
}
/* Creates comm socket */
#if defined(HB_OS_WIN_32)
Socket->com = socket( AF_INET, SOCK_STREAM, 0);
#else
Socket->com = socket( PF_INET, SOCK_STREAM, 0);
#endif
if( Socket->com == ( HB_SOCKET_T ) -1 )
{
HB_SOCKET_SET_ERROR( Socket );
}
else
{
iPort = htons( iPort );
Socket->remote.sin_family = AF_INET;
Socket->remote.sin_port= iPort;
Socket->remote.sin_addr.s_addr = inet_addr( szHost );
hb_socketConnect( Socket );
}
if( pSocket )
hb_itemReturnRelease( pSocket );
else
hb_itemReturn( hb_param( 3, HB_IT_ANY ) );
}
| hbinet.c | 1840 |
| HB_FUNC | HB_INETDGRAMBIND(void)
HB_FUNC( HB_INETDGRAMBIND )
{
HB_SOCKET_STRUCT *Socket;
PHB_ITEM pSocket = NULL;
int iPort = hb_parni(1);
int iOpt = 1;
char * szAddress;
/* Parameter error checking */
if( iPort == 0 || ( hb_pcount() > 3 && ! ISCHAR( 4 ) ) )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
HB_SOCKET_INIT( Socket, pSocket );
/* Creates comm socket */
#if defined(HB_OS_WIN_32)
Socket->com = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
#else
Socket->com = socket( PF_INET, SOCK_DGRAM, 0 );
#endif
if( Socket->com == ( HB_SOCKET_T ) -1 )
{
HB_SOCKET_SET_ERROR( Socket );
hb_itemReturnRelease( pSocket );
return;
}
/* Reusable socket; under unix, do not wait it is unused */
setsockopt( Socket->com, SOL_SOCKET, SO_REUSEADDR, (const char *) &iOpt, sizeof( iOpt ));
/* Setting broadcast if needed. */
if( hb_parl( 3 ) )
{
iOpt = 1;
setsockopt( Socket->com, SOL_SOCKET, SO_BROADCAST, (const char *) &iOpt, sizeof( iOpt ));
}
/* Binding here */
iPort = htons( iPort );
Socket->remote.sin_family = AF_INET;
Socket->remote.sin_port = iPort;
szAddress = hb_parc( 2 );
Socket->remote.sin_addr.s_addr = szAddress ? inet_addr( szAddress ) : INADDR_ANY;
hb_vmUnlock();
if( bind( Socket->com, (struct sockaddr *) &Socket->remote, sizeof(Socket->remote) ) )
{
HB_SOCKET_SET_ERROR( Socket );
HB_INET_CLOSE( Socket->com );
Socket->com = ( HB_SOCKET_T ) -1;
}
else if( hb_pcount() > 3 )
{
#ifndef IP_ADD_MEMBERSHIP
#define IP_ADD_MEMBERSHIP 5 /* which header should this be in? */
#endif
/* this structure should be define in a header file. The MS SDK indicates that */
/* it is in Ws2tcpip.h but I'm not sure I know where it should go in xHb */
struct ip_mreq
{
struct in_addr imr_multiaddr; /* IP multicast address of group */
struct in_addr imr_interface; /* local IP address of interface */
};
struct ip_mreq mreq ;
mreq.imr_multiaddr.s_addr = inet_addr( hb_parc( 4 ) ); /* HELLO_GROUP */
mreq.imr_interface.s_addr = htonl( INADDR_ANY );
#ifndef IPPROTO_IP
/*
* some systems may not have this definitions, it should
* be 0 what works with TCP/UDP sockets or explicitly set
* to IPPROTO_TCP/IPPROTO_UDP
*/
# define IPPROTO_IP 0
#endif
if( setsockopt( Socket->com, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *) &mreq, sizeof( mreq ) ) < 0 )
{
HB_SOCKET_SET_ERROR( Socket );
}
}
hb_vmLock();
hb_itemReturnRelease( pSocket );
}
| hbinet.c | 1899 |
| HB_FUNC | HB_INETDGRAM(void)
HB_FUNC( HB_INETDGRAM )
{
HB_SOCKET_STRUCT *Socket;
PHB_ITEM pSocket = NULL;
int iOpt = 1;
HB_SOCKET_INIT( Socket, pSocket );
/* Creates comm socket */
#if defined(HB_OS_WIN_32)
Socket->com = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
#else
Socket->com = socket( PF_INET, SOCK_DGRAM, 0 );
#endif
if( Socket->com == ( HB_SOCKET_T ) -1 )
{
HB_SOCKET_SET_ERROR( Socket );
hb_itemReturnRelease( pSocket );
return;
}
/* Setting broadcast if needed. */
if( hb_parl( 1 ) )
{
iOpt = 1;
setsockopt( Socket->com, SOL_SOCKET, SO_BROADCAST, (const char *) &iOpt, sizeof( iOpt ));
}
/* we'll be using non blocking sockets in all functions */
/* hb_socketSetNonBlocking( Socket ); */
hb_itemReturnRelease( pSocket );
}
| hbinet.c | 1996 |
| HB_FUNC | HB_INETDGRAMSEND(void)
HB_FUNC( HB_INETDGRAMSEND )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
char * szAddress = hb_parc( 2 );
int iPort = hb_parni( 3 );
PHB_ITEM pBuffer = hb_param( 4, HB_IT_STRING );
int iLen;
char *szBuffer ;
if( Socket == NULL ||
szAddress == NULL || iPort == 0 || pBuffer == NULL )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
Socket->count = 0;
hb_retni( 0 );
return;
}
Socket->remote.sin_family = AF_INET;
Socket->remote.sin_port = htons( iPort );
Socket->remote.sin_addr.s_addr = inet_addr( szAddress );
szBuffer = hb_itemGetCPtr( pBuffer );
iLen = ( int ) hb_itemGetCLen( pBuffer );
if( ISNUM( 5 ) )
{
int iMaxLen = hb_parni( 5 );
if( iMaxLen < iLen )
iLen = iMaxLen;
}
hb_vmUnlock();
HB_SOCKET_ZERO_ERROR( Socket );
Socket->count = 0;
if( hb_selectWriteSocket( Socket ) )
{
Socket->count = sendto( Socket->com, szBuffer, iLen, 0,
(const struct sockaddr *) &Socket->remote, sizeof( Socket->remote ) );
}
hb_vmLock();
hb_retni( Socket->count );
if( Socket->count == 0 )
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
}
else if( Socket->count < 0 )
{
Socket->count = 0;
HB_SOCKET_SET_ERROR( Socket );
}
}
| hbinet.c | 2030 |
| HB_FUNC | HB_INETDGRAMRECV(void)
HB_FUNC( HB_INETDGRAMRECV )
{
HB_SOCKET_STRUCT *Socket = HB_PARSOCKET( 1 );
PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING );
int iTimeElapsed = 0;
int iLen, iMaxLen;
char *Buffer;
BOOL fRepeat;
#if defined(HB_OS_WIN_32)
int iDtLen = sizeof( struct sockaddr );
#else
socklen_t iDtLen = (socklen_t) sizeof( struct sockaddr );
#endif
if( Socket == NULL || pBuffer == NULL || !ISBYREF( 2 ) )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
else if( !hb_inetIsOpen( Socket ) )
{
Socket->count = 0;
hb_retni( -1 );
return;
}
pBuffer = hb_itemUnShare( pBuffer );
Buffer = hb_itemGetCPtr( pBuffer );
if( ISNUM( 3 ) )
{
iMaxLen = hb_parni( 3 );
}
else
{
iMaxLen = ( int ) hb_itemGetCLen( pBuffer );
}
hb_vmUnlock();
HB_SOCKET_ZERO_ERROR( Socket );
do
{
fRepeat = FALSE;
iLen = -2;
if( hb_selectReadSocket( Socket ) )
{
iLen = recvfrom( Socket->com, Buffer, iMaxLen, 0,
(struct sockaddr *) &Socket->remote, &iDtLen );
}
iTimeElapsed += Socket->timeout;
if( Socket->caPeriodic )
{
hb_vmLock();
hb_execFromArray( Socket->caPeriodic );
/* do we continue? */
fRepeat = hb_parl( -1 ) && hb_vmRequestQuery() == 0 &&
( Socket->timelimit == -1 || iTimeElapsed < Socket->timelimit );
hb_vmUnlock();
}
}
while( fRepeat );
if( iLen == -2 )
{
HB_SOCKET_SET_ERROR2( Socket, -1, "Timeout" );
Socket->count = 0;
iLen = -1;
}
else if( iLen == 0 )
{
HB_SOCKET_SET_ERROR2( Socket, -2, "Connection closed" );
Socket->count = 0;
}
else if( iLen < 0 )
{
HB_SOCKET_SET_ERROR( Socket );
Socket->count = 0;
}
else
{
Socket->count = iLen;
}
hb_vmLock();
hb_retni( iLen );
}
| hbinet.c | 2094 |
| HB_FUNC | HB_INETCRLF(void)
HB_FUNC( HB_INETCRLF )
{
hb_retc( "\r\n" );
}
| hbinet.c | 2189 |
| HB_FUNC | HB_INETISSOCKET(void)
HB_FUNC( HB_INETISSOCKET )
{
hb_retl( HB_PARSOCKET( 1 ) != NULL );
}
| hbinet.c | 2194 |
| hbmd5.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_md5go( MD5_BUF * md5 )
static void hb_md5go( MD5_BUF * md5 )
{
UINT32 X[ 16 ], A[ 4 ];
BYTE * ptr;
int i;
/* copy accumulators first */
memcpy( A, md5->accum, sizeof( A ) );
/* fill buffer */
for( i = 0, ptr = md5->buf; i < 16; i++, ptr += 4 )
X[ i ] = HB_GET_LE_UINT32( ptr );
/* process buffer */
PF1( 0, 1, 2, 3, 0, 7, 0 );
PF1( 3, 0, 1, 2, 1, 12, 1 );
PF1( 2, 3, 0, 1, 2, 17, 2 );
PF1( 1, 2, 3, 0, 3, 22, 3 );
PF1( 0, 1, 2, 3, 4, 7, 4 );
PF1( 3, 0, 1, 2, 5, 12, 5 );
PF1( 2, 3, 0, 1, 6, 17, 6 );
PF1( 1, 2, 3, 0, 7, 22, 7 );
PF1( 0, 1, 2, 3, 8, 7, 8 );
PF1( 3, 0, 1, 2, 9, 12, 9 );
PF1( 2, 3, 0, 1, 10, 17, 10 );
PF1( 1, 2, 3, 0, 11, 22, 11 );
PF1( 0, 1, 2, 3, 12, 7, 12 );
PF1( 3, 0, 1, 2, 13, 12, 13 );
PF1( 2, 3, 0, 1, 14, 17, 14 );
PF1( 1, 2, 3, 0, 15, 22, 15 );
PF2( 0, 1, 2, 3, 1, 5, 16 );
PF2( 3, 0, 1, 2, 6, 9, 17 );
PF2( 2, 3, 0, 1, 11, 14, 18 );
PF2( 1, 2, 3, 0, 0, 20, 19 );
PF2( 0, 1, 2, 3, 5, 5, 20 );
PF2( 3, 0, 1, 2, 10, 9, 21 );
PF2( 2, 3, 0, 1, 15, 14, 22 );
PF2( 1, 2, 3, 0, 4, 20, 23 );
PF2( 0, 1, 2, 3, 9, 5, 24 );
PF2( 3, 0, 1, 2, 14, 9, 25 );
PF2( 2, 3, 0, 1, 3, 14, 26 );
PF2( 1, 2, 3, 0, 8, 20, 27 );
PF2( 0, 1, 2, 3, 13, 5, 28 );
PF2( 3, 0, 1, 2, 2, 9, 29 );
PF2( 2, 3, 0, 1, 7, 14, 30 );
PF2( 1, 2, 3, 0, 12, 20, 31 );
PF3( 0, 1, 2, 3, 5, 4, 32 );
PF3( 3, 0, 1, 2, 8, 11, 33 );
PF3( 2, 3, 0, 1, 11, 16, 34 );
PF3( 1, 2, 3, 0, 14, 23, 35 );
PF3( 0, 1, 2, 3, 1, 4, 36 );
PF3( 3, 0, 1, 2, 4, 11, 37 );
PF3( 2, 3, 0, 1, 7, 16, 38 );
PF3( 1, 2, 3, 0, 10, 23, 39 );
PF3( 0, 1, 2, 3, 13, 4, 40 );
PF3( 3, 0, 1, 2, 0, 11, 41 );
PF3( 2, 3, 0, 1, 3, 16, 42 );
PF3( 1, 2, 3, 0, 6, 23, 43 );
PF3( 0, 1, 2, 3, 9, 4, 44 );
PF3( 3, 0, 1, 2, 12, 11, 45 );
PF3( 2, 3, 0, 1, 15, 16, 46 );
PF3( 1, 2, 3, 0, 2, 23, 47 );
PF4( 0, 1, 2, 3, 0, 6, 48 );
PF4( 3, 0, 1, 2, 7, 10, 49 );
PF4( 2, 3, 0, 1, 14, 15, 50 );
PF4( 1, 2, 3, 0, 5, 21, 51 );
PF4( 0, 1, 2, 3, 12, 6, 52 );
PF4( 3, 0, 1, 2, 3, 10, 53 );
PF4( 2, 3, 0, 1, 10, 15, 54 );
PF4( 1, 2, 3, 0, 1, 21, 55 );
PF4( 0, 1, 2, 3, 8, 6, 56 );
PF4( 3, 0, 1, 2, 15, 10, 57 );
PF4( 2, 3, 0, 1, 6, 15, 58 );
PF4( 1, 2, 3, 0, 13, 21, 59 );
PF4( 0, 1, 2, 3, 4, 6, 60 );
PF4( 3, 0, 1, 2, 11, 10, 61 );
PF4( 2, 3, 0, 1, 2, 15, 62 );
PF4( 1, 2, 3, 0, 9, 21, 63 );
/* Update accumulators */
md5->accum[ 0 ] += A[ 0 ];
md5->accum[ 1 ] += A[ 1 ];
md5->accum[ 2 ] += A[ 2 ];
md5->accum[ 3 ] += A[ 3 ];
}
| hbmd5.c | 158 |
| STATIC VOID | hb_md5accinit( UINT32 accum[] )
static void hb_md5accinit( UINT32 accum[] )
{
/* fill initial accumulator state */
accum[ 0 ] = 0x67452301;
accum[ 1 ] = 0xEFCDAB89;
accum[ 2 ] = 0x98BADCFE;
accum[ 3 ] = 0x10325476;
}
| hbmd5.c | 244 |
| STATIC VOID | hb_md5val( UINT32 accum[], BYTE * md5val )
static void hb_md5val( UINT32 accum[], BYTE * md5val )
{
int i, n;
for( i = 0; i < 4; i++ )
{
for( n = 0; n < 4; n++ )
*md5val++ = ( BYTE ) ( ( accum[ i ] >> ( n << 3 ) ) & 0xFF );
}
}
| hbmd5.c | 253 |
| STATIC VOID | hb_md5digest( BYTE * md5val, char * digest )
static void hb_md5digest( BYTE * md5val, char * digest )
{
int i, b;
for( i = 0; i < 16; i++ )
{
b = ( md5val[ i ] >> 4 ) & 0x0F;
*digest++ = ( char ) ( b + ( b > 9 ? 'a' - 10 : '0' ) );
b = md5val[ i ] & 0x0F;
*digest++ = ( char ) ( b + ( b > 9 ? 'a' - 10 : '0' ) );
}
}
| hbmd5.c | 264 |
| HB_EXPORT VOID | hb_md5( BYTE * ucData, ULONG ulLen, BYTE * ucDigest )
HB_EXPORT void hb_md5( BYTE * ucData, ULONG ulLen, BYTE * ucDigest )
{
UCHAR buf[ 128 ];
MD5_BUF md5;
int i, n;
/* perform startup procedures */
hb_md5accinit( md5.accum );
/* count full 512bit blocks in data*/
n = ulLen >> 6;
/* process full blocks */
for( i = 0; i < n; i++, ucData += 64 )
{
memcpy( md5.buf, ucData, 64 );
hb_md5go( &md5 );
}
/* prepare additional block(s) */
n = ulLen & 63;
if( n )
memcpy( buf, ucData, n );
memcpy( buf + n, pad, 64 );
/* count bits length */
i = 56;
if( n >= 56 )
{
i += 64;
memcpy( md5.buf, buf, 64 );
hb_md5go( &md5 );
}
buf[ i++ ] = ( UCHAR ) ( ( ulLen << 3 ) & 0xF8 );
ulLen >>= 5;
for( n = 7; n; --n )
{
buf[ i++ ] = ( UCHAR ) ( ulLen & 0xFF );
ulLen >>= 8;
}
memcpy( md5.buf, buf + i - 64, 64 );
hb_md5go( &md5 );
/* write digest */
hb_md5val( md5.accum, ucDigest );
}
| hbmd5.c | 277 |
| HB_EXPORT VOID | hb_md5file( HB_FHANDLE hFile, BYTE * ucDigest )
HB_EXPORT void hb_md5file( HB_FHANDLE hFile, BYTE * ucDigest )
{
MD5_BUF md5;
ULONG n;
int i;
HB_FOFFSET flen = 0;
UCHAR buf[ 128 ], * readbuf = ( UCHAR * ) hb_xgrab( MAX_FBUF );
hb_md5accinit( md5.accum );
n = hb_fsReadLarge( hFile, readbuf, MAX_FBUF );
flen += n;
while( n == MAX_FBUF )
{
for( i = 0; i < ( MAX_FBUF >> 6 ); i++ )
{
memcpy( md5.buf, readbuf + ( i << 6 ), 64 );
hb_md5go( &md5 );
}
n = hb_fsReadLarge( hFile, readbuf, MAX_FBUF );
flen += n;
}
hb_fsClose( hFile );
i = 0;
while( n > 64 )
{
memcpy( md5.buf, readbuf + i, 64 );
hb_md5go( &md5 );
i += 64;
n -= 64;
}
if( n )
memcpy( buf, readbuf + i, n );
memcpy( buf + n, pad, 64 );
i = 56;
if( n >= 56 )
{
i += 64;
memcpy( md5.buf, buf, 64 );
hb_md5go( &md5 );
}
buf[ i++ ] = ( UCHAR ) ( ( flen << 3 ) & 0xF8 );
flen >>= 5;
for( n = 7; n; --n )
{
buf[ i++ ] = ( UCHAR ) ( flen & 0xFF );
flen >>= 8;
}
memcpy( md5.buf, buf + i - 64, 64 );
hb_md5go( &md5 );
hb_md5val( md5.accum, ucDigest );
hb_xfree( readbuf );
}
| hbmd5.c | 319 |
| HB_FUNC | HB_MD5(void)
HB_FUNC( HB_MD5 )
{
char * pszStr = hb_parc( 1 );
if( pszStr )
{
ULONG ulLen = hb_parclen( 1 );
BYTE dststr[ 16 ];
char digest[ 33 ];
hb_md5( ( BYTE * ) pszStr, ulLen, dststr );
hb_md5digest( dststr, digest );
hb_retclen( digest, 32 );
}
else
hb_retc( NULL ); /* return empty string on wrong call */
}
| hbmd5.c | 372 |
| HB_FUNC | HB_MD5FILE(void)
HB_FUNC( HB_MD5FILE )
{
char * pszFile = hb_parc( 1 );
if( pszFile )
{
HB_FHANDLE hFile = hb_fsOpen( ( BYTE * ) pszFile, FO_READ );
if( hFile != FS_ERROR )
{
BYTE dststr[ 16 ];
char digest[ 33 ];
hb_md5file( hFile, dststr );
hb_md5digest( dststr, digest );
hb_retclen( digest, 32 );
return;
}
}
hb_retc( NULL ); /* return empty string on wrong call */
}
| hbmd5.c | 390 |
| hbrandom.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_RANDOM(void)
HB_FUNC( HB_RANDOM )
{
double dRnd = hb_random_num();
if( ! ISNUM( 1 ) )
hb_retnd( dRnd );
else if( ! ISNUM( 2 ) )
hb_retnd( dRnd * hb_parnd( 1 ) );
else
{
double dX = hb_parnd( 2 );
double dY = hb_parnd( 1 );
if( dX > dY )
{
double dZ = dY;
dY = dX;
dX = dZ;
}
hb_retnd( dRnd * ( dY - dX ) + dX );
}
}
| hbrandom.c | 64 |
| HB_FUNC | HB_RANDOMINT(void)
HB_FUNC( HB_RANDOMINT )
{
double dRnd = hb_random_num();
if( ! ISNUM( 1 ) )
hb_retni( dRnd >= 0.5 ? 0 : 1 );
else if( ! ISNUM( 2 ) )
hb_retnint( ( HB_LONG ) ( 1 + ( dRnd * hb_parnint( 1 ) ) ) );
else
{
HB_LONG lX = hb_parnint( 1 );
HB_LONG lY = hb_parnint( 2 );
if( lX > lY )
{
HB_LONG lZ = lY;
lY = lX;
lX = lZ;
}
hb_retnint( ( HB_LONG ) ( lX + ( dRnd * ( lY - lX + 1 ) ) ) );
}
}
| hbrandom.c | 93 |
| HB_FUNC | HB_RANDOMSEED(void)
HB_FUNC( HB_RANDOMSEED )
{
srand( ISNUM( 1 ) ? ( unsigned ) hb_parni( 1 ) : ( unsigned ) hb_dateMilliSeconds() );
s_fInit = TRUE;
}
| hbrandom.c | 123 |
| DOUBLE | hb_random_num()
double hb_random_num()
{
double d1, d2;
if( !s_fInit )
{
srand( ( unsigned ) hb_dateMilliSeconds() );
s_fInit = TRUE;
}
d1 = ( double ) rand();
d2 = ( double ) RAND_MAX;
#if defined( HB_OS_WIN_32 )
/* It seems that on win32 platform there some weirdness about EPSILON value so
that a float division using an epsilon smaller than 1e-10 may be rounded.
Must dig if it's a borland lib bug or a windows problem.
*/
d2 += 0.001;
#else
d2 += DBL_EPSILON;
#endif
return d1 / d2;
}
| hbrandom.c | 129 |
| hbregex.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_regfree( PHB_REGEX pRegEx )
static void hb_regfree( PHB_REGEX pRegEx )
{
#if defined( HB_PCRE_REGEX )
( pcre_free )( pRegEx->re_pcre );
#elif defined( HB_POSIX_REGEX )
regfree( &pRegEx->reg );
#else
HB_SYMBOL_UNUSED( pRegEx );
#endif
}
| hbregex.c | 61 |
| STATIC INT | hb_regcomp( PHB_REGEX pRegEx, const char * szRegEx )
static int hb_regcomp( PHB_REGEX pRegEx, const char * szRegEx )
{
#if defined( HB_PCRE_REGEX )
const unsigned char * pCharTable = NULL;
const char *szError = NULL;
int iErrOffset = 0;
int iCFlags = ( ( pRegEx->iFlags & HBREG_ICASE ) ? PCRE_CASELESS : 0 ) |
( ( pRegEx->iFlags & HBREG_NEWLINE ) ? PCRE_MULTILINE : 0 ) |
( ( pRegEx->iFlags & HBREG_DOTALL ) ? PCRE_DOTALL : 0 );
pRegEx->iEFlags = ( ( pRegEx->iFlags & HBREG_NOTBOL ) ? PCRE_NOTBOL : 0 ) |
( ( pRegEx->iFlags & HBREG_NOTEOL ) ? PCRE_NOTEOL : 0 );
pRegEx->re_pcre = pcre_compile( szRegEx, iCFlags, &szError,
&iErrOffset, pCharTable );
return pRegEx->re_pcre ? 0 : -1;
#elif defined( HB_POSIX_REGEX )
int iCFlags = REG_EXTENDED |
( ( pRegEx->iFlags & HBREG_ICASE ) ? REG_ICASE : 0 ) |
( ( pRegEx->iFlags & HBREG_NEWLINE ) ? REG_NEWLINE : 0 ) |
( ( pRegEx->iFlags & HBREG_NOSUB ) ? REG_NOSUB : 0 );
pRegEx->iEFlags = ( ( pRegEx->iFlags & HBREG_NOTBOL ) ? REG_NOTBOL : 0 ) |
( ( pRegEx->iFlags & HBREG_NOTEOL ) ? REG_NOTEOL : 0 );
return regcomp( &pRegEx->reg, szRegEx, iCFlags );
#else
HB_SYMBOL_UNUSED( pRegEx );
HB_SYMBOL_UNUSED( szRegEx );
return -1;
#endif
}
| hbregex.c | 72 |
| STATIC INT | hb_regexec( PHB_REGEX pRegEx, const char * szString, ULONG ulLen, int iMatches, HB_REGMATCH * aMatches )
static int hb_regexec( PHB_REGEX pRegEx, const char * szString, ULONG ulLen,
int iMatches, HB_REGMATCH * aMatches )
{
#if defined( HB_PCRE_REGEX )
int iResult, i;
iResult = pcre_exec( pRegEx->re_pcre, NULL /* pcre_extra */,
szString, ulLen, 0 /* startoffset */,
pRegEx->iEFlags, aMatches, HB_REGMATCH_SIZE( iMatches ) );
if( iResult == 0 )
{
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) != -1 )
iResult = i + 1;
}
}
return iResult;
#elif defined( HB_POSIX_REGEX )
char * szBuffer = NULL;
int iResult, i;
if( szString[ ulLen ] != 0 )
{
szBuffer = hb_strndup( szString, ulLen );
szString = szBuffer;
}
for( i = 0; i < iMatches; i++ )
HB_REGMATCH_EO( aMatches, i ) = -1;
iResult = regexec( &pRegEx->reg, szString, iMatches, aMatches, pRegEx->iEFlags );
if( iResult == 0 )
{
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) != -1 )
iResult = i + 1;
}
}
else
iResult = -1;
if( szBuffer )
hb_xfree( szBuffer );
return iResult;
#else
HB_SYMBOL_UNUSED( pRegEx );
HB_SYMBOL_UNUSED( szString );
HB_SYMBOL_UNUSED( ulLen );
HB_SYMBOL_UNUSED( iMatches );
HB_SYMBOL_UNUSED( aMatches );
return -1;
#endif
}
| hbregex.c | 103 |
| HB_FUNC | HB_REGEXCOMP(void)
HB_FUNC( HB_REGEXCOMP )
{
ULONG ulLen = hb_parclen( 1 );
if( ulLen == 0 )
hb_errRT_BASE_SubstR( EG_ARG, 3012, "Wrong parameter count/type",
HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
else
{
int iFlags = HBREG_EXTENDED;
PHB_REGEX pRegEx;
if( ISLOG( 2 ) && !hb_parl( 2 ) )
iFlags |= HBREG_ICASE;
if( hb_parl( 3 ) )
iFlags |= HBREG_NEWLINE;
pRegEx = hb_regexCompile( hb_parc( 1 ), ulLen, iFlags );
if( pRegEx )
{
pRegEx->fFree = FALSE;
hb_retptrGC( pRegEx );
hb_gcUnlock( pRegEx );
}
}
}
| hbregex.c | 157 |
| HB_FUNC | HB_ISREGEX(void)
HB_FUNC( HB_ISREGEX )
{
hb_retl( hb_parptrGC( hb_regexRelease, 1 ) != NULL );
}
| hbregex.c | 184 |
| HB_FUNC | HB_ATX(void)
HB_FUNC( HB_ATX )
{
char * pszString;
ULONG ulLen, ulStart, ulEnd;
PHB_REGEX pRegEx;
PHB_ITEM pString;
int iPCount = hb_pcount();
pString = hb_param( 2, HB_IT_STRING );
if( !pString )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, "Wrong parameters",
HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return;
}
pszString = hb_itemGetCPtr( pString );
ulLen = hb_itemGetCLen( pString );
pRegEx = hb_regexGet( hb_param( 1, HB_IT_ANY ),
ISLOG( 3 ) && !hb_parl( 3 ) ? HBREG_ICASE : 0 );
if( !pRegEx )
return;
ulStart = hb_parnl( 4 );
ulEnd = hb_parnl( 5 );
if( ulLen && ulStart <= ulLen && ulStart <= ulEnd )
{
HB_REGMATCH aMatches[ HB_REGMATCH_SIZE( 1 ) ];
if( ulEnd < ulLen )
ulLen = ulEnd;
if( ulStart )
{
--ulStart;
ulLen -= ulStart;
}
if( hb_regexec( pRegEx, pszString + ulStart, ulLen, 1, aMatches ) > 0 )
{
ulStart += HB_REGMATCH_SO( aMatches, 0 ) + 1;
ulLen = HB_REGMATCH_EO( aMatches, 0 ) - HB_REGMATCH_SO( aMatches, 0 );
hb_retclen( pszString + ulStart - 1, ulLen );
}
else
ulStart = ulLen = 0;
}
else
ulStart = ulLen = 0;
hb_regexFree( pRegEx );
if( iPCount > 3 )
{
hb_stornl( ulStart, 4 );
if( iPCount > 4 )
hb_stornl( ulLen, 5 );
}
}
| hbregex.c | 189 |
| STATIC BOOL | hb_regex( int iRequest )
static BOOL hb_regex( int iRequest )
{
HB_REGMATCH aMatches[ HB_REGMATCH_SIZE( REGEX_MAX_GROUPS ) ];
PHB_ITEM pRetArray, pMatch, pString;
int i, iMatches, iMaxMatch;
BOOL fResult = FALSE;
PHB_REGEX pRegEx;
char * pszString;
ULONG ulLen;
pString = hb_param( 2, HB_IT_STRING );
if( !pString )
{
hb_errRT_BASE_SubstR( EG_ARG, 3012, "Wrong parameters",
HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return FALSE;
}
pRegEx = hb_regexGet( hb_param( 1, HB_IT_ANY ),
( ISLOG( 3 ) && !hb_parl( 3 ) ? HBREG_ICASE : 0 ) |
( hb_parl( 4 ) ? HBREG_NEWLINE : 0 ) );
if( !pRegEx )
return FALSE;
pszString = hb_itemGetCPtr( pString );
ulLen = hb_itemGetCLen( pString );
iMaxMatch = iRequest == 0 || iRequest == 4 || iRequest == 5 ?
REGEX_MAX_GROUPS : 1;
iMatches = hb_regexec( pRegEx, pszString, ulLen, iMaxMatch, aMatches );
if( iMatches > 0 )
{
switch( iRequest )
{
case 0:
pRetArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) > -1 )
hb_arraySetCL( pRetArray, i + 1,
pszString + HB_REGMATCH_SO( aMatches, i ),
HB_REGMATCH_EO( aMatches, i ) -
HB_REGMATCH_SO( aMatches, i ) );
else
hb_arraySetCL( pRetArray, i + 1, "", 0 );
}
hb_itemReturnRelease( pRetArray );
fResult = TRUE;
break;
case 1: /* LIKE */
fResult = HB_REGMATCH_SO( aMatches, 0 ) == 0 &&
( ULONG ) HB_REGMATCH_EO( aMatches, 0 ) == ulLen;
break;
case 2: /* MATCH ( HAS ) */
fResult = TRUE;
break;
case 3: /* SPLIT */
iMaxMatch = hb_parni( 5 );
pRetArray = hb_itemArrayNew( 0 );
pMatch = hb_itemNew( NULL );
iMatches = 0;
do
{
hb_itemPutCL( pMatch, pszString, HB_REGMATCH_SO( aMatches, 0 ) );
hb_arrayAddForward( pRetArray, pMatch );
ulLen -= HB_REGMATCH_EO( aMatches, 0 );
pszString += HB_REGMATCH_EO( aMatches, 0 );
iMatches++;
}
while( HB_REGMATCH_EO( aMatches, 0 ) > 0 && ulLen &&
( iMaxMatch == 0 || iMatches < iMaxMatch ) &&
hb_regexec( pRegEx, pszString, ulLen, 1, aMatches ) > 0 );
/* last match must be done also in case that pszString is empty;
this would mean an empty split field at the end of the string */
/* if( ulLen ) */
{
hb_itemPutCL( pMatch, pszString, ulLen );
hb_arrayAddForward( pRetArray, pMatch );
}
hb_itemRelease( pMatch );
hb_itemReturnRelease( pRetArray );
fResult = TRUE;
break;
case 4: /* results AND positions */
pRetArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
int iSO = HB_REGMATCH_SO( aMatches, i ),
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_arrayGetItemPtr( pRetArray, i + 1 );
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNI( pMatch, 2, iSO + 1 );
/* End of match */
hb_arraySetNI( pMatch, 3, iEO );
}
else
{
hb_arraySetCL( pMatch, 1, "", 0 );
hb_arraySetNI( pMatch, 2, 0 );
hb_arraySetNI( pMatch, 3, 0 );
}
}
hb_itemReturnRelease( pRetArray );
fResult = TRUE;
break;
case 5: /* _ALL_ results AND positions */
{
PHB_ITEM pAtxArray;
int iMax = hb_parni( 5 ); /* max nuber of matches I want, 0 = unlimited */
int iGetMatch = hb_parni( 6 ); /* Gets if want only one single match or a sub-match */
BOOL fOnlyMatch = !ISLOG( 7 ) || hb_parl( 7 ); /* if TRUE returns only matches and sub-matches, not positions */
ULONG ulOffSet = 0;
int iCount = 0;
int iSO, iEO;
/* Set new array */
pRetArray = hb_itemArrayNew( 0 );
do
{
/* If I want all matches */
if( iGetMatch == 0 || /* Check boundaries */
( iGetMatch < 0 || iGetMatch > iMatches ) )
{
pAtxArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
iSO = HB_REGMATCH_SO( aMatches, i );
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_arrayGetItemPtr( pAtxArray, i + 1 );
if( !fOnlyMatch )
{
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNI( pMatch, 2, ulOffSet + iSO + 1 );
/* End of match */
hb_arraySetNI( pMatch, 3, ulOffSet + iEO );
}
else
{
hb_arraySetCL( pMatch, 1, "", 0 );
hb_arraySetNI( pMatch, 2, 0 );
hb_arraySetNI( pMatch, 3, 0 );
}
}
else
{
if( iEO != -1 )
/* matched string */
hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO );
else
hb_itemPutC( pMatch, NULL );
}
}
hb_arrayAddForward( pRetArray, pAtxArray );
hb_itemRelease( pAtxArray );
}
else /* Here I get only single matches */
{
i = iGetMatch - 1;
iSO = HB_REGMATCH_SO( aMatches, i );
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_itemNew( NULL );
if( !fOnlyMatch )
{
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNI( pMatch, 2, ulOffSet + iSO + 1 );
/* End of match */
hb_arraySetNI( pMatch, 3, ulOffSet + iEO );
}
else
{
hb_arraySetCL( pMatch, 1, "", 0 );
hb_arraySetNI( pMatch, 2, 0 );
hb_arraySetNI( pMatch, 3, 0 );
}
}
else
{
if( iEO != -1 )
/* matched string */
hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO );
else
hb_itemPutC( pMatch, NULL );
}
hb_arrayAddForward( pRetArray, pMatch );
hb_itemRelease( pMatch );
}
iEO = HB_REGMATCH_EO( aMatches, 0 );
if( iEO == -1 )
break;
ulLen -= iEO;
pszString += iEO;
ulOffSet += iEO;
iCount++;
}
while( iEO && ulLen && ( iMax == 0 || iCount < iMax ) &&
( iMatches = hb_regexec( pRegEx, pszString, ulLen, iMaxMatch, aMatches ) ) > 0 );
hb_itemReturnRelease( pRetArray );
fResult = TRUE;
break;
}
}
}
else if( iRequest == 3 )
{
pRetArray = hb_itemArrayNew( 1 );
hb_arraySet( pRetArray, 1, pString );
hb_itemReturnRelease( pRetArray );
fResult = TRUE;
}
hb_regexFree( pRegEx );
return fResult;
}
| hbregex.c | 246 |
| HB_FUNC | HB_REGEX(void)
HB_FUNC( HB_REGEX )
{
hb_regex( 0 );
}
| hbregex.c | 482 |
| HB_FUNC | HB_REGEXMATCH(void)
HB_FUNC( HB_REGEXMATCH )
{
hb_retl( hb_regex( hb_parl( 3 ) ? 1 /* LIKE */ : 2 /* HAS */ ) );
}
| hbregex.c | 488 |
| HB_FUNC | HB_REGEXLIKE(void)
HB_FUNC( HB_REGEXLIKE )
{
hb_retl( hb_regex( 1 ) );
}
| hbregex.c | 494 |
| HB_FUNC | HB_REGEXHAS(void)
HB_FUNC( HB_REGEXHAS )
{
hb_retl( hb_regex( 2 ) );
}
| hbregex.c | 499 |
| HB_FUNC | HB_REGEXSPLIT(void)
HB_FUNC( HB_REGEXSPLIT )
{
hb_regex( 3 );
}
| hbregex.c | 504 |
| HB_FUNC | HB_REGEXATX(void)
HB_FUNC( HB_REGEXATX )
{
hb_regex( 4 );
}
| hbregex.c | 510 |
| HB_FUNC | HB_REGEXALL(void)
HB_FUNC( HB_REGEXALL )
{
hb_regex( 5 );
}
| hbregex.c | 532 |
| STATIC VOID * | hb_pcre_grab( size_t size )
static void * hb_pcre_grab( size_t size )
{
return hb_xgrab( size );
}
#endif
HB_CALL_ON_STARTUP_BEGIN( _hb_regex_init_ )
#if defined( HB_PCRE_REGEX )
/* Hack to force linking newer PCRE versions not the one included in BCC RTL */
# if defined( __BORLANDC__ )
{
int iUTF8Enabled;
pcre_config( PCRE_CONFIG_UTF8, &iUTF8Enabled );
}
# endif
pcre_malloc = hb_pcre_grab;
pcre_free = hb_xfree;
pcre_stack_malloc = hb_pcre_grab;
pcre_stack_free = hb_xfree;
#endif
hb_regexInit( hb_regfree, hb_regcomp, hb_regexec );
HB_CALL_ON_STARTUP_END( _hb_regex_init_ )
#if defined( HB_PRAGMA_STARTUP )
#pragma startup _hb_regex_init_
#elif defined( HB_MSC_STARTUP )
#if defined( HB_OS_WIN_64 )
#pragma section( HB_MSC_START_SEGMENT, long, read )
#endif
#pragma data_seg( HB_MSC_START_SEGMENT )
static HB_$INITSYM hb_vm_auto_regex_init_ = _hb_regex_init_;
| hbregex.c | 538 |
| hbregexc.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_regfree( PHB_REGEX pRegEx )
static void hb_regfree( PHB_REGEX pRegEx )
{
HB_SYMBOL_UNUSED( pRegEx );
}
| hbregexc.c | 60 |
| STATIC INT | hb_regcomp( PHB_REGEX pRegEx, const char * szRegEx )
static int hb_regcomp( PHB_REGEX pRegEx, const char * szRegEx )
{
HB_SYMBOL_UNUSED( pRegEx );
HB_SYMBOL_UNUSED( szRegEx );
return -1;
}
| hbregexc.c | 65 |
| STATIC INT | hb_regexec( PHB_REGEX pRegEx, const char * szString, ULONG ulLen, int iMatches, HB_REGMATCH * aMatches )
static int hb_regexec( PHB_REGEX pRegEx, const char * szString, ULONG ulLen,
int iMatches, HB_REGMATCH * aMatches )
{
HB_SYMBOL_UNUSED( pRegEx );
HB_SYMBOL_UNUSED( szString );
HB_SYMBOL_UNUSED( ulLen );
HB_SYMBOL_UNUSED( iMatches );
HB_SYMBOL_UNUSED( aMatches );
return -1;
}
static HB_REG_FREE s_reg_free = hb_regfree;
static HB_REG_COMP s_reg_comp = hb_regcomp;
static HB_REG_EXEC s_reg_exec = hb_regexec;
| hbregexc.c | 72 |
| VOID | hb_regexInit( HB_REG_FREE pFree, HB_REG_COMP pComp, HB_REG_EXEC pExec )
void hb_regexInit( HB_REG_FREE pFree, HB_REG_COMP pComp, HB_REG_EXEC pExec )
{
s_reg_free = pFree;
s_reg_comp = pComp;
s_reg_exec = pExec;
}
| hbregexc.c | 87 |
| HB_GARBAGE_FUNC( | hb_regexRelease )
HB_GARBAGE_FUNC( hb_regexRelease )
{
( s_reg_free )( ( PHB_REGEX ) Cargo );
}
| hbregexc.c | 94 |
| PHB_REGEX | hb_regexCompile( const char *szRegEx, ULONG ulLen, int iFlags )
PHB_REGEX hb_regexCompile( const char *szRegEx, ULONG ulLen, int iFlags )
{
PHB_REGEX pRegEx;
HB_SYMBOL_UNUSED( ulLen );
pRegEx = ( PHB_REGEX ) hb_gcAlloc( sizeof( HB_REGEX ), hb_regexRelease );
hb_gcLock( pRegEx );
memset( pRegEx, 0, sizeof( HB_REGEX ) );
pRegEx->fFree = TRUE;
pRegEx->iFlags = iFlags;
if( ( s_reg_comp )( pRegEx, szRegEx ) != 0 )
{
hb_gcFree( pRegEx );
pRegEx = NULL;
}
return pRegEx;
}
| hbregexc.c | 100 |
| PHB_REGEX | hb_regexGet( PHB_ITEM pRegExItm, int iFlags )
PHB_REGEX hb_regexGet( PHB_ITEM pRegExItm, int iFlags )
{
PHB_REGEX pRegEx = NULL;
if( pRegExItm )
{
if( HB_IS_POINTER( pRegExItm ) )
{
pRegEx = ( PHB_REGEX ) hb_itemGetPtrGC( pRegExItm, hb_regexRelease );
}
else if( HB_IS_STRING( pRegExItm ) )
{
ULONG ulLen = hb_itemGetCLen( pRegExItm );
char * szRegEx = hb_itemGetCPtr( pRegExItm );
if( ulLen > 0 )
pRegEx = hb_regexCompile( szRegEx, ulLen, iFlags );
}
}
if( !pRegEx )
hb_errRT_BASE_SubstR( EG_ARG, 3012, "Invalid Regular expression", HB_ERR_FUNCNAME, 1, pRegExItm );
return pRegEx;
}
| hbregexc.c | 121 |
| VOID | hb_regexFree( PHB_REGEX pRegEx )
void hb_regexFree( PHB_REGEX pRegEx )
{
if( pRegEx && pRegEx->fFree )
{
( s_reg_free )( pRegEx );
hb_gcFree( pRegEx );
}
}
| hbregexc.c | 146 |
| BOOL | hb_regexMatch( PHB_REGEX pRegEx, const char *szString, ULONG ulLen, BOOL fFull )
BOOL hb_regexMatch( PHB_REGEX pRegEx, const char *szString, ULONG ulLen, BOOL fFull )
{
HB_REGMATCH aMatches[ HB_REGMATCH_SIZE( 1 ) ];
BOOL fMatch;
fMatch = ( s_reg_exec )( pRegEx, szString, ulLen, 1, aMatches ) > 0;
return fMatch && ( !fFull ||
( HB_REGMATCH_SO( aMatches, 0 ) == 0 &&
HB_REGMATCH_EO( aMatches, 0 ) == ( int ) ulLen ) );
}
| hbregexc.c | 155 |
| hbrunfun.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_RUN(void)
HB_FUNC( HB_RUN )
{
char * szCommand = hb_parc( 1 );
if( szCommand )
{
int iResult = -1;
if( hb_gtSuspend() == SUCCESS )
{
iResult = system( szCommand );
hb_gtResume();
}
hb_retni( iResult );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbrunfun.c | 57 |
| hbstrsh.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_STRSHRINK(void)
HB_FUNC( HB_STRSHRINK )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText )
{
long lLen = hb_itemGetCLen( pText );
long lShrinkBy = ISNUM( 2 ) ? hb_parnl( 2 ) : 1;
if( lShrinkBy > 0 )
{
if( lShrinkBy < lLen )
lLen -= lShrinkBy;
else
lLen = 0;
}
hb_retclen( hb_itemGetCPtr( pText ), lLen );
}
else
hb_retc( NULL );
}
| hbstrsh.c | 56 |
| hbtoken.c |
| Type | Function | Source | Line |
|---|
| STATIC ULONG | hb_tokenCount( const char * szLine, ULONG ulLen, const char * szDelim, ULONG ulDelim, BOOL fSkipStrings, BOOL fDoubleQuoteOnly )
static ULONG hb_tokenCount( const char * szLine, ULONG ulLen,
const char * szDelim, ULONG ulDelim,
BOOL fSkipStrings, BOOL fDoubleQuoteOnly )
{
ULONG ul = 0, ulTokens = 1;
char cQuote = 0;
while( ul < ulLen )
{
if( cQuote )
{
if( szLine[ ul ] == cQuote )
cQuote = 0;
}
else if( fSkipStrings && ( szLine[ ul ] == '"' ||
( !fDoubleQuoteOnly && szLine[ ul ] == '\'' ) ) )
cQuote = szLine[ ul ];
else if( szLine[ ul ] == szDelim[ 0 ] &&
( ulDelim == 1 || !memcmp( szLine + ul, szDelim, ulDelim ) ) )
{
++ulTokens;
if( ulDelim == 1 && *szDelim == ' ' )
{
while( ul + 1 < ulLen && szLine[ ul + 1 ] == ' ' )
++ul;
}
ul += ulDelim - 1;
}
++ul;
}
return ulTokens;
}
| hbtoken.c | 57 |
| STATIC CONST CHAR * | hb_tokenGet( const char * szLine, ULONG ulLen, const char * szDelim, ULONG ulDelim, BOOL fSkipStrings, BOOL fDoubleQuoteOnly, ULONG ulToken, ULONG * pulLen )
static const char * hb_tokenGet( const char * szLine, ULONG ulLen,
const char * szDelim, ULONG ulDelim,
BOOL fSkipStrings, BOOL fDoubleQuoteOnly,
ULONG ulToken, ULONG * pulLen )
{
ULONG ul, ulStart;
char cQuote = 0;
for( ul = ulStart = 0; ul < ulLen; ++ul )
{
if( cQuote )
{
if( szLine[ ul ] == cQuote )
cQuote = 0;
}
else if( fSkipStrings && ( szLine[ ul ] == '"' ||
( !fDoubleQuoteOnly && szLine[ ul ] == '\'' ) ) )
cQuote = szLine[ ul ];
else if( szLine[ ul ] == szDelim[ 0 ] &&
( ulDelim == 1 || !memcmp( szLine + ul, szDelim, ulDelim ) ) )
{
if( --ulToken == 0 )
{
* pulLen = ul - ulStart;
return szLine + ulStart;
}
if( ulDelim == 1 && *szDelim == ' ' )
{
while( ul + 1 < ulLen && szLine[ ul + 1 ] == ' ' )
++ul;
}
ulStart = ul + ulDelim;
}
}
if( --ulToken == 0 )
{
* pulLen = ul - ulStart;
return szLine + ulStart;
}
* pulLen = 0;
return NULL;
}
| hbtoken.c | 91 |
| STATIC PHB_ITEM | hb_tokenArray( const char * szLine, ULONG ulLen, const char * szDelim, ULONG ulDelim, BOOL fSkipStrings, BOOL fDoubleQuoteOnly )
static PHB_ITEM hb_tokenArray( const char * szLine, ULONG ulLen,
const char * szDelim, ULONG ulDelim,
BOOL fSkipStrings, BOOL fDoubleQuoteOnly )
{
ULONG ulTokens = hb_tokenCount( szLine, ulLen, szDelim, ulDelim,
fSkipStrings, fDoubleQuoteOnly );
PHB_ITEM pArray = hb_itemArrayNew( ulTokens );
if( ulTokens )
{
ULONG ul, ulStart, ulToken;
char cQuote = 0;
for( ul = ulStart = ulToken = 0; ul < ulLen; ++ul )
{
if( cQuote )
{
if( szLine[ ul ] == cQuote )
cQuote = 0;
}
else if( fSkipStrings && ( szLine[ ul ] == '"' ||
( !fDoubleQuoteOnly && szLine[ ul ] == '\'' ) ) )
cQuote = szLine[ ul ];
else if( szLine[ ul ] == szDelim[ 0 ] &&
( ulDelim == 1 || !memcmp( szLine + ul, szDelim, ulDelim ) ) )
{
hb_arraySetCL( pArray, ++ulToken, szLine + ulStart, ul - ulStart );
if( ulDelim == 1 && *szDelim == ' ' )
{
while( ul + 1 < ulLen && szLine[ ul + 1 ] == ' ' )
++ul;
}
ulStart = ul + ulDelim;
}
}
hb_arraySetCL( pArray, ++ulToken, szLine + ulStart, ul - ulStart );
}
return pArray;
}
| hbtoken.c | 134 |
| STATIC VOID | hb_tokenParam( int iDelim, ULONG ulSkip, const char ** pszLine, ULONG * pulLen, const char ** pszDelim, ULONG * pulDelim )
static void hb_tokenParam( int iDelim, ULONG ulSkip,
const char ** pszLine, ULONG * pulLen,
const char ** pszDelim, ULONG * pulDelim )
{
const char * szLine = hb_parc( 1 ), * szDelim = NULL;
ULONG ulLen = hb_parclen( 1 ), ulDelim = 0;
if( ulLen )
{
if( ulSkip )
{
szLine += ulSkip;
if( ulLen <= ulSkip )
ulLen = 0;
else
ulLen -= ulSkip;
}
ulDelim = hb_parclen( iDelim );
if( ulDelim )
szDelim = hb_parc( iDelim );
else
{
szDelim = " ";
ulDelim = 1;
}
if( ulDelim == 1 && *szDelim == ' ' )
{
while( ulLen && * szLine == ' ' )
{
++szLine;
--ulLen;
}
while( ulLen && szLine[ ulLen - 1 ] == ' ' )
--ulLen;
}
}
*pulLen = ulLen;
*pulDelim = ulDelim;
*pszLine = szLine;
*pszDelim = szDelim;
}
| hbtoken.c | 175 |
| HB_FUNC | HB_TOKENCOUNT(void)
HB_FUNC( HB_TOKENCOUNT )
{
const char * szLine, * szDelim;
ULONG ulLen, ulDelim;
hb_tokenParam( 2, 0, &szLine, &ulLen, &szDelim, &ulDelim );
if( szLine )
hb_retnint( hb_tokenCount( szLine, ulLen, szDelim, ulDelim,
hb_parl( 3 ), hb_parl( 4 ) ) );
else
hb_retni( 0 );
}
| hbtoken.c | 220 |
| HB_FUNC | HB_TOKENGET(void)
HB_FUNC( HB_TOKENGET )
{
const char * szLine, * szDelim;
ULONG ulLen, ulDelim;
hb_tokenParam( 3, 0, &szLine, &ulLen, &szDelim, &ulDelim );
if( szLine )
{
szLine = hb_tokenGet( szLine, ulLen, szDelim, ulDelim,
hb_parl( 4 ), hb_parl( 5 ),
hb_parnl( 2 ), &ulLen );
hb_retclen( szLine, ulLen );
}
else
hb_retc( NULL );
}
| hbtoken.c | 234 |
| HB_FUNC | HB_TOKENPTR(void)
HB_FUNC( HB_TOKENPTR )
{
const char * szLine, * szDelim, * szToken;
ULONG ulLen, ulDelim, ulSkip, ulToken;
hb_tokenParam( 3, hb_parnl( 2 ), &szLine, &ulLen, &szDelim, &ulDelim );
if( szLine )
{
szToken = hb_tokenGet( szLine, ulLen, szDelim, ulDelim,
hb_parl( 4 ), hb_parl( 5 ),
1, &ulToken );
if( szToken && ulLen > ulToken )
ulSkip = szToken - hb_parc( 1 ) + ulToken + ulDelim;
else
ulSkip = hb_parclen( 1 ) + 1;
/* return position to start next search from */
hb_stornl( ulSkip, 2 );
/* return token */
hb_retclen( szToken, ulToken );
}
else
hb_retc( NULL );
}
| hbtoken.c | 252 |
| HB_FUNC | HB_ATOKENS(void)
HB_FUNC( HB_ATOKENS )
{
const char * szLine, * szDelim;
ULONG ulLen, ulDelim;
hb_tokenParam( 2, 0, &szLine, &ulLen, &szDelim, &ulDelim );
if( szLine )
hb_itemReturnRelease( hb_tokenArray( szLine, ulLen, szDelim, ulDelim,
hb_parl( 3 ), hb_parl( 4 ) ) );
else
hb_errRT_BASE_SubstR( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbtoken.c | 282 |
| HB_FUNC | __STRTOKEN(void)
HB_FUNC( __STRTOKEN )
{
HB_FUNC_EXEC( HB_TOKENGET );
}
| hbtoken.c | 296 |
| HB_FUNC | __STRTKPTR(void)
HB_FUNC( __STRTKPTR )
{
HB_FUNC_EXEC( HB_TOKENPTR );
}
| hbtoken.c | 301 |
| HB_FUNC | __STRTOKENCOUNT(void)
HB_FUNC( __STRTOKENCOUNT )
{
HB_FUNC_EXEC( HB_TOKENCOUNT );
}
| hbtoken.c | 306 |
| hbzlib.c |
| Type | Function | Source | Line |
|---|
| STATIC ULONG | hb_zlibUncompressedSize( const char * szSrc, ULONG ulLen )
static ULONG hb_zlibUncompressedSize( const char * szSrc, ULONG ulLen )
{
Byte buffer[ 1024 ];
z_stream stream;
ULONG ulDest = 0;
memset( &stream, 0, sizeof( z_stream ) );
stream.next_in = ( Bytef * ) szSrc;
stream.avail_in = ( uInt ) ulLen;
/*
stream.zalloc = Z_NULL;
stream.zfree = Z_NULL;
stream.opaque = NULL;
*/
if( inflateInit( &stream ) == Z_OK )
{
int iStatus;
do
{
stream.next_out = buffer;
stream.avail_out = sizeof( buffer );
iStatus = inflate( &stream, Z_NO_FLUSH );
}
while( iStatus == Z_OK );
if( iStatus == Z_STREAM_END )
ulDest = stream.total_out;
inflateEnd( &stream );
}
return ulDest;
}
| hbzlib.c | 58 |
| HB_FUNC | HB_ZLIBVERSION(void)
HB_FUNC( HB_ZLIBVERSION )
{
if( hb_parni( 1 ) == 1 )
hb_retc( ZLIB_VERSION );
else
hb_retc( zlibVersion() );
}
| hbzlib.c | 91 |
| HB_FUNC | HB_ZCOMPRESSBOUND(void)
HB_FUNC( HB_ZCOMPRESSBOUND )
{
if( ISCHAR( 1 ) )
hb_retnint( compressBound( hb_parclen( 1 ) ) );
else if( ISNUM( 1 ) )
hb_retnint( compressBound( ( uLong ) hb_parnint( 1 ) ) );
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 102 |
| HB_FUNC | HB_ZUNCOMPRESSLEN(void)
HB_FUNC( HB_ZUNCOMPRESSLEN )
{
ULONG ulLen = hb_parclen( 1 );
hb_retnint( ulLen ? hb_zlibUncompressedSize( hb_parc( 1 ), ulLen ) : 0 );
}
| hbzlib.c | 115 |
| HB_FUNC | HB_ZCOMPRESS(void)
HB_FUNC( HB_ZCOMPRESS )
{
char * szData = hb_parc( 1 );
if( szData )
{
ULONG ulLen = hb_parclen( 1 );
if( ulLen )
{
PHB_ITEM pBuffer = ISBYREF( 2 ) ? hb_param( 2, HB_IT_STRING ) : NULL;
uLong ulDstLen;
char * pDest;
int iResult;
if( pBuffer )
{
pBuffer = hb_itemUnShareString( pBuffer );
ulDstLen = hb_itemGetCLen( pBuffer );
pDest = hb_itemGetCPtr( pBuffer );
}
else
{
ulDstLen = ISNUM( 2 ) ? ( uLong ) hb_parnint( 2 ) :
compressBound( ulLen );
pDest = ( char * ) hb_xalloc( ulDstLen + 1 );
}
if( pDest )
{
if( ISNUM( 4 ) )
iResult = compress2( ( Bytef * ) pDest, &ulDstLen, ( Bytef * ) szData, ulLen, hb_parni( 4 ) );
else
iResult = compress( ( Bytef * ) pDest, &ulDstLen, ( Bytef * ) szData, ulLen );
if( !pBuffer )
{
if( iResult == Z_OK )
hb_retclen_buffer( pDest, ulDstLen );
else
hb_xfree( pDest );
}
else if( iResult == Z_OK )
hb_retclen( pDest, ulDstLen );
}
else
iResult = Z_MEM_ERROR;
hb_storni( iResult, 3 );
}
else
{
hb_retc( NULL );
hb_storni( Z_OK, 3 );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 125 |
| HB_FUNC | HB_ZUNCOMPRESS(void)
HB_FUNC( HB_ZUNCOMPRESS )
{
PHB_ITEM pBuffer = ISBYREF( 2 ) ? hb_param( 2, HB_IT_STRING ) : NULL;
char * szData = hb_parc( 1 );
if( szData )
{
ULONG ulLen = hb_parclen( 1 );
if( ulLen )
{
uLong ulDstLen;
char * pDest;
int iResult;
if( pBuffer )
{
pBuffer = hb_itemUnShareString( pBuffer );
ulDstLen = hb_itemGetCLen( pBuffer );
pDest = hb_itemGetCPtr( pBuffer );
}
else
{
ulDstLen = ISNUM( 2 ) ? ( uLong ) hb_parnint( 2 ) :
hb_zlibUncompressedSize( szData, ulLen );
pDest = ( char * ) hb_xalloc( ulDstLen + 1 );
}
if( pDest )
{
iResult = uncompress( ( Bytef * ) pDest, &ulDstLen, ( Bytef * ) szData, ulLen );
if( !pBuffer )
{
if( iResult == Z_OK )
hb_retclen_buffer( pDest, ulDstLen );
else
hb_xfree( pDest );
}
else if( iResult == Z_OK )
hb_retclen( pDest, ulDstLen );
}
else
iResult = Z_MEM_ERROR;
hb_storni( iResult, 3 );
}
else
{
hb_retc( NULL );
hb_storni( Z_OK, 3 );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 188 |
| STATIC HB_GARBAGE_FUNC( | hb_gz_Destructor )
static HB_GARBAGE_FUNC( hb_gz_Destructor )
{
gzFile * gz = ( gzFile * ) Cargo;
if( * gz )
{
gzclose( * gz );
* gz = NULL;
}
}
| hbzlib.c | 250 |
| STATIC GZFILE | hb_gzParam( int iParam )
static gzFile hb_gzParam( int iParam )
{
gzFile * gzHolder = ( gzFile * ) hb_parptrGC( hb_gz_Destructor, iParam );
if( gzHolder && * gzHolder )
return * gzHolder;
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return NULL;
}
| hbzlib.c | 261 |
| HB_FUNC | HB_GZOPEN(void)
HB_FUNC( HB_GZOPEN )
{
char * cFile = hb_parc( 1 ), * cMode = hb_parc( 2 );
if( cFile && cMode )
{
gzFile gz = gzopen( cFile, cMode );
if( gz )
{
gzFile * gzHolder = ( gzFile * ) hb_gcAlloc( sizeof( gzFile ),
hb_gz_Destructor );
* gzHolder = gz;
hb_retptrGC( gzHolder );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 272 |
| HB_FUNC | HB_GZDOPEN(void)
HB_FUNC( HB_GZDOPEN )
{
char * cMode = hb_parc( 2 );
if( ISNUM( 1 ) && cMode )
{
gzFile gz = gzdopen( hb_parni( 1 ), cMode );
if( gz )
{
gzFile * gzHolder = ( gzFile * ) hb_gcAlloc( sizeof( gzFile ),
hb_gz_Destructor );
* gzHolder = gz;
hb_retptrGC( gzHolder );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 293 |
| HB_FUNC | HB_GZCLOSE(void)
HB_FUNC( HB_GZCLOSE )
{
gzFile * gzHolder = ( gzFile * ) hb_parptrGC( hb_gz_Destructor, 1 );
if( gzHolder )
{
gzFile gz = * gzHolder;
* gzHolder = NULL;
hb_retni( gzclose( gz ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 314 |
| HB_FUNC | HB_GZSETPARAMS(void)
HB_FUNC( HB_GZSETPARAMS )
{
if( ISNUM( 2 ) && ISNUM( 3 ) )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retni( gzsetparams( gz, hb_parni( 2 ), hb_parni( 3 ) ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 331 |
| HB_FUNC | HB_GZREAD(void)
HB_FUNC( HB_GZREAD )
{
PHB_ITEM pBuffer = ISBYREF( 2 ) ? hb_param( 2, HB_IT_STRING ) : NULL;
if( pBuffer )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
{
pBuffer = hb_itemUnShareString( pBuffer );
hb_retni( gzread( gz, hb_itemGetCPtr( pBuffer ), ISNUM( 3 ) ?
( ULONG ) hb_parnl( 3 ) : hb_itemGetCLen( pBuffer ) ) );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 346 |
| HB_FUNC | HB_GZWRITE(void)
HB_FUNC( HB_GZWRITE )
{
char * szData = hb_parc( 2 );
if( szData )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retni( gzwrite( gz, szData, ISNUM( 3 ) ?
( ULONG ) hb_parnl( 3 ) : hb_parclen( 2 ) ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 367 |
| HB_FUNC | HB_GZGETS(void)
HB_FUNC( HB_GZGETS )
{
int iLen = hb_parni( 2 );
if( iLen > 0 )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
{
char * szBuffer = ( char * ) hb_xalloc( iLen + 1 );
if( szBuffer )
{
if( gzgets( gz, szBuffer, iLen ) != Z_NULL )
hb_retc_buffer( szBuffer );
else
hb_xfree( szBuffer );
}
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 384 |
| HB_FUNC | HB_GZPUTS(void)
HB_FUNC( HB_GZPUTS )
{
char * szData = hb_parc( 2 );
if( szData )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retni( gzputs( gz, szData ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 410 |
| HB_FUNC | HB_GZGETC(void)
HB_FUNC( HB_GZGETC )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retni( gzgetc( gz ) );
}
| hbzlib.c | 426 |
| HB_FUNC | HB_GZUNGETC(void)
HB_FUNC( HB_GZUNGETC )
{
if( ISNUM( 1 ) )
{
gzFile gz = hb_gzParam( 2 );
if( gz )
hb_retni( gzungetc( hb_parni( 1 ), gz ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 436 |
| HB_FUNC | HB_GZFLUSH(void)
HB_FUNC( HB_GZFLUSH )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retni( gzflush( gz, ISNUM( 2 ) ? hb_parni( 2 ) : Z_SYNC_FLUSH ) );
}
| hbzlib.c | 451 |
| HB_FUNC | HB_GZSEEK(void)
HB_FUNC( HB_GZSEEK )
{
if( ISNUM( 2 ) )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retnint( gzseek( gz, ( z_off_t ) hb_parnint( 2 ), ISNUM( 3 ) ?
hb_parni( 3 ) : SEEK_SET ) );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 3012, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hbzlib.c | 461 |
| HB_FUNC | HB_GZREWIND(void)
HB_FUNC( HB_GZREWIND )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retni( gzrewind( gz ) );
}
| hbzlib.c | 477 |
| HB_FUNC | HB_GZTELL(void)
HB_FUNC( HB_GZTELL )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retnint( gztell( gz ) );
}
| hbzlib.c | 487 |
| HB_FUNC | HB_GZEOF(void)
HB_FUNC( HB_GZEOF )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retl( gzeof( gz ) != 0 );
}
| hbzlib.c | 497 |
| HB_FUNC | HB_GZDIRECT(void)
HB_FUNC( HB_GZDIRECT )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
hb_retl( gzdirect( gz ) != 0 );
}
| hbzlib.c | 508 |
| HB_FUNC | HB_GZERROR(void)
HB_FUNC( HB_GZERROR )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
{
int iErrNum = 0;
hb_retc( gzerror( gz, &iErrNum ) );
hb_storni( iErrNum, 2 );
}
}
| hbzlib.c | 519 |
| HB_FUNC | HB_GZCLEARERR(void)
HB_FUNC( HB_GZCLEARERR )
{
gzFile gz = hb_gzParam( 1 );
if( gz )
gzclearerr( gz );
}
| hbzlib.c | 534 |
| idle.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_idleDataRelease( void * Cargo )
static void hb_idleDataRelease( void * Cargo )
{
PHB_IDLEDATA pIdleData = ( PHB_IDLEDATA ) Cargo;
if( pIdleData->pIdleTasks )
{
do
{
hb_itemRelease( pIdleData->pIdleTasks[ --pIdleData->iIdleMaxTask ] );
}
while( pIdleData->iIdleMaxTask );
hb_xfree( pIdleData->pIdleTasks );
}
}
static HB_TSD_NEW( s_idleData, sizeof( HB_IDLEDATA ), NULL, hb_idleDataRelease );
| idle.c | 96 |
| VOID | hb_releaseCPU( void )
void hb_releaseCPU( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_releaseCPU()"));
hb_vmUnlock();
/* TODO: Add code to release time slices on all platforms */
#if defined(HB_OS_WIN_32) || defined(__CYGWIN__)
/* Forfeit the remainder of the current time slice. */
Sleep( 20 );
#elif defined(HB_OS_OS2)
/* 23/nov/2000 - maurilio.longo@libero.it
Minimum time slice under OS/2 is 32 milliseconds, passed 1 will be rounded to 32 and
will give a chance to threads of lower priority to get executed.
Passing 0 causes current thread to give up its time slice only if there are threads of
equal priority waiting to be dispatched. Note: certain versions of OS/2 kernel have a
bug which causes DosSleep(0) not to work as expected. */
DosSleep( 1 ); /* Duration is in milliseconds */
#elif defined(HB_OS_DOS)
/* NOTE: there is a bug under NT 4 and 2000 - if the app is running
in protected mode, time slices will _not_ be released - you must switch
to real mode first, execute the following, and switch back.
It just occurred to me that this is actually by design. Since MS doesn't
want you to do this from a console app, their solution was to not allow
the call to work in protected mode - screw the rest of the planet .
returns zero on failure. (means not supported)
*/
{
union REGS regs;
regs.h.ah = 2;
regs.HB_XREGS.ax = 0x1680;
HB_DOS_INT86( 0x2F, ®s, ®s );
}
#elif defined(HB_OS_UNIX)
{
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 1000;
select( 0, NULL, NULL, NULL, &tv );
}
/* the code below is simpler but seems that some Linux kernels
* (f.e. from Centos 5.1) have problems with nanosleep()
* so it was replaced by above code
*/
/*
{
static const struct timespec nanosecs = { 0, 1000000 };
nanosleep( &nanosecs, NULL );
}
*/
#else
/* Do nothing */
#endif
hb_vmLock();
}
| idle.c | 113 |
| VOID | hb_idleState( void )
void hb_idleState( void )
{
PHB_IDLEDATA pIdleData = ( PHB_IDLEDATA ) hb_stackGetTSD( &s_idleData );
if( ! pIdleData->fIamIdle )
{
pIdleData->fIamIdle = TRUE;
hb_releaseCPU();
if( hb_vmRequestQuery() == 0 )
{
if( pIdleData->fCollectGarbage )
{
hb_gcCollectAll( FALSE );
pIdleData->fCollectGarbage = FALSE;
}
if( pIdleData->pIdleTasks && pIdleData->iIdleTask < pIdleData->iIdleMaxTask )
{
hb_itemRelease( hb_itemDo( pIdleData->pIdleTasks[ pIdleData->iIdleTask ], 0 ) );
++pIdleData->iIdleTask;
if( pIdleData->iIdleTask == pIdleData->iIdleMaxTask && hb_setGetIdleRepeat() )
{
pIdleData->iIdleTask = 0; /* restart processing of idle tasks */
pIdleData->fCollectGarbage = TRUE;
}
}
pIdleData->fIamIdle = FALSE;
}
}
}
| idle.c | 183 |
| VOID | hb_idleReset( void )
void hb_idleReset( void )
{
PHB_IDLEDATA pIdleData = ( PHB_IDLEDATA ) hb_stackGetTSD( &s_idleData );
if( pIdleData->iIdleTask == pIdleData->iIdleMaxTask && !hb_setGetIdleRepeat() )
{
pIdleData->iIdleTask = 0;
}
pIdleData->fCollectGarbage = TRUE;
}
| idle.c | 216 |
| VOID | hb_idleSleep( double dSeconds )
void hb_idleSleep( double dSeconds )
{
if( dSeconds >= 0 )
{
HB_ULONG end_timer = hb_dateMilliSeconds() + ( HB_ULONG ) ( dSeconds * 1000 );
while( hb_dateMilliSeconds() < end_timer && hb_vmRequestQuery() == 0 )
hb_idleState();
hb_idleReset();
}
}
| idle.c | 228 |
| HB_FUNC | HB_IDLESTATE(void)
HB_FUNC( HB_IDLESTATE )
{
PHB_IDLEDATA pIdleData = ( PHB_IDLEDATA ) hb_stackGetTSD( &s_idleData );
pIdleData->fCollectGarbage = TRUE;
hb_idleState();
}
| idle.c | 241 |
| HB_FUNC | HB_IDLERESET(void)
HB_FUNC( HB_IDLERESET )
{
hb_idleReset();
}
| idle.c | 249 |
| HB_FUNC | HB_IDLESLEEP(void)
HB_FUNC( HB_IDLESLEEP )
{
hb_idleSleep( hb_parnd( 1 ) );
}
| idle.c | 255 |
| HB_FUNC | HB_IDLEADD(void)
HB_FUNC( HB_IDLEADD )
{
HB_ITEM_PTR pBlock = hb_param( 1, HB_IT_BLOCK );
if( pBlock )
{
PHB_IDLEDATA pIdleData = ( PHB_IDLEDATA ) hb_stackGetTSD( &s_idleData );
++pIdleData->iIdleMaxTask;
if( !pIdleData->pIdleTasks )
{
pIdleData->pIdleTasks = ( HB_ITEM_PTR * ) hb_xgrab( sizeof( HB_ITEM_PTR ) );
}
else
{
pIdleData->pIdleTasks = ( HB_ITEM_PTR * ) hb_xrealloc( pIdleData->pIdleTasks, sizeof( HB_ITEM_PTR ) * pIdleData->iIdleMaxTask );
}
/* store a copy of passed codeblock
*/
pIdleData->pIdleTasks[ pIdleData->iIdleMaxTask - 1 ] = hb_itemNew( pBlock );
/* return a pointer as a handle to this idle task
*/
hb_retptr( ( void * ) hb_codeblockId( pBlock ) ); /* TODO: access to pointers from harbour code */
}
}
| idle.c | 261 |
| HB_FUNC | HB_IDLEDEL(void)
HB_FUNC( HB_IDLEDEL )
{
PHB_IDLEDATA pIdleData = ( PHB_IDLEDATA ) hb_stackTestTSD( &s_idleData );
void * pID = hb_parptr( 1 );
if( pID && pIdleData && pIdleData->pIdleTasks )
{
SHORT iTask;
HB_ITEM_PTR pItem;
iTask = 0;
while( iTask < pIdleData->iIdleMaxTask )
{
pItem = pIdleData->pIdleTasks[ iTask ];
if( pID == hb_codeblockId( pItem ) )
{
hb_itemClear( hb_itemReturn( pItem ) ); /* return a codeblock */
hb_itemRelease( pItem );
--pIdleData->iIdleMaxTask;
if( pIdleData->iIdleMaxTask )
{
if( iTask != pIdleData->iIdleMaxTask )
{
memmove( &pIdleData->pIdleTasks[ iTask ], &pIdleData->pIdleTasks[ iTask + 1 ],
sizeof( HB_ITEM_PTR ) * ( pIdleData->iIdleMaxTask - iTask ) );
}
pIdleData->pIdleTasks = ( HB_ITEM_PTR * ) hb_xrealloc( pIdleData->pIdleTasks, sizeof( HB_ITEM_PTR ) * pIdleData->iIdleMaxTask );
if( pIdleData->iIdleTask >= pIdleData->iIdleMaxTask )
pIdleData->iIdleTask = 0;
}
else
{
hb_xfree( pIdleData->pIdleTasks );
pIdleData->pIdleTasks = NULL;
pIdleData->iIdleTask = 0;
}
break;
}
++iTask;
}
}
}
| idle.c | 289 |
| HB_FUNC | HB_RELEASECPU(void)
HB_FUNC( HB_RELEASECPU )
{
hb_releaseCPU();
}
| idle.c | 334 |
| inkey.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_inkeyBlockRelease( void * cargo )
static void hb_inkeyBlockRelease( void * cargo )
{
PHB_INKEYBLOCK pInkeyBlock = ( PHB_INKEYBLOCK ) cargo;
if( pInkeyBlock->before )
hb_itemRelease( pInkeyBlock->before );
if( pInkeyBlock->after )
hb_itemRelease( pInkeyBlock->after );
}
static HB_TSD_NEW( s_inkeyBlock, sizeof( HB_INKEYBLOCK ), NULL, hb_inkeyBlockRelease );
| inkey.c | 86 |
| HB_FUNC | INKEY(void)
HB_FUNC( INKEY )
{
PHB_INKEYBLOCK pInkeyBlock = ( PHB_INKEYBLOCK ) hb_stackTestTSD( &s_inkeyBlock );
USHORT uiPCount = ( USHORT ) hb_pcount();
PHB_ITEM pKey = NULL;
int iKey;
if( pInkeyBlock && pInkeyBlock->before )
hb_vmEvalBlock( pInkeyBlock->before );
do
{
iKey = hb_inkey( uiPCount == 1 || ( uiPCount > 1 && ISNUM( 1 ) ),
hb_parnd( 1 ),
ISNUM( 2 ) ? hb_parni( 2 ) : hb_setGetEventMask() );
if( iKey == 0 || !pInkeyBlock || !pInkeyBlock->after )
break;
pKey = hb_itemPutNI( pKey, iKey );
iKey = hb_itemGetNI( hb_vmEvalBlockV( pInkeyBlock->after, 1, pKey ) );
hb_inkeySetLast( iKey );
}
while( iKey == 0 );
if( pKey )
hb_itemRelease( pKey );
hb_retni( iKey );
}
| inkey.c | 98 |
| HB_FUNC | HB_SETINKEYBEFOREBLOCK(void)
HB_FUNC( HB_SETINKEYBEFOREBLOCK )
{
PHB_INKEYBLOCK pInkeyBlock = ( PHB_INKEYBLOCK ) hb_stackGetTSD( &s_inkeyBlock );
if( pInkeyBlock->before )
hb_itemReturn( pInkeyBlock->before );
if( hb_pcount() > 0 )
{
PHB_ITEM pBlock = hb_param( 1, HB_IT_BLOCK );
if( pInkeyBlock->before )
hb_itemRelease( pInkeyBlock->before );
pInkeyBlock->before = pBlock ? hb_itemNew( pBlock ) : pBlock;
}
}
| inkey.c | 131 |
| HB_FUNC | HB_SETINKEYAFTERBLOCK(void)
HB_FUNC( HB_SETINKEYAFTERBLOCK )
{
PHB_INKEYBLOCK pInkeyBlock = ( PHB_INKEYBLOCK ) hb_stackGetTSD( &s_inkeyBlock );
if( pInkeyBlock->after )
hb_itemReturn( pInkeyBlock->after );
if( hb_pcount() > 0 )
{
PHB_ITEM pBlock = hb_param( 1, HB_IT_BLOCK );
if( pInkeyBlock->after )
hb_itemRelease( pInkeyBlock->after );
pInkeyBlock->after = pBlock ? hb_itemNew( pBlock ) : pBlock;
}
}
| inkey.c | 148 |
| HB_FUNC | __KEYBOARD(void)
HB_FUNC( __KEYBOARD )
{
/* Clear the typeahead buffer without reallocating the keyboard buffer */
hb_inkeyReset();
if( ISCHAR( 1 ) )
hb_inkeySetText( hb_parc( 1 ), hb_parclen( 1 ) );
}
| inkey.c | 167 |
| HB_FUNC | HB_KEYPUT(void)
HB_FUNC( HB_KEYPUT )
{
if( ISNUM( 1 ) )
{
hb_inkeyPut( hb_parni( 1 ) );
}
else if( ISCHAR( 1 ) )
{
hb_inkeySetText( hb_parc( 1 ), hb_parclen( 1 ) );
}
else if( ISARRAY( 1 ) )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
ULONG ulIndex;
ULONG ulElements = hb_arrayLen( pArray );
for( ulIndex = 1; ulIndex <= ulElements; ulIndex++ )
{
HB_TYPE type = hb_arrayGetType( pArray, ulIndex );
if( type & HB_IT_NUMERIC )
{
hb_inkeyPut( hb_arrayGetNI( pArray, ulIndex ) );
}
else if( type & HB_IT_STRING )
{
hb_inkeySetText( ( const char * ) hb_arrayGetCPtr( pArray, ulIndex ), hb_arrayGetCLen( pArray, ulIndex ) );
}
}
}
}
| inkey.c | 176 |
| HB_FUNC | HB_KEYINS(void)
HB_FUNC( HB_KEYINS )
{
if( ISNUM( 1 ) )
{
hb_inkeyIns( hb_parni( 1 ) );
}
else if( ISCHAR( 1 ) )
{
hb_inkeySetText( hb_parc( 1 ), hb_parclen( 1 ) );
}
else if( ISARRAY( 1 ) )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
ULONG ulIndex;
ULONG ulElements = hb_arrayLen( pArray );
for( ulIndex = 1; ulIndex <= ulElements; ulIndex++ )
{
HB_TYPE type = hb_arrayGetType( pArray, ulIndex );
if( type & HB_IT_NUMERIC )
{
hb_inkeyIns( hb_arrayGetNI( pArray, ulIndex ) );
}
else if( type & HB_IT_STRING )
{
hb_inkeySetText( ( const char * ) hb_arrayGetCPtr( pArray, ulIndex ), hb_arrayGetCLen( pArray, ulIndex ) );
}
}
}
}
| inkey.c | 208 |
| HB_FUNC | NEXTKEY(void)
HB_FUNC( NEXTKEY )
{
hb_retni( hb_inkeyNext( ISNUM( 1 ) ? hb_parni( 1 ) : hb_setGetEventMask() ) );
}
| inkey.c | 240 |
| HB_FUNC | LASTKEY(void)
HB_FUNC( LASTKEY )
{
hb_retni( hb_inkeyLast( ISNUM( 1 ) ? hb_parni( 1 ) : INKEY_ALL ) );
}
| inkey.c | 245 |
| HB_FUNC | HB_SETLASTKEY(void)
HB_FUNC( HB_SETLASTKEY )
{
if( ISNUM( 1 ) )
hb_retni( hb_inkeySetLast( hb_parni( 1 ) ) );
}
| inkey.c | 250 |
| inkeyapi.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT INT | hb_inkey( BOOL fWait, double dSeconds, int iEventMask )
HB_EXPORT int hb_inkey( BOOL fWait, double dSeconds, int iEventMask )
{
int iKey = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkey(%d, %f, %d)", (int) fWait, dSeconds, iEventMask));
pGT = hb_gt_Base();
if( pGT )
{
iKey = HB_GTSELF_INKEYGET( pGT, fWait, dSeconds, iEventMask );
hb_gt_BaseFree( pGT );
}
return iKey;
}
| inkeyapi.c | 55 |
| HB_EXPORT VOID | hb_inkeyPut( int iKey )
HB_EXPORT void hb_inkeyPut( int iKey )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeyPut(%d)", iKey));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_INKEYPUT( pGT, iKey );
hb_gt_BaseFree( pGT );
}
}
| inkeyapi.c | 71 |
| HB_EXPORT VOID | hb_inkeyIns( int iKey )
HB_EXPORT void hb_inkeyIns( int iKey )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeyIns(%d)", iKey));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_INKEYINS( pGT, iKey );
hb_gt_BaseFree( pGT );
}
}
| inkeyapi.c | 85 |
| HB_EXPORT INT | hb_inkeyLast( int iEventMask )
HB_EXPORT int hb_inkeyLast( int iEventMask )
{
int iKey = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeyLast(%d)", iEventMask));
pGT = hb_gt_Base();
if( pGT )
{
iKey = HB_GTSELF_INKEYLAST( pGT, iEventMask );
hb_gt_BaseFree( pGT );
}
return iKey;
}
| inkeyapi.c | 99 |
| HB_EXPORT INT | hb_inkeyNext( int iEventMask )
HB_EXPORT int hb_inkeyNext( int iEventMask )
{
int iKey = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeyNext(%d)", iEventMask));
pGT = hb_gt_Base();
if( pGT )
{
iKey = HB_GTSELF_INKEYNEXT( pGT, iEventMask );
hb_gt_BaseFree( pGT );
}
return iKey;
}
| inkeyapi.c | 115 |
| HB_EXPORT VOID | hb_inkeyPoll( void )
HB_EXPORT void hb_inkeyPoll( void )
{
PHB_GT pGT;
HB_TRACE( HB_TR_DEBUG, ("hb_inkeyPoll()") );
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_INKEYPOLL( pGT );
hb_gt_BaseFree( pGT );
}
}
| inkeyapi.c | 131 |
| HB_EXPORT INT | hb_inkeySetLast( int iKey )
HB_EXPORT int hb_inkeySetLast( int iKey )
{
int iLast = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetLast(%d)", iKey));
pGT = hb_gt_Base();
if( pGT )
{
iLast = HB_GTSELF_INKEYSETLAST( pGT, iKey );
hb_gt_BaseFree( pGT );
}
return iLast;
}
| inkeyapi.c | 145 |
| HB_EXPORT VOID | hb_inkeySetText( const char * szText, ULONG ulLen )
HB_EXPORT void hb_inkeySetText( const char * szText, ULONG ulLen )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetText(%s,%lu)", szText, ulLen));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_INKEYSETTEXT( pGT, szText, ulLen );
hb_gt_BaseFree( pGT );
}
}
| inkeyapi.c | 161 |
| HB_EXPORT VOID | hb_inkeyReset( void )
HB_EXPORT void hb_inkeyReset( void )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeyReset()"));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_INKEYRESET( pGT );
hb_gt_BaseFree( pGT );
}
}
| inkeyapi.c | 175 |
| HB_EXPORT VOID | hb_inkeySetCancelKeys( int iCancelKey, int iCancelKeyEx )
HB_EXPORT void hb_inkeySetCancelKeys( int iCancelKey, int iCancelKeyEx )
{
HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetCancelKeys(%d,%d)", iCancelKey, iCancelKeyEx));
/*
s_InkeyAltC = iCancelKey;
s_InkeyAltCEx = iCancelKeyEx;
*/
HB_SYMBOL_UNUSED( iCancelKey );
HB_SYMBOL_UNUSED( iCancelKeyEx );
}
| inkeyapi.c | 189 |
| is.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | ISALPHA(void)
HB_FUNC( ISALPHA )
{
char * szString = hb_parc( 1 );
if( szString )
{
if( isalpha( ( unsigned char ) * szString ) )
hb_retl( TRUE );
else
{
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp->nChars && szString[0] &&
( strchr( cdp->CharsUpper,* szString ) ||
strchr( cdp->CharsLower,* szString ) ) )
hb_retl( TRUE );
else
#endif
hb_retl( FALSE );
}
}
else
hb_retl( FALSE );
}
| is.c | 60 |
| HB_FUNC | ISDIGIT(void)
HB_FUNC( ISDIGIT )
{
char * szString = hb_parc( 1 );
hb_retl( szString && isdigit( ( unsigned char ) * szString ) );
}
| is.c | 87 |
| HB_FUNC | ISUPPER(void)
HB_FUNC( ISUPPER )
{
char * szString = hb_parc( 1 );
if( szString )
{
if( isupper( ( unsigned char ) * szString ) )
hb_retl( TRUE );
else
{
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp->nChars && szString[0] &&
strchr( cdp->CharsUpper, * szString ) )
hb_retl( TRUE );
else
#endif
hb_retl( FALSE );
}
}
else
hb_retl( FALSE );
}
| is.c | 96 |
| HB_FUNC | ISLOWER(void)
HB_FUNC( ISLOWER )
{
char * szString = hb_parc( 1 );
if( szString )
{
if( islower( ( unsigned char ) * szString ) )
hb_retl( TRUE );
else
{
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp->nChars && szString[0] &&
strchr( cdp->CharsLower,* szString ) )
hb_retl( TRUE );
#endif
else
hb_retl( FALSE );
}
}
else
hb_retl( FALSE );
}
| is.c | 122 |
| isprint.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT BOOL | hb_printerIsReady( char * pszPrinterName )
HB_EXPORT BOOL hb_printerIsReady( char * pszPrinterName )
{
BOOL bIsPrinter;
#if defined(HB_OS_DOS)
/* NOTE: DOS specific solution, using BIOS interrupt */
{
USHORT uiPort;
if( pszPrinterName == NULL )
pszPrinterName = "LPT1";
if( hb_strnicmp( pszPrinterName, "PRN", 3 ) == 0 )
{
union REGS regs;
regs.h.ah = 2;
regs.HB_XREGS.dx = 0; /* LPT1 */
HB_DOS_INT86( 0x17, ®s, ®s );
bIsPrinter = ( regs.h.ah == 0x90 );
}
else if( strlen( pszPrinterName ) >= 4 &&
hb_strnicmp( pszPrinterName, "LPT", 3 ) == 0 &&
( uiPort = atoi( pszPrinterName + 3 ) ) > 0 )
{
union REGS regs;
regs.h.ah = 2;
regs.HB_XREGS.dx = uiPort - 1;
HB_DOS_INT86( 0x17, ®s, ®s );
bIsPrinter = ( regs.h.ah == 0x90 );
}
else
bIsPrinter = FALSE;
}
#elif defined(HB_OS_WIN_32)
/* NOTE: Platform independent method, at least it will compile and run
on any platform, but the result may not be the expected one,
since Unix/Linux doesn't support LPT/COM by nature, other OSs
may not reflect the actual physical presence of the printer when
trying to open it, since we are talking to the spooler.
[vszakats] */
{
HB_FHANDLE fhnd;
if( pszPrinterName == NULL )
pszPrinterName = "LPT1";
fhnd = hb_fsOpen( ( BYTE * ) pszPrinterName, FO_WRITE | FO_SHARED | FO_PRIVATE );
bIsPrinter = ( fhnd != FS_ERROR );
hb_fsClose( fhnd );
}
#else
{
/* TODO */
HB_SYMBOL_UNUSED( pszPrinterName );
bIsPrinter = FALSE;
}
#endif
return bIsPrinter;
}
| isprint.c | 56 |
| HB_FUNC | HB_ISPRINTER(void)
HB_FUNC( HB_ISPRINTER )
{
hb_retl( hb_printerIsReady( hb_parc( 1 ) ) );
}
| isprint.c | 133 |
| HB_FUNC | ISPRINTER(void)
HB_FUNC( ISPRINTER )
{
#ifdef HB_COMPAT_XPP
HB_FUNC_EXEC( HB_ISPRINTER );
#else
hb_retl( hb_printerIsReady( NULL ) );
#endif
}
| isprint.c | 140 |
| itemseri.c |
| Type | Function | Source | Line |
|---|
| STATIC BOOL | hb_itemSerialValueRef( PHB_CYCLIC_REF * pRefPtr, void * value, ULONG ulOffset )
static BOOL hb_itemSerialValueRef( PHB_CYCLIC_REF * pRefPtr, void * value,
ULONG ulOffset )
{
while( * pRefPtr )
{
if( ( * pRefPtr )->value == value )
{
( * pRefPtr )->fRef = TRUE;
return TRUE;
}
pRefPtr = &( * pRefPtr )->pNext;
}
* pRefPtr = ( PHB_CYCLIC_REF ) hb_xgrab( sizeof( HB_CYCLIC_REF ) );
( * pRefPtr )->value = value;
( * pRefPtr )->ulOffset = ulOffset;
( * pRefPtr )->fRef = FALSE;
( * pRefPtr )->pNext = NULL;
return FALSE;
}
| itemseri.c | 147 |
| STATIC VOID | hb_itemSerialUnRefFree( PHB_CYCLIC_REF * pRefPtr )
static void hb_itemSerialUnRefFree( PHB_CYCLIC_REF * pRefPtr )
{
PHB_CYCLIC_REF pRef;
while( * pRefPtr )
{
pRef = * pRefPtr;
if( ! pRef->fRef )
{
* pRefPtr =pRef->pNext;
hb_xfree( pRef );
}
else
pRefPtr = &pRef->pNext;
}
}
| itemseri.c | 169 |
| STATIC BOOL | hb_itemSerialValueOffset( PHB_CYCLIC_REF pRef, void * value, ULONG ulOffset, ULONG * pulRef )
static BOOL hb_itemSerialValueOffset( PHB_CYCLIC_REF pRef, void * value,
ULONG ulOffset, ULONG * pulRef )
{
while( pRef )
{
if( pRef->value == value )
{
* pulRef = pRef->ulOffset;
return pRef->ulOffset < ulOffset;
}
pRef = pRef->pNext;
}
* pulRef = HB_SERIAL_DUMMYOFFSET;
return FALSE;
}
| itemseri.c | 186 |
| STATIC BOOL | hb_itemSerialOffsetRef( PHB_CYCLIC_REF * pRefPtr, void * value, ULONG ulOffset )
static BOOL hb_itemSerialOffsetRef( PHB_CYCLIC_REF * pRefPtr, void * value,
ULONG ulOffset )
{
while( * pRefPtr )
{
if( ( * pRefPtr )->ulOffset == ulOffset )
return TRUE;
pRefPtr = &( * pRefPtr )->pNext;
}
* pRefPtr = ( PHB_CYCLIC_REF ) hb_xgrab( sizeof( HB_CYCLIC_REF ) );
( * pRefPtr )->value = value;
( * pRefPtr )->ulOffset = ulOffset;
( * pRefPtr )->fRef = FALSE;
( * pRefPtr )->pNext = NULL;
return FALSE;
}
| itemseri.c | 203 |
| STATIC VOID | hb_itemSerialOffsetSet( PHB_CYCLIC_REF pRef, PHB_ITEM pItem, ULONG ulOffset )
static void hb_itemSerialOffsetSet( PHB_CYCLIC_REF pRef, PHB_ITEM pItem,
ULONG ulOffset )
{
while( pRef )
{
if( pRef->ulOffset == ulOffset )
{
pRef->value = ( void * ) pItem;
break;
}
pRef = pRef->pNext;
}
}
| itemseri.c | 222 |
| STATIC VOID | hb_itemSerialOffsetGet( PHB_CYCLIC_REF pRef, PHB_ITEM pItem, ULONG ulOffset )
static void hb_itemSerialOffsetGet( PHB_CYCLIC_REF pRef, PHB_ITEM pItem,
ULONG ulOffset )
{
while( pRef )
{
if( pRef->ulOffset == ulOffset )
{
hb_itemCopy( pItem, ( PHB_ITEM ) pRef->value );
break;
}
pRef = pRef->pNext;
}
}
| itemseri.c | 236 |
| STATIC VOID | hb_itemSerialRefFree( PHB_CYCLIC_REF pRef )
static void hb_itemSerialRefFree( PHB_CYCLIC_REF pRef )
{
while( pRef )
{
PHB_CYCLIC_REF pNext = pRef->pNext;
hb_xfree( pRef );
pRef = pNext;
}
}
| itemseri.c | 250 |
| STATIC ULONG | hb_itemSerialSize( PHB_ITEM pItem, PHB_CYCLIC_REF * pRefPtr, ULONG ulOffset )
static ULONG hb_itemSerialSize( PHB_ITEM pItem, PHB_CYCLIC_REF * pRefPtr, ULONG ulOffset )
{
ULONG ulSize, ulLen, u;
HB_LONG lVal;
double d;
USHORT uiClass;
const char * szVal;
switch( hb_itemType( pItem ) )
{
case HB_IT_NIL:
case HB_IT_LOGICAL:
ulSize = 1;
break;
case HB_IT_DATE:
ulSize = 4;
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
lVal = hb_itemGetNInt( pItem );
if( lVal == 0 )
ulSize = 1;
else if( HB_LIM_INT8( lVal ) )
ulSize = 2;
else if( HB_LIM_INT16( lVal ) )
ulSize = 3;
else if( HB_LIM_INT24( lVal ) )
ulSize = 4;
else if( HB_LIM_INT32( lVal ) )
ulSize = 5;
else
ulSize = 9;
break;
case HB_IT_DOUBLE:
d = hb_itemGetND( pItem );
if( d == 0.0 )
ulSize = 1;
else
ulSize = 9;
break;
case HB_IT_SYMBOL:
ulSize = 2 + strlen( hb_itemGetSymbol( pItem )->szName );
break;
case HB_IT_STRING:
case HB_IT_MEMO:
szVal = hb_itemGetCPtr( pItem );
ulLen = hb_itemGetCLen( pItem );
if( ulLen == 0 )
ulSize = 1;
else
{
u = ulLen;
while( u && szVal[ u - 1 ] == ' ' )
--u;
u = ulLen - u;
if( ulLen <= 255 )
ulSize = u > 1 ? ulLen - u + 3: ulLen + 2;
else if( ulLen <= UINT16_MAX )
ulSize = u > 2 ? ulLen - u + 5: ulLen + 3;
else
ulSize = u > 4 ? ulLen - u + 9: ulLen + 5;
}
break;
case HB_IT_ARRAY:
ulSize = 0;
uiClass = hb_objGetClass( pItem );
if( uiClass )
{
const char * szClass = hb_clsName( uiClass ),
* szFunc = hb_clsFuncName( uiClass );
if( szClass && szFunc )
ulSize += strlen( szClass ) + strlen( szFunc ) + 3;
}
if( hb_itemSerialValueRef( pRefPtr, hb_arrayId( pItem ), ulOffset + ulSize ) )
{
ulSize = 5;
}
else
{
ulLen = hb_arrayLen( pItem );
if( ulLen <= 255 )
ulSize += 2;
else if( ulLen <= UINT16_MAX )
ulSize += 3;
else
ulSize += 5;
for( u = 1; u <= ulLen; u++ )
ulSize += hb_itemSerialSize( hb_arrayGetItemPtr( pItem, u ),
pRefPtr, ulOffset + ulSize );
}
break;
case HB_IT_HASH:
if( hb_itemSerialValueRef( pRefPtr, hb_hashId( pItem ), ulOffset ) )
{
ulSize = 5;
}
else
{
ulLen = hb_hashLen( pItem );
if( ulLen <= 255 )
ulSize = 2;
else if( ulLen <= UINT16_MAX )
ulSize = 3;
else
ulSize = 5;
for( u = 1; u <= ulLen; u++ )
{
ulSize += hb_itemSerialSize( hb_hashGetKeyAt( pItem, u ),
pRefPtr, ulOffset + ulSize );
ulSize += hb_itemSerialSize( hb_hashGetValueAt( pItem, u ),
pRefPtr, ulOffset + ulSize );
}
}
break;
default:
/* map to NIL */
ulSize = 1;
}
return ulSize;
}
| itemseri.c | 260 |
| STATIC ULONG | hb_serializeItem( PHB_ITEM pItem, UCHAR * pBuffer, ULONG ulOffset, PHB_CYCLIC_REF pRef )
static ULONG hb_serializeItem( PHB_ITEM pItem, UCHAR * pBuffer,
ULONG ulOffset, PHB_CYCLIC_REF pRef )
{
HB_LONG lVal;
ULONG ulRef, ulLen, u;
LONG l;
double d;
const char * szVal;
switch( hb_itemType( pItem ) )
{
case HB_IT_NIL:
pBuffer[ ulOffset++ ] = HB_SERIAL_NIL;
break;
case HB_IT_LOGICAL:
pBuffer[ ulOffset++ ] = hb_itemGetL( pItem ) ? HB_SERIAL_TRUE : HB_SERIAL_FALSE;
break;
case HB_IT_DATE:
pBuffer[ ulOffset++ ] = HB_SERIAL_DATE;
l = hb_itemGetDL( pItem );
HB_PUT_LE_UINT24( &pBuffer[ ulOffset ], l );
ulOffset += 3;
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
lVal = hb_itemGetNInt( pItem );
if( lVal == 0 )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_ZERO;
}
else if( HB_LIM_INT8( lVal ) )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_INT8;
pBuffer[ ulOffset++ ] = ( UCHAR ) lVal;
}
else if( HB_LIM_INT16( lVal ) )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_INT16;
HB_PUT_LE_UINT16( &pBuffer[ ulOffset ], lVal );
ulOffset += 2;
}
else if( HB_LIM_INT24( lVal ) )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_INT24;
HB_PUT_LE_UINT24( &pBuffer[ ulOffset ], lVal );
ulOffset += 3;
}
else if( HB_LIM_INT32( lVal ) )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_INT32;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], lVal );
ulOffset += 4;
}
else
{
pBuffer[ ulOffset++ ] = HB_SERIAL_INT64;
HB_PUT_LE_UINT64( &pBuffer[ ulOffset ], lVal );
ulOffset += 8;
}
break;
case HB_IT_DOUBLE:
d = hb_itemGetND( pItem );
if( d == 0.0 )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_ZERO;
}
else
{
pBuffer[ ulOffset++ ] = HB_SERIAL_DOUBLE;
HB_PUT_LE_DOUBLE( &pBuffer[ ulOffset ], d );
ulOffset += 8;
}
break;
case HB_IT_SYMBOL:
szVal = hb_itemGetSymbol( pItem )->szName;
ulLen = strlen( szVal );
if( ulLen > 0xFF )
ulLen = 0xFF;
pBuffer[ ulOffset++ ] = HB_SERIAL_SYMBOL;
pBuffer[ ulOffset++ ] = ( UCHAR ) ulLen;
memcpy( &pBuffer[ ulOffset ], szVal, ulLen );
ulOffset += ulLen;
break;
case HB_IT_STRING:
case HB_IT_MEMO:
szVal = hb_itemGetCPtr( pItem );
ulLen = hb_itemGetCLen( pItem );
if( ulLen == 0 )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_STRNUL;
}
else
{
u = ulLen;
while( u && szVal[ u - 1 ] == ' ' )
--u;
u = ulLen - u;
if( ulLen <= 255 )
{
if( u > 1 )
{
ulLen -= u;
pBuffer[ ulOffset++ ] = HB_SERIAL_STRPAD8;
pBuffer[ ulOffset++ ] = ( UCHAR ) ulLen;
pBuffer[ ulOffset++ ] = ( UCHAR ) u;
}
else
{
pBuffer[ ulOffset++ ] = HB_SERIAL_STRING8;
pBuffer[ ulOffset++ ] = ( UCHAR ) ulLen;
}
}
else if( ulLen <= UINT16_MAX )
{
if( u > 2 )
{
ulLen -= u;
pBuffer[ ulOffset++ ] = HB_SERIAL_STRPAD16;
HB_PUT_LE_UINT16( &pBuffer[ ulOffset ], ulLen );
ulOffset += 2;
HB_PUT_LE_UINT16( &pBuffer[ ulOffset ], u );
ulOffset += 2;
}
else
{
pBuffer[ ulOffset++ ] = HB_SERIAL_STRING16;
HB_PUT_LE_UINT16( &pBuffer[ ulOffset ], ulLen );
ulOffset += 2;
}
}
else
{
if( u > 4 )
{
ulLen -= u;
pBuffer[ ulOffset++ ] = HB_SERIAL_STRPAD32;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], ulLen );
ulOffset += 4;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], u );
ulOffset += 4;
}
else
{
pBuffer[ ulOffset++ ] = HB_SERIAL_STRING32;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], ulLen );
ulOffset += 4;
}
}
memcpy( &pBuffer[ ulOffset ], szVal, ulLen );
ulOffset += ulLen;
}
break;
case HB_IT_ARRAY:
if( hb_itemSerialValueOffset( pRef, hb_arrayId( pItem ), ulOffset, &ulRef ) )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_REF;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], ulRef );
ulOffset += 4;
}
else
{
USHORT uiClass = hb_objGetClass( pItem );
if( uiClass )
{
const char * szClass = hb_clsName( uiClass ),
* szFunc = hb_clsFuncName( uiClass );
if( szClass && szFunc )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_OBJ;
ulLen = strlen( szClass ) + 1;
memcpy( &pBuffer[ ulOffset ], szClass, ulLen );
ulOffset += ulLen;
ulLen = strlen( szFunc ) + 1;
memcpy( &pBuffer[ ulOffset ], szFunc, ulLen );
ulOffset += ulLen;
}
}
ulLen = hb_arrayLen( pItem );
if( ulLen <= 255 )
{
pBuffer[ ulOffset++ ] = ulRef == HB_SERIAL_DUMMYOFFSET ?
HB_SERIAL_ARRAY8 : HB_SERIAL_ARRAYREF8;
pBuffer[ ulOffset++ ] = ( UCHAR ) ulLen;
}
else if( ulLen <= UINT16_MAX )
{
pBuffer[ ulOffset++ ] = ulRef == HB_SERIAL_DUMMYOFFSET ?
HB_SERIAL_ARRAY16 : HB_SERIAL_ARRAYREF16;
HB_PUT_LE_UINT16( &pBuffer[ ulOffset ], ulLen );
ulOffset += 2;
}
else
{
pBuffer[ ulOffset++ ] = ulRef == HB_SERIAL_DUMMYOFFSET ?
HB_SERIAL_ARRAY32 : HB_SERIAL_ARRAYREF32;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], ulLen );
ulOffset += 4;
}
for( u = 1; u <= ulLen; u++ )
ulOffset = hb_serializeItem( hb_arrayGetItemPtr( pItem, u ), pBuffer, ulOffset, pRef );
}
break;
case HB_IT_HASH:
if( hb_itemSerialValueOffset( pRef, hb_hashId( pItem ), ulOffset, &ulRef ) )
{
pBuffer[ ulOffset++ ] = HB_SERIAL_REF;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], ulRef );
ulOffset += 4;
}
else
{
ulLen = hb_hashLen( pItem );
if( ulLen <= 255 )
{
pBuffer[ ulOffset++ ] = ulRef == HB_SERIAL_DUMMYOFFSET ?
HB_SERIAL_HASH8 : HB_SERIAL_HASHREF8;
pBuffer[ ulOffset++ ] = ( UCHAR ) ulLen;
}
else if( ulLen <= UINT16_MAX )
{
pBuffer[ ulOffset++ ] = ulRef == HB_SERIAL_DUMMYOFFSET ?
HB_SERIAL_HASH16 : HB_SERIAL_HASHREF16;
HB_PUT_LE_UINT16( &pBuffer[ ulOffset ], ulLen );
ulOffset += 2;
}
else
{
pBuffer[ ulOffset++ ] = ulRef == HB_SERIAL_DUMMYOFFSET ?
HB_SERIAL_HASH32 : HB_SERIAL_HASHREF32;
HB_PUT_LE_UINT32( &pBuffer[ ulOffset ], ulLen );
ulOffset += 4;
}
for( u = 1; u <= ulLen; u++ )
{
ulOffset = hb_serializeItem( hb_hashGetKeyAt( pItem, u ), pBuffer, ulOffset, pRef );
ulOffset = hb_serializeItem( hb_hashGetValueAt( pItem, u ), pBuffer, ulOffset, pRef );
}
}
break;
default:
/* map to NIL */
pBuffer[ ulOffset++ ] = HB_SERIAL_NIL;
break;
}
return ulOffset;
}
| itemseri.c | 390 |
| STATIC ULONG | hb_deserializeHash( PHB_ITEM pItem, UCHAR * pBuffer, ULONG ulOffset, ULONG ulLen, PHB_CYCLIC_REF pRef )
static ULONG hb_deserializeHash( PHB_ITEM pItem, UCHAR * pBuffer, ULONG ulOffset,
ULONG ulLen, PHB_CYCLIC_REF pRef )
{
hb_hashNew( pItem );
if( ulLen )
{
PHB_ITEM pKey = hb_itemNew( NULL );
PHB_ITEM pVal = hb_itemNew( NULL );
hb_hashPreallocate( pItem, ulLen );
while( ulLen-- )
{
ulOffset = hb_deserializeItem( pKey, pBuffer, ulOffset, pRef );
ulOffset = hb_deserializeItem( pVal, pBuffer, ulOffset, pRef );
hb_hashAdd( pItem, pKey, pVal );
}
hb_itemRelease( pKey );
hb_itemRelease( pVal );
}
return ulOffset;
}
| itemseri.c | 647 |
| STATIC ULONG | hb_deserializeArray( PHB_ITEM pItem, UCHAR * pBuffer, ULONG ulOffset, ULONG ulLen, PHB_CYCLIC_REF pRef )
static ULONG hb_deserializeArray( PHB_ITEM pItem, UCHAR * pBuffer, ULONG ulOffset,
ULONG ulLen, PHB_CYCLIC_REF pRef )
{
ULONG u;
hb_arrayNew( pItem, ulLen );
for( u = 1; u <= ulLen; u++ )
ulOffset = hb_deserializeItem( hb_arrayGetItemPtr( pItem, u ),
pBuffer, ulOffset, pRef );
return ulOffset;
}
| itemseri.c | 671 |
| STATIC ULONG | hb_deserializeItem( PHB_ITEM pItem, UCHAR * pBuffer, ULONG ulOffset, PHB_CYCLIC_REF pRef )
static ULONG hb_deserializeItem( PHB_ITEM pItem, UCHAR * pBuffer,
ULONG ulOffset, PHB_CYCLIC_REF pRef )
{
ULONG ulLen, ulPad;
char * szVal;
switch( pBuffer[ ulOffset++ ] )
{
case HB_SERIAL_NIL:
hb_itemClear( pItem );
break;
case HB_SERIAL_TRUE:
hb_itemPutL( pItem, TRUE );
break;
case HB_SERIAL_FALSE:
hb_itemPutL( pItem, FALSE );
break;
case HB_SERIAL_ZERO:
hb_itemPutNI( pItem, 0 );
break;
case HB_SERIAL_INT8:
hb_itemPutNI( pItem, pBuffer[ ulOffset++ ] );
break;
case HB_SERIAL_INT16:
hb_itemPutNI( pItem, HB_GET_LE_INT16( &pBuffer[ ulOffset ] ) );
ulOffset += 2;
break;
case HB_SERIAL_INT24:
hb_itemPutNInt( pItem, HB_GET_LE_INT24( &pBuffer[ ulOffset ] ) );
ulOffset += 3;
break;
case HB_SERIAL_INT32:
hb_itemPutNInt( pItem, HB_GET_LE_INT32( &pBuffer[ ulOffset ] ) );
ulOffset += 4;
break;
case HB_SERIAL_INT64:
hb_itemPutNInt( pItem, HB_GET_LE_INT64( &pBuffer[ ulOffset ] ) );
ulOffset += 8;
break;
case HB_SERIAL_DOUBLE:
hb_itemPutND( pItem, HB_GET_LE_DOUBLE( &pBuffer[ ulOffset ] ) );
ulOffset += 8;
break;
case HB_SERIAL_DATE:
hb_itemPutDL( pItem, HB_GET_LE_UINT24( &pBuffer[ ulOffset ] ) );
ulOffset += 3;
break;
case HB_SERIAL_SYMBOL:
ulLen = pBuffer[ ulOffset++ ];
szVal = hb_strndup( ( char * ) &pBuffer[ ulOffset ], ulLen );
hb_itemPutSymbol( pItem, hb_dynsymGetSymbol( szVal ) );
hb_xfree( szVal );
ulOffset += ulLen;
break;
case HB_SERIAL_STRNUL:
hb_itemPutCL( pItem, NULL, 0 );
break;
case HB_SERIAL_STRING8:
ulLen = pBuffer[ ulOffset++ ];
hb_itemPutCL( pItem, ( char * ) &pBuffer[ ulOffset ], ulLen );
ulOffset += ulLen;
break;
case HB_SERIAL_STRING16:
ulLen = HB_GET_LE_UINT16( &pBuffer[ ulOffset ] );
ulOffset += 2;
hb_itemPutCL( pItem, ( char * ) &pBuffer[ ulOffset ], ulLen );
ulOffset += ulLen;
break;
case HB_SERIAL_STRING32:
ulLen = HB_GET_LE_UINT32( &pBuffer[ ulOffset ] );
ulOffset += 4;
hb_itemPutCL( pItem, ( char * ) &pBuffer[ ulOffset ], ulLen );
ulOffset += ulLen;
break;
case HB_SERIAL_STRPAD8:
ulLen = pBuffer[ ulOffset++ ];
ulPad = pBuffer[ ulOffset++ ];
szVal = ( char * ) hb_xgrab( ulLen + ulPad + 1 );
memcpy( szVal, &pBuffer[ ulOffset ], ulLen );
memset( szVal + ulLen, ' ', ulPad + 1 );
hb_itemPutCLPtr( pItem, szVal, ulLen + ulPad );
ulOffset += ulLen;
break;
case HB_SERIAL_STRPAD16:
ulLen = HB_GET_LE_UINT16( &pBuffer[ ulOffset ] );
ulOffset += 2;
ulPad = HB_GET_LE_UINT16( &pBuffer[ ulOffset ] );
ulOffset += 2;
szVal = ( char * ) hb_xgrab( ulLen + ulPad + 1 );
memcpy( szVal, &pBuffer[ ulOffset ], ulLen );
memset( szVal + ulLen, ' ', ulPad + 1 );
hb_itemPutCLPtr( pItem, szVal, ulLen + ulPad );
ulOffset += ulLen;
break;
case HB_SERIAL_STRPAD32:
ulLen = HB_GET_LE_UINT32( &pBuffer[ ulOffset ] );
ulOffset += 4;
ulPad = HB_GET_LE_UINT32( &pBuffer[ ulOffset ] );
ulOffset += 4;
szVal = ( char * ) hb_xgrab( ulLen + ulPad + 1 );
memcpy( szVal, &pBuffer[ ulOffset ], ulLen );
hb_xmemset( szVal + ulLen, ' ', ulPad + 1 );
hb_itemPutCLPtr( pItem, szVal, ulLen + ulPad );
ulOffset += ulLen;
break;
case HB_SERIAL_ARRAYREF8:
hb_itemSerialOffsetSet( pRef, pItem, ulOffset - 1 );
case HB_SERIAL_ARRAY8:
ulLen = pBuffer[ ulOffset++ ];
ulOffset = hb_deserializeArray( pItem, pBuffer, ulOffset, ulLen, pRef );
break;
case HB_SERIAL_ARRAYREF16:
hb_itemSerialOffsetSet( pRef, pItem, ulOffset - 1 );
case HB_SERIAL_ARRAY16:
ulLen = HB_GET_LE_UINT16( &pBuffer[ ulOffset ] );
ulOffset = hb_deserializeArray( pItem, pBuffer, ulOffset + 2, ulLen, pRef );
break;
case HB_SERIAL_ARRAYREF32:
hb_itemSerialOffsetSet( pRef, pItem, ulOffset - 1 );
case HB_SERIAL_ARRAY32:
ulLen = HB_GET_LE_UINT32( &pBuffer[ ulOffset ] );
ulOffset = hb_deserializeArray( pItem, pBuffer, ulOffset + 4, ulLen, pRef );
break;
case HB_SERIAL_HASHREF8:
hb_itemSerialOffsetSet( pRef, pItem, ulOffset - 1 );
case HB_SERIAL_HASH8:
ulLen = pBuffer[ ulOffset++ ];
ulOffset = hb_deserializeHash( pItem, pBuffer, ulOffset, ulLen, pRef );
break;
case HB_SERIAL_HASHREF16:
hb_itemSerialOffsetSet( pRef, pItem, ulOffset - 1 );
case HB_SERIAL_HASH16:
ulLen = HB_GET_LE_UINT16( &pBuffer[ ulOffset ] );
ulOffset = hb_deserializeHash( pItem, pBuffer, ulOffset + 2, ulLen, pRef );
break;
case HB_SERIAL_HASHREF32:
hb_itemSerialOffsetSet( pRef, pItem, ulOffset - 1 );
case HB_SERIAL_HASH32:
ulLen = HB_GET_LE_UINT32( &pBuffer[ ulOffset ] );
ulOffset = hb_deserializeHash( pItem, pBuffer, ulOffset + 4, ulLen, pRef );
break;
case HB_SERIAL_REF:
hb_itemSerialOffsetGet( pRef, pItem,
HB_GET_LE_UINT32( &pBuffer[ ulOffset ] ) );
ulOffset += 4;
break;
case HB_SERIAL_OBJ:
{
char * szClass, * szFunc;
szClass = ( char * ) &pBuffer[ ulOffset ];
ulLen = strlen( szClass );
szFunc = szClass + ulLen + 1;
ulOffset = hb_deserializeItem( pItem, pBuffer,
ulOffset + ulLen + strlen( szFunc ) + 2, pRef );
hb_objSetClass( pItem, szClass, szFunc );
break;
}
default:
hb_itemClear( pItem );
break;
}
return ulOffset;
}
| itemseri.c | 684 |
| STATIC BOOL | hb_deserializeTest( UCHAR ** pBufferPtr, ULONG * pulSize, ULONG ulOffset, PHB_CYCLIC_REF * pRefPtr )
static BOOL hb_deserializeTest( UCHAR ** pBufferPtr, ULONG * pulSize,
ULONG ulOffset, PHB_CYCLIC_REF * pRefPtr )
{
UCHAR * pBuffer = * pBufferPtr;
ULONG ulSize = * pulSize, ulLen = 0;
if( ulSize == 0 )
return FALSE;
switch( *pBuffer++ )
{
case HB_SERIAL_NIL:
case HB_SERIAL_TRUE:
case HB_SERIAL_FALSE:
case HB_SERIAL_ZERO:
case HB_SERIAL_STRNUL:
ulSize = 1;
break;
case HB_SERIAL_INT8:
ulSize = 2;
break;
case HB_SERIAL_INT16:
ulSize = 3;
break;
case HB_SERIAL_INT24:
case HB_SERIAL_DATE:
ulSize = 4;
break;
case HB_SERIAL_INT32:
ulSize = 5;
break;
case HB_SERIAL_INT64:
case HB_SERIAL_DOUBLE:
ulSize = 9;
break;
case HB_SERIAL_SYMBOL:
case HB_SERIAL_STRING8:
ulSize = 2 + ( ulSize >= 2 ? *pBuffer : ulSize );
break;
case HB_SERIAL_STRING16:
ulSize = 3 + ( ulSize >= 3 ? HB_GET_LE_UINT16( pBuffer ) : ulSize );
break;
case HB_SERIAL_STRING32:
ulSize = 5 + ( ulSize >= 5 ? HB_GET_LE_UINT32( pBuffer ) : ulSize );
break;
case HB_SERIAL_STRPAD8:
ulSize = 3 + ( ulSize >= 3 ? *pBuffer : ulSize );
break;
case HB_SERIAL_STRPAD16:
ulSize = 5 + ( ulSize >= 5 ? HB_GET_LE_UINT16( pBuffer ) : ulSize );
break;
case HB_SERIAL_STRPAD32:
ulSize = 9 + ( ulSize >= 9 ? HB_GET_LE_UINT32( pBuffer ) : ulSize );
break;
case HB_SERIAL_ARRAYREF8:
if( hb_itemSerialOffsetRef( pRefPtr, NULL, ulOffset ) )
return FALSE;
case HB_SERIAL_ARRAY8:
if( ulSize >= 2 )
{
ulSize = 2;
ulLen = *pBuffer;
}
else
ulSize++;
break;
case HB_SERIAL_ARRAYREF16:
if( hb_itemSerialOffsetRef( pRefPtr, NULL, ulOffset ) )
return FALSE;
case HB_SERIAL_ARRAY16:
if( ulSize >= 3 )
{
ulSize = 3;
ulLen = HB_GET_LE_UINT16( pBuffer );
}
else
ulSize++;
break;
case HB_SERIAL_ARRAYREF32:
if( hb_itemSerialOffsetRef( pRefPtr, NULL, ulOffset ) )
return FALSE;
case HB_SERIAL_ARRAY32:
if( ulSize >= 5 )
{
ulSize = 5;
ulLen = HB_GET_LE_UINT32( pBuffer );
}
else
ulSize++;
break;
case HB_SERIAL_HASHREF8:
if( hb_itemSerialOffsetRef( pRefPtr, NULL, ulOffset ) )
return FALSE;
case HB_SERIAL_HASH8:
if( ulSize >= 2 )
{
ulSize = 2;
ulLen = *pBuffer << 1;
}
else
ulSize++;
break;
case HB_SERIAL_HASHREF16:
if( hb_itemSerialOffsetRef( pRefPtr, NULL, ulOffset ) )
return FALSE;
case HB_SERIAL_HASH16:
if( ulSize >= 3 )
{
ulSize = 3;
ulLen = HB_GET_LE_UINT16( pBuffer ) << 1;
}
else
ulSize++;
break;
case HB_SERIAL_HASHREF32:
if( hb_itemSerialOffsetRef( pRefPtr, NULL, ulOffset ) )
return FALSE;
case HB_SERIAL_HASH32:
if( ulSize >= 5 )
{
ulSize = 5;
ulLen = HB_GET_LE_UINT32( pBuffer ) << 1;
}
else
ulSize++;
break;
case HB_SERIAL_REF:
if( !hb_itemSerialOffsetRef( pRefPtr, NULL, HB_GET_LE_UINT32( pBuffer ) ) )
return FALSE;
ulSize = 5;
break;
case HB_SERIAL_OBJ:
ulLen = hb_strnlen( ( char * ) pBuffer, ulSize - 1 ) + 1;
if( ulLen >= ulSize )
ulSize++;
else
{
ulLen += hb_strnlen( ( char * ) pBuffer + ulLen, ulSize - ulLen - 1 ) + 2;
if( ulLen >= ulSize )
ulSize++;
else
ulSize = ulLen;
}
ulLen = 1;
break;
default:
ulSize = 1;
break;
}
if( ulSize > * pulSize )
return FALSE;
* pulSize -= ulSize;
* pBufferPtr += ulSize;
while( ulLen )
{
ulOffset += ulSize;
ulSize = * pulSize;
if( !hb_deserializeTest( pBufferPtr, pulSize, ulOffset, pRefPtr ) )
return FALSE;
ulSize -= * pulSize;
--ulLen;
}
return TRUE;
}
| itemseri.c | 866 |
| STATIC CHAR * | hb_itemSerial( PHB_ITEM pItem, ULONG *pulSize )
static char * hb_itemSerial( PHB_ITEM pItem, ULONG *pulSize )
{
PHB_CYCLIC_REF pRef = NULL;
ULONG ulSize = hb_itemSerialSize( pItem, &pRef, 0 );
UCHAR * pBuffer = ( UCHAR * ) hb_xgrab( ulSize + 1 );
hb_itemSerialUnRefFree( &pRef );
hb_serializeItem( pItem, pBuffer, 0, pRef );
pBuffer[ ulSize ] = '\0';
if( pulSize )
*pulSize = ulSize;
hb_itemSerialRefFree( pRef );
return ( char * ) pBuffer;
}
| itemseri.c | 1035 |
| STATIC PHB_ITEM | hb_itemDeSerial( char ** pBufferPtr, ULONG * pulSize )
static PHB_ITEM hb_itemDeSerial( char ** pBufferPtr, ULONG * pulSize )
{
PHB_CYCLIC_REF pRef = NULL;
UCHAR * pBuffer = ( UCHAR * ) *pBufferPtr;
PHB_ITEM pItem = NULL;
if( !pulSize || hb_deserializeTest( ( UCHAR ** ) pBufferPtr, pulSize, 0, &pRef ) )
{
pItem = hb_itemNew( NULL );
hb_deserializeItem( pItem, pBuffer, 0, pRef );
}
hb_itemSerialRefFree( pRef );
return pItem;
}
| itemseri.c | 1055 |
| HB_FUNC | HB_SERIALIZE(void)
HB_FUNC( HB_SERIALIZE )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem )
{
ULONG ulSize;
char * pBuffer = hb_itemSerial( pItem, &ulSize );
hb_retclen_buffer( pBuffer, ulSize );
}
}
| itemseri.c | 1074 |
| HB_FUNC | HB_DESERIALIZE(void)
HB_FUNC( HB_DESERIALIZE )
{
PHB_ITEM pItem, pParam = hb_param( 1, HB_IT_BYREF );
ULONG ulSize = hb_parclen( 1 );
if( ulSize )
{
char * pBuffer = hb_parc( 1 );
pItem = hb_itemDeSerial( &pBuffer, &ulSize );
if( pItem )
{
hb_itemReturn( pItem );
if( pParam )
{
hb_itemPutCL( pItem, pBuffer, ulSize );
hb_itemMove( pParam, pItem );
}
hb_itemRelease( pItem );
}
else if( pParam )
hb_itemClear( pParam );
}
else if( pParam )
hb_itemClear( pParam );
}
| itemseri.c | 1086 |
| langapi.c |
| Type | Function | Source | Line |
|---|
| STATIC INT | hb_langFindPos( const char * pszID )
static int hb_langFindPos( const char * pszID )
{
int iPos;
if( pszID )
{
for( iPos = 0; iPos < HB_LANG_MAX_; iPos++ )
{
if( s_langList[ iPos ] && strcmp( ( const char * ) s_langList[ iPos ]->pItemList[ HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_ID ], pszID ) == 0 )
return iPos;
}
}
return -1;
}
| langapi.c | 219 |
| BOOL | hb_langRegister( PHB_LANG lang )
BOOL hb_langRegister( PHB_LANG lang )
{
HB_TRACE(HB_TR_DEBUG, ("hb_langRegister(%p)", lang));
if( lang )
{
int iPos = hb_langFindPos( ( const char * ) lang->pItemList[ HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_ID ] );
if( iPos == -1 )
{
for( iPos = 0; iPos < HB_LANG_MAX_; iPos++ )
{
if( s_langList[ iPos ] == NULL )
{
s_langList[ iPos ] = lang;
return TRUE;
}
}
}
else
{
s_langList[ iPos ] = lang;
return TRUE;
}
}
return FALSE;
}
| langapi.c | 235 |
| BOOL | hb_langDeRegister( const char * pszID )
BOOL hb_langDeRegister( const char * pszID )
{
int iPos;
HB_TRACE(HB_TR_DEBUG, ("hb_langDeRegister(%s)", pszID));
iPos = hb_langFindPos( pszID );
if( iPos != -1 )
{
s_langList[ iPos ] = NULL;
return TRUE;
}
else
return FALSE;
}
| langapi.c | 264 |
| PHB_LANG | hb_langFind( const char * pszID )
PHB_LANG hb_langFind( const char * pszID )
{
int iPos;
HB_TRACE(HB_TR_DEBUG, ("hb_langFind(%s)", pszID));
iPos = hb_langFindPos( pszID );
return ( iPos != -1 ) ? s_langList[ iPos ] : NULL;
}
| langapi.c | 281 |
| PHB_LANG | hb_langSelect( PHB_LANG lang )
PHB_LANG hb_langSelect( PHB_LANG lang )
{
PHB_LANG langOld;
HB_TRACE(HB_TR_DEBUG, ("hb_langSelect(%p)", lang));
langOld = hb_vmLang();
if( lang )
hb_vmSetLang( lang );
return langOld;
}
| langapi.c | 292 |
| CHAR * | hb_langSelectID( const char * pszID )
char * hb_langSelectID( const char * pszID )
{
char * pszIDOld = hb_langID();
HB_TRACE(HB_TR_DEBUG, ("hb_langSelectID(%s)", pszID));
hb_langSelect( hb_langFind( pszID ) );
return pszIDOld;
}
| langapi.c | 305 |
| CHAR * | hb_langDGetItem( int iIndex )
char * hb_langDGetItem( int iIndex )
{
PHB_LANG lang;
HB_TRACE(HB_TR_DEBUG, ("hb_langDGetItem(%i)", iIndex));
lang = hb_vmLang();
if( lang && iIndex >= 0 && iIndex < HB_LANG_ITEM_MAX_ )
return ( char * ) lang->pItemList[ iIndex ];
else
return NULL;
}
| langapi.c | 316 |
| CHAR * | hb_langID( void )
char * hb_langID( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_langID()"));
return hb_langDGetItem( HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_ID );
}
| langapi.c | 329 |
| CHAR * | hb_langName( void )
char * hb_langName( void )
{
char * pszName;
PHB_LANG lang;
lang = hb_vmLang();
if( lang )
{
pszName = ( char * ) hb_xgrab( 128 );
snprintf( pszName, 128, "Harbour Language: %s %s (%s)",
( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_ID ),
( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_NAME ),
( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_NAMENAT ) );
}
else
pszName = hb_strdup( "Harbour Language: (not installed)" );
return pszName;
}
| langapi.c | 338 |
| CHAR * | hb_langDGetErrorDesc( ULONG ulIndex )
char * hb_langDGetErrorDesc( ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_langDGetErrorDesc(%lu)", ulIndex));
return ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_ERRDESC + ulIndex );
}
| langapi.c | 360 |
| HB_FUNC | HB_LANGSELECT(void)
HB_FUNC( HB_LANGSELECT )
{
char * szNewLang;
hb_retc( hb_langID() );
szNewLang = hb_parc( 1 );
if( szNewLang )
hb_langSelectID( szNewLang );
}
| langapi.c | 369 |
| HB_FUNC | HB_LANGNAME(void)
HB_FUNC( HB_LANGNAME )
{
hb_retc_buffer( hb_langName() );
}
| langapi.c | 380 |
| HB_FUNC | HB_LANGERRMSG(void)
HB_FUNC( HB_LANGERRMSG )
{
hb_retc( hb_langDGetErrorDesc( hb_parnl( 1 ) ) );
}
| langapi.c | 385 |
| HB_FUNC | HB_LANGMESSAGE(void)
HB_FUNC( HB_LANGMESSAGE )
{
hb_retc( hb_langDGetItem( hb_parnl( 1 ) ) );
}
| langapi.c | 390 |
| left.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | LEFT(void)
HB_FUNC( LEFT )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText && ISNUM( 2 ) )
{
long lLen = hb_parnl( 2 );
if( lLen <= 0 )
hb_retc( NULL );
else
{
ULONG ulText = hb_itemGetCLen( pText );
if( ( ULONG ) lLen >= ulText )
hb_itemReturn( pText );
else
hb_retclen( hb_itemGetCPtr( pText ), lLen );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1124, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| left.c | 59 |
| len.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | LEN(void)
HB_FUNC( LEN )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
/* NOTE: Double safety to ensure that a parameter was really passed,
compiler checks this, but a direct hb_vmDo() call
may not do so. [vszakats] */
if( pItem )
{
if( HB_IS_STRING( pItem ) )
{
hb_retnl( hb_itemGetCLen( pItem ) );
return;
}
else if( HB_IS_ARRAY( pItem ) )
{
hb_retnl( hb_arrayLen( pItem ) );
return;
}
else if( HB_IS_HASH( pItem ) )
{
hb_retnl( hb_hashLen( pItem ) );
return;
}
}
hb_errRT_BASE_SubstR( EG_ARG, 1111, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| len.c | 57 |
| lennum.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | LENNUM(void)
HB_FUNC( LENNUM )
{
PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC );
ULONG ulLen = 0;
if( pNumber )
{
char * pszString = hb_itemStr( pNumber, NULL, NULL );
if( pszString )
{
ulLen = strlen( pszString );
hb_strLTrim( pszString, &ulLen );
hb_xfree( pszString );
}
}
hb_retnl( ulLen );
}
| lennum.c | 56 |
| math.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_mathErrDataInit( void * Cargo )
static void hb_mathErrDataInit( void * Cargo )
{
PHB_MATHERRDATA pMathErr = ( PHB_MATHERRDATA ) Cargo;
pMathErr->mode = HB_MATH_ERRMODE_DEFAULT;
pMathErr->handler = hb_matherr;
#if defined(HB_MATH_HANDLER)
pMathErr->exception.type = HB_MATH_ERR_NONE;
pMathErr->exception.funcname = "";
pMathErr->exception.error = "";
pMathErr->exception.arg1 = 0.0;
pMathErr->exception.arg2 = 0.0;
pMathErr->exception.retval = 0.0;
pMathErr->exception.retvalwidth = -1; /* we don't know */
pMathErr->exception.retvaldec = -1; /* use standard SET DECIMALS */
pMathErr->exception.handled = 1;
#endif
}
| math.c | 90 |
| STATIC VOID | hb_mathErrDataRelease( void * Cargo )
static void hb_mathErrDataRelease( void * Cargo )
{
PHB_MATHERRDATA pMathErr = ( PHB_MATHERRDATA ) Cargo;
hb_itemRelease( pMathErr->block );
}
static HB_TSD_NEW( s_mathErrData, sizeof( HB_MATHERRDATA ),
hb_mathErrDataInit, hb_mathErrDataRelease );
| math.c | 111 |
| VOID | hb_mathResetError( HB_MATH_EXCEPTION * phb_exc )
void hb_mathResetError( HB_MATH_EXCEPTION * phb_exc )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_mathResetError(%p)", phb_exc ) );
HB_SYMBOL_UNUSED( phb_exc );
#if defined(HB_MATH_HANDLER)
{
PHB_MATHERRDATA pMathErr = hb_mathErrData();
pMathErr->exception.type = HB_MATH_ERR_NONE;
pMathErr->exception.funcname = "";
pMathErr->exception.error = "";
pMathErr->exception.arg1 = 0.0;
pMathErr->exception.arg2 = 0.0;
pMathErr->exception.retval = 0.0;
pMathErr->exception.retvalwidth = -1; /* we don't know */
pMathErr->exception.retvaldec = -1; /* use standard SET DECIMALS */
pMathErr->exception.handled = 1;
}
#elif defined(HB_MATH_ERRNO)
errno = 0;
#endif
}
| math.c | 131 |
| HB_EXPORT INT | matherr( struct exception *err )
HB_EXPORT int matherr( struct exception *err )
{
int retval;
HB_MATH_HANDLERPROC mathHandler;
HB_MATH_EXCEPTION * pExc;
HB_TRACE( HB_TR_DEBUG, ( "matherr(%p)", err ) );
pExc = &hb_mathErrData()->exception;
/* map math error types */
switch( err->type )
{
case DOMAIN:
pExc->type = HB_MATH_ERR_DOMAIN;
pExc->error = "Argument not in domain of function";
break;
case SING:
pExc->type = HB_MATH_ERR_SING;
pExc->error = "Calculation results in singularity";
break;
case OVERFLOW:
pExc->type = HB_MATH_ERR_OVERFLOW;
pExc->error = "Calculation result too large to represent";
break;
case UNDERFLOW:
pExc->type = HB_MATH_ERR_UNDERFLOW;
pExc->error = "Calculation result too small to represent";
break;
case TLOSS:
pExc->type = HB_MATH_ERR_TLOSS;
pExc->error = "Total loss of significant digits";
break;
case PLOSS:
pExc->type = HB_MATH_ERR_PLOSS;
pExc->error = "Partial loss of significant digits";
break;
default:
pExc->type = HB_MATH_ERR_UNKNOWN;
pExc->error = "Unknown math error";
break;
}
pExc->funcname = ( char * ) err->name; /* (char *) Avoid warning in DJGPP */
pExc->arg1 = err->arg1;
pExc->arg2 = err->arg2;
pExc->retval = err->retval;
pExc->handled = 0;
mathHandler = hb_mathGetHandler();
if( mathHandler )
{
retval = ( *( mathHandler ) ) ( pExc );
err->retval = pExc->retval;
}
else
{
/* there is no custom math handler */
retval = 1; /* don't print any message, don't set errno and use return value provided by C RTL */
}
return retval;
}
| math.c | 159 |
| BOOL | hb_mathGetError( HB_MATH_EXCEPTION * phb_exc, const char *szFunc, double arg1, double arg2, double dResult )
BOOL hb_mathGetError( HB_MATH_EXCEPTION * phb_exc, const char *szFunc,
double arg1, double arg2, double dResult )
{
#if defined(HB_MATH_ERRNO)
int errCode;
HB_TRACE( HB_TR_DEBUG, ( "hb_mathGetError(%p,%s,%lf,%lf,%lf)", phb_exc, szFunc, arg1, arg2, dResult ) );
switch( errno )
{
case 0:
return FALSE;
case EDOM:
case ERANGE:
# if defined(EOVERFLOW)
case EOVERFLOW:
# endif
errCode = errno;
break;
default:
if( isnan( dResult ) )
errCode = EDOM;
# if defined(HB_OS_SUNOS)
else if( !finite( dResult ) )
# elif defined(HB_OS_OS2)
else if( !isfinite( dResult ) )
# else
else if( isinf( dResult ) )
# endif
errCode = ERANGE;
else
errCode = errno;
}
/* map math error types */
switch( errCode )
{
case EDOM:
phb_exc->type = HB_MATH_ERR_DOMAIN;
phb_exc->error = "Argument not in domain of function";
break;
case ERANGE:
phb_exc->type = HB_MATH_ERR_SING;
phb_exc->error = "Calculation results in singularity";
break;
# if defined(EOVERFLOW)
case EOVERFLOW:
phb_exc->type = HB_MATH_ERR_OVERFLOW;
phb_exc->error = "Calculation result too large to represent";
break;
# endif
default:
phb_exc->type = HB_MATH_ERR_UNKNOWN;
phb_exc->error = "Unknown math error";
break;
}
phb_exc->funcname = szFunc;
phb_exc->arg1 = arg1;
phb_exc->arg2 = arg2;
phb_exc->retval = dResult;
phb_exc->handled = 0;
phb_exc->retvalwidth = -1; /* we don't know */
phb_exc->retvaldec = -1; /* use standard SET DECIMALS */
{
HB_MATH_HANDLERPROC mathHandler = hb_mathGetHandler();
if( mathHandler )
( *mathHandler )( phb_exc );
}
return TRUE;
#else
HB_TRACE( HB_TR_DEBUG, ( "hb_mathGetError(%p,%s,%lf,%lf,%lf)", phb_exc, szFunc, arg1, arg2, dResult ) );
HB_SYMBOL_UNUSED( dResult );
HB_SYMBOL_UNUSED( arg1 );
HB_SYMBOL_UNUSED( arg2 );
HB_SYMBOL_UNUSED( szFunc );
# if defined(HB_MATH_HANDLER)
memcpy( phb_exc, &hb_mathErrData()->exception, sizeof( HB_MATH_EXCEPTION ) );
return phb_exc->type != HB_MATH_ERR_NONE;
# else
HB_SYMBOL_UNUSED( phb_exc );
return FALSE;
# endif
#endif
}
| math.c | 229 |
| INT | hb_mathSetErrMode( int imode )
int hb_mathSetErrMode( int imode )
{
PHB_MATHERRDATA pMathErr;
int oldmode;
HB_TRACE( HB_TR_DEBUG, ( "hb_mathSetErrMode (%i)", imode ) );
pMathErr = hb_mathErrData();
oldmode = pMathErr->mode;
if( imode == HB_MATH_ERRMODE_DEFAULT ||
imode == HB_MATH_ERRMODE_CDEFAULT ||
imode == HB_MATH_ERRMODE_USER ||
imode == HB_MATH_ERRMODE_USERDEFAULT ||
imode == HB_MATH_ERRMODE_USERCDEFAULT )
{
pMathErr->mode = imode;
}
return oldmode;
}
| math.c | 334 |
| INT | hb_mathGetErrMode( void )
int hb_mathGetErrMode( void )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_mathGetErrMode()" ) );
return hb_mathErrData()->mode;
}
| math.c | 357 |
| HB_FUNC | HB_MATHERMODE(void)
HB_FUNC( HB_MATHERMODE ) /* ([]) -> */
{
hb_retni( hb_mathGetErrMode() );
/* set new mode */
if( ISNUM( 1 ) )
hb_mathSetErrMode( hb_parni( 1 ) );
}
| math.c | 364 |
| INT | hb_matherr( HB_MATH_EXCEPTION * pexc )
int hb_matherr( HB_MATH_EXCEPTION * pexc )
{
int mode = hb_mathGetErrMode();
int iRet = 1;
HB_TRACE( HB_TR_DEBUG, ( "hb_matherr(%p)", pexc ) );
if( pexc == NULL || pexc->handled != 0 )
{
/* error already handled by other handlers ! */
return 1;
}
if( mode == HB_MATH_ERRMODE_USER || mode == HB_MATH_ERRMODE_USERDEFAULT ||
mode == HB_MATH_ERRMODE_USERCDEFAULT )
{
PHB_ITEM pArg1, pArg2, pError;
PHB_ITEM pMatherrResult;
/* create an error object */
/* NOTE: In case of HB_MATH_ERRMODE_USER[C]DEFAULT, I am setting both EF_CANSUBSTITUTE and EF_CANDEFAULT to .T. here.
This is forbidden according to the original Cl*pper docs, but I think this reflects the situation best here:
The error handler can either substitute the errorneous value (by returning a numeric value) or choose the
default error handling (by returning .F., as usual) [martin vogel] */
pError = hb_errRT_New_Subst( ES_ERROR, "MATH", EG_NUMERR, pexc->type,
pexc->error, pexc->funcname, 0, EF_CANSUBSTITUTE |
( mode == HB_MATH_ERRMODE_USER ? 0 : EF_CANDEFAULT ) );
/* Assign the new array to the object data item. */
/* NOTE: Unfortunately, we cannot decide whether one or two parameters have been used when the
math function has been called, so we always take two */
pArg1 = hb_itemPutND( NULL, pexc->arg1 );
pArg2 = hb_itemPutND( NULL, pexc->arg2 );
hb_errPutArgs( pError, 2, pArg1, pArg2 );
hb_itemRelease( pArg1 );
hb_itemRelease( pArg2 );
/* launch error codeblock */
pMatherrResult = hb_errLaunchSubst( pError );
hb_errRelease( pError );
if( pMatherrResult )
{
if( HB_IS_NUMERIC( pMatherrResult ) )
{
pexc->retval = hb_itemGetND( pMatherrResult );
hb_itemGetNLen( pMatherrResult, &pexc->retvalwidth, &pexc->retvaldec );
pexc->handled = 1;
}
hb_itemRelease( pMatherrResult );
}
}
/* math exception not handled by Harbour error routine above ? */
if( pexc->handled == 0 )
{
switch( mode )
{
case HB_MATH_ERRMODE_USER:
/* user failed to handle the math exception, so quit the app [yes, that's the meaning of this mode !!] */
iRet = 0;
hb_vmRequestQuit();
break;
case HB_MATH_ERRMODE_DEFAULT:
case HB_MATH_ERRMODE_USERDEFAULT:
/* return 1 to suppress C RTL error msgs, but leave error handling to the calling Harbour routine */
break;
case HB_MATH_ERRMODE_CDEFAULT:
case HB_MATH_ERRMODE_USERCDEFAULT:
/* use the correction value supplied in pexc->retval */
pexc->handled = 1;
break;
}
}
return iRet; /* error handling successful */
}
| math.c | 374 |
| HB_MATH_HANDLERPROC | hb_mathSetHandler( HB_MATH_HANDLERPROC handlerproc )
HB_MATH_HANDLERPROC hb_mathSetHandler( HB_MATH_HANDLERPROC handlerproc )
{
HB_MATH_HANDLERPROC oldHandlerProc;
PHB_MATHERRDATA pMathErr;
HB_TRACE( HB_TR_DEBUG, ( "hb_mathSetHandler (%p)", handlerproc ) );
pMathErr = hb_mathErrData();
oldHandlerProc = pMathErr->handler;
pMathErr->handler = handlerproc;
return oldHandlerProc;
}
| math.c | 463 |
| HB_MATH_HANDLERPROC | hb_mathGetHandler( void )
HB_MATH_HANDLERPROC hb_mathGetHandler( void )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_mathGetHandler ()" ) );
return hb_mathErrData()->handler;
}
| math.c | 478 |
| STATIC INT | hb_matherrblock( HB_MATH_EXCEPTION * pexc )
static int hb_matherrblock( HB_MATH_EXCEPTION * pexc )
{
PHB_MATHERRDATA pMathErr = hb_mathErrData();
int retval;
/* call codeblock for both case: handled and unhandled exceptions */
if( pMathErr->block )
{
PHB_ITEM pArray, pRet;
PHB_ITEM pType, pFuncname, pError, pArg1, pArg2, pRetval, pHandled;
pType = hb_itemPutNI( NULL, pexc->type );
pFuncname = hb_itemPutC( NULL, pexc->funcname );
pError = hb_itemPutC( NULL, pexc->error );
pArg1 = hb_itemPutND( NULL, pexc->arg1 );
pArg2 = hb_itemPutND( NULL, pexc->arg2 );
pRetval = hb_itemPutNDLen( NULL, pexc->retval, pexc->retvalwidth, pexc->retvaldec );
pHandled = hb_itemPutL( NULL, pexc->handled );
pArray = hb_itemArrayNew( 2 );
hb_itemArrayPut( pArray, 1, pRetval );
hb_itemArrayPut( pArray, 2, pHandled );
/* launch error codeblock that can
a) change the members of the array = {dRetval, lHandled} to set the return value of the math C RTL routine and
the and it
b) can return an integer value to set the return value of matherr().
NOTE that these values are only used if lHandled was .F. and is set to .T. within the codeblock */
pRet = hb_itemDo( pMathErr->block, 6, pType, pFuncname, pError, pArg1, pArg2, pArray );
hb_itemRelease( pType );
hb_itemRelease( pFuncname );
hb_itemRelease( pError );
hb_itemRelease( pArg1 );
hb_itemRelease( pArg2 );
hb_itemRelease( pRetval );
hb_itemRelease( pHandled );
if( pexc->handled )
{
/* math exception has already been handled, so codeblock call above was only informative */
retval = 1;
}
else
{
/* exception handled by codeblock ? */
pHandled = hb_itemArrayGet( pArray, 2 );
if( pHandled )
{
pexc->handled = hb_itemGetL( pHandled );
hb_itemRelease( pHandled );
}
if( pexc->handled )
{
/* YES ! */
/* extract retval for math routine and matherr() */
pRetval = hb_itemArrayGet( pArray, 1 );
if( pRetval )
{
pexc->retval = hb_itemGetND( pRetval );
hb_itemGetNLen( pRetval, &pexc->retvalwidth, &pexc->retvaldec );
hb_itemRelease( pRetval );
}
if( pRet && HB_IS_NUMERIC( pRet ) )
{
retval = hb_itemGetNI( pRet ); /* block may also return 0 to force C math lib warnings */
hb_itemRelease( pRet );
}
else
{
retval = 1; /* default return value to suppress C math lib warnings */
}
}
else
{
/* NO ! */
retval = 1;
}
}
hb_itemRelease( pArray );
}
else
{
retval = 1; /* default return value to suppress C math lib warnings */
}
if( pMathErr->prevHandler )
{
if( pexc->handled )
{
/* the error is handled, so simply inform the previous handler */
( *pMathErr->prevHandler ) ( pexc );
}
else
{
/* else go on error handling within previous handler */
retval = ( *pMathErr->prevHandler ) ( pexc );
}
}
return retval;
}
| math.c | 494 |
| HB_FUNC | HB_MATHERBLOCK(void)
HB_FUNC( HB_MATHERBLOCK ) /* ([]) -> */
{
PHB_MATHERRDATA pMathErr = hb_mathErrData();
/* immediately install hb_matherrblock and keep it permanently installed !
This is not dangerous because hb_matherrorblock will always call the previous error handler */
if( pMathErr->prevHandler == NULL )
{
pMathErr->prevHandler = hb_mathSetHandler( hb_matherrblock );
}
/* return old math handler */
if( pMathErr->block == NULL )
{
hb_ret();
}
else
{
hb_itemReturn( pMathErr->block );
}
if( hb_pcount() > 0 )
{
/* set new error block */
PHB_ITEM pNewErrorBlock = hb_param( 1, HB_IT_BLOCK );
if( pNewErrorBlock )
{
if( pMathErr->block == NULL )
{
pMathErr->block = hb_itemNew( NULL );
}
hb_itemCopy( pMathErr->block, pNewErrorBlock );
}
else
{
/* a parameter other than a block has been passed -> delete error handler ! */
if( pMathErr->block )
{
hb_itemRelease( pMathErr->block );
pMathErr->block = NULL;
}
}
}
}
| math.c | 598 |
| HB_FUNC | EXP(void)
HB_FUNC( EXP )
{
if( ISNUM( 1 ) )
{
HB_MATH_EXCEPTION hb_exc;
double dResult, dArg = hb_parnd( 1 );
hb_mathResetError( &hb_exc );
dResult = exp( dArg );
if( hb_mathGetError( &hb_exc, "EXP", dArg, 0.0, dResult ) )
{
if( hb_exc.handled )
hb_retndlen( hb_exc.retval, hb_exc.retvalwidth, hb_exc.retvaldec );
else
{
/* math exception is up to the Harbour function, so do this as Clipper compatible as possible */
if( hb_exc.type == HB_MATH_ERR_OVERFLOW )
hb_retndlen( HUGE_VAL, -1, -1 );
else
hb_retnd( 0.0 );
}
}
else
hb_retnd( dResult );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1096, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| math.c | 652 |
| HB_FUNC | LOG(void)
HB_FUNC( LOG )
{
if( ISNUM( 1 ) )
{
HB_MATH_EXCEPTION hb_exc;
double dResult, dArg = hb_parnd( 1 );
if( dArg <= 0 )
hb_retndlen( -HUGE_VAL, -1, -1 ); /* return -infinity */
else
{
hb_mathResetError( &hb_exc );
dResult = log( dArg );
if( hb_mathGetError( &hb_exc, "LOG", dArg, 0.0, dResult ) )
{
if( hb_exc.handled )
hb_retndlen( hb_exc.retval, hb_exc.retvalwidth, hb_exc.retvaldec );
else
{
/* math exception is up to the Harbour function, so do this as Clipper compatible as possible */
switch( hb_exc.type )
{
case HB_MATH_ERR_SING: /* argument to log was 0.0 */
case HB_MATH_ERR_DOMAIN: /* argument to log was < 0.0 */
hb_retndlen( -HUGE_VAL, -1, -1 ); /* return -infinity */
break;
default:
hb_retnd( 0.0 );
break;
}
}
}
else
hb_retnd( dResult );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1095, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| math.c | 681 |
| HB_FUNC | SQRT(void)
HB_FUNC( SQRT )
{
if( ISNUM( 1 ) )
{
HB_MATH_EXCEPTION hb_exc;
double dResult, dArg = hb_parnd( 1 );
if( dArg <= 0 )
hb_retnd( 0.0 );
else
{
hb_mathResetError( &hb_exc );
dResult = sqrt( dArg );
if( hb_mathGetError( &hb_exc, "SQRT", dArg, 0.0, dResult ) )
{
if( hb_exc.handled )
hb_retndlen( hb_exc.retval, hb_exc.retvalwidth, hb_exc.retvaldec );
else
/* math exception is up to the Harbour function, so do this as Clipper compatible as possible */
hb_retnd( 0.0 ); /* return 0.0 on all errors (all (?) of type DOMAIN) */
}
else
hb_retnd( dResult );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1097, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| math.c | 722 |
| maxrow.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | MAXROW(void)
HB_FUNC( MAXROW ) /* Return the maximum screen/window row number (zero origin) */
{
#ifdef HB_COMPAT_CT3
/*
* if called with logical .T. parameter then return real screen high - 1
* It gives exactly the same result in all standard GT drivers so we
* are still Clipper compatible. The difference can appear in some extended
* GT drivers which have additional functionality, f.e. CTW GT which
* is upper level GT and add CTIII Window support. When it's activated
* then MaxRow() will return current window max row and MaxRow(.T.) real
* screen (window 0) max row what is the exact behavior of MaxRow()
* in CT3, [druzus]
*/
if( ISLOG( 1 ) && hb_parl( 1 ) )
{
USHORT uiRows, uiCols;
hb_gtScrDim( &uiRows, &uiCols );
hb_retni( uiRows - 1 );
}
else
#endif
hb_retni( hb_gtMaxRow() );
}
| maxrow.c | 68 |
| HB_FUNC | MAXCOL(void)
HB_FUNC( MAXCOL ) /* Return the maximum screen/window column number (zero origin) */
{
#ifdef HB_COMPAT_CT3
/* See notes about MaxRow(.T.) above */
if( ISLOG( 1 ) && hb_parl( 1 ) )
{
USHORT uiRows, uiCols;
hb_gtScrDim( &uiRows, &uiCols );
hb_retni( uiCols - 1 );
}
else
#endif
hb_retni( hb_gtMaxCol() );
}
| maxrow.c | 93 |
| memofile.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | MEMOREAD(void)
HB_FUNC( MEMOREAD )
{
PHB_ITEM pFileName = hb_param( 1, HB_IT_STRING );
if( pFileName )
{
HB_FHANDLE fhnd = hb_fsOpen( ( BYTE * ) hb_itemGetCPtr( pFileName ), FO_READ | FO_SHARED | FO_PRIVATE );
if( fhnd != FS_ERROR )
{
ULONG ulSize = hb_fsSeek( fhnd, 0, FS_END );
if( ulSize != 0 )
{
BYTE * pbyBuffer;
/* Don't read the file terminating EOF character */
#if ! defined(HB_OS_UNIX_COMPATIBLE)
{
BYTE byEOF = HB_CHAR_NUL;
hb_fsSeek( fhnd, -1, FS_END );
hb_fsRead( fhnd, &byEOF, sizeof( BYTE ) );
if( byEOF == HB_CHAR_EOF )
ulSize--;
}
#endif
pbyBuffer = ( BYTE * ) hb_xgrab( ulSize + sizeof( char ) );
hb_fsSeek( fhnd, 0, FS_SET );
hb_fsReadLarge( fhnd, pbyBuffer, ulSize );
hb_retclen_buffer( ( char * ) pbyBuffer, ulSize );
}
else
hb_retc( NULL );
hb_fsClose( fhnd );
}
else
hb_retc( NULL );
}
else
hb_retc( NULL );
}
| memofile.c | 61 |
| STATIC BOOL | hb_memowrit( BOOL bWriteEOF )
static BOOL hb_memowrit( BOOL bWriteEOF )
{
PHB_ITEM pFileName = hb_param( 1, HB_IT_STRING );
PHB_ITEM pString = hb_param( 2, HB_IT_STRING );
BOOL bRetVal = FALSE;
if( pFileName && pString )
{
HB_FHANDLE fhnd = hb_fsCreate( ( BYTE * ) hb_itemGetCPtr( pFileName ), FC_NORMAL );
if( fhnd != FS_ERROR )
{
ULONG ulSize = hb_itemGetCLen( pString );
bRetVal = ( hb_fsWriteLarge( fhnd, ( BYTE * ) hb_itemGetCPtr( pString ), ulSize ) == ulSize );
/* NOTE: CA-Cl*pper will add the EOF even if the write failed. [vszakats] */
/* NOTE: CA-Cl*pper will not return .F. when the EOF could not be written. [vszakats] */
#if ! defined(HB_OS_UNIX_COMPATIBLE)
if( bWriteEOF ) /* if true, then write EOF */
{
BYTE byEOF = HB_CHAR_EOF;
hb_fsWrite( fhnd, &byEOF, sizeof( BYTE ) );
}
#else
HB_SYMBOL_UNUSED( bWriteEOF );
#endif
hb_fsClose( fhnd );
}
}
return bRetVal;
}
| memofile.c | 110 |
| HB_FUNC | HB_MEMOWRIT(void)
HB_FUNC( HB_MEMOWRIT )
{
hb_retl( hb_memowrit( FALSE ) );
}
| memofile.c | 145 |
| HB_FUNC | MEMOWRIT(void)
HB_FUNC( MEMOWRIT )
{
#ifdef HB_EXTENSION
hb_retl( hb_memowrit( hb_parinfo(0) == 3 && ISLOG( 3 ) ? hb_parl( 3 ) : TRUE ) );
#else
hb_retl( hb_memowrit( TRUE ) );
#endif
}
| memofile.c | 150 |
| minmax.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | MAX(void)
HB_FUNC( MAX )
{
PHB_ITEM p1 = hb_param( 1, HB_IT_ANY );
PHB_ITEM p2 = hb_param( 2, HB_IT_ANY );
if( p1 && p2 )
{
if( HB_IS_NUMINT( p1 ) && HB_IS_NUMINT( p2 ) )
{
HB_LONG l1 = hb_itemGetNInt( p1 );
HB_LONG l2 = hb_itemGetNInt( p2 );
hb_retnint( l1 >= l2 ? l1 : l2 );
return;
}
else if( HB_IS_NUMERIC( p1 ) && HB_IS_NUMERIC( p2 ) )
{
double d1 = hb_itemGetND( p1 );
double d2 = hb_itemGetND( p2 );
int iDec1;
int iDec2;
hb_itemGetNLen( p1, NULL, &iDec1 );
hb_itemGetNLen( p2, NULL, &iDec2 );
if( d1 >= d2 )
hb_retndlen( d1, 0, iDec1 );
else
hb_retndlen( d2, 0, iDec2 );
return;
}
else if( HB_IS_LOGICAL( p1 ) && HB_IS_LOGICAL( p2 ) )
{
BOOL b1 = hb_itemGetL( p1 );
BOOL b2 = hb_itemGetL( p2 );
hb_retl( b1 >= b2 ? b1 : b2 );
return;
}
else if( HB_IS_DATE( p1 ) && HB_IS_DATE( p2 ) )
{
char szDate[ 9 ];
hb_retds( hb_itemGetDL( p1 ) >= hb_itemGetDL( p2 ) ? hb_pardsbuff( szDate, 1 ) : hb_pardsbuff( szDate, 2 ) );
return;
}
}
hb_errRT_BASE_SubstR( EG_ARG, 1093, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| minmax.c | 57 |
| HB_FUNC | MIN(void)
HB_FUNC( MIN )
{
PHB_ITEM p1 = hb_param( 1, HB_IT_ANY );
PHB_ITEM p2 = hb_param( 2, HB_IT_ANY );
if( p1 && p2 )
{
if( HB_IS_NUMINT( p1 ) && HB_IS_NUMINT( p2 ) )
{
HB_LONG l1 = hb_itemGetNInt( p1 );
HB_LONG l2 = hb_itemGetNInt( p2 );
hb_retnint( l1 <= l2 ? l1 : l2 );
return;
}
else if( HB_IS_NUMERIC( p1 ) && HB_IS_NUMERIC( p2 ) )
{
double d1 = hb_itemGetND( p1 );
double d2 = hb_itemGetND( p2 );
int iDec1;
int iDec2;
hb_itemGetNLen( p1, NULL, &iDec1 );
hb_itemGetNLen( p2, NULL, &iDec2 );
if( d1 <= d2 )
hb_retndlen( d1, 0, iDec1 );
else
hb_retndlen( d2, 0, iDec2 );
return;
}
else if( HB_IS_LOGICAL( p1 ) && HB_IS_LOGICAL( p2 ) )
{
BOOL b1 = hb_itemGetL( p1 );
BOOL b2 = hb_itemGetL( p2 );
hb_retl( b1 <= b2 ? b1 : b2 );
return;
}
else if( HB_IS_DATE( p1 ) && HB_IS_DATE( p2 ) )
{
char szDate[ 9 ];
hb_retds( hb_itemGetDL( p1 ) <= hb_itemGetDL( p2 ) ? hb_pardsbuff( szDate, 1 ) : hb_pardsbuff( szDate, 2 ) );
return;
}
}
hb_errRT_BASE_SubstR( EG_ARG, 1092, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| minmax.c | 109 |
| mlcfunc.c |
| Type | Function | Source | Line |
|---|
| STATIC INT | hb_mlEol( char * pszString, ULONG ulLen, PHB_EOL_INFO pEOLs, int iEOLs )
static int hb_mlEol( char * pszString, ULONG ulLen,
PHB_EOL_INFO pEOLs, int iEOLs )
{
int i;
for( i = 0; i < iEOLs; ++i )
{
if( ulLen >= pEOLs[ i ].ulLen &&
memcmp( pszString, pEOLs[ i ].szEOL, pEOLs[ i ].ulLen ) == 0 )
return i;
}
return -1;
}
| mlcfunc.c | 63 |
| STATIC ULONG | hb_mlGetLine( char * pszString, ULONG ulLen, ULONG ulOffset, ULONG ulLineLength, ULONG ulTabSize, ULONG ulMaxPos, BOOL fWordWrap, PHB_EOL_INFO pEOLs, int iEOLs, ULONG * pulLen, ULONG * pulEOL )
static ULONG hb_mlGetLine( char * pszString, ULONG ulLen, ULONG ulOffset,
ULONG ulLineLength, ULONG ulTabSize, ULONG ulMaxPos,
BOOL fWordWrap, PHB_EOL_INFO pEOLs, int iEOLs,
ULONG * pulLen, ULONG * pulEOL )
{
ULONG ulCol = 0, ulBlankCol = 0, ulBlankPos = 0;
int i;
if( pulEOL )
* pulEOL = 0;
while( ulOffset < ulLen && ( ulMaxPos == 0 || ulOffset < ulMaxPos ) )
{
if( pszString[ ulOffset ] == HB_CHAR_SOFT1 &&
pszString[ ulOffset + 1 ] == HB_CHAR_SOFT2 )
{
ulOffset += 2;
if( !fWordWrap )
break;
continue;
}
i = hb_mlEol( pszString + ulOffset, ulLen - ulOffset, pEOLs, iEOLs );
if( i >= 0 )
{
if( ulMaxPos )
ulCol += pEOLs[ i ].ulLen;
else
ulOffset += pEOLs[ i ].ulLen;
if( pulEOL )
* pulEOL = pEOLs[ i ].ulLen;
break;
}
if( pszString[ ulOffset ] == ' ' || pszString[ ulOffset ] == HB_CHAR_HT )
{
ulBlankCol = ulCol;
ulBlankPos = ulOffset;
}
if( ulCol >= ulLineLength )
{
if( fWordWrap )
{
if( ulBlankCol == 0 || pszString[ ulOffset ] == ' ' ||
pszString[ ulOffset ] == HB_CHAR_HT )
{
ulCol = ulLineLength;
if( pszString[ ulOffset ] == ' ' )
++ulOffset;
if( pszString[ ulOffset ] == HB_CHAR_SOFT1 &&
pszString[ ulOffset + 1 ] == HB_CHAR_SOFT2 )
ulOffset += 2;
}
else
{
ulCol = ulBlankCol;
ulOffset = ulBlankPos + 1;
}
}
else
{
if( ulCol > ulLineLength )
--ulOffset;
ulCol = ulLineLength;
}
break;
}
ulCol += pszString[ ulOffset ] == HB_CHAR_HT ?
ulTabSize - ( ulCol % ulTabSize ) : 1;
ulOffset++;
}
* pulLen = ulCol;
return ulOffset;
}
| mlcfunc.c | 76 |
| STATIC PHB_EOL_INFO | hb_mlGetEOLs( int iParam, int * piEOLs )
static PHB_EOL_INFO hb_mlGetEOLs( int iParam, int * piEOLs )
{
PHB_EOL_INFO pEOLs = NULL;
int iEOLs = 0;
#ifdef HB_EXTENSION
char * szEOL;
ULONG ulLen, ul;
szEOL = hb_parc( iParam );
if( szEOL )
{
ulLen = hb_parclen( iParam );
if( ulLen )
{
pEOLs = ( PHB_EOL_INFO ) hb_xgrab( sizeof( HB_EOL_INFO ) );
pEOLs->szEOL = szEOL;
pEOLs->ulLen = ulLen;
iEOLs = 1;
}
}
else if( ISARRAY( iParam ) )
{
PHB_ITEM pArray = hb_param( iParam, HB_IT_ARRAY );
ULONG ulSize = hb_arrayLen( pArray );
for( ul = 1; ul <= ulSize; ++ul )
{
if( hb_arrayGetCLen( pArray, ul ) > 0 )
++iEOLs;
}
if( iEOLs )
{
iEOLs = 0;
pEOLs = ( PHB_EOL_INFO ) hb_xgrab( sizeof( HB_EOL_INFO ) * iEOLs );
for( ul = 1; ul <= ulSize; ++ul )
{
ulLen = hb_arrayGetCLen( pArray, ul );
if( ulLen > 0 )
{
pEOLs[ iEOLs ].szEOL = hb_arrayGetCPtr( pArray, ul );
pEOLs[ iEOLs ].ulLen = ulLen;
++iEOLs;
}
}
}
}
#else
HB_SYMBOL_UNUSED( iParam );
#endif
if( iEOLs == 0 )
{
pEOLs = ( PHB_EOL_INFO ) hb_xgrab( sizeof( HB_EOL_INFO ) );
pEOLs->szEOL = hb_setGetEOL();
if( !pEOLs->szEOL || !pEOLs->szEOL[ 0 ] )
pEOLs->szEOL = hb_conNewLine();
pEOLs->ulLen = strlen( pEOLs->szEOL );
iEOLs = pEOLs->ulLen ? 1 : 0;
}
* piEOLs = iEOLs;
return pEOLs;
}
| mlcfunc.c | 154 |
| STATIC CHAR * | hb_mlGetParams( int iParAdd, ULONG * pulLen, ULONG * pulLineLength, ULONG * pulTabSize, BOOL * pfWordWrap, PHB_EOL_INFO * pEOLs, int * piEOLs )
static char * hb_mlGetParams( int iParAdd, ULONG * pulLen, ULONG * pulLineLength,
ULONG * pulTabSize, BOOL * pfWordWrap,
PHB_EOL_INFO * pEOLs, int * piEOLs )
{
char * pszString = hb_parc( 1 );
if( pszString )
{
if( ISNUM( 2 ) )
{
if( hb_parnd( 2 ) <= 0 )
return NULL;
* pulLineLength = hb_parnl( 2 );
}
else
* pulLineLength = 79;
* pulLen = hb_parclen( 1 );
* pulTabSize = ISNUM( 3 + iParAdd ) ? hb_parnl( 3 + iParAdd ) : 4;
* pfWordWrap = ISLOG( 4 + iParAdd ) ? hb_parl( 4 + iParAdd ) : TRUE;
* pEOLs = hb_mlGetEOLs( 5 + iParAdd, piEOLs );
#ifdef HB_C52_STRICT
if( * pulLineLength > 254 )
* pulLineLength = 79;
#endif
if( * pulTabSize >= * pulLineLength )
* pulTabSize = * pulLineLength - 1;
else if( * pulTabSize == 0 )
* pulTabSize = 1;
}
return pszString;
}
| mlcfunc.c | 218 |
| HB_FUNC | MEMOLINE(void)
HB_FUNC( MEMOLINE )
{
ULONG ulLen, ulLineLength, ulTabSize;
BOOL fWordWrap;
PHB_EOL_INFO pEOLs;
int iEOLs;
char * pszString = hb_mlGetParams( 1, &ulLen, &ulLineLength,
&ulTabSize, &fWordWrap, &pEOLs, &iEOLs );
char * szLine;
ULONG ulLine = hb_parnl( 3 );
ULONG ulOffset = 0;
ULONG ulCols = 0;
if( !pszString )
{
hb_retc( NULL );
return;
}
if( ulLine == 0 )
ulLine = 1;
while( --ulLine && ulOffset < ulLen )
{
ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset,
ulLineLength, ulTabSize, 0, fWordWrap,
pEOLs, iEOLs, &ulCols, NULL );
}
if( ulOffset < ulLen )
{
ULONG ulCol = 0;
hb_mlGetLine( pszString, ulLen, ulOffset,
ulLineLength, ulTabSize, 0, fWordWrap,
pEOLs, iEOLs, &ulCols, NULL );
szLine = ( char * ) hb_xgrab( ulLineLength + 1 );
while( ulCol < ulCols )
{
if( pszString[ ulOffset ] == HB_CHAR_HT )
{
ULONG ul = ulTabSize - ( ulCol % ulTabSize );
do
szLine[ ulCol++ ] = ' ';
while( --ul && ulCol < ulCols );
}
else if( pszString[ ulOffset ] == HB_CHAR_SOFT1 &&
pszString[ ulOffset + 1 ] == HB_CHAR_SOFT2 )
ulOffset++;
else
szLine[ ulCol++ ] = pszString[ ulOffset ];
ulOffset++;
}
if( ulCols < ulLineLength )
memset( szLine + ulCols, ' ', ulLineLength - ulCols );
szLine[ ulLineLength ] = 0;
hb_retclen_buffer( szLine, ulLineLength );
}
else
hb_retc( NULL );
hb_xfree( pEOLs );
}
| mlcfunc.c | 249 |
| HB_FUNC | MLCOUNT(void)
HB_FUNC( MLCOUNT )
{
ULONG ulLen, ulLineLength, ulTabSize;
BOOL fWordWrap;
PHB_EOL_INFO pEOLs;
int iEOLs;
char * pszString = hb_mlGetParams( 0, &ulLen, &ulLineLength,
&ulTabSize, &fWordWrap, &pEOLs, &iEOLs );
ULONG ulLines = 0;
ULONG ulOffset = 0;
ULONG ulCols = 0;
if( pszString )
{
while( ulOffset < ulLen )
{
++ulLines;
ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset,
ulLineLength, ulTabSize, 0, fWordWrap,
pEOLs, iEOLs, &ulCols, NULL );
}
hb_xfree( pEOLs );
}
hb_retnl( ulLines );
}
| mlcfunc.c | 310 |
| HB_FUNC | MLPOS(void)
HB_FUNC( MLPOS )
{
ULONG ulLen, ulLineLength, ulTabSize;
BOOL fWordWrap;
PHB_EOL_INFO pEOLs;
int iEOLs;
char * pszString = hb_mlGetParams( 1, &ulLen, &ulLineLength,
&ulTabSize, &fWordWrap, &pEOLs, &iEOLs );
ULONG ulLine = hb_parnl( 3 );
ULONG ulOffset = 0;
ULONG ulCols = 0;
if( pszString )
{
if( ulLine == 0 )
ulLine = 1;
while( --ulLine && ulOffset < ulLen )
ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset,
ulLineLength, ulTabSize, 0, fWordWrap,
pEOLs, iEOLs, &ulCols, NULL );
if( ulOffset < ulLen )
++ulOffset;
hb_xfree( pEOLs );
}
hb_retnl( ulOffset );
}
| mlcfunc.c | 336 |
| HB_FUNC | MLCTOPOS(void)
HB_FUNC( MLCTOPOS )
{
ULONG ulLen, ulLineLength, ulTabSize;
BOOL fWordWrap;
PHB_EOL_INFO pEOLs;
int iEOLs;
char * pszString = hb_mlGetParams( 2, &ulLen, &ulLineLength,
&ulTabSize, &fWordWrap, &pEOLs, &iEOLs );
ULONG ulLine = hb_parnl( 3 );
ULONG ulCol = hb_parnl( 4 );
ULONG ulOffset = 0;
ULONG ulCols = 0;
if( pszString )
{
if( ulLineLength > 4 && ulLine && ISNUM( 4 ) )
{
while( --ulLine && ulOffset < ulLen )
ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset,
ulLineLength, ulTabSize, 0, fWordWrap,
pEOLs, iEOLs, &ulCols, NULL );
if( ulOffset < ulLen && ulCol )
ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset,
ulCol, ulTabSize, ulLen, FALSE,
pEOLs, iEOLs, &ulCols, NULL );
}
hb_xfree( pEOLs );
}
++ulOffset;
hb_retnl( ulOffset );
}
| mlcfunc.c | 363 |
| HB_FUNC | MPOSTOLC(void)
HB_FUNC( MPOSTOLC )
{
ULONG ulLen, ulLineLength, ulTabSize;
BOOL fWordWrap;
PHB_EOL_INFO pEOLs;
int iEOLs;
char * pszString = hb_mlGetParams( 1, &ulLen, &ulLineLength,
&ulTabSize, &fWordWrap, &pEOLs, &iEOLs );
ULONG ulPos = hb_parnl( 3 );
ULONG ulOffset = 0;
ULONG ulLine = 0;
ULONG ulCol = 0;
ULONG ulEOL = 0;
if( pszString )
{
if( ulPos && ulLen )
{
if( --ulPos )
{
do
{
++ulLine;
ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset,
ulLineLength, ulTabSize, ulPos, fWordWrap,
pEOLs, iEOLs, &ulCol, &ulEOL );
if( ulEOL )
{
if( ulOffset + ulEOL == ulPos )
{
ulCol = 0;
++ulLine;
break;
}
ulOffset += ulEOL;
}
}
while( ulOffset < ulLen && ulOffset < ulPos );
if( ulLine && ulCol == ulLineLength && ulPos <= ulLen &&
( hb_mlEol( pszString + ulPos, ulLen - ulPos, pEOLs, iEOLs ) >= 0 ||
( pszString[ ulPos ] == HB_CHAR_SOFT1 &&
pszString[ ulPos + 1 ] == HB_CHAR_SOFT2 ) ||
( ulPos > 0 && pszString[ ulPos - 1 ] == HB_CHAR_SOFT1 &&
pszString[ ulPos ] == HB_CHAR_SOFT2 ) ||
( ulPos > 1 && pszString[ ulPos - 2 ] == HB_CHAR_SOFT1 &&
pszString[ ulPos - 1 ] == HB_CHAR_SOFT2 ) ) )
{
ulCol = 0;
++ulLine;
}
}
else
++ulLine;
}
hb_xfree( pEOLs );
}
hb_reta( 2 );
hb_stornl( ulLine, -1, 1 );
hb_stornl( ulCol, -1, 2 );
}
| mlcfunc.c | 395 |
| mod.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | MOD(void)
HB_FUNC( MOD )
{
PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC );
PHB_ITEM pBase = hb_param( 2, HB_IT_NUMERIC );
if( pNumber && pBase )
{
double dNumber = hb_itemGetND( pNumber );
double dBase = hb_itemGetND( pBase ); /* dBase! Cool! */
if( dBase )
{
double dResult = fmod( dNumber, dBase );
if( dResult && ( dNumber > 0 ? dBase < 0 : dBase > 0 ) )
dResult += dBase;
hb_retnd( dResult );
}
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ZERODIV, 1341, NULL, "%", HB_ERR_ARGS_BASEPARAMS );
/* In CA-Cl*pper MOD() function ignores substitution result
* and return original numeric item keeping its internal
* representation: integer or double, size and number of
* decimal places, it can be seen in code like:
* proc main()
* set fixed on
* ? transform(mod( 12345, 0 ),"")
* return
*
* [druzus]
*/
if( pResult )
{
hb_itemReturn( pNumber );
hb_itemRelease( pResult );
}
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1085, NULL, "%", 2, hb_param( 1, HB_IT_ANY ), hb_param( 2, HB_IT_ANY ) );
}
| mod.c | 68 |
| mouse53.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | MPRESENT(void)
HB_FUNC( MPRESENT )
{
hb_retl( hb_mouseIsPresent() );
}
| mouse53.c | 63 |
| HB_FUNC | MHIDE(void)
HB_FUNC( MHIDE )
{
hb_mouseSetCursor( FALSE );
}
| mouse53.c | 68 |
| HB_FUNC | MSHOW(void)
HB_FUNC( MSHOW )
{
hb_mouseSetCursor( TRUE );
}
| mouse53.c | 73 |
| HB_FUNC | MSETCURSOR(void)
HB_FUNC( MSETCURSOR )
{
hb_retl( hb_mouseGetCursor() );
if( ISLOG( 1 ) )
hb_mouseSetCursor( hb_parl( 1 ) );
}
| mouse53.c | 78 |
| HB_FUNC | MROW(void)
HB_FUNC( MROW )
{
if( ISLOG( 1 ) && hb_parl( 1 ) )
{
int iRow, iCol;
hb_mouseGetPos( &iRow, &iCol );
hb_retni( iRow );
}
else
hb_retni( hb_mouseRow() );
}
| mouse53.c | 86 |
| HB_FUNC | MCOL(void)
HB_FUNC( MCOL )
{
if( ISLOG( 1 ) && hb_parl( 1 ) )
{
int iRow, iCol;
hb_mouseGetPos( &iRow, &iCol );
hb_retni( iCol );
}
else
hb_retni( hb_mouseCol() );
}
| mouse53.c | 99 |
| HB_FUNC | MSETPOS(void)
HB_FUNC( MSETPOS )
{
if( ISNUM( 1 ) && ISNUM( 2 ) )
hb_mouseSetPos( hb_parni( 1 ), hb_parni( 2 ) );
}
| mouse53.c | 112 |
| HB_FUNC | MLEFTDOWN(void)
HB_FUNC( MLEFTDOWN )
{
hb_retl( hb_mouseButtonState( M_BUTTON_LEFT ) );
}
| mouse53.c | 118 |
| HB_FUNC | MRIGHTDOWN(void)
HB_FUNC( MRIGHTDOWN )
{
hb_retl( hb_mouseButtonState( M_BUTTON_RIGHT ) );
}
| mouse53.c | 123 |
| HB_FUNC | MDBLCLK(void)
HB_FUNC( MDBLCLK )
{
hb_retni( hb_mouseGetDoubleClickSpeed() );
if( ISNUM( 1 ) )
{
hb_mouseSetDoubleClickSpeed( hb_parni( 1 ) );
}
}
| mouse53.c | 128 |
| HB_FUNC | MSAVESTATE(void)
HB_FUNC( MSAVESTATE )
{
int iLen = hb_mouseStorageSize();
if( iLen > 0 )
{
BYTE * pBuffer = ( BYTE * ) hb_xgrab( iLen + 1 );
hb_mouseSaveState( pBuffer );
hb_retclen_buffer( ( char * ) pBuffer, iLen );
}
else
hb_retc( NULL );
}
| mouse53.c | 138 |
| HB_FUNC | MRESTSTATE(void)
HB_FUNC( MRESTSTATE )
{
if( ISCHAR( 1 ) && hb_parclen( 1 ) == ( ULONG ) hb_mouseStorageSize() )
{
hb_mouseRestoreState( ( BYTE * ) hb_parc( 1 ) );
}
}
| mouse53.c | 153 |
| HB_FUNC | MSETBOUNDS(void)
HB_FUNC( MSETBOUNDS )
{
hb_mouseSetBounds( hb_parni( 1 ), /* Defaults to zero on bad type */
hb_parni( 2 ), /* Defaults to zero on bad type */
ISNUM( 3 ) ? hb_parni( 3 ) : hb_gtMaxRow(),
ISNUM( 4 ) ? hb_parni( 4 ) : hb_gtMaxCol() );
}
| mouse53.c | 161 |
| mouseapi.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT BOOL | hb_mouseIsPresent( void )
HB_EXPORT BOOL hb_mouseIsPresent( void )
{
BOOL fPresent = FALSE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseIsPresent()"));
pGT = hb_gt_Base();
if( pGT )
{
fPresent = HB_GTSELF_MOUSEISPRESENT( pGT );
hb_gt_BaseFree( pGT );
}
return fPresent;
}
| mouseapi.c | 73 |
| HB_EXPORT BOOL | hb_mouseGetCursor( void )
HB_EXPORT BOOL hb_mouseGetCursor( void )
{
BOOL fVisible = FALSE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseGetCursor()"));
pGT = hb_gt_Base();
if( pGT )
{
fVisible = HB_GTSELF_MOUSEGETCURSOR( pGT );
hb_gt_BaseFree( pGT );
}
return fVisible;
}
| mouseapi.c | 89 |
| HB_EXPORT VOID | hb_mouseSetCursor( BOOL fVisible )
HB_EXPORT void hb_mouseSetCursor( BOOL fVisible )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetCursor(%d)", (int) fVisible));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSESETCURSOR( pGT, fVisible );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 105 |
| HB_EXPORT INT | hb_mouseCol( void )
HB_EXPORT int hb_mouseCol( void )
{
int iCol = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseCol()"));
pGT = hb_gt_Base();
if( pGT )
{
iCol = HB_GTSELF_MOUSECOL( pGT );
hb_gt_BaseFree( pGT );
}
return iCol;
}
| mouseapi.c | 119 |
| HB_EXPORT INT | hb_mouseRow( void )
HB_EXPORT int hb_mouseRow( void )
{
int iRow = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseRow()"));
pGT = hb_gt_Base();
if( pGT )
{
iRow = HB_GTSELF_MOUSEROW( pGT );
hb_gt_BaseFree( pGT );
}
return iRow;
}
| mouseapi.c | 135 |
| HB_EXPORT VOID | hb_mouseGetPos( int * piRow, int * piCol )
HB_EXPORT void hb_mouseGetPos( int * piRow, int * piCol )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetPos(%p, %p)", piRow, piCol));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSEGETPOS( pGT, piRow, piCol );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 151 |
| HB_EXPORT VOID | hb_mouseSetPos( int iRow, int iCol )
HB_EXPORT void hb_mouseSetPos( int iRow, int iCol )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetPos(%d, %d)", iRow, iCol));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSESETPOS( pGT, iRow, iCol );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 165 |
| HB_EXPORT VOID | hb_mouseSetBounds( int iTop, int iLeft, int iBottom, int iRight )
HB_EXPORT void hb_mouseSetBounds( int iTop, int iLeft, int iBottom, int iRight )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetBounds(%d, %d, %d, %d)", iTop, iLeft, iBottom, iRight));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSESETBOUNDS( pGT, iTop, iLeft, iBottom, iRight );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 179 |
| HB_EXPORT VOID | hb_mouseGetBounds( int * piTop, int * piLeft, int * piBottom, int * piRight )
HB_EXPORT void hb_mouseGetBounds( int * piTop, int * piLeft, int * piBottom, int * piRight )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetBounds(%p, %p, %p, %p)", piTop, piLeft, piBottom, piRight));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSEGETBOUNDS( pGT, piTop, piLeft, piBottom, piRight );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 193 |
| HB_EXPORT INT | hb_mouseStorageSize( void )
HB_EXPORT int hb_mouseStorageSize( void )
{
int iSize = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseStorageSize()"));
pGT = hb_gt_Base();
if( pGT )
{
iSize = HB_GTSELF_MOUSESTORAGESIZE( pGT );
hb_gt_BaseFree( pGT );
}
return iSize;
}
| mouseapi.c | 207 |
| HB_EXPORT VOID | hb_mouseSaveState( BYTE * pBuffer )
HB_EXPORT void hb_mouseSaveState( BYTE * pBuffer )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseSaveState(%p)", pBuffer));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSESAVESTATE( pGT, pBuffer );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 223 |
| HB_EXPORT VOID | hb_mouseRestoreState( BYTE * pBuffer )
HB_EXPORT void hb_mouseRestoreState( BYTE * pBuffer )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseRestoreState(%p)", pBuffer));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSERESTORESTATE( pGT, pBuffer );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 237 |
| HB_EXPORT INT | hb_mouseGetDoubleClickSpeed( void )
HB_EXPORT int hb_mouseGetDoubleClickSpeed( void )
{
int iSpeed = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseGetDoubleClickSpeed()"));
pGT = hb_gt_Base();
if( pGT )
{
iSpeed = HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT );
hb_gt_BaseFree( pGT );
}
return iSpeed;
}
| mouseapi.c | 251 |
| HB_EXPORT VOID | hb_mouseSetDoubleClickSpeed( int iSpeed )
HB_EXPORT void hb_mouseSetDoubleClickSpeed( int iSpeed )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetDoubleClickSpeed(%d)", iSpeed));
pGT = hb_gt_Base();
if( pGT )
{
HB_GTSELF_MOUSESETDOUBLECLICKSPEED( pGT, iSpeed );
hb_gt_BaseFree( pGT );
}
}
| mouseapi.c | 267 |
| HB_EXPORT INT | hb_mouseCountButton( void )
HB_EXPORT int hb_mouseCountButton( void )
{
int iButtons = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseCountButton()"));
pGT = hb_gt_Base();
if( pGT )
{
iButtons = HB_GTSELF_MOUSECOUNTBUTTON( pGT );
hb_gt_BaseFree( pGT );
}
return iButtons;
}
| mouseapi.c | 281 |
| HB_EXPORT BOOL | hb_mouseButtonState( int iButton )
HB_EXPORT BOOL hb_mouseButtonState( int iButton )
{
BOOL fPressed = FALSE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseButtonState(%d)", iButton));
pGT = hb_gt_Base();
if( pGT )
{
fPressed = HB_GTSELF_MOUSEBUTTONSTATE( pGT, iButton );
hb_gt_BaseFree( pGT );
}
return fPressed;
}
| mouseapi.c | 297 |
| HB_EXPORT BOOL | hb_mouseButtonPressed( int iButton, int * piRow, int * piCol )
HB_EXPORT BOOL hb_mouseButtonPressed( int iButton, int * piRow, int * piCol )
{
BOOL fPressed = FALSE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseButtonPressed(%d,%p,%p)", iButton, piRow, piCol));
pGT = hb_gt_Base();
if( pGT )
{
fPressed = HB_GTSELF_MOUSEBUTTONPRESSED( pGT, iButton, piRow, piCol );
hb_gt_BaseFree( pGT );
}
return fPressed;
}
| mouseapi.c | 313 |
| HB_EXPORT BOOL | hb_mouseButtonReleased( int iButton, int * piRow, int * piCol )
HB_EXPORT BOOL hb_mouseButtonReleased( int iButton, int * piRow, int * piCol )
{
BOOL fReleased = FALSE;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseButtonReleased(%d,%p,%p)", iButton, piRow, piCol));
pGT = hb_gt_Base();
if( pGT )
{
fReleased = HB_GTSELF_MOUSEBUTTONRELEASED( pGT, iButton, piRow, piCol );
hb_gt_BaseFree( pGT );
}
return fReleased;
}
| mouseapi.c | 329 |
| HB_EXPORT INT | hb_mouseReadKey( int iEventMask )
HB_EXPORT int hb_mouseReadKey( int iEventMask )
{
int iKey = 0;
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_mouseReadKey(%d)", iEventMask));
pGT = hb_gt_Base();
if( pGT )
{
iKey = HB_GTSELF_MOUSEREADKEY( pGT, iEventMask );
hb_gt_BaseFree( pGT );
}
return iKey;
}
| mouseapi.c | 345 |
| mousex.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | NUMBUTTONS(void)
HB_FUNC( NUMBUTTONS )
{
hb_retni( hb_mouseCountButton() );
}
| mousex.c | 61 |
| HB_FUNC | SETMOUSE(void)
HB_FUNC( SETMOUSE )
{
BOOL fRow, fCol;
hb_retl( hb_mouseGetCursor() );
if( ISLOG( 1 ) )
hb_mouseSetCursor( hb_parl( 1 ) );
fRow = ISNUM( 2 );
fCol = ISNUM( 3 );
if( fRow || fCol )
{
int iRow = 0, iCol = 0;
if( !fRow || !fCol )
hb_mouseGetPos( &iRow, &iCol );
if( fRow )
iRow = hb_parni( 2 );
if( fCol )
iCol = hb_parni( 3 );
hb_mouseSetPos( iRow, iCol );
}
}
| mousex.c | 66 |
| mtran.c |
| Type | Function | Source | Line |
|---|
| STATIC CHAR * | hb_strMemotran( char * pszResult, ULONG * ulResultLen, const char * pszString, ULONG ulStringLen, char cHardcr, char cSoftcr )
static char * hb_strMemotran( char * pszResult, ULONG * ulResultLen, const char * pszString, ULONG ulStringLen, char cHardcr, char cSoftcr )
{
ULONG ulStringPos = 0;
ULONG ulResultPos = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_strMemotran(%s, %p, %s, %lu, %x, %x)", pszResult, ulResultLen, pszString, ulStringLen, cHardcr, cSoftcr));
while( ulStringPos < ulStringLen )
{
if( pszString[ ulStringPos ] == HB_CHAR_HARD1 &&
pszString[ ulStringPos + 1 ] == HB_CHAR_HARD2 )
{
pszResult[ ulResultPos++ ] = cHardcr;
ulStringPos += 2;
}
else if( pszString[ ulStringPos ] == HB_CHAR_SOFT1 &&
pszString[ ulStringPos + 1 ] == HB_CHAR_SOFT2 )
{
pszResult[ ulResultPos++ ] = cSoftcr;
ulStringPos += 2;
}
else
pszResult[ ulResultPos++ ] = pszString[ ulStringPos++ ];
}
pszResult[ ulResultPos ] = '\0';
*ulResultLen = ulResultPos;
return pszResult;
}
| mtran.c | 58 |
| HB_FUNC | MEMOTRAN(void)
HB_FUNC( MEMOTRAN )
{
PHB_ITEM pString = hb_param( 1, HB_IT_STRING );
if( pString )
{
char * pszResult = ( char * ) hb_xgrab( hb_itemGetCLen( pString ) + 1 );
char cHardcr = ISCHAR( 2 ) ? *hb_parc( 2 ) : ';';
char cSoftcr = ISCHAR( 3 ) ? *hb_parc( 3 ) : ' ';
ULONG ulResultLen;
hb_strMemotran( pszResult, &ulResultLen, hb_itemGetCPtr( pString ), hb_itemGetCLen( pString ), cHardcr, cSoftcr );
hb_retclen_buffer( pszResult, ulResultLen );
}
else
hb_retc( NULL );
}
| mtran.c | 90 |
| natmsg.c |
| Type | Function | Source | Line |
|---|
| STATIC CHAR * | hb_nationGetMsg( int iMsg )
static char * hb_nationGetMsg( int iMsg )
{
HB_TRACE(HB_TR_DEBUG, ("hb_nationGetMsg(%hu)", iMsg));
return ( iMsg >= 1 && iMsg <= 13 ) ? ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_NATMSG + iMsg - 1 ) : ( char * ) "";
}
| natmsg.c | 89 |
| HB_FUNC | __NATISAFFIRM(void)
HB_FUNC( __NATISAFFIRM )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_STRING );
hb_retl( pItem && hb_itemGetCLen( pItem ) >= 1 && toupper( hb_itemGetCPtr( pItem )[ 0 ] ) == ( ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_NATMSG + _LF_YN - 1 ) )[ 0 ] );
}
| natmsg.c | 96 |
| HB_FUNC | __NATISNEGATIVE(void)
HB_FUNC( __NATISNEGATIVE )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_STRING );
hb_retl( pItem && hb_itemGetCLen( pItem ) >= 1 && toupper( hb_itemGetCPtr( pItem )[ 0 ] ) == ( ( char * ) hb_langDGetItem( HB_LANG_ITEM_BASE_NATMSG + _LF_YN - 1 ) )[ 2 ] );
}
| natmsg.c | 103 |
| HB_FUNC | __NATMSG(void)
HB_FUNC( __NATMSG )
{
if( hb_pcount() == 0 )
/* TODO: Replace this with Language API call. */
hb_retc( "Invalid argument" );
else if( ISNUM( 1 ) )
hb_retc( hb_nationGetMsg( hb_parni( 1 ) ) );
else
hb_retc( NULL );
}
| natmsg.c | 110 |
| HB_FUNC | __NATSORTVER(void)
HB_FUNC( __NATSORTVER )
{
/* NOTE: CA-Cl*pper 5.2e Intl. will return: "NATSORT v1.2i x14 19/Mar/93" */
/* NOTE: CA-Cl*pper 5.3 Intl. will return: "NATSORT v1.3i x19 06/Mar/95" */
hb_retc( "NATSORT (Harbour)" );
}
| natmsg.c | 121 |
| HB_FUNC | __NATMSGVER(void)
HB_FUNC( __NATMSGVER )
{
/* NOTE: CA-Cl*pper 5.2e Intl. will return: "NATMSGS v1.2i x14 19/Mar/93" */
/* NOTE: CA-Cl*pper 5.3 Intl. will return: "NATMSGS v1.3i x19 06/Mar/95" */
hb_retc( "NATMSGS (Harbour)" );
}
| natmsg.c | 129 |
| natmsgu.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | ISAFFIRM(void)
HB_FUNC( ISAFFIRM )
{
HB_FUNC_EXEC( __NATISAFFIRM )
}
HB_FUNC_EXTERN( __NATISNEGATIVE );
| natmsgu.c | 71 |
| HB_FUNC | ISNEGATIVE(void)
HB_FUNC( ISNEGATIVE )
{
HB_FUNC_EXEC( __NATISNEGATIVE )
}
HB_FUNC_EXTERN( __NATMSG );
| natmsgu.c | 78 |
| HB_FUNC | NATIONMSG(void)
HB_FUNC( NATIONMSG )
{
HB_FUNC_EXEC( __NATMSG )
}
/* NOTE: Intentionally using one leading underscore, like in Clipper.
[vszakats] */
HB_FUNC_EXTERN( __NATSORTVER );
| natmsgu.c | 85 |
| HB_FUNC | _NATSORTVER(void)
HB_FUNC( _NATSORTVER )
{
HB_FUNC_EXEC( __NATSORTVER )
}
/* NOTE: Intentionally using one leading underscore, like in Clipper.
[vszakats] */
HB_FUNC_EXTERN( __NATMSGVER );
| natmsgu.c | 95 |
| HB_FUNC | _NATMSGVER(void)
HB_FUNC( _NATMSGVER )
{
HB_FUNC_EXEC( __NATMSGVER )
}
| natmsgu.c | 105 |
| net.c |
| Type | Function | Source | Line |
|---|
| CHAR * | hb_netname( void )
char * hb_netname( void )
{
#if defined(HB_OS_UNIX) || ( defined(HB_OS_OS2) && defined(__GNUC__) )
# if defined(__WATCOMC__)
return hb_getenv( "HOSTNAME" );
# else
char * pszValue = ( char * ) hb_xgrab( MAXGETHOSTNAME + 1 );
pszValue[ 0 ] = '\0';
gethostname( pszValue, MAXGETHOSTNAME );
return pszValue;
# endif
#elif defined(HB_OS_DOS)
# if defined(__DJGPP__) || defined(__RSX32__) || defined(__GNUC__)
char * pszValue = ( char * ) hb_xgrab( MAXGETHOSTNAME + 1 );
pszValue[ 0 ] = '\0';
gethostname( pszValue, MAXGETHOSTNAME );
return pszValue;
# else
union REGS regs;
char * pszValue = ( char * ) hb_xgrab( 16 );
pszValue[ 0 ] = '\0';
regs.HB_XREGS.ax = 0x5E00;
{
struct SREGS sregs;
regs.HB_XREGS.dx = FP_OFF( pszValue );
sregs.ds = FP_SEG( pszValue );
HB_DOS_INT86X( 0x21, ®s, ®s, &sregs );
}
return regs.h.ch == 0 ? hb_strdup( "" ) : pszValue;
# endif
#elif defined(HB_OS_WIN_32)
DWORD ulLen = MAX_COMPUTERNAME_LENGTH + 1;
char * pszValue = ( char * ) hb_xgrab( ulLen );
pszValue[ 0 ] = '\0';
GetComputerNameA( pszValue, &ulLen );
return pszValue;
#else
return hb_strdup( "" );
#endif
}
| net.c | 110 |
| CHAR * | hb_username( void )
char * hb_username( void )
{
#if defined(HB_OS_UNIX) || ( defined(HB_OS_OS2) && defined(__GNUC__) )
# if defined(__WATCOMC__)
return hb_getenv( "USER" );
# else
struct passwd * pwd;
pwd = getpwuid( getuid() );
return pwd ? hb_strdup( pwd->pw_name ) : hb_getenv( "USER" );
# endif
#elif defined(HB_OS_WIN_32)
DWORD ulLen = 256;
char * pszValue = ( char * ) hb_xgrab( ulLen );
pszValue[ 0 ] = '\0';
GetUserNameA( pszValue, &ulLen );
return pszValue;
#else
return hb_strdup( "" );
#endif
}
| net.c | 167 |
| HB_FUNC | NETNAME(void)
HB_FUNC( NETNAME )
{
hb_retc_buffer( hb_netname() );
}
| net.c | 195 |
| HB_FUNC | HB_USERNAME(void)
HB_FUNC( HB_USERNAME )
{
hb_retc_buffer( hb_username() );
}
| net.c | 200 |
| oemansi.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_ANSITOOEM(void)
HB_FUNC( HB_ANSITOOEM )
{
PHB_ITEM pString = hb_param( 1, HB_IT_STRING );
if( pString )
#if defined(HB_OS_WIN_32)
{
DWORD ulLen = hb_itemGetCLen( pString );
char * pszDst = ( char * ) hb_xgrab( ulLen + 1 );
CharToOemBuffA( ( LPCSTR ) hb_itemGetCPtr( pString ), ( LPSTR ) pszDst, ulLen );
hb_retclen_buffer( pszDst, ulLen );
}
#else
hb_itemReturn( pString );
#endif
else
hb_retc( NULL );
}
| oemansi.c | 61 |
| HB_FUNC | HB_OEMTOANSI(void)
HB_FUNC( HB_OEMTOANSI )
{
PHB_ITEM pString = hb_param( 1, HB_IT_STRING );
if( pString )
#if defined(HB_OS_WIN_32)
{
DWORD ulLen = hb_itemGetCLen( pString );
char * pszDst = ( char * ) hb_xgrab( ulLen + 1 );
OemToCharBuffA( ( LPCSTR ) hb_itemGetCPtr( pString ), ( LPSTR ) pszDst, ulLen );
hb_retclen_buffer( pszDst, ulLen );
}
#else
hb_itemReturn( pString );
#endif
else
hb_retc( NULL );
}
| oemansi.c | 82 |
| oemansix.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | CONVTOOEMCP(void)
HB_FUNC( CONVTOOEMCP )
{
HB_FUNC_EXEC( HB_ANSITOOEM );
}
| oemansix.c | 60 |
| HB_FUNC | CONVTOANSICP(void)
HB_FUNC( CONVTOANSICP )
{
HB_FUNC_EXEC( HB_OEMTOANSI );
}
| oemansix.c | 65 |
| oldbox.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | __BOX(void)
HB_FUNC( __BOX )
{
PHB_ITEM pTop = hb_param( 1, HB_IT_NUMERIC );
PHB_ITEM pLeft = hb_param( 2, HB_IT_NUMERIC );
PHB_ITEM pBottom = hb_param( 3, HB_IT_NUMERIC );
PHB_ITEM pRight = hb_param( 4, HB_IT_NUMERIC );
char * pszBox = hb_parc( 5 );
if( pTop && pLeft && pBottom && pRight && pszBox )
hb_gtBox( ( SHORT ) hb_itemGetNI( pTop ),
( SHORT ) hb_itemGetNI( pLeft),
( SHORT ) hb_itemGetNI( pBottom ),
( SHORT ) hb_itemGetNI( pRight ),
( BYTE * ) ( *pszBox ? pszBox : " " ) );
}
| oldbox.c | 59 |
| HB_FUNC | __BOXD(void)
HB_FUNC( __BOXD )
{
PHB_ITEM pTop = hb_param( 1, HB_IT_NUMERIC );
PHB_ITEM pLeft = hb_param( 2, HB_IT_NUMERIC );
PHB_ITEM pBottom = hb_param( 3, HB_IT_NUMERIC );
PHB_ITEM pRight = hb_param( 4, HB_IT_NUMERIC );
if( pTop && pLeft && pBottom && pRight )
hb_gtBoxD( ( SHORT ) hb_itemGetNI( pTop ),
( SHORT ) hb_itemGetNI( pLeft),
( SHORT ) hb_itemGetNI( pBottom ),
( SHORT ) hb_itemGetNI( pRight ) );
}
| oldbox.c | 75 |
| HB_FUNC | __BOXS(void)
HB_FUNC( __BOXS )
{
PHB_ITEM pTop = hb_param( 1, HB_IT_NUMERIC );
PHB_ITEM pLeft = hb_param( 2, HB_IT_NUMERIC );
PHB_ITEM pBottom = hb_param( 3, HB_IT_NUMERIC );
PHB_ITEM pRight = hb_param( 4, HB_IT_NUMERIC );
if( pTop && pLeft && pBottom && pRight )
hb_gtBoxS( ( SHORT ) hb_itemGetNI( pTop ),
( SHORT ) hb_itemGetNI( pLeft),
( SHORT ) hb_itemGetNI( pBottom ),
( SHORT ) hb_itemGetNI( pRight ) );
}
| oldbox.c | 89 |
| oldclear.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | __ATCLEAR(void)
HB_FUNC( __ATCLEAR )
{
if( hb_pcount() == 4 )
{
hb_gtSetPos( ( SHORT ) hb_parni( 1 ), ( SHORT ) hb_parni( 2 ) );
hb_gtScroll( ( USHORT ) hb_parni( 1 ),
( USHORT ) hb_parni( 2 ),
( USHORT ) hb_parni( 3 ),
( USHORT ) hb_parni( 4 ), 0, 0 );
}
}
| oldclear.c | 57 |
| HB_FUNC | __CLEAR(void)
HB_FUNC( __CLEAR )
{
hb_gtScroll( 0, 0, hb_gtMaxRow(), hb_gtMaxCol(), 0, 0 );
hb_gtSetPos( 0, 0 );
}
| oldclear.c | 69 |
| pad.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | PAD(void)
HB_FUNC( PAD )
{
HB_FUNC_EXEC( PADR );
}
| pad.c | 57 |
| padc.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | PADC(void)
HB_FUNC( PADC )
{
ULONG ulSize;
BOOL bFreeReq;
char * szText;
long lLen = hb_parnl( 2 );
if( lLen > 0 )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem && HB_IS_STRING( pItem ) && ( ULONG ) lLen == hb_itemGetCLen( pItem ) )
{
hb_itemReturn( pItem );
}
else
{
szText = hb_itemPadConv( pItem, &ulSize, &bFreeReq );
if( szText )
{
if( ( ULONG ) lLen > ulSize )
{
char * szResult = ( char * ) hb_xgrab( lLen + 1 );
char cPad;
long ulPad = ( ( ULONG ) lLen - ulSize ) >> 1;
cPad = ( ISCHAR( 3 ) ? *( hb_parc( 3 ) ) : ' ' );
hb_xmemset( szResult, cPad, ulPad );
hb_xmemcpy( szResult + ulPad, szText, ulSize );
hb_xmemset( szResult + ulPad + ulSize, cPad,
( ULONG ) lLen - ulSize - ulPad );
hb_retclen_buffer( szResult, ( ULONG ) lLen );
if( bFreeReq )
hb_xfree( szText );
}
else
{
if( bFreeReq )
hb_retclen_buffer( szText, ( ULONG ) lLen );
else
hb_retclen( szText, lLen );
}
}
else
hb_retc( NULL );
}
}
else
hb_retc( NULL );
}
| padc.c | 57 |
| padl.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | PADL(void)
HB_FUNC( PADL )
{
ULONG ulSize;
BOOL bFreeReq;
char * szText;
long lLen = hb_parnl( 2 );
if( lLen > 0 )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem && HB_IS_STRING( pItem ) && ( ULONG ) lLen == hb_itemGetCLen( pItem ) )
{
hb_itemReturn( pItem );
}
else
{
szText = hb_itemPadConv( pItem, &ulSize, &bFreeReq );
if( szText )
{
if( ( ULONG ) lLen > ulSize )
{
char * szResult = ( char * ) hb_xgrab( lLen + 1 );
char cPad;
cPad = ( ISCHAR( 3 ) ? *( hb_parc( 3 ) ) : ' ' );
hb_xmemset( szResult, cPad, ( ULONG ) lLen - ulSize );
hb_xmemcpy( szResult + ( ULONG ) lLen - ulSize, szText, ulSize );
hb_retclen_buffer( szResult, ( ULONG ) lLen );
if( bFreeReq )
hb_xfree( szText );
}
else
{
if( bFreeReq )
hb_retclen_buffer( szText, ( ULONG ) lLen );
else
hb_retclen( szText, lLen );
}
}
else
hb_retc( NULL );
}
}
else
hb_retc( NULL );
}
| padl.c | 57 |
| padr.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | PADR(void)
HB_FUNC( PADR )
{
ULONG ulSize;
BOOL bFreeReq;
char * szText;
long lLen = hb_parnl( 2 );
if( lLen > 0 )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem && HB_IS_STRING( pItem ) && ( ULONG ) lLen == hb_itemGetCLen( pItem ) )
{
hb_itemReturn( pItem );
}
else
{
szText = hb_itemPadConv( pItem, &ulSize, &bFreeReq );
if( szText )
{
if( ( ULONG ) lLen > ulSize )
{
char * szResult = ( char * ) hb_xgrab( lLen + 1 );
char cPad;
cPad = ( ISCHAR( 3 ) ? *( hb_parc( 3 ) ) : ' ' );
hb_xmemcpy( szResult, szText, ulSize );
hb_xmemset( szResult + ulSize, cPad, ( ULONG ) lLen - ulSize );
hb_retclen_buffer( szResult, ( ULONG ) lLen );
if( bFreeReq )
hb_xfree( szText );
}
else
{
if( bFreeReq )
hb_retclen_buffer( szText, ( ULONG ) lLen );
else
hb_retclen( szText, lLen );
}
}
else
hb_retc( NULL );
}
}
else
hb_retc( NULL );
}
| padr.c | 57 |
| philes.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | FOPEN(void)
HB_FUNC( FOPEN )
{
if( ISCHAR( 1 ) )
{
hb_retnint( ( HB_NHANDLE ) hb_fsOpen( ( BYTE * ) hb_parc( 1 ),
ISNUM( 2 ) ? ( USHORT ) hb_parni( 2 ) : FO_READ | FO_COMPAT ) );
hb_fsSetFError( hb_fsError() );
}
else
{
hb_fsSetFError( 0 );
/* NOTE: Undocumented but existing Clipper Run-time error */
hb_errRT_BASE( EG_ARG, 2021, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
}
| philes.c | 57 |
| HB_FUNC | FCREATE(void)
HB_FUNC( FCREATE )
{
if( ISCHAR( 1 ) )
{
hb_retnint( ( HB_NHANDLE ) hb_fsCreate( ( BYTE * ) hb_parc( 1 ),
ISNUM( 2 ) ? hb_parni( 2 ) : FC_NORMAL ) );
hb_fsSetFError( hb_fsError() );
}
else
{
hb_retni( F_ERROR );
hb_fsSetFError( 0 );
}
}
| philes.c | 73 |
| HB_FUNC | HB_FCREATE(void)
HB_FUNC( HB_FCREATE )
{
if( ISCHAR( 1 ) )
{
hb_retnint( ( HB_NHANDLE ) hb_fsCreateEx( ( BYTE * ) hb_parc( 1 ),
ISNUM( 2 ) ? hb_parni( 2 ) : FC_NORMAL,
ISNUM( 3 ) ? ( USHORT ) hb_parni( 3 ) : FO_COMPAT ) );
hb_fsSetFError( hb_fsError() );
}
else
{
hb_retni( F_ERROR );
hb_fsSetFError( 0 );
}
}
| philes.c | 88 |
| HB_FUNC | FREAD(void)
HB_FUNC( FREAD )
{
PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING );
USHORT uiError = 0;
ULONG ulRead = 0;
if( ISNUM( 1 ) && pBuffer && ISBYREF( 2 ) && ISNUM( 3 ) )
{
ulRead = hb_parnl( 3 );
/* NOTE: CA-Cl*pper determines the maximum size by calling _parcsiz()
instead of _parclen(), this means that the maximum read length
will be one more than the length of the passed buffer, because
the terminating zero could be used if needed. [vszakats] */
if( ulRead <= hb_parcsiz( 2 ) )
{
/* NOTE: Warning, the read buffer will be directly modified,
this is normal here ! [vszakats] */
/* Unshare the item to avoid GPF on static buffers and changing
other items which shares this buffer. [druzus] */
pBuffer = hb_itemUnShareString( pBuffer );
ulRead = hb_fsReadLarge( hb_numToHandle( hb_parnint( 1 ) ),
( BYTE * ) hb_itemGetCPtr( pBuffer ),
ulRead );
uiError = hb_fsError();
}
else
ulRead = 0;
}
hb_retnint( ulRead );
hb_fsSetFError( uiError );
}
| philes.c | 104 |
| HB_FUNC | FWRITE(void)
HB_FUNC( FWRITE )
{
USHORT uiError = 0;
if( ISNUM( 1 ) && ISCHAR( 2 ) )
{
hb_retnl( hb_fsWriteLarge( hb_numToHandle( hb_parnint( 1 ) ),
( BYTE * ) hb_parc( 2 ),
ISNUM( 3 ) ? ( ULONG ) hb_parnl( 3 ) : hb_parclen( 2 ) ) );
uiError = hb_fsError();
}
else
hb_retni( 0 );
hb_fsSetFError( uiError );
}
| philes.c | 141 |
| HB_FUNC | FERROR(void)
HB_FUNC( FERROR )
{
hb_retni( hb_fsGetFError() );
}
| philes.c | 157 |
| HB_FUNC | FCLOSE(void)
HB_FUNC( FCLOSE )
{
USHORT uiError = 0;
if( ISNUM( 1 ) )
{
hb_fsClose( hb_numToHandle( hb_parnint( 1 ) ) );
uiError = hb_fsError();
hb_retl( uiError == 0 );
}
else
hb_retl( FALSE );
hb_fsSetFError( uiError );
}
| philes.c | 162 |
| HB_FUNC | FERASE(void)
HB_FUNC( FERASE )
{
USHORT uiError = 3;
if( ISCHAR( 1 ) )
{
hb_retni( hb_fsDelete( ( BYTE * ) hb_parc( 1 ) ) ? 0 : F_ERROR );
uiError = hb_fsError();
}
else
hb_retni( F_ERROR );
hb_fsSetFError( uiError );
}
| philes.c | 176 |
| HB_FUNC | FRENAME(void)
HB_FUNC( FRENAME )
{
USHORT uiError = 2;
if( ISCHAR( 1 ) && ISCHAR( 2 ) )
{
hb_retni( hb_fsRename( ( BYTE * ) hb_parc( 1 ),
( BYTE * ) hb_parc( 2 ) ) ? 0 : F_ERROR );
uiError = hb_fsError();
}
else
hb_retni( F_ERROR );
hb_fsSetFError( uiError );
}
| philes.c | 190 |
| HB_FUNC | FSEEK(void)
HB_FUNC( FSEEK )
{
USHORT uiError = 0;
if( ISNUM( 1 ) && ISNUM( 2 ) )
{
hb_retnint( hb_fsSeekLarge( hb_numToHandle( hb_parnint( 1 ) ),
hb_parnint( 2 ),
ISNUM( 3 ) ? ( USHORT ) hb_parni( 3 ) : FS_SET ) );
uiError = hb_fsError();
}
else
hb_retni( 0 );
hb_fsSetFError( uiError );
}
| philes.c | 205 |
| HB_FUNC | FREADSTR(void)
HB_FUNC( FREADSTR )
{
USHORT uiError = 0;
if( ISNUM( 1 ) && ISNUM( 2 ) )
{
ULONG ulToRead = ( ULONG ) hb_parnl( 2 );
if( ulToRead > 0 )
{
HB_FHANDLE fhnd = ( HB_FHANDLE ) hb_parni( 1 );
BYTE * buffer = ( BYTE * ) hb_xgrab( ulToRead + 1 );
ULONG ulRead;
ulRead = hb_fsReadLarge( fhnd, buffer, ulToRead );
uiError = hb_fsError();
buffer[ ulRead ] = '\0';
/* NOTE: Clipper will not return zero chars from this functions. */
hb_retc_buffer( ( char * ) buffer );
}
else
hb_retc( NULL );
}
else
hb_retc( NULL );
hb_fsSetFError( uiError );
}
/* NOTE: This function should not return the leading and trailing */
| philes.c | 222 |
| HB_FUNC | CURDIR(void)
HB_FUNC( CURDIR )
{
BYTE byBuffer[ _POSIX_PATH_MAX + 1 ];
hb_fsCurDirBuff( ( ISCHAR( 1 ) && hb_parclen( 1 ) > 0 ) ?
( USHORT )( toupper( *hb_parc( 1 ) ) - 'A' + 1 ) : 0, byBuffer, _POSIX_PATH_MAX + 1 );
hb_retc( ( char * ) byBuffer );
}
| philes.c | 256 |
| HB_FUNC | HB_FEOF(void)
HB_FUNC( HB_FEOF )
{
USHORT uiError = 6;
if( ISNUM( 1 ) )
{
hb_retl( hb_fsEof( hb_numToHandle( hb_parnint( 1 ) ) ) );
uiError = hb_fsError();
}
else
hb_retl( TRUE );
hb_fsSetFError( uiError );
}
| philes.c | 266 |
| HB_FUNC | HB_FCOMMIT(void)
HB_FUNC( HB_FCOMMIT )
{
USHORT uiError = 6;
if( ISNUM( 1 ) )
{
hb_fsCommit( hb_numToHandle( hb_parnint( 1 ) ) );
uiError = hb_fsError();
}
hb_fsSetFError( uiError );
}
| philes.c | 280 |
| HB_FUNC | HB_OSERROR(void)
HB_FUNC( HB_OSERROR )
{
hb_retni( hb_fsOsError() );
}
| philes.c | 293 |
| HB_FUNC | HB_OSPATHSEPARATOR(void)
HB_FUNC( HB_OSPATHSEPARATOR )
{
const char ret[ 2 ] = { HB_OS_PATH_DELIM_CHR, 0 };
hb_retc( ret );
}
| philes.c | 298 |
| HB_FUNC | HB_OSPATHLISTSEPARATOR(void)
HB_FUNC( HB_OSPATHLISTSEPARATOR )
{
const char ret[ 2 ] = { HB_OS_PATH_LIST_SEP_CHR, 0 };
hb_retc( ret );
}
| philes.c | 304 |
| HB_FUNC | HB_OSPATHDELIMITERS(void)
HB_FUNC( HB_OSPATHDELIMITERS )
{
hb_retc( HB_OS_PATH_DELIM_CHR_LIST );
}
| philes.c | 310 |
| HB_FUNC | HB_OSDRIVESEPARATOR(void)
HB_FUNC( HB_OSDRIVESEPARATOR )
{
#ifdef HB_OS_HAS_DRIVE_LETTER
const char ret[ 2 ] = { HB_OS_DRIVE_DELIM_CHR, 0 };
hb_retc( ret );
#else
hb_retc( NULL );
#endif
}
| philes.c | 315 |
| HB_FUNC | HB_OSFILEMASK(void)
HB_FUNC( HB_OSFILEMASK )
{
hb_retc( HB_OS_ALLFILE_MASK );
}
| philes.c | 325 |
| philes53.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | FSETDEVMOD(void)
HB_FUNC( FSETDEVMOD )
{
/* C53 checks only number of parameters: hb_pcount() == 2 */
if( ISNUM( 1 ) && ISNUM( 2 ) )
{
hb_fsSetDevMode( hb_numToHandle( hb_parnint( 1 ) ), ( USHORT ) hb_parni( 2 ) );
hb_fsSetFError( hb_fsError() );
}
/* NOTE: INCOMPATIBILITY! C53 will return the device flags
before applying the new setting, Harbour will
always return 0. [vszakats] */
hb_retni( 0 );
}
| philes53.c | 60 |
| philesx.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | CURDRIVE(void)
HB_FUNC( CURDRIVE )
{
char szDrive[ 1 ];
szDrive[ 0 ] = ( ( char ) hb_fsCurDrv() ) + 'A';
hb_retclen( szDrive, 1 );
if( ISCHAR( 1 ) && hb_parclen( 1 ) > 0 )
{
while( hb_fsChDrv( ( BYTE )( toupper( *hb_parc( 1 ) ) - 'A' ) ) != 0 )
{
USHORT uiAction = hb_errRT_BASE_Ext1( EG_OPEN, 6001, "Operating system error", HB_ERR_FUNCNAME, 0, EF_CANDEFAULT | EF_CANRETRY, HB_ERR_ARGS_BASEPARAMS );
if( uiAction != E_RETRY )
break;
}
}
}
| philesx.c | 63 |
| rat.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | RAT(void)
HB_FUNC( RAT )
{
ULONG ulSubLen = hb_parclen( 1 );
if( ulSubLen )
{
long lPos = hb_parclen( 2 ) - ulSubLen;
if( lPos >= 0 )
{
char * pszSub = hb_parc( 1 );
char * pszText = hb_parc( 2 );
BOOL bFound = FALSE;
while( lPos >= 0 && !bFound )
{
if( *( pszText + lPos ) == *pszSub )
bFound = ( memcmp( pszSub, pszText + lPos, ulSubLen ) == 0 );
lPos--;
}
hb_retnl( bFound ? lPos + 2 : 0 );
}
else
hb_retni( 0 );
}
else
/* This function never seems to raise an error */
hb_retni( 0 );
}
| rat.c | 55 |
| replic.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | REPLICATE(void)
HB_FUNC( REPLICATE )
{
if( ISCHAR( 1 ) && ISNUM( 2 ) )
{
long lTimes = hb_parnl( 2 );
if( lTimes > 0 )
{
ULONG ulLen = hb_parclen( 1 );
if( ( double ) ( ( double ) ulLen * ( double ) lTimes ) < ( double ) ULONG_MAX )
{
char * szText = hb_parc( 1 );
char * szResult = ( char * ) hb_xgrab( ( ulLen * lTimes ) + 1 );
char * szPtr = szResult;
long i;
for( i = 0; i < lTimes; i++ )
{
hb_xmemcpy( szPtr, szText, ulLen );
szPtr += ulLen;
}
hb_retclen_buffer( szResult, ulLen * lTimes );
}
else
hb_errRT_BASE_SubstR( EG_STROVERFLOW, 1234, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1106, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| replic.c | 59 |
| right.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | RIGHT(void)
HB_FUNC( RIGHT )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText && ISNUM( 2 ) )
{
long lLen = hb_parnl( 2 );
if( lLen <= 0 )
hb_retc( NULL );
else
{
ULONG ulText = hb_itemGetCLen( pText );
if( ( ULONG ) lLen >= ulText )
hb_itemReturn( pText );
else
hb_retclen( hb_itemGetCPtr( pText ) + ulText - lLen, lLen );
}
}
else
hb_retc( NULL ); /* Clipper doesn't error */
}
| right.c | 59 |
| round.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | INT(void)
HB_FUNC( INT )
{
PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC );
if( pNumber )
{
if( HB_IS_NUMINT( pNumber ) )
hb_itemReturn( pNumber );
else
{
int iWidth;
hb_itemGetNLen( pNumber, &iWidth, NULL );
hb_retnlen( hb_numInt( hb_itemGetND( pNumber ) ), iWidth, 0 );
}
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1090, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| round.c | 73 |
| HB_FUNC | ROUND(void)
HB_FUNC( ROUND )
{
PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC );
if( pNumber && ISNUM( 2 ) )
{
int iDec = hb_parni( 2 );
#ifdef HB_C52_STRICT
/* In CA-Cl*pper ROUND() always returns double item, what in some
* applications may be important due to different formatting rules
* when SET FIXED is ON [druzus]
*/
hb_retndlen( hb_numRound( hb_itemGetND( pNumber ), iDec ), 0, HB_MAX( iDec, 0 ) );
#else
if( iDec == 0 && HB_IS_NUMINT( pNumber ) )
hb_retnint( hb_itemGetNInt( pNumber ) );
else
hb_retnlen( hb_numRound( hb_itemGetND( pNumber ), iDec ), 0, HB_MAX( iDec, 0 ) );
#endif
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1094, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| round.c | 93 |
| run.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | __RUN(void)
HB_FUNC( __RUN )
{
if( ISCHAR( 1 ) && hb_gtSuspend() == 0 )
{
system( hb_parc( 1 ) );
if( hb_gtResume() != 0 )
{
/* an error should be generated here !! Something like */
/* hb_errRT_BASE_Ext1( EG_GTRESUME, 6002, NULL, HB_ERR_FUNCNAME, 0, EF_CANDEFAULT ); */
}
}
}
| run.c | 60 |
| samples.c |
| Type | Function | Source | Line |
|---|
| STATIC CHAR * | hb_SecToTimeStr( char * pszTime, ULONG ulTime )
static char * hb_SecToTimeStr( char * pszTime, ULONG ulTime )
{
USHORT uiValue;
HB_TRACE(HB_TR_DEBUG, ("hb_SecToTimeStr(%s, %lu)", pszTime, ulTime));
uiValue = ( USHORT ) ( ( ulTime / 3600 ) % 24 );
pszTime[ 0 ] = ( char ) ( uiValue / 10 ) + '0';
pszTime[ 1 ] = ( char ) ( uiValue % 10 ) + '0';
pszTime[ 2 ] = ':';
uiValue = ( USHORT ) ( ( ulTime / 60 ) % 60 );
pszTime[ 3 ] = ( char ) ( uiValue / 10 ) + '0';
pszTime[ 4 ] = ( char ) ( uiValue % 10 ) + '0';
pszTime[ 5 ] = ':';
uiValue = ( USHORT ) ( ulTime % 60 );
pszTime[ 6 ] = ( char ) ( uiValue / 10 ) + '0';
pszTime[ 7 ] = ( char ) ( uiValue % 10 ) + '0';
pszTime[ 8 ] = '\0';
return pszTime;
}
| samples.c | 57 |
| STATIC ULONG | hb_TimeStrToSec( char * pszTime )
static ULONG hb_TimeStrToSec( char * pszTime )
{
ULONG ulLen;
ULONG ulTime = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_TimeStrToSec(%s)", pszTime));
ulLen = strlen( pszTime );
if( ulLen >= 1 )
ulTime += ( ULONG ) hb_strVal( pszTime, ulLen ) * 3600;
if( ulLen >= 4 )
ulTime += ( ULONG ) hb_strVal( pszTime + 3, ulLen - 3 ) * 60;
if( ulLen >= 7 )
ulTime += ( ULONG ) hb_strVal( pszTime + 6, ulLen - 6 );
return ulTime;
}
| samples.c | 79 |
| HB_FUNC | DAYS(void)
HB_FUNC( DAYS )
{
hb_retnl( hb_parnl( 1 ) / 86400 );
}
| samples.c | 100 |
| HB_FUNC | ELAPTIME(void)
HB_FUNC( ELAPTIME )
{
ULONG ulStart = hb_TimeStrToSec( hb_parcx( 1 ) );
ULONG ulEnd = hb_TimeStrToSec( hb_parcx( 2 ) );
char szTime[ 9 ];
hb_retc( hb_SecToTimeStr( szTime, ( ulEnd < ulStart ? 86400 : 0 ) + ulEnd - ulStart ) );
}
| samples.c | 105 |
| HB_FUNC | SECS(void)
HB_FUNC( SECS )
{
hb_retnl( hb_TimeStrToSec( hb_parcx( 1 ) ) );
}
| samples.c | 114 |
| HB_FUNC | TSTRING(void)
HB_FUNC( TSTRING )
{
char szTime[ 9 ];
hb_retc( hb_SecToTimeStr( szTime, hb_parnl( 1 ) ) );
}
| samples.c | 119 |
| saverest.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_getScreenRange( USHORT * pusMin, USHORT * pusMax, BOOL fNoCheck, BOOL fVertical )
static void hb_getScreenRange( USHORT * pusMin, USHORT * pusMax,
BOOL fNoCheck, BOOL fVertical )
{
int iFrom, iTo, iMax;
if( fVertical )
{
iMax = hb_gtMaxRow();
iFrom = hb_parni( 1 );
iTo = ISNUM( 3 ) ? hb_parni( 3 ) : iMax;
}
else
{
iMax = hb_gtMaxCol();
iFrom = hb_parni( 2 );
iTo = ISNUM( 4 ) ? hb_parni( 4 ) : iMax;
}
if( iFrom < 0 )
iFrom = 0;
else if( iFrom > iMax && !fNoCheck )
iFrom = iMax;
if( iTo < 0 )
iTo = 0;
else if( iTo > iMax && !fNoCheck )
iTo = iMax;
if( iFrom > iTo )
{
*pusMin = ( USHORT ) iTo;
*pusMax = ( USHORT ) iFrom;
}
else
{
*pusMin = ( USHORT ) iFrom;
*pusMax = ( USHORT ) iTo;
}
}
| saverest.c | 56 |
| HB_FUNC | SAVESCREEN(void)
HB_FUNC( SAVESCREEN )
{
USHORT uiTop, uiLeft, uiBottom, uiRight;
ULONG ulSize;
void * pBuffer;
#if defined( HB_EXTENSION )
BOOL fNoCheck = hb_parl( 5 );
#else
BOOL fNoCheck = FALSE;
#endif
hb_getScreenRange( &uiTop, &uiBottom, fNoCheck, TRUE );
hb_getScreenRange( &uiLeft, &uiRight, fNoCheck, FALSE );
hb_gtRectSize( uiTop, uiLeft, uiBottom, uiRight, &ulSize );
pBuffer = hb_xgrab( ulSize + 1 );
hb_gtSave( uiTop, uiLeft, uiBottom, uiRight, pBuffer );
hb_retclen_buffer( ( char * ) pBuffer, ulSize );
}
| saverest.c | 96 |
| HB_FUNC | RESTSCREEN(void)
HB_FUNC( RESTSCREEN )
{
if( ISCHAR( 5 ) )
{
USHORT uiTop, uiLeft, uiBottom, uiRight;
#if defined( HB_EXTENSION )
BOOL fNoCheck = hb_parl( 6 );
#else
BOOL fNoCheck = FALSE;
#endif
hb_getScreenRange( &uiTop, &uiBottom, fNoCheck, TRUE );
hb_getScreenRange( &uiLeft, &uiRight, fNoCheck, FALSE );
hb_gtRest( uiTop, uiLeft, uiBottom, uiRight, ( void * ) hb_parc( 5 ) );
}
}
| saverest.c | 117 |
| scroll.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | SCROLL(void)
HB_FUNC( SCROLL )
{
int iMaxRow = hb_gtMaxRow();
int iMaxCol = hb_gtMaxCol();
int iTop;
int iLeft;
int iBottom;
int iRight;
/* Enforce limits of (0,0) to (MAXROW(),MAXCOL()) */
iTop = hb_parni( 1 ); /* Defaults to zero on bad type */
if( iTop < 0 )
iTop = 0;
else if( iTop > iMaxRow )
iTop = iMaxRow;
iLeft = hb_parni( 2 ); /* Defaults to zero on bad type */
if( iLeft < 0 )
iLeft = 0;
else if( iLeft > iMaxCol )
iLeft = iMaxCol;
if( ISNUM( 3 ) )
{
iBottom = hb_parni( 3 );
if( iBottom < 0 )
iBottom = 0;
else if( iBottom > iMaxRow )
iBottom = iMaxRow;
}
else
iBottom = iMaxRow;
if( ISNUM( 4 ) )
{
iRight = hb_parni( 4 );
if( iRight < 0 )
iRight = 0;
else if( iRight > iMaxCol )
iRight = iMaxCol;
}
else
iRight = iMaxCol;
hb_gtScroll( ( USHORT ) iTop,
( USHORT ) iLeft,
( USHORT ) iBottom,
( USHORT ) iRight,
( SHORT ) hb_parni( 5 ), /* Defaults to zero on bad type */
( SHORT ) hb_parni( 6 ) ); /* Defaults to zero on bad type */
}
| scroll.c | 58 |
| scrrow.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_SCRMAXROW(void)
HB_FUNC( HB_SCRMAXROW ) /* Return the maximum screen row number (zero origin) */
{
USHORT uiRows, uiCols;
hb_gtScrDim( &uiRows, &uiCols );
hb_retni( uiRows - 1 );
}
| scrrow.c | 66 |
| HB_FUNC | HB_SCRMAXCOL(void)
HB_FUNC( HB_SCRMAXCOL ) /* Return the maximum screen column number (zero origin) */
{
USHORT uiRows, uiCols;
hb_gtScrDim( &uiRows, &uiCols );
hb_retni( uiCols - 1 );
}
| scrrow.c | 73 |
| secondfs.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | SECONDSCPU(void)
HB_FUNC( SECONDSCPU )
{
hb_retnd( hb_secondsCPU( hb_parni( 1 ) ) );
}
| secondfs.c | 58 |
| seconds.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT VOID | hb_dateTimeStamp( LONG * plJulian, LONG * plMilliSec )
HB_EXPORT void hb_dateTimeStamp( LONG * plJulian, LONG * plMilliSec )
{
#if defined(HB_OS_WIN_32)
SYSTEMTIME st;
HB_TRACE(HB_TR_DEBUG, ("hb_dateTimeStamp(%p,%p)", plJulian, plMilliSec));
GetLocalTime( &st );
*plJulian = hb_dateEncode( st.wYear, st.wMonth, st.wDay );
*plMilliSec = ( ( st.wHour * 60 + st.wMinute ) * 60 + st.wSecond ) * 1000 +
st.wMilliseconds;
#elif defined( HB_OS_LINUX ) && !defined( __WATCOMC__ )
struct timeval tv;
struct tm st;
time_t seconds;
HB_TRACE(HB_TR_DEBUG, ("hb_dateTimeStamp(%p,%p)", plJulian, plMilliSec));
gettimeofday( &tv, NULL );
seconds = tv.tv_sec;
localtime_r( &seconds, &st );
*plJulian = hb_dateEncode( st.tm_year + 1900, st.tm_mon + 1, st.tm_mday );
*plMilliSec = ( ( st.tm_hour * 60 + st.tm_min ) * 60 + st.tm_sec ) * 1000 +
tv.tv_usec / 1000;
#elif defined( HB_OS_BSD )
struct timeval tv;
struct tm * st;
time_t seconds;
HB_TRACE(HB_TR_DEBUG, ("hb_dateTimeStamp(%p,%p)", plJulian, plMilliSec));
gettimeofday( &tv, NULL );
seconds = tv.tv_sec;
st = localtime( &seconds );
*plJulian = hb_dateEncode( st->tm_year + 1900, st->tm_mon + 1, st->tm_mday );
*plMilliSec = ( ( st->tm_hour * 60 + st->tm_min ) * 60 + st->tm_sec ) * 1000 +
tv.tv_usec / 1000.0;
#else
struct timeb tb;
struct tm * st;
time_t seconds;
HB_TRACE(HB_TR_DEBUG, ("hb_dateTimeStamp(%p,%p)", plJulian, plMilliSec));
ftime( &tb );
seconds = tb.time;
st = localtime( &seconds );
*plJulian = hb_dateEncode( st->tm_year + 1900, st->tm_mon + 1, st->tm_mday );
*plMilliSec = ( ( st->tm_hour * 60 + st->tm_min ) * 60 + st->tm_sec ) * 1000 +
tb.millitm;
#endif
}
| seconds.c | 76 |
| HB_EXPORT HB_ULONG | hb_dateMilliSeconds( void )
HB_EXPORT HB_ULONG hb_dateMilliSeconds( void )
{
#if defined(HB_OS_WIN_32)
SYSTEMTIME st;
HB_TRACE(HB_TR_DEBUG, ("hb_dateMilliSeconds()"));
GetLocalTime( &st );
return ( HB_ULONG ) hb_dateEncode( st.wYear, st.wMonth, st.wDay ) * 86400000L +
( ( st.wHour * 60 + st.wMinute ) * 60 + st.wSecond ) * 1000 +
st.wMilliseconds;
#elif ( defined( HB_OS_LINUX ) || defined( HB_OS_BSD ) ) && !defined( __WATCOMC__ )
struct timeval tv;
HB_TRACE(HB_TR_DEBUG, ("hb_dateMilliSeconds()"));
gettimeofday( &tv, NULL );
return ( HB_ULONG ) tv.tv_sec * 1000 + tv.tv_usec / 1000;
#else
struct timeb tb;
HB_TRACE(HB_TR_DEBUG, ("hb_dateMilliSeconds()"));
ftime( &tb );
return ( HB_ULONG ) tb.time * 1000 + tb.millitm;
#endif
}
| seconds.c | 131 |
| HB_EXPORT DOUBLE | hb_dateSeconds( void )
HB_EXPORT double hb_dateSeconds( void )
{
#if defined(HB_OS_WIN_32)
SYSTEMTIME SystemTime;
HB_TRACE(HB_TR_DEBUG, ("hb_dateSeconds()"));
GetLocalTime( &SystemTime );
return ( SystemTime.wHour * 3600 ) +
( SystemTime.wMinute * 60 ) +
SystemTime.wSecond +
( ( double ) SystemTime.wMilliseconds / 1000.0 );
#elif defined( HB_OS_LINUX ) && !defined( __WATCOMC__ )
struct timeval tv;
struct tm oTime;
time_t seconds;
HB_TRACE(HB_TR_DEBUG, ("hb_dateSeconds()"));
gettimeofday( &tv, NULL );
seconds = tv.tv_sec;
localtime_r( &seconds, &oTime );
return ( oTime.tm_hour * 3600 ) +
( oTime.tm_min * 60 ) +
oTime.tm_sec +
( ( double ) tv.tv_usec / 1000000.0 );
#elif defined( HB_OS_BSD )
struct timeval tv;
struct tm * oTime;
time_t seconds;
HB_TRACE(HB_TR_DEBUG, ("hb_dateSeconds()"));
gettimeofday( &tv, NULL );
seconds = tv.tv_sec;
oTime = localtime( &seconds );
return ( oTime->tm_hour * 3600 ) +
( oTime->tm_min * 60 ) +
oTime->tm_sec +
( ( double ) tv.tv_usec / 1000000.0 );
#else
struct timeb tb;
struct tm * oTime;
time_t seconds;
HB_TRACE(HB_TR_DEBUG, ("hb_dateSeconds()"));
ftime( &tb );
seconds = tb.time;
oTime = localtime( &seconds );
return ( oTime->tm_hour * 3600 ) +
( oTime->tm_min * 60 ) +
oTime->tm_sec +
( ( double ) tb.millitm / 1000.0 );
#endif
}
| seconds.c | 162 |
| HB_FUNC | SECONDS(void)
HB_FUNC( SECONDS )
{
hb_retnd( hb_dateSeconds() );
}
| seconds.c | 221 |
| HB_FUNC | HB_CLOCKS2SECS(void)
HB_FUNC( HB_CLOCKS2SECS )
{
#ifdef CLOCKS_PER_SEC
hb_retnd( ( double ) hb_parnint( 1 ) / CLOCKS_PER_SEC );
#else
hb_retnd( ( double ) hb_parnint( 1 ) / 1000 );
#endif
}
| seconds.c | 226 |
| HB_EXPORT DOUBLE | hb_secondsCPU( int n )
HB_EXPORT double hb_secondsCPU( int n )
{
double d = 0.0;
#if defined( HB_OS_WIN_32 ) && !defined( HB_OS_UNIX_COMPATIBLE )
FILETIME Create, Exit, Kernel, User;
#endif
if( ( n < 1 || n > 3 ) && ( n < 11 || n > 13 ) )
n = 3;
#if defined( HB_OS_UNIX_COMPATIBLE )
{
struct tms tm;
times(&tm);
if( n > 10 )
{
n -= 10;
if( n & 1 )
d += tm.tms_cutime;
if( n & 2 )
d += tm.tms_cstime;
}
if( n & 1 )
d += tm.tms_utime;
if( n & 2 )
d += tm.tms_stime;
/* In POSIX-1996 the CLK_TCK symbol is mentioned as obsolescent */
/* d /= CLK_TCK; */
d /= (double) sysconf(_SC_CLK_TCK);
}
#else
if( n > 10 )
n -= 10;
#if defined( HB_OS_WIN_32 )
if( hb_iswinnt() &&
GetProcessTimes( GetCurrentProcess(), &Create, &Exit, &Kernel, &User ) )
{
if( n & 1 )
{
d += ( double ) ( ( ( HB_LONG ) User.dwHighDateTime << 32 ) +
( HB_LONG ) User.dwLowDateTime );
}
if( n & 2 )
{
d += ( double ) ( ( ( HB_LONG ) Kernel.dwHighDateTime << 32 ) +
( HB_LONG ) Kernel.dwLowDateTime );
}
d /= 10000000.0;
}
else
#endif
{
/* TODO: this code is only for DOS and other platforms which cannot
calculate process time */
if( n & 1 )
d = hb_dateSeconds( );
}
#endif
return d;
}
| seconds.c | 235 |
| setcolor.c |
| Type | Function | Source | Line |
|---|
| CHAR * | hb_conSetColor( const char * szColor )
char * hb_conSetColor( const char * szColor )
{
char * szOldColor;
HB_TRACE(HB_TR_DEBUG, ("hb_conSetColor(%s)", szColor));
szOldColor = hb_setGetColor();
hb_gtGetColorStr( szOldColor );
if( szColor != ( char * ) NULL )
hb_gtSetColorStr( szColor );
return szOldColor;
}
| setcolor.c | 57 |
| HB_FUNC | SETCOLOR(void)
HB_FUNC( SETCOLOR )
{
hb_retc( hb_conSetColor( hb_parc( 1 ) ) );
}
| setcolor.c | 72 |
| HB_FUNC | COLORSELECT(void)
HB_FUNC( COLORSELECT )
{
if( ISNUM( 1 ) )
hb_gtColorSelect( ( USHORT ) hb_parni( 1 ) );
}
| setcolor.c | 77 |
| HB_FUNC | SETBLINK(void)
HB_FUNC( SETBLINK )
{
BOOL bPreviousBlink;
hb_gtGetBlink( &bPreviousBlink );
if( ISLOG( 1 ) )
hb_gtSetBlink( hb_parl( 1 ) );
hb_retl( bPreviousBlink );
}
| setcolor.c | 83 |
| HB_FUNC | HB_COLORTON(void)
HB_FUNC( HB_COLORTON )
{
if( ISCHAR( 1 ) )
hb_retni( hb_gtColorToN( hb_parc( 1 ) ) );
else
hb_retni( 0 );
}
| setcolor.c | 95 |
| HB_FUNC | HB_NTOCOLOR(void)
HB_FUNC( HB_NTOCOLOR )
{
if( ISNUM( 1 ) )
{
char szColorString[ 10 ];
int colors[ 1 ];
colors[ 0 ] = hb_parni( 1 );
hb_gtColorsToString( colors, 1, szColorString, 10 );
hb_retc( szColorString );
}
else
hb_retc( "N/N" );
}
| setcolor.c | 103 |
| setcurs.c |
| Type | Function | Source | Line |
|---|
| USHORT | hb_conSetCursor( BOOL bSetCursor, USHORT uiNewCursor )
USHORT hb_conSetCursor( BOOL bSetCursor, USHORT uiNewCursor )
{
USHORT uiCursor;
HB_TRACE(HB_TR_DEBUG, ("hb_conSetCursor(%d, %hu)", (int) bSetCursor, uiNewCursor));
hb_gtGetCursor( &uiCursor );
if( bSetCursor )
hb_gtSetCursor( uiNewCursor );
return uiCursor;
}
| setcurs.c | 56 |
| HB_FUNC | SETCURSOR(void)
HB_FUNC( SETCURSOR )
{
USHORT uiCursor;
hb_gtGetCursor( &uiCursor );
hb_retni( uiCursor );
if( ISNUM( 1 ) )
hb_gtSetCursor( ( USHORT ) hb_parni( 1 ) );
}
| setcurs.c | 70 |
| setkey.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_setkeyRelease( void * cargo )
static void hb_setkeyRelease( void * cargo )
{
PHB_SETKEY sk_list = ( ( PHB_SK_DATA ) cargo )->sk_list;
while( sk_list )
{
PHB_SETKEY sk_list_tmp;
hb_itemRelease( sk_list->pAction );
if( sk_list->pIsActive )
hb_itemRelease( sk_list->pIsActive );
sk_list_tmp = sk_list;
sk_list = sk_list->next;
hb_xfree( ( void * ) sk_list_tmp );
}
( ( PHB_SK_DATA ) cargo )->sk_list = NULL;
}
static HB_TSD_NEW( s_skData, sizeof( HB_SK_DATA ), NULL, hb_setkeyRelease );
| setkey.c | 78 |
| STATIC PHB_SETKEY | sk_findkey( int iKeyCode, PHB_SETKEY sk_list, PHB_SETKEY * sk_list_end )
static PHB_SETKEY sk_findkey( int iKeyCode, PHB_SETKEY sk_list,
PHB_SETKEY * sk_list_end )
{
PHB_SETKEY sk_list_tmp;
*sk_list_end = NULL;
for( sk_list_tmp = sk_list;
sk_list_tmp && sk_list_tmp->iKeyCode != iKeyCode;
sk_list_tmp = sk_list_tmp->next )
*sk_list_end = sk_list_tmp;
return sk_list_tmp;
}
| setkey.c | 99 |
| STATIC VOID | sk_add( PHB_SETKEY * sk_list_ptr, BOOL bReturn, int iKeyCode, PHB_ITEM pAction, PHB_ITEM pIsActive )
static void sk_add( PHB_SETKEY * sk_list_ptr, BOOL bReturn,
int iKeyCode, PHB_ITEM pAction, PHB_ITEM pIsActive )
{
if( iKeyCode )
{
PHB_SETKEY sk_list_tmp, sk_list_end;
if( pIsActive && !HB_IS_BLOCK( pIsActive ) )
pIsActive = NULL;
if( pAction && !HB_IS_BLOCK( pAction ) )
pAction = NULL;
sk_list_tmp = sk_findkey( iKeyCode, *sk_list_ptr, &sk_list_end );
if( sk_list_tmp == NULL )
{
if( pAction )
{
sk_list_tmp = ( PHB_SETKEY ) hb_xgrab( sizeof( HB_SETKEY ) );
sk_list_tmp->next = NULL;
sk_list_tmp->iKeyCode = iKeyCode;
sk_list_tmp->pAction = hb_itemNew( pAction );
sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL;
if( sk_list_end == NULL )
*sk_list_ptr = sk_list_tmp;
else
sk_list_end->next = sk_list_tmp;
}
}
else
{
/* Return the previous value */
if( bReturn )
hb_itemReturn( sk_list_tmp->pAction );
/* Free the previous values */
hb_itemRelease( sk_list_tmp->pAction );
if( sk_list_tmp->pIsActive )
{
hb_itemRelease( sk_list_tmp->pIsActive );
}
/* Set the new values or free the entry */
if( pAction )
{
sk_list_tmp->pAction = hb_itemNew( pAction );
sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL;
}
else
{
/* if this is true, then the key found is the first key in the list */
if( sk_list_end == NULL )
{
sk_list_tmp = *sk_list_ptr;
*sk_list_ptr = sk_list_tmp->next;
hb_xfree( sk_list_tmp );
}
else
{
sk_list_end->next = sk_list_tmp->next;
hb_xfree( sk_list_tmp );
}
}
}
}
}
| setkey.c | 113 |
| HB_FUNC | SETKEY(void)
HB_FUNC( SETKEY )
{
PHB_ITEM pKeyCode = hb_param( 1, HB_IT_NUMERIC );
if( pKeyCode )
{
PHB_SK_DATA sk_data = ( PHB_SK_DATA ) hb_stackGetTSD( &s_skData );
if( hb_pcount() == 1 )
{
/* Get a SETKEY value */
PHB_SETKEY sk_list_tmp, sk_list_end;
/* sk_list_end is not used in this context */
sk_list_tmp = sk_findkey( hb_itemGetNI( pKeyCode ), sk_data->sk_list, &sk_list_end );
if( sk_list_tmp )
{
#if defined( HB_EXTENSION )
PHB_ITEM pIsActiveResults = sk_list_tmp->pIsActive ? hb_vmEvalBlockV( sk_list_tmp->pIsActive, 1, pKeyCode ) : NULL;
if( pIsActiveResults == NULL || ! HB_IS_LOGICAL( pIsActiveResults ) || hb_itemGetL( pIsActiveResults ) )
#endif
hb_itemReturn( sk_list_tmp->pAction );
}
}
else
{
/* Set a SETKEY value */
#if defined( HB_EXTENSION )
sk_add( &sk_data->sk_list, TRUE, hb_itemGetNI( pKeyCode ),
hb_param( 2, HB_IT_BLOCK ), hb_param( 3, HB_IT_BLOCK ) );
#else
sk_add( &sk_data->sk_list, TRUE, hb_itemGetNI( pKeyCode ),
hb_param( 2, HB_IT_BLOCK ), NULL );
#endif
}
}
}
| setkey.c | 182 |
| HB_FUNC | HB_SETKEYARRAY(void)
HB_FUNC( HB_SETKEYARRAY )
{
PHB_ITEM pKeyCodeArray = hb_param( 1, HB_IT_ARRAY );
PHB_ITEM pAction = hb_param( 2, HB_IT_BLOCK );
if( pKeyCodeArray && pAction )
{
PHB_SK_DATA sk_data = ( PHB_SK_DATA ) hb_stackGetTSD( &s_skData );
PHB_ITEM pIsActive = hb_param( 3, HB_IT_BLOCK );
ULONG nLen = hb_arrayLen( pKeyCodeArray );
ULONG nPos;
for( nPos = 1; nPos <= nLen; nPos++ )
sk_add( &sk_data->sk_list, FALSE, hb_arrayGetNI( pKeyCodeArray, nPos ), pAction, pIsActive );
}
}
| setkey.c | 224 |
| HB_FUNC | HB_SETKEYGET(void)
HB_FUNC( HB_SETKEYGET )
{
PHB_ITEM pKeyCode = hb_param( 1, HB_IT_NUMERIC );
if( pKeyCode )
{
PHB_SK_DATA sk_data = ( PHB_SK_DATA ) hb_stackGetTSD( &s_skData );
PHB_SETKEY sk_list_tmp, sk_list_end;
/* sk_list_end is not used in this context */
sk_list_tmp = sk_findkey( hb_itemGetNI( pKeyCode ), sk_data->sk_list, &sk_list_end );
if( sk_list_tmp )
{
PHB_ITEM pIsActive = hb_param( 2, HB_IT_ANY );
hb_itemReturn( sk_list_tmp->pAction );
if( pIsActive )
hb_itemCopy( pIsActive, sk_list_tmp->pIsActive );
}
}
}
| setkey.c | 241 |
| HB_FUNC | HB_SETKEYSAVE(void)
HB_FUNC( HB_SETKEYSAVE )
{
PHB_SK_DATA sk_data = ( PHB_SK_DATA ) hb_stackGetTSD( &s_skData );
PHB_ITEM pKeys, pKeyElements, pParam;
PHB_SETKEY sk_list_tmp;
ULONG itemcount, nitem;
/* build an multi-dimensional array from existing hot-keys, and return it */
/* count the number of items in the list */
for( itemcount = 0, sk_list_tmp = sk_data->sk_list;
sk_list_tmp;
itemcount++, sk_list_tmp = sk_list_tmp->next )
;
pKeys = hb_itemArrayNew( itemcount );
pKeyElements = hb_itemNew( NULL );
for( nitem = 1, sk_list_tmp = sk_data->sk_list;
nitem <= itemcount;
nitem++, sk_list_tmp = sk_list_tmp->next )
{
hb_arrayNew( pKeyElements, 3 );
hb_arraySetNI( pKeyElements, 1, sk_list_tmp->iKeyCode );
hb_arraySet( pKeyElements, 2, sk_list_tmp->pAction );
if( sk_list_tmp->pIsActive )
hb_arraySet( pKeyElements, 3, sk_list_tmp->pIsActive );
hb_arraySetForward( pKeys, nitem, pKeyElements );
}
hb_itemRelease( pKeyElements );
hb_itemReturnRelease( pKeys );
pParam = hb_param( 1, HB_IT_ANY );
if( pParam )
{
hb_setkeyRelease( sk_data ); /* destroy the internal list */
if( HB_IS_ARRAY( pParam ) )
{
itemcount = hb_arrayLen( pParam );
for( nitem = 1; nitem <= itemcount; nitem++ )
{
PHB_ITEM itmKeyElements = hb_arrayGetItemPtr( pParam, nitem );
sk_add( &sk_data->sk_list, FALSE,
hb_arrayGetNI( itmKeyElements, 1 ),
hb_arrayGetItemPtr( itmKeyElements, 2 ),
hb_arrayGetItemPtr( itmKeyElements, 3 ) );
}
}
}
}
| setkey.c | 265 |
| HB_FUNC | HB_SETKEYCHECK(void)
HB_FUNC( HB_SETKEYCHECK )
{
PHB_ITEM pKeyCode = hb_param( 1, HB_IT_NUMERIC );
BOOL bIsKeySet = FALSE;
if( pKeyCode )
{
PHB_SK_DATA sk_data = ( PHB_SK_DATA ) hb_stackGetTSD( &s_skData );
PHB_SETKEY sk_list_tmp, sk_list_end;
/* sk_list_end is not used in this context */
sk_list_tmp = sk_findkey( hb_itemGetNI( pKeyCode ), sk_data->sk_list, &sk_list_end );
if( sk_list_tmp )
{
PHB_ITEM pIsActiveResults = sk_list_tmp->pIsActive ? hb_vmEvalBlockV( sk_list_tmp->pIsActive, 1, pKeyCode ) : NULL;
if( pIsActiveResults == NULL || ! HB_IS_LOGICAL( pIsActiveResults ) || hb_itemGetL( pIsActiveResults ) )
{
bIsKeySet = TRUE;
switch( hb_pcount() )
{
case 1: hb_vmEvalBlockV( sk_list_tmp->pAction, 1, pKeyCode ); break;
case 2: hb_vmEvalBlockV( sk_list_tmp->pAction, 2, hb_param( 2, HB_IT_ANY ), pKeyCode ); break;
case 3: hb_vmEvalBlockV( sk_list_tmp->pAction, 3, hb_param( 2, HB_IT_ANY ), hb_param( 3, HB_IT_ANY ), pKeyCode ); break;
default: hb_vmEvalBlockV( sk_list_tmp->pAction, 4, hb_param( 2, HB_IT_ANY ), hb_param( 3, HB_IT_ANY ), hb_param( 4, HB_IT_ANY ), pKeyCode ); break;
}
}
}
}
hb_retl( bIsKeySet );
}
| setkey.c | 319 |
| setpos.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | SETPOS(void)
HB_FUNC( SETPOS ) /* Sets the screen position */
{
if( ISNUM( 1 ) && ISNUM( 2 ) )
hb_gtSetPos( ( SHORT ) hb_parni( 1 ), ( SHORT ) hb_parni( 2 ) );
}
| setpos.c | 67 |
| HB_FUNC | ROW(void)
HB_FUNC( ROW ) /* Return the current screen row position (zero origin) */
{
SHORT iRow;
SHORT iCol;
hb_gtGetPos( &iRow, &iCol );
hb_retni( iRow );
}
| setpos.c | 73 |
| HB_FUNC | COL(void)
HB_FUNC( COL ) /* Return the current screen column position (zero origin) */
{
SHORT iRow;
SHORT iCol;
hb_gtGetPos( &iRow, &iCol );
hb_retni( iCol );
}
| setpos.c | 83 |
| setposbs.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | SETPOSBS(void)
HB_FUNC( SETPOSBS ) /* Move the screen position to the right by one column */
{
SHORT iRow;
SHORT iCol;
/* NOTE: CA-Cl*pper does no checks about reaching the border or anything.
[vszakats] */
hb_gtGetPos( &iRow, &iCol );
hb_gtSetPos( iRow, iCol + 1 );
}
| setposbs.c | 61 |
| shadow.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_SHADOW(void)
HB_FUNC( HB_SHADOW )
{
if( hb_pcount() >= 4 )
hb_gtDrawShadow( ( USHORT ) hb_parni( 1 ),
( USHORT ) hb_parni( 2 ),
( USHORT ) hb_parni( 3 ),
( USHORT ) hb_parni( 4 ),
ISNUM( 5 ) ? ( BYTE ) hb_parni( 5 ) : 7 );
}
| shadow.c | 56 |
| HB_FUNC | HB_CLRAREA(void)
HB_FUNC( HB_CLRAREA )
{
if( hb_pcount() > 4 )
hb_gtSetAttribute( ( USHORT ) hb_parni( 1 ),
( USHORT ) hb_parni( 2 ),
( USHORT ) hb_parni( 3 ),
( USHORT ) hb_parni( 4 ),
( BYTE ) hb_parni( 5 ) );
}
| shadow.c | 66 |
| shadowu.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DBGSHADOW(void)
HB_FUNC( DBGSHADOW )
{
HB_FUNC_EXEC( HB_SHADOW );
}
| shadowu.c | 59 |
| soundex.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | SOUNDEX(void)
HB_FUNC( SOUNDEX )
{
PHB_ITEM pString = hb_param( 1, HB_IT_STRING );
char szResult[ SOUNDEX_LEN_MAX + 1 ];
/* NOTE: The result will always be a zero terminated string without any
embedded zeros and special characters. [vszakats] */
memset( szResult, '0', SOUNDEX_LEN_MAX );
szResult[ SOUNDEX_LEN_MAX ] = '\0';
if( pString )
{
char * pszString = hb_itemGetCPtr( pString );
ULONG ulLen = hb_itemGetCLen( pString );
ULONG nPos = 0;
ULONG nResultPos = 0;
char cCharPrev = '0';
while( nPos < ulLen && nResultPos < SOUNDEX_LEN_MAX )
{
char cChar = pszString[ nPos ];
/* NOTE: Intentionally not using toupper()/isalpha() to be 100%
Clipper compatible here, these ANSI C functions may behave
differently for accented and national characters. It's also
faster this way. [vszakats] */
/* Convert to uppercase: toupper() */
if( cChar >= 'a' && cChar <= 'z' )
cChar -= ( 'a' - 'A' );
/* Check if isalpha() */
if( cChar >= 'A' && cChar <= 'Z' )
{
static const char s_szTable[] = "01230120022455012623010202"; /* NOTE: SoundEx result codes for letters from "A" to "Z" */
/* "ABCDEFGHIJKLMNOPQRSTUVWXYZ" */
char cCharConverted = ( ( cChar - 'A' ) > ( ( int ) sizeof( s_szTable ) - 1 ) ) ? '9' : s_szTable[ cChar - 'A' ];
if( nResultPos == 0 )
szResult[ nResultPos++ ] = cChar;
else if( cCharConverted != '0' && cCharConverted != cCharPrev )
szResult[ nResultPos++ ] = cCharConverted;
cCharPrev = cCharConverted;
}
nPos++;
}
}
hb_retc( szResult );
}
| soundex.c | 60 |
| space.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | SPACE(void)
HB_FUNC( SPACE )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_NUMERIC );
if( pItem )
{
long lLen = hb_itemGetNL( pItem );
if( lLen > 0 )
{
char * szResult = ( char * ) hb_xgrab( lLen + 1 );
/* NOTE: String overflow could never occure since a string can
be as large as ULONG_MAX, and the maximum length that
can be specified is LONG_MAX here. [vszakats] */
/* hb_errRT_BASE( EG_STROVERFLOW, 1233, NULL, HB_ERR_FUNCNAME ); */
hb_xmemset( szResult, ' ', lLen );
hb_retclen_buffer( szResult, lLen );
}
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1105, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| space.c | 59 |
| spfiles.c |
| Type | Function | Source | Line |
|---|
| BOOL | hb_spFile( BYTE * pFilename, BYTE * pRetPath )
BOOL hb_spFile( BYTE * pFilename, BYTE * pRetPath )
{
BYTE *Path;
BOOL bIsFile = FALSE;
PHB_FNAME pFilepath;
HB_TRACE(HB_TR_DEBUG, ("hb_spFile(%s, %p)", (char*) pFilename, pRetPath));
if( pRetPath )
{
Path = pRetPath;
}
else
{
Path = (BYTE *) hb_xgrab( _POSIX_PATH_MAX + 1 );
}
pFilepath = hb_fsFNameSplit( (char*) pFilename );
if( pFilepath->szPath )
{
hb_fsFNameMerge( (char*) Path, pFilepath );
bIsFile = hb_fsFile( Path );
}
else
{
char * szDefault = hb_setGetDefault();
if( szDefault )
{
pFilepath->szPath = szDefault;
hb_fsFNameMerge( (char*) Path, pFilepath );
bIsFile = hb_fsFile( Path );
}
if( !bIsFile && hb_setGetPath() )
{
HB_PATHNAMES *NextPath = hb_setGetFirstSetPath();
while( bIsFile == FALSE && NextPath )
{
pFilepath->szPath = NextPath->szPath;
hb_fsFNameMerge( (char*) Path, pFilepath );
bIsFile = hb_fsFile( Path );
NextPath = NextPath->pNext;
}
}
/*
* This code is intentional. To eliminate race condition,
* in pending hb_spCreate()/hb_spOpen() call when we have to know
* real path and file name we have to set its deterministic value
* here. If it's not necessary the caller may drop this value.
*/
if( ! bIsFile )
{
pFilepath->szPath = szDefault ? szDefault : ( char * ) ".";
hb_fsFNameMerge( (char*) Path, pFilepath );
}
}
hb_xfree( pFilepath );
if( pRetPath == NULL )
{
hb_xfree( Path );
}
return bIsFile;
}
| spfiles.c | 56 |
| HB_FHANDLE | hb_spOpen( BYTE * pFilename, USHORT uiFlags )
HB_FHANDLE hb_spOpen( BYTE * pFilename, USHORT uiFlags )
{
BYTE path[ _POSIX_PATH_MAX + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_spOpen(%p, %hu)", pFilename, uiFlags));
if( hb_spFile( pFilename, path ) )
return hb_fsOpen( path, uiFlags );
else
return hb_fsOpen( pFilename, uiFlags );
}
| spfiles.c | 126 |
| HB_FHANDLE | hb_spCreate( BYTE * pFilename, ULONG ulAttr )
HB_FHANDLE hb_spCreate( BYTE * pFilename, ULONG ulAttr )
{
BYTE path[ _POSIX_PATH_MAX + 1 ];
PHB_FNAME pFilepath;
HB_TRACE(HB_TR_DEBUG, ("hb_spCreate(%p, %lu)", pFilename, ulAttr));
pFilepath = hb_fsFNameSplit( (char*) pFilename );
if( ! pFilepath->szPath )
pFilepath->szPath = hb_setGetDefault();
hb_fsFNameMerge( (char*) path, pFilepath );
hb_xfree( pFilepath );
return hb_fsCreate( path, ulAttr );
}
| spfiles.c | 138 |
| HB_FHANDLE | hb_spCreateEx( BYTE * pFilename, ULONG ulAttr, USHORT uiFlags )
HB_FHANDLE hb_spCreateEx( BYTE * pFilename, ULONG ulAttr, USHORT uiFlags )
{
BYTE path[ _POSIX_PATH_MAX + 1 ];
PHB_FNAME pFilepath;
HB_TRACE(HB_TR_DEBUG, ("hb_spCreateEx(%p, %lu, %hu)", pFilename, ulAttr, uiFlags));
pFilepath = hb_fsFNameSplit( (char*) pFilename );
if( ! pFilepath->szPath )
pFilepath->szPath = hb_setGetDefault();
hb_fsFNameMerge( (char*) path, pFilepath );
hb_xfree( pFilepath );
return hb_fsCreateEx( path, ulAttr, uiFlags );
}
| spfiles.c | 155 |
| str.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | STR(void)
HB_FUNC( STR )
{
int iParams = hb_pcount();
PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC );
PHB_ITEM pWidth = NULL;
PHB_ITEM pDec = NULL;
if( iParams >= 2 )
{
pWidth = hb_param( 2, HB_IT_NUMERIC );
if( pWidth == NULL )
pNumber = NULL;
else if( iParams >= 3 )
{
pDec = hb_param( 3, HB_IT_NUMERIC );
if( pDec == NULL )
pNumber = NULL;
}
}
if( pNumber )
{
char * szResult = hb_itemStr( pNumber, pWidth, pDec );
if( szResult )
hb_retc_buffer( szResult );
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| str.c | 57 |
| strcase.c |
| Type | Function | Source | Line |
|---|
| CHAR * | hb_strLower( char * szText, ULONG ulLen )
char * hb_strLower( char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strLower(%s, %lu)", szText, ulLen));
{
ULONG i;
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp->nChars )
for( i = 0; i < ulLen; i++ )
szText[ i ] = ( char ) cdp->s_lower[ ( UCHAR ) szText[ i ] ];
else
#endif
for( i = 0; i < ulLen; i++ )
szText[ i ] = ( char ) tolower( ( UCHAR ) szText[ i ] );
}
return szText;
}
| strcase.c | 60 |
| CHAR * | hb_strUpper( char * szText, ULONG ulLen )
char * hb_strUpper( char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strUpper(%s, %lu)", szText, ulLen));
{
ULONG i;
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp->nChars )
for( i = 0; i < ulLen; i++ )
szText[ i ] = ( char ) cdp->s_upper[ ( UCHAR ) szText[ i ] ];
else
#endif
for( i = 0; i < ulLen; i++ )
szText[ i ] = ( char ) toupper( ( UCHAR ) szText[ i ] );
}
return szText;
}
| strcase.c | 81 |
| INT | hb_charUpper( int iChar )
int hb_charUpper( int iChar )
{
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp->nChars )
return (unsigned char) cdp->s_upper[ (unsigned char) iChar ];
else
#endif
return toupper( (unsigned char) iChar );
}
| strcase.c | 103 |
| INT | hb_charLower( int iChar )
int hb_charLower( int iChar )
{
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp->nChars )
return (unsigned char) cdp->s_lower[ (unsigned char) iChar ];
else
#endif
return tolower( (unsigned char) iChar );
}
| strcase.c | 115 |
| HB_FUNC | LOWER(void)
HB_FUNC( LOWER )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText )
{
char * pszBuffer = hb_itemGetC( pText );
ULONG ulLen = hb_itemGetCLen( pText );
hb_retclen_buffer( hb_strLower( pszBuffer, ulLen ), ulLen );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1103, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| strcase.c | 127 |
| HB_FUNC | UPPER(void)
HB_FUNC( UPPER )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText )
{
char * pszBuffer = hb_itemGetC( pText );
ULONG ulLen = hb_itemGetCLen( pText );
hb_retclen_buffer( hb_strUpper( pszBuffer, ulLen ), ulLen );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1102, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| strcase.c | 143 |
| strmatch.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT BOOL | hb_strMatchWild( const char *szString, const char *szPattern )
HB_EXPORT BOOL hb_strMatchWild( const char *szString, const char *szPattern )
{
BOOL fMatch = TRUE, fAny = FALSE;
ULONG pulBufPosP[ HB_MAX_WILDPATTERN ], pulBufPosV[ HB_MAX_WILDPATTERN ],
ulBufSize = HB_MAX_WILDPATTERN;
ULONG * ulAnyPosP = pulBufPosP, * ulAnyPosV = pulBufPosV,
ulSize, ulLen, ulAny, i, j;
i = j = ulAny = 0;
ulLen = strlen( szString );
ulSize = strlen( szPattern );
while( i < ulSize )
{
if( szPattern[i] == '*' )
{
fAny = TRUE;
i++;
}
else if( j < ulLen && ( szPattern[i] == '?' || szPattern[i] == szString[j] ) )
{
if( fAny )
{
if( ulAny >= ulBufSize )
{
if( ( ulBufSize <<= 1 ) == ( HB_MAX_WILDPATTERN << 1 ) )
{
ulAnyPosP = ( ULONG * ) hb_xgrab( ulBufSize * sizeof( ULONG ) );
ulAnyPosV = ( ULONG * ) hb_xgrab( ulBufSize * sizeof( ULONG ) );
memcpy( ulAnyPosP, pulBufPosP, HB_MAX_WILDPATTERN * sizeof( ULONG ) );
memcpy( ulAnyPosV, pulBufPosV, HB_MAX_WILDPATTERN * sizeof( ULONG ) );
}
else
{
ulAnyPosP = ( ULONG * ) hb_xrealloc( ulAnyPosP, ulBufSize * sizeof( ULONG ) );
ulAnyPosV = ( ULONG * ) hb_xrealloc( ulAnyPosV, ulBufSize * sizeof( ULONG ) );
}
}
ulAnyPosP[ulAny] = i;
ulAnyPosV[ulAny] = j;
ulAny++;
fAny = FALSE;
}
j++;
i++;
}
else if( fAny && j < ulLen )
{
j++;
}
else if( ulAny > 0 )
{
ulAny--;
i = ulAnyPosP[ulAny];
j = ulAnyPosV[ulAny] + 1;
fAny = TRUE;
}
else
{
fMatch = FALSE;
break;
}
}
if( ulBufSize > HB_MAX_WILDPATTERN )
{
hb_xfree( ulAnyPosP );
hb_xfree( ulAnyPosV );
}
return fMatch;
}
| strmatch.c | 62 |
| HB_EXPORT BOOL | hb_strMatchWildExact( const char *szString, const char *szPattern )
HB_EXPORT BOOL hb_strMatchWildExact( const char *szString, const char *szPattern )
{
BOOL fMatch = TRUE, fAny = FALSE;
ULONG pulBufPosP[ HB_MAX_WILDPATTERN ], pulBufPosV[ HB_MAX_WILDPATTERN ],
ulBufSize = HB_MAX_WILDPATTERN;
ULONG * ulAnyPosP = pulBufPosP, * ulAnyPosV = pulBufPosV,
ulSize, ulLen, ulAny, i, j;
i = j = ulAny = 0;
ulLen = strlen( szString );
ulSize = strlen( szPattern );
while( i < ulSize || ( j < ulLen && !fAny ) )
{
if( i < ulSize && szPattern[i] == '*' )
{
fAny = TRUE;
i++;
}
else if( j < ulLen && i < ulSize &&
( szPattern[i] == '?' || szPattern[i] == szString[j] ) )
{
if( fAny )
{
if( ulAny >= ulBufSize )
{
if( ( ulBufSize <<= 1 ) == ( HB_MAX_WILDPATTERN << 1 ) )
{
ulAnyPosP = ( ULONG * ) hb_xgrab( ulBufSize * sizeof( ULONG ) );
ulAnyPosV = ( ULONG * ) hb_xgrab( ulBufSize * sizeof( ULONG ) );
memcpy( ulAnyPosP, pulBufPosP, HB_MAX_WILDPATTERN * sizeof( ULONG ) );
memcpy( ulAnyPosV, pulBufPosV, HB_MAX_WILDPATTERN * sizeof( ULONG ) );
}
else
{
ulAnyPosP = ( ULONG * ) hb_xrealloc( ulAnyPosP, ulBufSize * sizeof( ULONG ) );
ulAnyPosV = ( ULONG * ) hb_xrealloc( ulAnyPosV, ulBufSize * sizeof( ULONG ) );
}
}
ulAnyPosP[ulAny] = i;
ulAnyPosV[ulAny] = j;
ulAny++;
fAny = FALSE;
}
j++;
i++;
}
else if( fAny && j < ulLen )
{
j++;
}
else if( ulAny > 0 )
{
ulAny--;
i = ulAnyPosP[ulAny];
j = ulAnyPosV[ulAny] + 1;
fAny = TRUE;
}
else
{
fMatch = FALSE;
break;
}
}
if( ulBufSize > HB_MAX_WILDPATTERN )
{
hb_xfree( ulAnyPosP );
hb_xfree( ulAnyPosV );
}
return fMatch;
}
| strmatch.c | 132 |
| HB_EXPORT BOOL | hb_strMatchCaseWildExact( const char *szString, const char *szPattern )
HB_EXPORT BOOL hb_strMatchCaseWildExact( const char *szString, const char *szPattern )
{
BOOL fMatch = TRUE, fAny = FALSE;
ULONG pulBufPosP[ HB_MAX_WILDPATTERN ], pulBufPosV[ HB_MAX_WILDPATTERN ],
ulBufSize = HB_MAX_WILDPATTERN;
ULONG * ulAnyPosP = pulBufPosP, * ulAnyPosV = pulBufPosV,
ulSize, ulLen, ulAny, i, j;
i = j = ulAny = 0;
ulLen = strlen( szString );
ulSize = strlen( szPattern );
while ( i < ulSize || ( j < ulLen && !fAny ) )
{
if( i < ulSize && szPattern[i] == '*' )
{
fAny = TRUE;
i++;
}
else if( j < ulLen && i < ulSize &&
( szPattern[i] == '?' ||
hb_charUpper( szPattern[i] ) == hb_charUpper( szString[j] ) ) )
{
if( fAny )
{
if( ulAny >= ulBufSize )
{
if( ( ulBufSize <<= 1 ) == ( HB_MAX_WILDPATTERN << 1 ) )
{
ulAnyPosP = ( ULONG * ) hb_xgrab( ulBufSize * sizeof( ULONG ) );
ulAnyPosV = ( ULONG * ) hb_xgrab( ulBufSize * sizeof( ULONG ) );
memcpy( ulAnyPosP, pulBufPosP, HB_MAX_WILDPATTERN * sizeof( ULONG ) );
memcpy( ulAnyPosV, pulBufPosV, HB_MAX_WILDPATTERN * sizeof( ULONG ) );
}
else
{
ulAnyPosP = ( ULONG * ) hb_xrealloc( ulAnyPosP, ulBufSize * sizeof( ULONG ) );
ulAnyPosV = ( ULONG * ) hb_xrealloc( ulAnyPosV, ulBufSize * sizeof( ULONG ) );
}
}
ulAnyPosP[ulAny] = i;
ulAnyPosV[ulAny] = j;
ulAny++;
fAny = FALSE;
}
j++;
i++;
}
else if( fAny && j < ulLen )
{
j++;
}
else if( ulAny > 0 )
{
ulAny--;
i = ulAnyPosP[ulAny];
j = ulAnyPosV[ulAny] + 1;
fAny = TRUE;
}
else
{
fMatch = FALSE;
break;
}
}
if( ulBufSize > HB_MAX_WILDPATTERN )
{
hb_xfree( ulAnyPosP );
hb_xfree( ulAnyPosV );
}
return fMatch;
}
| strmatch.c | 203 |
| BOOL | hb_strMatchRegExp( const char * szString, const char * szPattern )
BOOL hb_strMatchRegExp( const char * szString, const char * szPattern )
{
PHB_REGEX pRegEx;
HB_TRACE(HB_TR_DEBUG, ("hb_strMatchRegExp(%s, %s)", szString, szPattern));
pRegEx = hb_regexCompile( szPattern, strlen( szPattern ), HBREG_EXTENDED );
if( pRegEx )
{
BOOL fMatch;
fMatch = hb_regexMatch( pRegEx, szString, strlen( szString ), TRUE );
hb_regexFree( pRegEx );
return fMatch;
}
else
return hb_strMatchWildExact( szString, szPattern );
}
| strmatch.c | 275 |
| HB_EXPORT BOOL | hb_strMatchFile( const char * szString, const char * szPattern )
HB_EXPORT BOOL hb_strMatchFile( const char * szString, const char * szPattern )
{
#if defined( HB_OS_UNIX )
# if defined( __WATCOMC__ )
return hb_strMatchWildExact( szString, szPattern );
# else
return fnmatch( szPattern, szString, FNM_PERIOD | FNM_PATHNAME ) == 0;
# endif
#else
return hb_strMatchCaseWildExact( szString, szPattern );
#endif
}
| strmatch.c | 293 |
| HB_FUNC | HB_WILDMATCH(void)
HB_FUNC( HB_WILDMATCH )
{
hb_retl( ( ! ISCHAR( 1 ) || ! ISCHAR( 2 ) ) ? FALSE :
hb_parl( 3 ) ? hb_strMatchWildExact( hb_parc( 2 ), hb_parc( 1 ) ) :
hb_strMatchWild( hb_parc( 2 ), hb_parc( 1 ) ) );
}
| strmatch.c | 317 |
| HB_FUNC | HB_FILEMATCH(void)
HB_FUNC( HB_FILEMATCH )
{
hb_retl( ( ! ISCHAR( 1 ) || ! ISCHAR( 2 ) ) ? FALSE :
hb_strMatchFile( hb_parc( 1 ), hb_parc( 2 ) ) );
}
| strmatch.c | 324 |
| strpeek.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | STRPEEK(void)
HB_FUNC( STRPEEK )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText && ISNUM( 2 ) )
{
ULONG ulPos = hb_parnl( 2 );
if( ulPos > 0 && ulPos <= hb_itemGetCLen( pText ) )
hb_retni( ( BYTE ) * ( hb_itemGetCPtr( pText ) + ulPos - 1 ) );
else
hb_retni( 0 );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| strpeek.c | 59 |
| HB_FUNC | STRPOKE(void)
HB_FUNC( STRPOKE )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText && ISNUM( 2 ) && ISNUM( 3 ) )
{
ULONG ulPos = hb_parnl( 2 );
if( ulPos > 0 && ulPos <= hb_itemGetCLen( pText ) )
{
pText = hb_itemUnShareString( pText );
hb_itemGetCPtr( pText )[ ulPos - 1 ] = (char) ( hb_parni( 3 ) & 0xff );
}
hb_itemReturn( pText );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| strpeek.c | 77 |
| strtran.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | STRTRAN(void)
HB_FUNC( STRTRAN )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
PHB_ITEM pSeek = hb_param( 2, HB_IT_STRING );
if( pText && pSeek )
{
const char * szText = hb_itemGetCPtr( pText );
ULONG ulText = hb_itemGetCLen( pText );
ULONG ulSeek = hb_itemGetCLen( pSeek );
if( ulSeek && ulSeek <= ulText )
{
const char * szSeek = hb_itemGetCPtr( pSeek );
const char * szReplace;
ULONG ulStart;
ulStart = ( ISNUM( 4 ) ? hb_parnl( 4 ) : 1 );
if( !ulStart )
{
/* Clipper seems to work this way */
hb_retc( NULL );
}
else if( ulStart > 0 )
{
PHB_ITEM pReplace = hb_param( 3, HB_IT_STRING );
ULONG ulReplace;
ULONG ulCount;
BOOL bAll;
if( pReplace )
{
szReplace = hb_itemGetCPtr( pReplace );
ulReplace = hb_itemGetCLen( pReplace );
}
else
{
szReplace = ""; /* shouldn't matter that we don't allocate */
ulReplace = 0;
}
if( ISNUM( 5 ) )
{
ulCount = hb_parnl( 5 );
bAll = FALSE;
}
else
{
ulCount = 0;
bAll = TRUE;
}
if( bAll || ulCount > 0 )
{
ULONG ulFound = 0;
long lReplaced = 0;
ULONG i = 0;
ULONG ulLength = ulText;
ULONG ulStop = ulText - ulSeek + 1;
while( i < ulStop )
{
if( ( bAll || lReplaced < ( long ) ulCount ) &&
! memcmp( szText + i, szSeek, ulSeek ) )
{
ulFound++;
if( ulFound >= ulStart )
{
lReplaced++;
ulLength = ulLength - ulSeek + ulReplace;
i += ulSeek;
}
else
i++;
}
else
i++;
}
if( ulFound )
{
char * szResult = ( char * ) hb_xgrab( ulLength + 1 );
char * szPtr = szResult;
ulFound = 0;
i = 0;
while( i < ulText )
{
if( lReplaced && ! memcmp( szText + i, szSeek, ulSeek ) )
{
ulFound++;
if( ulFound >= ulStart )
{
lReplaced--;
memcpy( szPtr, szReplace, ulReplace );
szPtr += ulReplace;
i += ulSeek;
}
else
{
*szPtr = szText[ i ];
szPtr++;
i++;
}
}
else
{
*szPtr = szText[ i ];
szPtr++;
i++;
}
}
hb_retclen_buffer( szResult, ulLength );
}
else
hb_itemReturn( pText );
}
else
hb_itemReturn( pText );
}
else
hb_itemReturn( pText );
}
else
hb_itemReturn( pText );
}
else
{
/* NOTE: Undocumented but existing Clipper Run-time error [vszakats] */
#ifdef HB_C52_STRICT
hb_errRT_BASE_SubstR( EG_ARG, 1126, NULL, HB_ERR_FUNCNAME, 0 );
#else
hb_errRT_BASE_SubstR( EG_ARG, 1126, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
#endif
}
}
| strtran.c | 61 |
| strzero.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | STRZERO(void)
HB_FUNC( STRZERO )
{
int iParams = hb_pcount();
if( iParams >= 1 && iParams <= 3 )
{
PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC );
PHB_ITEM pWidth = NULL;
PHB_ITEM pDec = NULL;
if( iParams >= 2 )
{
pWidth = hb_param( 2, HB_IT_NUMERIC );
if( pWidth == NULL )
pNumber = NULL;
else if( iParams >= 3 )
{
pDec = hb_param( 3, HB_IT_NUMERIC );
if( pDec == NULL )
pNumber = NULL;
}
}
if( pNumber )
{
char * szResult = hb_itemStr( pNumber, pWidth, pDec );
if( szResult )
{
ULONG ulPos = 0;
while( szResult[ ulPos ] != '\0' && szResult[ ulPos ] != '-' )
ulPos++;
if( szResult[ ulPos ] == '-' )
{
/* NOTE: Negative sign found, put it to the first position */
szResult[ ulPos ] = ' ';
ulPos = 0;
while( szResult[ ulPos ] != '\0' && szResult[ ulPos ] == ' ' )
szResult[ ulPos++ ] = '0';
szResult[ 0 ] = '-';
}
else
{
/* Negative sign not found */
ulPos = 0;
while( szResult[ ulPos ] != '\0' && szResult[ ulPos ] == ' ' )
szResult[ ulPos++ ] = '0';
}
hb_retc_buffer( szResult );
}
else
hb_retc( NULL );
}
else
#ifdef HB_C52_STRICT
/* NOTE: In CA-Cl*pper STRZERO() is written in Clipper, and will call
STR() to do the job, the error (if any) will also be thrown
by STR(). [vszakats] */
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, "STR", HB_ERR_ARGS_BASEPARAMS );
#else
hb_errRT_BASE_SubstR( EG_ARG, 6003, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
#endif
}
}
| strzero.c | 57 |
| stuff.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | STUFF(void)
HB_FUNC( STUFF )
{
if( ISCHAR( 1 ) && ISNUM( 2 ) && ISNUM( 3 ) && ISCHAR( 4 ) )
{
char * szText = hb_parc( 1 );
ULONG ulText = hb_parclen( 1 );
ULONG ulPos = hb_parnl( 2 );
ULONG ulDel = hb_parnl( 3 );
ULONG ulInsert = hb_parclen( 4 );
ULONG ulTotalLen;
if( ulPos > 0 )
ulPos--;
if( ulPos > ulText )
ulPos = ulText;
if( ulDel > ulText - ulPos )
ulDel = ulText - ulPos;
if( ( ulTotalLen = ulText + ulInsert - ulDel ) > 0 )
{
char * szResult = ( char * ) hb_xgrab( ulTotalLen + 1 );
hb_xmemcpy( szResult, szText, ulPos );
hb_xmemcpy( szResult + ulPos, hb_parc( 4 ), ulInsert );
hb_xmemcpy( szResult + ulPos + ulInsert, szText + ulPos + ulDel, ulText - ( ulPos + ulDel ) );
szResult[ ulTotalLen ] = '\0';
hb_retclen_buffer( szResult, ulTotalLen );
}
else
hb_retc( NULL );
}
else
hb_retc( NULL );
}
| stuff.c | 55 |
| substr.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | SUBSTR(void)
HB_FUNC( SUBSTR )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText && ISNUM( 2 ) )
{
long lPos = hb_parnl( 2 );
long lSize = ( long ) hb_itemGetCLen( pText );
if( lPos < 0 )
{
lPos += lSize;
if( lPos < 0 )
lPos = 0;
}
else if( lPos )
{
lPos--;
}
if( lPos < lSize )
{
long lLen;
if( hb_pcount() >= 3 )
{
if( ISNUM( 3 ) )
{
lLen = hb_parnl( 3 );
if( lLen > lSize - lPos )
lLen = lSize - lPos;
}
else
{
hb_errRT_BASE_SubstR( EG_ARG, 1110, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
/* NOTE: Exit from inside [vszakats] */
return;
}
}
else
lLen = lSize - lPos;
if( lLen > 0 )
{
if( lLen == lSize )
hb_itemReturn( pText );
else
hb_retclen( hb_itemGetCPtr( pText ) + lPos, lLen );
}
else
hb_retc( NULL );
}
else
hb_retc( NULL );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1110, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| substr.c | 59 |
| tone.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | TONE(void)
HB_FUNC( TONE )
{
if( ISNUM( 1 ) )
hb_gtTone( hb_parnd( 1 ), ( ISNUM( 2 ) ? hb_parnd( 2 ) : 1.0 ) );
}
| tone.c | 56 |
| trace.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_TRACESTATE(void)
HB_FUNC( HB_TRACESTATE )
{
hb_retni( hb_tracestate( ISNUM( 1 ) ? hb_parni( 1 ) : -1 ) );
}
| trace.c | 56 |
| HB_FUNC | HB_TRACELEVEL(void)
HB_FUNC( HB_TRACELEVEL )
{
hb_retni( hb_tracelevel( ISNUM( 1 ) ? hb_parni( 1 ) : -1 ) );
}
| trace.c | 61 |
| HB_FUNC | HB_TRACESTRING(void)
HB_FUNC( HB_TRACESTRING )
{
char * szMessage = hb_parc( 1 );
if( szMessage )
{
HB_TRACE(HB_TR_ALWAYS, (szMessage) );
}
}
| trace.c | 66 |
| transfrm.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | TRANSFORM(void)
HB_FUNC( TRANSFORM )
{
PHB_ITEM pValue = hb_param( 1, HB_IT_ANY ); /* Input parameter */
PHB_ITEM pPic = hb_param( 2, HB_IT_STRING ); /* Picture string */
BOOL bError = FALSE;
if( pPic && hb_itemGetCLen( pPic ) > 0 )
{
char szPicDate[ 11 ];
char * szPic = hb_itemGetCPtr( pPic );
ULONG ulPicLen = hb_itemGetCLen( pPic );
USHORT uiPicFlags; /* Function flags */
ULONG ulParamS = 0; /* To avoid GCC -O2 warning */
BYTE byParamL = '\0'; /* To avoid GCC -O2 warning */
char * szResult;
ULONG ulResultPos;
ULONG ulOffset = 0;
/* ======================================================= */
/* Analyze picture functions */
/* ======================================================= */
uiPicFlags = 0;
/* If an "@" char is at the first pos, we have picture function */
if( *szPic == '@' )
{
BOOL bDone = FALSE;
/* Skip the "@" char */
szPic++;
ulPicLen--;
/* Go through all function chars, until the end of the picture string
or any whitespace found. */
while( ulPicLen && ! bDone )
{
switch( hb_charUpper( *szPic ) )
{
case HB_CHAR_HT:
case ' ':
bDone = TRUE; /* End of function string */
break;
case '!':
uiPicFlags |= PF_UPPER;
break;
case '(':
uiPicFlags |= PF_PARNEG;
break;
case ')':
uiPicFlags |= PF_PARNEGWOS;
break;
#if defined(HB_COMPAT_XPP) || defined(HB_COMPAT_FOXPRO)
case 'L':
case '0':
uiPicFlags |= PF_PADL; /* FoxPro/XPP extension */
byParamL = '0';
break;
#endif
case 'B':
uiPicFlags |= PF_LEFT;
break;
case 'C':
uiPicFlags |= PF_CREDIT;
break;
case 'D':
uiPicFlags |= PF_DATE;
break;
case 'E':
uiPicFlags |= PF_BRITISH;
break;
case 'R':
uiPicFlags |= PF_REMAIN;
break;
case 'S':
uiPicFlags |= PF_WIDTH;
ulParamS = 0;
while( ulPicLen > 1 && *( szPic + 1 ) >= '0' && *( szPic + 1 ) <= '9' )
{
szPic++;
ulPicLen--;
ulParamS = ( ulParamS * 10 ) + ( ( ULONG ) ( *szPic - '0' ) );
}
break;
case 'X':
uiPicFlags |= PF_DEBIT;
break;
case 'Z':
uiPicFlags |= PF_EMPTY;
break;
}
szPic++;
ulPicLen--;
}
}
/* ======================================================= */
/* Handle STRING values */
/* ======================================================= */
if( HB_IS_STRING( pValue ) )
{
char * szExp = hb_itemGetCPtr( pValue );
ULONG ulExpLen = hb_itemGetCLen( pValue );
ULONG ulExpPos = 0;
BOOL bAnyPic = FALSE;
BOOL bFound = FALSE;
/* Grab enough */
/* Support date function for strings */
if( uiPicFlags & ( PF_DATE | PF_BRITISH ) )
{
hb_dateFormat( "XXXXXXXX", szPicDate, hb_setGetDateFormat() );
szPic = szPicDate;
ulPicLen = strlen( szPicDate );
}
szResult = ( char * ) hb_xgrab( ulExpLen + ulPicLen + 1 );
ulResultPos = 0;
/* Template string */
if( ulPicLen )
{
while( ulPicLen ) /* Analyze picture mask */
{
if( ulExpPos < ulExpLen )
{
switch( *szPic )
{
/* Upper */
case '!':
{
szResult[ ulResultPos++ ] = ( char ) hb_charUpper( szExp[ ulExpPos ] );
ulExpPos++;
bAnyPic = TRUE;
break;
}
/* Out the character */
case '#':
case '9':
case 'a':
case 'A':
case 'l':
case 'L':
case 'n':
case 'N':
case 'x':
case 'X':
{
szResult[ ulResultPos++ ] = ( uiPicFlags & PF_UPPER ) ? ( char ) hb_charUpper( szExp[ ulExpPos ] ) : szExp[ ulExpPos ];
ulExpPos++;
bAnyPic = TRUE;
break;
}
/* Logical */
case 'y':
case 'Y':
{
szResult[ ulResultPos++ ] = ( szExp[ ulExpPos ] == 't' ||
szExp[ ulExpPos ] == 'T' ||
szExp[ ulExpPos ] == 'y' ||
szExp[ ulExpPos ] == 'Y' ) ? ( char ) 'Y' : ( char ) 'N';
ulExpPos++;
bAnyPic = TRUE;
break;
}
/* Other choices */
default:
{
szResult[ ulResultPos++ ] = *szPic;
if( !( uiPicFlags & PF_REMAIN ) )
ulExpPos++;
}
}
}
else if( !( uiPicFlags & PF_REMAIN ) )
break;
else
{
/* NOTE: This is a FoxPro compatible [jarabal] */
#if defined(HB_COMPAT_FOXPRO)
ulPicLen = 0;
break;
#else
switch( *szPic )
{
case '!':
case '#':
case '9':
case 'a':
case 'A':
case 'l':
case 'L':
case 'n':
case 'N':
case 'x':
case 'X':
case 'y':
case 'Y':
{
szResult[ ulResultPos++ ] = ' ';
break;
}
default:
szResult[ ulResultPos++ ] = *szPic;
}
#endif
}
szPic++;
ulPicLen--;
}
}
else
{
while( ulExpPos++ < ulExpLen )
{
if( uiPicFlags & PF_EXCHANG )
{
switch( *szExp )
{
case ',':
{
szResult[ ulResultPos++ ] = '.';
break;
}
case '.':
{
if( !bFound && ulResultPos )
{
szResult[ ulResultPos++ ] = ',';
bFound = TRUE;
}
break;
}
default:
szResult[ ulResultPos++ ] = ( uiPicFlags & PF_UPPER ) ? ( char ) hb_charUpper( *szExp ) : *szExp;
}
}
else
{
szResult[ ulResultPos++ ] = ( uiPicFlags & PF_UPPER ) ? ( char ) hb_charUpper( *szExp ) : *szExp;
}
szExp++;
}
}
if( ( uiPicFlags & PF_REMAIN ) && ! bAnyPic )
{
while( ulExpPos++ < ulExpLen )
{
szResult[ ulResultPos++ ] = ( uiPicFlags & PF_UPPER ) ? ( char ) hb_charUpper( *szExp ) : *szExp;
szExp++;
}
}
/* Any chars left ? */
if( ( uiPicFlags & PF_REMAIN ) && ulPicLen )
{
/* Export remainder */
while( ulPicLen-- )
szResult[ ulResultPos++ ] = ' ';
}
if( uiPicFlags & PF_BRITISH )
{
/* CA-Cl*pper do not check result size and always exchanges
* bytes 1-2 with bytes 4-5. It's buffer overflow bug and I do
* not want to replicate it. It also causes that the results of
* @E conversion used for strings smaller then 5 bytes behaves
* randomly.
* In fact precise tests can show that it's not random behavior
* but CA-Cl*pper uses static buffer for result and when current
* one is smaller then 5 bytes then first two bytes are exchanged
* with 4-5 bytes from previous result which was length enough,
* f.e.:
* ? transform( "0123456789", "" )
* ? transform( "AB", "@E" )
* ? transform( "ab", "@E" )
* [druzus]
*/
if( ulResultPos >= 5 )
{
szPicDate[ 0 ] = szResult[ 0 ];
szPicDate[ 1 ] = szResult[ 1 ];
szResult[ 0 ] = szResult[ 3 ];
szResult[ 1 ] = szResult[ 4 ];
szResult[ 3 ] = szPicDate[ 0 ];
szResult[ 4 ] = szPicDate[ 1 ];
}
}
}
/* ======================================================= */
/* Handle NUMERIC values */
/* ======================================================= */
else if( HB_IS_NUMERIC( pValue ) )
{
int iWidth; /* Width of string */
int iDec; /* Number of decimals */
int iCount;
ULONG i;
char cPic;
PHB_ITEM pNumber = NULL;
double dValue = hb_itemGetND( pValue );
/* Support date function for numbers */
if( uiPicFlags & PF_DATE )
{
hb_dateFormat( "99999999", szPicDate, hb_setGetDateFormat() );
szPic = szPicDate;
ulPicLen = strlen( szPicDate );
}
for( i = iWidth = iDec = 0; i < ulPicLen; i++ )
{
if( szPic[ i ] == '.' )
{
while( ++i < ulPicLen )
{
if( szPic[ i ] == '9' || szPic[ i ] == '#' ||
szPic[ i ] == '$' || szPic[ i ] == '*' )
{
iWidth++;
iDec++;
}
}
if( iDec )
iWidth++;
break;
}
else if( szPic[ i ] == '9' || szPic[ i ] == '#' ||
szPic[ i ] == '$' || szPic[ i ] == '*' )
iWidth++;
}
iCount = 0;
if( iWidth == 0 ) /* Width calculated ?? */
{
hb_itemGetNLen( pValue, &iWidth, &iDec );
if( hb_setGetFixed() )
{
if( HB_IS_NUMINT( pValue ) )
iWidth += 2 + ( hb_setGetDecimals() << 1 );
else
iDec = hb_setGetDecimals();
}
if( iDec )
iWidth += iDec + 1;
}
else if( iDec > 0 && iWidth - iDec == 1 )
{
iCount = 1;
iWidth++;
}
if( ( uiPicFlags & ( PF_DEBIT | PF_PARNEG | PF_PARNEGWOS ) ) && dValue < 0 )
{
/* Always convert absolute val */
if( HB_IS_NUMINT( pValue ) ) /* workaround for 64bit integer conversion */
pNumber = hb_itemPutNInt( NULL, - hb_itemGetNInt( pValue ) );
else
pNumber = hb_itemPutND( NULL, -dValue );
pValue = pNumber;
}
if( dValue != 0 )
/* Don't empty the result if the number is not zero */
uiPicFlags &= ~PF_EMPTY;
/* allocate 4 additional bytes for possible ") CR" or ") DB" suffix */
szResult = ( char * ) hb_xgrab( iWidth + 5 );
hb_itemStrBuf( szResult, pValue, iWidth, iDec );
if( pNumber )
hb_itemRelease( pNumber );
if( iCount )
{
iWidth--;
if( *szResult != '0' )
{
memset( szResult + 1, '*', iWidth );
*szResult = '.';
}
else
memmove( szResult, szResult + 1, iWidth );
szResult[ iWidth ] = '\0';
}
/* Pad with padding char */
if( uiPicFlags & PF_PADL )
{
for( i = 0; szResult[ i ] == ' '; i++ )
szResult[ i ] = byParamL;
/* please test it with FoxPro and xbase++ to check
* if they made the same [druzus]
*/
if( i && szResult[ i ] == '-' )
{
szResult[ 0 ] = '-';
szResult[ i ] = byParamL;
}
}
if( ulPicLen == 0 )
{
if( uiPicFlags & PF_EXCHANG )
{
for( i = 0; i < ( ULONG ) iWidth; ++i )
{
if( szResult[ i ] == '.' )
{
szResult[ i ] = ',';
break;
}
}
}
i = iWidth;
}
else
{
char * szStr = szResult;
/* allocate 4 additional bytes for possible ") CR" or ") DB" suffix */
szResult = ( char * ) hb_xgrab( ulPicLen + 5 );
for( i = iCount = 0; i < ulPicLen; i++ )
{
cPic = szPic[ i ];
if( cPic == '9' || cPic == '#' )
{
szResult[ i ] = iCount < iWidth ? szStr[ iCount++ ] : ' ';
}
else if( cPic == '$' || cPic == '*' )
{
if( iCount < iWidth )
{
szResult[ i ] = szStr[ iCount ] == ' ' ? cPic : szStr[ iCount ];
iCount++;
}
else
szResult[ i ] = ' ';
}
else if( cPic == '.' && iCount < iWidth )
{
szResult[ i ] = ( uiPicFlags & PF_EXCHANG ) ? ',' : '.';
iCount++;
}
else if( cPic == ',' && i && iCount < iWidth )
{
if( isdigit( ( UCHAR ) szResult[ i - 1 ] ) )
szResult[ i ] = ( uiPicFlags & PF_EXCHANG ) ? '.' : ',';
else
{
szResult[ i ] = szResult[ i - 1 ];
if( szResult[ i - 1 ] == '-' )
{
szResult[ i - 1 ] = i > 1 && szResult[ i - 2 ] != '$' ?
szResult[ i - 2 ] : ' ';
}
}
}
else
szResult[ i ] = cPic;
}
hb_xfree( szStr );
}
if( dValue < 0 )
{
/* PF_PARNEGWOS has higher priority then PF_PARNEG */
if( ( uiPicFlags & PF_PARNEGWOS ) )
{
iCount = 0;
if( ulPicLen && i > 1 )
{
if( *szPic == *szResult && ( *szPic == '*' || *szPic == '$' ) &&
szResult[ 1 ] == ' ' )
++iCount;
}
while( ( ULONG ) iCount + 1 < i && szResult[ iCount + 1 ] == ' ' )
++iCount;
#ifndef HB_C52_STRICT
/* This is not Clipper compatible */
if( szResult[ iCount ] >= '1' && szResult[ iCount ] <= '9' &&
( ulPicLen == 0 || szPic[ iCount ] == '9' ||
szPic[ iCount ] != szResult[ iCount ] ) )
{
szResult[ iCount ] = '(';
for( ++iCount; ( ULONG ) iCount < i; iCount++ )
{
if( szResult[ iCount ] >= '0' && szResult[ iCount ] <= '9' &&
( ulPicLen == 0 || szPic[ iCount ] == '9' ||
szPic[ iCount ] != szResult[ iCount ] ) )
szResult[ iCount ] = '*';
}
}
else
#endif
szResult[ iCount ] = '(';
szResult[ i++ ] = ')';
}
else if( ( uiPicFlags & PF_PARNEG ) )
{
#ifndef HB_C52_STRICT
/* This is not Clipper compatible */
if( *szResult >= '1' && *szResult <= '9' &&
( ulPicLen == 0 || *szPic == '9' || *szPic != *szResult ) )
{
for( iCount = 1; ( ULONG ) iCount < i; iCount++ )
{
if( szResult[ iCount ] >= '0' && szResult[ iCount ] <= '9' &&
( ulPicLen == 0 || szPic[ iCount ] == '9' ||
szPic[ iCount ] != szResult[ iCount ] ) )
szResult[ iCount ] = '*';
}
}
#endif
*szResult = '(';
szResult[ i++ ] = ')';
ulOffset = 1;
}
if( ( uiPicFlags & PF_DEBIT ) )
{
szResult[ i++ ] = ' ';
szResult[ i++ ] = 'D';
szResult[ i++ ] = 'B';
}
}
else if( ( uiPicFlags & PF_CREDIT ) && dValue > 0 )
{
szResult[ i++ ] = ' ';
szResult[ i++ ] = 'C';
szResult[ i++ ] = 'R';
}
ulResultPos = i;
szResult[ i ] = '\0';
}
/* ======================================================= */
/* Handle DATE values */
/* ======================================================= */
else if( HB_IS_DATE( pValue ) )
{
char szDate[ 9 ];
char * szDateFormat;
char szNewFormat[ 11 ];
UINT nFor;
szResult = ( char * ) hb_xgrab( 13 );
szDateFormat = hb_setGetDateFormat();
#ifndef HB_C52_STRICT
if( uiPicFlags & PF_BRITISH )
{
/* When @E is used CA-Cl*pper do not update date format
* pattern but wrongly moves 4-th and 5-th bytes of
* formatted date to the beginning (see below). It causes
* that date formats formats different then MM?DD?YY[YY]
* are wrongly translated. The code below is not CA-Cl*pper
* compatible but it tries to respect user date format
* [druzus]
*/
const char * szBritish = hb_setGetCentury() ?
"DDMMYYYY" : "DDMMYY";
char cLast = 'x';
for( nFor = 0; nFor < 10; nFor++ )
{
if( *szBritish == cLast )
{
szNewFormat[ nFor ] = cLast;
szBritish++;
}
else if( ! *szDateFormat )
break;
else if( *szBritish &&
( *szDateFormat == 'Y' || *szDateFormat == 'y' ||
*szDateFormat == 'D' || *szDateFormat == 'd' ||
*szDateFormat == 'M' || *szDateFormat == 'm' ) )
{
szNewFormat[ nFor ] = cLast = *szBritish++;
do
szDateFormat++;
while( szDateFormat[ -1 ] == szDateFormat[ 0 ] );
}
else
szNewFormat[ nFor ] = *szDateFormat++;
}
szNewFormat[ nFor ] = '\0';
szDateFormat = szNewFormat;
}
#endif
hb_dateFormat( hb_itemGetDS( pValue, szDate ), szResult, szDateFormat );
ulResultPos = strlen( szResult );
#ifdef HB_C52_STRICT
if( uiPicFlags & PF_BRITISH )
{
/* replicated wrong Clipper behavior, see note above.
* It's not exact CA-Cl*pper behavior because it does
* not check for size of results and can extract data
* from static memory buffer used in previous conversions
* (see my note for @E in string conversion above)
* but this is buffer overflow and I do not plan to
* replicated it too [druzus]
*/
if( ulResultPos >= 5 )
{
szNewFormat[ 0 ] = szResult[ 0 ];
szNewFormat[ 1 ] = szResult[ 1 ];
szResult[ 0 ] = szResult[ 3 ];
szResult[ 1 ] = szResult[ 4 ];
szResult[ 3 ] = szNewFormat[ 0 ];
szResult[ 4 ] = szNewFormat[ 1 ];
}
}
#endif
if( uiPicFlags & PF_REMAIN )
{
/* Here we also respect the date format modified for @E [druzus]
*/
hb_dateFormat( "99999999", szPicDate, szDateFormat );
ulPicLen = strlen( szPicDate );
for( nFor = 0; nFor < ulPicLen; nFor++ )
{
if( szPicDate[ nFor ] != '9' )
{
memmove( szResult + nFor + 1, szResult + nFor, 12 - nFor );
szResult[ nFor ] = szPicDate[ nFor ];
ulResultPos++;
}
}
}
}
/* ======================================================= */
/* Handle LOGICAL values */
/* ======================================================= */
else if( HB_IS_LOGICAL( pValue ) )
{
BOOL bDone = FALSE;
BOOL bExit = FALSE;
char cPic;
if( uiPicFlags & ( PF_DATE | PF_BRITISH ) )
{
hb_dateFormat( "99999999", szPicDate, hb_setGetDateFormat() );
szPic = szPicDate;
ulPicLen = strlen( szPicDate );
}
ulResultPos = 0;
szResult = ( char * ) hb_xgrab( ulPicLen + 2 );
for( ; ( ulPicLen || !bDone ) && !bExit ; ulResultPos++, szPic++, ulPicLen-- )
{
if( ulPicLen )
cPic = *szPic;
else
{
cPic = 'L';
bExit = TRUE;
}
switch( cPic )
{
case 'y': /* Yes/No */
case 'Y': /* Yes/No */
{
if( !bDone )
{
szResult[ ulResultPos ] = hb_itemGetL( pValue ) ? 'Y' : 'N';
bDone = TRUE; /* Logical written */
}
else
szResult[ ulResultPos ] = ' ';
break;
}
case '#':
case 'l': /* True/False */
case 'L': /* True/False */
{
if( !bDone )
{
szResult[ ulResultPos ] = hb_itemGetL( pValue ) ? 'T' : 'F';
bDone = TRUE;
}
else
szResult[ ulResultPos ] = ' ';
break;
}
default:
szResult[ ulResultPos ] = cPic;
}
if( !( uiPicFlags & PF_REMAIN ) )
bExit = TRUE;
}
}
/* ======================================================= */
else
{
szResult = NULL; /* To avoid GCC -O2 warning */
ulResultPos = 0; /* To avoid GCC -O2 warning */
bError = TRUE;
}
if( ! bError )
{
if( uiPicFlags & PF_EMPTY )
memset( szResult, ' ', ulResultPos );
else if( uiPicFlags & PF_LEFT )
{
/* Trim left and pad with spaces */
ULONG ulFirstChar = ulOffset;
while( ulFirstChar < ulResultPos && szResult[ ulFirstChar ] == ' ' )
ulFirstChar++;
if( ulFirstChar > ulOffset && ulFirstChar < ulResultPos )
{
memmove( szResult + ulOffset, szResult + ulFirstChar, ulResultPos - ulFirstChar );
memset( szResult + ulOffset + ulResultPos - ulFirstChar, ' ', ulFirstChar - ulOffset );
}
}
hb_retclen_buffer( szResult, ( ulParamS && ulResultPos > ulParamS ) ? ulParamS : ulResultPos );
}
}
else if( pPic || ISNIL( 2 ) ) /* Picture is an empty string or NIL */
{
if( HB_IS_STRING( pValue ) )
{
hb_itemReturn( pValue );
}
else if( HB_IS_NUMERIC( pValue ) )
{
char * szStr;
if( HB_IS_NUMINT( pValue ) && hb_setGetFixed() )
{
int iWidth, iDec;
hb_itemGetNLen( pValue, &iWidth, &iDec );
iWidth += 2 + ( hb_setGetDecimals() << 1 );
szStr = ( char * ) hb_xgrab( iWidth + 1 );
hb_itemStrBuf( szStr, pValue, iWidth, iDec );
hb_retclen_buffer( szStr, iWidth );
}
else
{
ULONG ulLen;
BOOL bFreeReq;
szStr = hb_itemString( pValue, &ulLen, &bFreeReq );
if( bFreeReq )
hb_retclen_buffer( szStr, ulLen );
else
hb_retclen( szStr, ulLen );
}
}
else if( HB_IS_DATE( pValue ) )
{
char szDate[ 9 ];
char szResult[ 11 ];
hb_retc( hb_dateFormat( hb_itemGetDS( pValue, szDate ), szResult, hb_setGetDateFormat() ) );
}
else if( HB_IS_LOGICAL( pValue ) )
{
hb_retc( hb_itemGetL( pValue ) ? "T" : "F" );
}
else
bError = TRUE;
}
else
bError = TRUE;
/* If there was any parameter error, launch a runtime error */
if( bError )
hb_errRT_BASE_SubstR( EG_ARG, 1122, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| transfrm.c | 88 |
| trim.c |
| Type | Function | Source | Line |
|---|
| CHAR * | hb_strLTrim( const char * szText, ULONG * ulLen )
char * hb_strLTrim( const char * szText, ULONG * ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strLTrim(%s, %p)", szText, ulLen));
while( *ulLen && HB_ISSPACE( *szText ) )
{
szText++;
( *ulLen )--;
}
return ( char * ) szText;
}
| trim.c | 57 |
| ULONG | hb_strRTrimLen( const char * szText, ULONG ulLen, BOOL bAnySpace )
ULONG hb_strRTrimLen( const char * szText, ULONG ulLen, BOOL bAnySpace )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strRTrimLen(%s, %lu. %d)", szText, ulLen, (int) bAnySpace));
if( bAnySpace )
{
while( ulLen && HB_ISSPACE( szText[ ulLen - 1 ] ) )
ulLen--;
}
else
{
while( ulLen && szText[ ulLen - 1 ] == ' ' )
ulLen--;
}
return ulLen;
}
| trim.c | 72 |
| HB_FUNC | LTRIM(void)
HB_FUNC( LTRIM )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText )
{
ULONG ulLen, ulSrc;
char * szText;
ulLen = ulSrc = hb_itemGetCLen( pText );
szText = hb_strLTrim( hb_itemGetCPtr( pText ), &ulLen );
if( ulLen == ulSrc )
hb_itemReturn( pText );
else
hb_retclen( szText, ulLen );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1101, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| trim.c | 93 |
| HB_FUNC | RTRIM(void)
HB_FUNC( RTRIM )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText )
{
ULONG ulLen, ulSrc;
char * szText = hb_itemGetCPtr( pText );
ulSrc = hb_itemGetCLen( pText );
#ifdef HB_EXTENSION
ulLen = hb_strRTrimLen( szText, ulSrc, ISLOG( 2 ) && hb_parl( 2 ) );
#else
ulLen = hb_strRTrimLen( szText, ulSrc, FALSE );
#endif
if( ulLen == ulSrc )
hb_itemReturn( pText );
else
hb_retclen( szText, ulLen );
}
else
/* NOTE: "TRIM" is right here [vszakats] */
hb_errRT_BASE_SubstR( EG_ARG, 1100, NULL, "TRIM", HB_ERR_ARGS_BASEPARAMS );
}
| trim.c | 118 |
| HB_FUNC | TRIM(void)
HB_FUNC( TRIM )
{
HB_FUNC_EXEC( RTRIM );
}
| trim.c | 144 |
| HB_FUNC | ALLTRIM(void)
HB_FUNC( ALLTRIM )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText )
{
ULONG ulLen, ulSrc;
char * szText = hb_itemGetCPtr( pText );
ulSrc = hb_itemGetCLen( pText );
#ifdef HB_EXTENSION
ulLen = hb_strRTrimLen( szText, ulSrc, ISLOG( 2 ) && hb_parl( 2 ) );
#else
ulLen = hb_strRTrimLen( szText, ulSrc, FALSE );
#endif
szText = hb_strLTrim( szText, &ulLen );
if( ulLen == ulSrc )
hb_itemReturn( pText );
else
hb_retclen( szText, ulLen );
}
else
#ifdef HB_COMPAT_C53
/* NOTE: This runtime error appeared in CA-Cl*pper 5.3 [vszakats] */
#ifdef HB_C52_STRICT
hb_errRT_BASE_SubstR( EG_ARG, 2022, NULL, HB_ERR_FUNCNAME, 0 );
#else
hb_errRT_BASE_SubstR( EG_ARG, 2022, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
#endif
#else
hb_retc( NULL );
#endif
}
| trim.c | 154 |
| tscalara.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBARRAY(void)
HB_FUNC( HBARRAY )
{
HB_FUNC_EXEC( __HBARRAY );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalara.c | 58 |
| tscalarb.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBBLOCK(void)
HB_FUNC( HBBLOCK )
{
HB_FUNC_EXEC( __HBBLOCK );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalarb.c | 58 |
| tscalarc.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBCHARACTER(void)
HB_FUNC( HBCHARACTER )
{
HB_FUNC_EXEC( __HBCHARACTER );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalarc.c | 58 |
| tscalard.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBDATE(void)
HB_FUNC( HBDATE )
{
HB_FUNC_EXEC( __HBDATE );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalard.c | 58 |
| tscalarh.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBHASH(void)
HB_FUNC( HBHASH )
{
HB_FUNC_EXEC( __HBHASH );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalarh.c | 58 |
| tscalarl.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBLOGICAL(void)
HB_FUNC( HBLOGICAL )
{
HB_FUNC_EXEC( __HBLOGICAL );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalarl.c | 58 |
| tscalarn.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBNUMERIC(void)
HB_FUNC( HBNUMERIC )
{
HB_FUNC_EXEC( __HBNUMERIC );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalarn.c | 58 |
| tscalarp.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBPOINTER(void)
HB_FUNC( HBPOINTER )
{
HB_FUNC_EXEC( __HBPOINTER );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalarp.c | 58 |
| tscalars.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBSYMBOL(void)
HB_FUNC( HBSYMBOL )
{
HB_FUNC_EXEC( __HBSYMBOL );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalars.c | 58 |
| tscalaru.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HBNIL(void)
HB_FUNC( HBNIL )
{
HB_FUNC_EXEC( __HBNIL );
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pItem = hb_param( -1, HB_IT_ANY );
if( HB_IS_OBJECT( pItem ) )
{
hb_vmPushDynSym( hb_dynsymGetCase( "NEW" ) );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
}
}
| tscalaru.c | 58 |
| type.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | TYPE(void)
HB_FUNC( TYPE )
{
HB_ITEM_PTR pItem = hb_param( 1, HB_IT_STRING );
if( pItem )
{
hb_retc( hb_macroGetType( pItem ) );
hb_memvarUpdatePrivatesBase();
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1121, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| type.c | 56 |
| val.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | VAL(void)
HB_FUNC( VAL )
{
PHB_ITEM pText = hb_param( 1, HB_IT_STRING );
if( pText )
{
char * szText = hb_itemGetCPtr( pText );
int iWidth, iDec, iLen = ( int ) hb_itemGetCLen( pText );
BOOL fDbl;
HB_LONG lValue;
double dValue;
fDbl = hb_valStrnToNum( szText, iLen, &lValue, &dValue , &iDec, &iWidth );
if( !fDbl )
hb_retnintlen( lValue, iWidth );
else
hb_retnlen( dValue, iWidth, iDec );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1098, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| val.c | 57 |
| valtostr.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_VALTOSTR(void)
HB_FUNC( HB_VALTOSTR )
{
ULONG ulLen;
BOOL bFreeReq;
char * buffer = hb_itemString( hb_param( 1, HB_IT_ANY ), &ulLen, &bFreeReq );
if( bFreeReq )
hb_retclen_buffer( buffer, ulLen );
else
hb_retclen( buffer, ulLen );
}
| valtostr.c | 56 |
| HB_FUNC | HB_STRTOEXP(void)
HB_FUNC( HB_STRTOEXP )
{
char * pszString = hb_parc( 1 );
if( pszString )
{
ULONG ulLen = hb_parclen( 1 ), ulRet, ul;
int iType = 0, iQ = 0;
char ch, * pDst, * pszResult;
for( ul = 0; ul < ulLen; ++ul )
{
if( pszString[ ul ] == '"' )
{
++iQ;
iType |= 1;
}
else if( pszString[ ul ] == '\\' )
++iQ;
else if( pszString[ ul ] == '\'' )
iType |= 2;
else if( pszString[ ul ] == ']' )
iType |= 4;
else if( pszString[ ul ] == '\r' ||
pszString[ ul ] == '\n' ||
pszString[ ul ] == '\0' )
{
iType |= 7;
iQ += 3;
}
}
if( iType == 7 )
{
ulRet = ulLen + 3 + iQ;
pDst = pszResult = ( char * ) hb_xgrab( ulRet + 1 );
*pDst++ = 'e';
*pDst++ = '"';
for( ul = 0; ul < ulLen; ++ul )
{
ch = pszString[ ul ];
if( ch == '"' )
{
*pDst++ = '\\';
*pDst++ = '"';
}
else if( ch == '\\' )
{
*pDst++ = '\\';
*pDst++ = '\\';
}
else if( ch == '\r' || ch == '\n' || ch == '\0' )
{
*pDst++ = '\\';
*pDst++ = '0';
*pDst++ = '0' + ( ch >> 3 );
*pDst++ = '0' + ( ch & 7 );
}
else
*pDst++ = ch;
}
*pDst++ = '"';
}
else
{
ulRet = ulLen + 2;
pDst = pszResult = ( char * ) hb_xgrab( ulRet + 1 );
if( ( iType & 1 ) == 0 )
*pDst++ = ch = '"';
else if( ( iType & 2 ) == 0 )
*pDst++ = ch = '\'';
else
{
*pDst++ = '[';
ch = ']';
}
memcpy( pDst, pszString, ulLen );
pDst += ulLen;
*pDst++ = ch;
}
*pDst = '\0';
hb_retclen_buffer( pszResult, ulRet );
}
}
| valtostr.c | 68 |
| valtype.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | VALTYPE(void)
HB_FUNC( VALTYPE )
{
hb_retc( hb_itemTypeStr( hb_param( 1, HB_IT_ANY ) ) );
}
| valtype.c | 70 |
| HB_FUNC | HB_ISNIL(void)
HB_FUNC( HB_ISNIL )
{
hb_retl( ISNIL( 1 ) );
}
| valtype.c | 89 |
| HB_FUNC | HB_ISNUMERIC(void)
HB_FUNC( HB_ISNUMERIC )
{
hb_retl( ISNUM( 1 ) );
}
| valtype.c | 94 |
| HB_FUNC | HB_ISLOGICAL(void)
HB_FUNC( HB_ISLOGICAL )
{
hb_retl( ISLOG( 1 ) );
}
| valtype.c | 99 |
| HB_FUNC | HB_ISDATE(void)
HB_FUNC( HB_ISDATE )
{
hb_retl( ISDATE( 1 ) );
}
| valtype.c | 104 |
| HB_FUNC | HB_ISBLOCK(void)
HB_FUNC( HB_ISBLOCK )
{
hb_retl( ISBLOCK( 1 ) );
}
| valtype.c | 109 |
| HB_FUNC | HB_ISPOINTER(void)
HB_FUNC( HB_ISPOINTER )
{
hb_retl( ISPOINTER( 1 ) );
}
| valtype.c | 114 |
| HB_FUNC | HB_ISSYMBOL(void)
HB_FUNC( HB_ISSYMBOL )
{
hb_retl( ISSYMBOL( 1 ) );
}
| valtype.c | 119 |
| HB_FUNC | HB_ISSTRING(void)
HB_FUNC( HB_ISSTRING )
{
hb_retl( ISCHAR( 1 ) );
}
| valtype.c | 124 |
| HB_FUNC | HB_ISCHAR(void)
HB_FUNC( HB_ISCHAR )
{
hb_retl( ( hb_parinfo( 1 ) & HB_IT_MEMO ) == HB_IT_STRING );
}
| valtype.c | 129 |
| HB_FUNC | HB_ISMEMO(void)
HB_FUNC( HB_ISMEMO )
{
hb_retl( ( hb_parinfo( 1 ) & HB_IT_MEMOFLAG ) != 0 );
}
| valtype.c | 134 |
| HB_FUNC | HB_ISARRAY(void)
HB_FUNC( HB_ISARRAY )
{
hb_retl( hb_extIsArray( 1 ) );
}
| valtype.c | 139 |
| HB_FUNC | HB_ISOBJECT(void)
HB_FUNC( HB_ISOBJECT )
{
hb_retl( ISOBJECT( 1 ) );
}
| valtype.c | 144 |
| HB_FUNC | HB_ISHASH(void)
HB_FUNC( HB_ISHASH )
{
hb_retl( ISHASH( 1 ) );
}
| valtype.c | 149 |
| HB_FUNC | HB_ISNULL(void)
HB_FUNC( HB_ISNULL )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem )
{
if( HB_IS_STRING( pItem ) )
{
hb_retl( hb_itemGetCLen( pItem ) == 0 );
return;
}
else if( HB_IS_ARRAY( pItem ) )
{
hb_retl( hb_arrayLen( pItem ) == 0 );
return;
}
else if( HB_IS_HASH( pItem ) )
{
hb_retl( hb_hashLen( pItem ) == 0 );
return;
}
}
hb_errRT_BASE_SubstR( EG_ARG, 1111, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| valtype.c | 154 |
| version.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | OS(void)
HB_FUNC( OS )
{
hb_retc_buffer( hb_verPlatform() );
}
| version.c | 66 |
| HB_FUNC | HB_COMPILER(void)
HB_FUNC( HB_COMPILER )
{
hb_retc_buffer( hb_verCompiler() );
}
| version.c | 71 |
| HB_FUNC | VERSION(void)
HB_FUNC( VERSION )
{
hb_retc_buffer( hb_verHarbour() );
}
| version.c | 76 |
| HB_FUNC | HB_PCODEVER(void)
HB_FUNC( HB_PCODEVER )
{
hb_retc_buffer( hb_verPCode() );
}
| version.c | 81 |
| HB_FUNC | HB_BUILDDATE(void)
HB_FUNC( HB_BUILDDATE )
{
hb_retc_buffer( hb_verBuildDate() );
}
| version.c | 86 |
| word.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | WORD(void)
HB_FUNC( WORD )
{
if( ISNUM( 1 ) )
hb_retni( hb_parni( 1 ) );
else
hb_errRT_BASE( EG_ARG, 1091, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| word.c | 60 |
| xhelp.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | __XHELP(void)
HB_FUNC( __XHELP )
{
static PHB_DYNS s_pDynSym = NULL;
if( s_pDynSym == NULL )
s_pDynSym = hb_dynsymGetCase( "HELP" );
if( hb_dynsymIsFunction( s_pDynSym ) )
{
/* awhite: push the existing params after the dyn symbol */
USHORT uiPCount = ( USHORT ) hb_pcount();
USHORT uiParam;
hb_vmPushDynSym( s_pDynSym );
hb_vmPushNil();
/* CA-Cl*pper respects references so hb_stackItemFromBase() is
* used insted of hb_param() [druzus]
*/
for( uiParam = 1; uiParam <= uiPCount; uiParam++ )
hb_vmPush( hb_stackItemFromBase( uiParam ) );
hb_vmDo( uiPCount );
/* NOTE: Leave the return value as it is. */
}
}
| xhelp.c | 57 |
| xsavescr.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_xSaveRestRelease( void * cargo )
static void hb_xSaveRestRelease( void * cargo )
{
PHB_SCRDATA pScrData = ( PHB_SCRDATA ) cargo;
if( pScrData->buffer )
hb_xfree( pScrData->buffer );
}
static HB_TSD_NEW( s_scrData, sizeof( HB_SCRDATA ), NULL, hb_xSaveRestRelease );
| xsavescr.c | 77 |
| HB_FUNC | __XSAVESCREEN(void)
HB_FUNC( __XSAVESCREEN )
{
PHB_SCRDATA pScrData = ( PHB_SCRDATA ) hb_stackGetTSD( &s_scrData );
ULONG ulSize;
hb_gtGetPos( &pScrData->row, &pScrData->col );
hb_gtRectSize( 0, 0, hb_gtMaxRow(), hb_gtMaxCol(), &ulSize );
if( pScrData->buffer )
hb_xfree( pScrData->buffer );
pScrData->buffer = hb_xgrab( ulSize );
hb_gtSave( 0, 0, hb_gtMaxRow(), hb_gtMaxCol(), pScrData->buffer );
}
| xsavescr.c | 87 |
| HB_FUNC | __XRESTSCREEN(void)
HB_FUNC( __XRESTSCREEN )
{
PHB_SCRDATA pScrData = ( PHB_SCRDATA ) hb_stackGetTSD( &s_scrData );
if( pScrData->buffer )
{
hb_gtRest( 0, 0, hb_gtMaxRow(), hb_gtMaxCol(), pScrData->buffer );
hb_xfree( pScrData->buffer );
pScrData->buffer = NULL;
hb_gtSetPos( pScrData->row, pScrData->col );
}
}
| xsavescr.c | 105 |
| achoice.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | AChoice( nTop, nLeft, nBottom, nRight, acItems, xSelect, xUserFunc, nPos, nHiLiteRow )
FUNCTION AChoice( nTop, nLeft, nBottom, nRight, acItems, xSelect, xUserFunc, nPos, nHiLiteRow )
LOCAL nNumCols // Number of columns in the window
LOCAL nNumRows // Number of rows in the window
LOCAL nRowsClr // Number of rows to clear
LOCAL acCopy := {} // A padded copy of the items
LOCAL alSelect // Select permission
LOCAL nNewPos := 0 // The next item to be selected
LOCAL lFinished := .F. // Is processing finished?
LOCAL nKey := 0 // The keystroke to be processed
LOCAL nMode := AC_IDLE // The current operating mode
LOCAL nAtTop := 1 // The number of the item at the top
LOCAL nAtBtm := 1 // The number of the item at the bottom
LOCAL nItems := 0 // The number of items
LOCAL nGap := 0 // The number of lines between top and current lines
// Block used to search for items
LOCAL lUserFunc // Is a user function to be used?
LOCAL nUserFunc := 0 // Return value from user function
LOCAL nSaveCsr := SetCursor( SC_NONE )
LOCAL nFrstItem := 0
LOCAL nLastItem := 0
LOCAL bAction
LOCAL cKey
LOCAL nAux
LOCAL bSelect := { | x, y | iif( ISLOGICAL( x ), x, iif( !Empty( x ), ( y := &( x ), iif( ISLOGICAL( y ), y, .T. ) ), .T.) ) }
ColorSelect( CLR_STANDARD )
lUserFunc := !Empty( xUserFunc ) .AND. ValType( xUserFunc ) $ "CB"
DEFAULT nTop TO 0 // The topmost row of the window
DEFAULT nLeft TO 0 // The leftmost column of the window
DEFAULT nBottom TO MaxRow() // The bottommost row of the window
DEFAULT nRight TO MaxCol() // The rightmost column of the window
DEFAULT acItems TO {} // The items from which to choose
DEFAULT xSelect TO .T. // Array or logical, what is selectable
DEFAULT nPos TO 1 // The number of the selected item
DEFAULT nHiLiteRow TO 0 // The row to be highlighted
nNumCols := nRight - nLeft + 1
IF nRight > MaxCol()
nRight := MaxCol()
ENDIF
IF nBottom > MaxRow()
nBottom := MaxRow()
ENDIF
nNumRows := nBottom - nTop + 1
IF VALTYPE( xSelect ) $ "A"
alSelect := xSelect
ELSE
alSelect := ARRAY( LEN( acItems ) )
AFill( alSelect, xSelect )
ENDIF
IF !lFinished
nMode := Ach_Limits( @nFrstItem, @nLastItem, @nItems, bSelect, alSelect, acItems )
IF nMode == AC_NOITEM
nPos := 0
ENDIF
// Ensure hilighted item can be selected
nPos := BETWEEN( nFrstItem, nPos, nLastItem )
// Force hilighted row to be valid
nHiLiteRow := BETWEEN( 0, nHiLiteRow, nNumRows - 1 )
// Force the topmost item to be a valid index of the array
nAtTop := BETWEEN( 1, Max( 1, nPos - nHiLiteRow ), nItems )
// Ensure as much of the selection area as possible is covered
IF ( nAtTop + nNumRows - 1 ) > nItems
nAtTop := Max( 1, nItems - nNumrows + 1 )
ENDIF
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect, nItems )
ENDIF
DO WHILE !lFinished
IF nMode != AC_GOTO .AND. nMode != AC_NOITEM
nKey := Inkey( 0 )
nMode := AC_IDLE
ENDIF
DO CASE
CASE ( bAction := SetKey( nKey ) ) != NIL
Eval( bAction, ProcName( 1 ), ProcLine( 1 ), "" )
IF Empty( NextKey() )
KEYBOARD Chr( 255 )
Inkey()
nKey := 0
ENDIF
nRowsClr := Min( nNumRows, nItems )
nMode := Ach_Limits( @nFrstItem, @nLastItem, @nItems, bSelect, alSelect, acItems )
IF nMode == AC_NOITEM
nPos := 0
nAtTop := Max( 1, nPos - nNumRows + 1 )
ELSE
DO WHILE nPos < nLastItem .AND. !Eval( bSelect, alSelect[ nPos ] )
nPos++
ENDDO
IF nPos > nLastItem
nPos := BETWEEN( nFrstItem, nPos, nLastItem )
ENDIF
nAtTop := MIN( nAtTop, nPos )
IF nAtTop + nNumRows - 1 > nItems
nAtTop := BETWEEN( 1, nPos - nNumRows + 1, nItems - nNumRows + 1 )
ENDIF
IF nAtTop < 1
nAtTop := 1
ENDIF
ENDIF
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect, nRowsClr )
CASE ( nKey == K_ESC .OR. nMode == AC_NOITEM ) .AND. !lUserFunc
nMode := AC_ABORT
nPos := 0
lFinished := .T.
CASE nKey == K_LDBLCLK .OR. nKey == K_LBUTTONDOWN
nAux := HitTest( nTop, nLeft, nBottom, nRight, MRow(), MCol() )
IF nAux != 0 .AND. ( nNewPos := nAtTop + nAux - 1 ) <= nItems
IF Eval( bSelect, alSelect[ nNewPos ] )
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
IF nKey == K_LDBLCLK
Keyboard( Chr( K_ENTER ) )
ENDIF
ENDIF
ENDIF
#ifdef HB_C52_STRICT
CASE nKey == K_UP
#else
CASE nKey == K_UP .OR. nKey == K_MWFORWARD
#endif
IF nPos == nFrstItem
nMode := AC_HITTOP
IF nAtTop > Max( 1, nPos - nNumRows + 1 )
nAtTop := Max( 1, nPos - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
nNewPos := nPos - 1
DO WHILE !Eval( bSelect, alSelect[ nNewPos ] )
nNewPos--
ENDDO
IF INRANGE( nAtTop, nNewPos, nAtTop + nNumRows - 1 )
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
ELSE
DispBegin()
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
Scroll( nTop, nLeft, nBottom, nRight, ( nNewPos - ( nAtTop + nNumRows - 1 ) ) )
nAtTop := nNewPos
nPos := Max( nPos, nAtTop + nNumRows - 1 )
DO WHILE nPos > nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos--
ENDDO
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
DispEnd()
ENDIF
ENDIF
#ifdef HB_C52_STRICT
CASE nKey == K_DOWN
#else
CASE nKey == K_DOWN .OR. nKey == K_MWBACKWARD
#endif
// Find the next selectable item to display
IF nPos == nLastItem
nMode := AC_HITBOTTOM
IF nAtTop < Min( nPos, nItems - nNumRows + 1 )
nAtTop := Min( nPos, nItems - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
nNewPos := nPos + 1
DO WHILE !Eval( bSelect, alSelect[ nNewPos ] )
nNewPos++
ENDDO
IF INRANGE( nAtTop, nNewPos, nAtTop + nNumRows - 1 )
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
ELSE
DispBegin()
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
Scroll( nTop, nLeft, nBottom, nRight, ( nNewPos - ( nAtTop + nNumRows - 1 ) ) )
nAtTop := nNewPos - nNumRows + 1
nPos := Max( nPos, nAtTop )
DO WHILE nPos < nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos++
ENDDO
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
DispEnd()
ENDIF
ENDIF
CASE nKey == K_CTRL_PGUP .OR. ( nKey == K_HOME .AND. !lUserFunc )
IF nPos == nFrstItem
IF nAtTop == Max( 1, nPos - nNumRows + 1 )
nMode := AC_HITTOP
ELSE
nAtTop := Max( 1, nPos - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
nPos := nFrstItem
nAtTop := nPos
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
CASE nKey == K_CTRL_PGDN .OR. ( nKey == K_END .AND. !lUserFunc )
IF nPos == nLastItem
IF nAtTop == Min( nLastItem, nItems - nNumRows + 1 )
nMode := AC_HITBOTTOM
ELSE
nAtTop := Min( nLastItem, nItems - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
IF INRANGE( nAtTop, nLastItem, nAtTop + nNumRows - 1 )
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nLastItem
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
ELSE
nPos := nLastItem
nAtTop := Max( 1, nPos - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ENDIF
CASE nKey == K_CTRL_HOME
IF nPos == nFrstItem
IF nAtTop == Max( 1, nPos - nNumRows + 1 )
nMode := AC_HITTOP
ELSE
nAtTop := Max( 1, nPos - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
nNewPos := nAtTop
DO WHILE !Eval( bSelect, alSelect[ nNewPos ] )
nNewPos++
ENDDO
IF nNewPos != nPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
ENDIF
ENDIF
CASE nKey == K_CTRL_END
IF nPos == nLastItem
IF nAtTop == Min( nPos, nItems - nNumRows + 1 )
nMode := AC_HITBOTTOM
ELSE
nAtTop := Min( nPos, nItems - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
nNewPos := Min( nAtTop + nNumRows - 1, nItems )
DO WHILE !Eval( bSelect, alSelect[ nNewPos ] )
nNewPos--
ENDDO
IF nNewPos != nPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
ENDIF
ENDIF
CASE nKey == K_PGUP
IF nPos == nFrstItem
nMode := AC_HITTOP
IF nAtTop > Max( 1, nPos - nNumRows + 1 )
nAtTop := Max( 1, nPos - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
IF INRANGE( nAtTop, nFrstItem, nAtTop + nNumRows - 1 )
// On same page as nFrstItem
nPos := nFrstItem
nAtTop := Max( nPos - nNumRows + 1, 1 )
ELSE
IF ( nPos - nNumRows + 1 ) < nFrstItem
nPos := nFrstItem
nAtTop := nFrstItem
ELSE
nPos := Max( nFrstItem, nPos - nNumRows + 1 )
nAtTop := Max( 1, nAtTop - nNumRows + 1 )
DO WHILE nPos > nFrstItem .AND. !Eval( bSelect, alSelect[ nPos ] )
nPos--
nAtTop--
ENDDO
nAtTop := Max( 1, nAtTop )
ENDIF
ENDIF
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
CASE nKey == K_PGDN
IF nPos == nLastItem
nMode := AC_HITBOTTOM
IF nAtTop < Min( nPos, nItems - nNumRows + 1 )
nAtTop := Min( nPos, nItems - nNumRows + 1 )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ELSE
IF INRANGE( nAtTop, nLastItem, nAtTop + nNumRows - 1 )
// On the same page as nLastItem
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nLastItem
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
ELSE
nGap := nPos - nAtTop
nPos := Min( nLastItem, nPos + nNumRows - 1 )
IF ( nPos + nNumRows - 1 ) > nLastItem
// On the last page
nAtTop := nLastItem - nNumRows + 1
nPos := Min( nLastItem, nAtTop + nGap )
ELSE
// Not on the last page
nAtTop := nPos - nGap
ENDIF
// Make sure that the item is selectable
DO WHILE nPos < nLastItem .AND. !Eval( bSelect, alSelect[ nPos ] )
nPos++
nAtTop++
ENDDO
// Don't leave blank space on the page
DO WHILE ( nAtTop + nNumRows - 1 ) > nItems
nAtTop--
ENDDO
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ENDIF
CASE nKey == K_ENTER .AND. !lUserFunc
nMode := AC_SELECT
lFinished := .T.
CASE nKey == K_RIGHT .AND. !lUserFunc
nPos := 0
lFinished := .T.
CASE nKey == K_LEFT .AND. !lUserFunc
nPos := 0
lFinished := .T.
CASE INRANGE( 32, nKey, 255 ) .AND. ( !lUserFunc .OR. nMode == AC_GOTO )
cKey := Upper( Chr( nKey ) )
// Find next selectable item
FOR nNewPos := nPos + 1 TO nItems
IF Eval( bSelect, alSelect[ nNewPos ] ) .AND. Upper( Left( acItems[ nNewPos ], 1 ) ) == cKey
EXIT
ENDIF
NEXT
IF nNewPos == nItems + 1
FOR nNewPos := 1 TO nPos - 1
IF Eval( bSelect, alSelect[ nNewPos ] ) .AND. Upper( Left( acItems[ nNewPos ], 1 ) ) == cKey
EXIT
ENDIF
NEXT
ENDIF
IF nNewPos != nPos
IF INRANGE( nAtTop, nNewPos, nAtTop + nNumRows - 1 )
// On same page
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .F., nNumCols )
nPos := nNewPos
DispLine( acItems[ nPos ], nTop + ( nPos - nAtTop ), nLeft, Eval( bSelect, alSelect[ nPos ] ), .T., nNumCols )
ELSE
// On different page
nPos := nNewPos
nAtTop := BETWEEN( 1, nPos - nNumRows + 1, nItems )
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect )
ENDIF
ENDIF
nMode := AC_IDLE
CASE nMode == AC_GOTO
// Garbage collect gotos which aren't valid ASCII characters
nMode := AC_IDLE
OTHERWISE
IF nMode != AC_NOITEM
IF nKey == 0 // No keystroke
nMode := AC_IDLE
ELSE
nMode := AC_EXCEPT
ENDIF
ENDIF
ENDCASE
IF lUserFunc
nUserFunc := Do( xUserFunc, nMode, nPos, nPos - nAtTop )
IF ISNUMBER( nUserFunc )
DO CASE
CASE nUserFunc == AC_ABORT .OR. nMode == AC_NOITEM
lFinished := .T.
nPos := 0
CASE nUserFunc == AC_SELECT
lFinished := .T.
CASE nUserFunc == AC_CONT .OR. nUserFunc == AC_REDRAW
// Do nothing
nMode := AC_CONT
CASE nUserFunc == AC_GOTO
// Do nothing. The next keystroke won't be read and
// this keystroke will be processed as a goto.
nMode := AC_GOTO
ENDCASE
IF nPos > 0 .AND. nMode != AC_GOTO
nRowsClr := Min( nNumRows, nItems )
nMode := Ach_Limits( @nFrstItem, @nLastItem, @nItems, bSelect, alSelect, acItems )
IF nMode == AC_NOITEM
nPos := 0
nAtTop := Max( 1, nPos - nNumRows + 1 )
ELSE
DO WHILE nPos < nLastItem .AND. !Eval( bSelect, alSelect[ nPos ] )
nPos++
ENDDO
IF nPos > nLastItem
nPos := BETWEEN( nFrstItem, nPos, nLastItem )
ENDIF
nAtTop := MIN( nAtTop, nPos )
IF nAtTop + nNumRows - 1 > nItems
nAtTop := BETWEEN( 1, nPos - nNumRows + 1, nItems - nNumRows + 1 )
ENDIF
IF nAtTop < 1
nAtTop := 1
ENDIF
ENDIF
DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nItems, bSelect, nRowsClr )
ENDIF
ELSE
nPos := 0
lFinished := .T.
ENDIF
ENDIF
ENDDO
SetCursor( nSaveCsr )
RETURN nPos
| achoice.prg | 23 |
| STATIC FUNCTION | HitTest( nTop, nLeft, nBottom, nRight, mRow, mCol )
STATIC FUNCTION HitTest( nTop, nLeft, nBottom, nRight, mRow, mCol )
IF mCol >= nLeft .AND. ;
mCol <= nRight .AND. ;
mRow >= nTop .AND. ;
mRow <= nBottom
RETURN mRow - nTop + 1
ENDIF
RETURN 0
| achoice.prg | 529 |
| STATIC PROCEDURE | DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nArrLen, bSelect, nRowsClr )
STATIC PROCEDURE DispPage( acItems, alSelect, nTop, nLeft, nRight, nNumRows, nPos, nAtTop, nArrLen, bSelect, nRowsClr )
LOCAL nCntr
LOCAL nRow // Screen row
LOCAL nIndex // Array index
LOCAL nSaveRow := Row() // Position at start of routine
LOCAL nSaveCol := Col() // Position at start of routine
DEFAULT nRowsClr TO nNumRows
DispBegin()
FOR nCntr := 1 TO Min( nNumRows, nRowsClr )
nRow := nTop + nCntr - 1
nIndex := nCntr + nAtTop - 1
IF INRANGE( 1, nIndex, nArrLen )
DispLine( acItems[ nIndex ], nRow, nLeft, Eval( bSelect, alSelect[ nIndex ] ), nIndex == nPos, nRight - nLeft + 1 )
ELSE
ColorSelect( CLR_STANDARD )
DispOutAt( nRow, nLeft, Space( nRight - nLeft + 1 ) )
ENDIF
NEXT
DispEnd()
SetPos( nSaveRow, nSaveCol )
RETURN
| achoice.prg | 540 |
| STATIC PROCEDURE | DispLine( cLine, nRow, nCol, lSelect, lHiLite, nNumCols )
STATIC PROCEDURE DispLine( cLine, nRow, nCol, lSelect, lHiLite, nNumCols )
ColorSelect( iif( lSelect .AND. ISCHARACTER( cLine ), ;
iif( lHiLite, CLR_ENHANCED, CLR_STANDARD ), CLR_UNSELECTED ) )
DispOutAt( nRow, nCol, iif( ISCHARACTER( cLine ), PadR( cLine, nNumCols ), Space( nNumCols ) ) )
ColorSelect( CLR_STANDARD )
RETURN
| achoice.prg | 571 |
| STATIC FUNCTION | Ach_Limits( nFrstItem, nLastItem, nItems, bSelect, alSelect, acItems )
STATIC FUNCTION Ach_Limits( nFrstItem, nLastItem, nItems, bSelect, alSelect, acItems )
LOCAL nMode
LOCAL nCntr
nItems := 0
FOR nCntr := 1 TO LEN( acItems )
IF ISCHARACTER( acItems[ nCntr ] )
nItems++
ELSE
EXIT
ENDIF
NEXT
nFrstItem := AScan( alSelect, bSelect ) // First valid item
IF nFrstItem == 0
nLastItem := 0
ELSE
nMode := AC_IDLE
nLastItem := nItems // Last valid item
DO WHILE nLastItem > 0 .AND. !Eval( bSelect, alSelect[ nLastItem ] )
nLastItem--
ENDDO
ENDIF
IF nLastItem <= 0
nMode := AC_NOITEM
nLastItem := nItems
ENDIF
RETURN nMode
| achoice.prg | 582 |
| adir.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | ADir( cFileMask, aName, aSize, aDate, aTime, aAttr )
FUNCTION ADir( cFileMask, aName, aSize, aDate, aTime, aAttr )
LOCAL aDir
LOCAL nDirLen
LOCAL nDirPos
LOCAL nNameLen, nSizeLen, nDateLen, nTimeLen, nAttrLen
LOCAL aFileInfo
LOCAL cDir
LOCAL cName
LOCAL cExt
// ; CA-Cl*pper would fail on this case.
IF !ISCHARACTER( cFileMask )
RETURN 0
ENDIF
// ; If no drive/dir specified, use the SET DEFAULT setting.
hb_FNameSplit( cFileMask, @cDir, @cName, @cExt )
IF Empty( cDir )
cFileMask := hb_FNameMerge( __DefPath(), cName, cExt )
ENDIF
// ;
IF ISARRAY( aAttr )
aDir := Directory( cFileMask, "HSD" )
ELSE
aDir := Directory( cFileMask )
ENDIF
IF ISARRAY( aName )
nNameLen := Len( aName )
ENDIF
IF ISARRAY( aSize )
nSizeLen := Len( aSize )
ENDIF
IF ISARRAY( aDate )
nDateLen := Len( aDate )
ENDIF
IF ISARRAY( aTime )
nTimeLen := Len( aTime )
ENDIF
IF ISARRAY( aAttr )
nAttrLen := Len( aAttr )
ENDIF
// ;
nDirLen := Len( aDir )
FOR nDirPos := 1 TO nDirLen
aFileInfo := aDir[ nDirPos ]
IF nNameLen != NIL .AND. nNameLen >= nDirPos
aName[ nDirPos ] := aFileInfo[ F_NAME ]
ENDIF
IF nSizeLen != NIL .AND. nSizeLen >= nDirPos
aSize[ nDirPos ] := aFileInfo[ F_SIZE ]
ENDIF
IF nDateLen != NIL .AND. nDateLen >= nDirPos
aDate[ nDirPos ] := aFileInfo[ F_DATE ]
ENDIF
IF nTimeLen != NIL .AND. nTimeLen >= nDirPos
aTime[ nDirPos ] := aFileInfo[ F_TIME ]
ENDIF
IF nAttrLen != NIL .AND. nAttrLen >= nDirPos
aAttr[ nDirPos ] := aFileInfo[ F_ATTR ]
ENDIF
NEXT
RETURN nDirLen
| adir.prg | 56 |
| alert.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | Alert( xMessage, aOptions, cColorNorm, nDelay )
FUNCTION Alert( xMessage, aOptions, cColorNorm, nDelay )
LOCAL cMessage
LOCAL cColorHigh
LOCAL aOptionsOK
LOCAL nEval
#ifdef HB_EXTENSION
LOCAL lFirst
LOCAL cLine
#endif
#ifdef HB_C52_UNDOC
DEFAULT s_lNoAlert TO hb_argCheck( "NOALERT" )
IF s_lNoAlert
RETURN NIL
ENDIF
#endif
#ifdef HB_EXTENSION
IF PCount() == 0
RETURN NIL
ENDIF
cMessage := ""
IF ISARRAY( xMessage )
lFirst := .T.
FOR nEval := 1 TO Len( xMessage )
IF ISCHARACTER( cLine := xMessage[ nEval ] )
cMessage += iif( lFirst, "", Chr( 10 ) ) + cLine
lFirst := .F.
ENDIF
NEXT
ELSE
DO CASE
CASE ValType( xMessage ) $ "CM" ; cMessage := StrTran( xMessage, ";", Chr( 10 ) )
CASE ValType( xMessage ) == "N" ; cMessage := LTrim( Str( xMessage ) )
CASE ValType( xMessage ) == "D" ; cMessage := DToC( xMessage )
CASE ValType( xMessage ) == "L" ; cMessage := iif( xMessage, ".T.", ".F." )
CASE ValType( xMessage ) == "O" ; cMessage := xMessage:className + " Object"
CASE ValType( xMessage ) == "S" ; cMessage := "@" + xMessage:Name + "()"
CASE ValType( xMessage ) == "B" ; cMessage := "{||...}"
OTHERWISE ; cMessage := "NIL"
ENDCASE
ENDIF
#else
IF !ISCHARACTER( xMessage )
RETURN NIL
ENDIF
cMessage := StrTran( xMessage, ";", Chr( 10 ) )
#endif
IF !ISARRAY( aOptions )
aOptions := {}
ENDIF
IF !ISCHARACTER( cColorNorm ) .OR. EMPTY( cColorNorm )
cColorNorm := "W+/R" // first pair color (Box line and Text)
cColorHigh := "W+/B" // second pair color (Options buttons)
ELSE
cColorHigh := StrTran( StrTran( iif( At( "/", cColorNorm ) == 0, "N", SubStr( cColorNorm, At( "/", cColorNorm ) + 1 ) ) + "/" +;
iif( At( "/", cColorNorm ) == 0, cColorNorm, Left( cColorNorm, At( "/", cColorNorm ) - 1 ) ), "+", "" ), "*", "" )
ENDIF
IF nDelay == NIL
nDelay := 0
ENDIF
aOptionsOK := {}
FOR nEval := 1 TO Len( aOptions )
IF ISCHARACTER( aOptions[ nEval ] ) .AND. !Empty( aOptions[ nEval ] )
AAdd( aOptionsOK, aOptions[ nEval ] )
ENDIF
NEXT
IF Len( aOptionsOK ) == 0
aOptionsOK := { "Ok" }
#ifdef HB_C52_STRICT
/* NOTE: Clipper allows only four options [vszakats] */
ELSEIF Len( aOptionsOK ) > 4
ASize( aOptionsOK, 4 )
#endif
ENDIF
RETURN hb_gtAlert( cMessage, aOptionsOK, cColorNorm, cColorHigh, nDelay );
| alert.prg | 48 |
| PROCEDURE | __NONOALERT()
PROCEDURE __NONOALERT()
s_lNoAlert := .F.
RETURN
| alert.prg | 147 |
| altd.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | AltD( nAction )
PROCEDURE AltD( nAction )
IF PCOUNT() == 0
/* do not activate the debugger imediatelly because the module
where ALTD() was called can have no debugger info - stop
on first LINE with debugged info
*/
__dbgINVOKEDEBUG( SET( _SET_DEBUG ) )
ELSEIF HB_ISNUMERIC( nAction )
IF nAction == ALTD_DISABLE
SET( _SET_DEBUG, .F. )
ELSEIF nAction == ALTD_ENABLE
SET( _SET_DEBUG, .T. )
ENDIF
ENDIF
RETURN
| altd.prg | 61 |
| browdb.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | TBrowseDB( nTop, nLeft, nBottom, nRight )
FUNCTION TBrowseDB( nTop, nLeft, nBottom, nRight )
LOCAL oBrowse := TBrowseNew( nTop, nLeft, nBottom, nRight )
#ifdef HB_COMPAT_XPP
oBrowse:SkipBlock := { | nRecs | DbSkipper( nRecs ) }
#else
oBrowse:SkipBlock := { | nRecs | Skipped( nRecs ) }
#endif
oBrowse:GoTopBlock := { || dbGoTop() }
oBrowse:GoBottomBlock := { || dbGoBottom() }
RETURN oBrowse
| browdb.prg | 53 |
| STATIC FUNCTION | Skipped( nRecs )
STATIC FUNCTION Skipped( nRecs )
LOCAL nSkipped := 0
IF LastRec() != 0
IF nRecs == 0
dbSkip( 0 )
ELSEIF nRecs > 0 .AND. RecNo() != LastRec() + 1
DO WHILE nSkipped < nRecs
dbSkip( 1 )
IF Eof()
dbSkip( -1 )
EXIT
ENDIF
nSkipped++
ENDDO
ELSEIF nRecs < 0
DO WHILE nSkipped > nRecs
dbSkip( -1 )
IF Bof()
EXIT
ENDIF
nSkipped--
ENDDO
ENDIF
ENDIF
RETURN nSkipped
| browdb.prg | 68 |
| browdbx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbSkipper( nRecs )
FUNCTION dbSkipper( nRecs )
LOCAL nSkipped := 0
IF LastRec() != 0
IF nRecs == 0
dbSkip( 0 )
ELSEIF nRecs > 0 .AND. RecNo() != LastRec() + 1
DO WHILE nSkipped < nRecs
dbSkip( 1 )
IF Eof()
dbSkip( -1 )
EXIT
ENDIF
nSkipped++
ENDDO
ELSEIF nRecs < 0
DO WHILE nSkipped > nRecs
dbSkip( -1 )
IF Bof()
EXIT
ENDIF
nSkipped--
ENDDO
ENDIF
ENDIF
RETURN nSkipped
| browdbx.prg | 63 |
| browse.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | Browse( nTop, nLeft, nBottom, nRight )
FUNCTION Browse( nTop, nLeft, nBottom, nRight )
LOCAL oBrw
LOCAL lExit, lGotKey, lAppend, lKeyPressed, lRefresh
LOCAL n, nOldCursor, nKey
LOCAL cOldScreen
LOCAL bAction
IF ! Used()
RETURN .F.
ENDIF
lExit := lGotKey := lAppend := lKeyPressed := lRefresh := .F.
IF PCount() < 4
nTop := 1
nLeft := 0
nBottom := MaxRow()
nRight := MaxCol()
ENDIF
DispBegin()
nOldCursor := SetCursor( SC_NONE )
cOldScreen := SaveScreen( nTop, nLeft, nBottom, nRight )
DispBox( nTop, nLeft, nBottom, nRight, B_DOUBLE_SINGLE )
DispBox( nTop + 3, nLeft, nTop + 3, nLeft, chr( 198 ) )
DispBox( nTop + 3, nRight, nTop + 3, nRight, chr( 181 ) )
DispOutAt( nTop + 1, nLeft + 1, Space( nRight - nLeft - 1 ) )
oBrw := TBrowseDB( nTop + 2, nLeft + 1, nBottom - 1, nRight - 1 )
oBrw:HeadSep := " " + Chr( 205 )
oBrw:SkipBlock := { | nRecs | Skipped( nRecs, lAppend ) }
FOR n := 1 to FCount()
oBrw:AddColumn( TBColumnNew( FieldName( n ), FieldBlock( FieldName( n ) ) ) )
NEXT
IF Eof()
DbGoTop()
ENDIF
oBrw:ForceStable()
DispEnd()
IF LastRec() == 0
nKey := K_DOWN
lKeyPressed := .T.
ENDIF
DO WHILE ! lExit
DO WHILE ! lKeyPressed .AND. ! oBrw:Stabilize()
lKeyPressed := ( nKey := Inkey() ) != 0
ENDDO
IF ! lKeyPressed
IF oBrw:HitBottom() .AND. ( ! lAppend .OR. RecNo() != LastRec() + 1 )
IF lAppend
oBrw:RefreshCurrent()
oBrw:ForceStable()
dbGoBottom()
ELSE
lAppend := .T.
SetCursor( IIF( ReadInsert(), SC_INSERT, SC_NORMAL ) )
ENDIF
oBrw:Down()
oBrw:ForceStable()
oBrw:ColorRect( { oBrw:RowPos, 1, oBrw:RowPos, oBrw:ColCount() }, ;
{ 2, 2 } )
ENDIF
StatLine( oBrw, lAppend )
oBrw:ForceStable()
nKey := InKey( 0 )
IF ( bAction := SetKey( nKey ) ) != NIL
Eval( bAction, ProcName( 1 ), ProcLine( 1 ), "")
LOOP
ENDIF
ELSE
lKeyPressed := .F.
ENDIF
SWITCH nKey
#ifdef HB_COMPAT_C53
CASE K_LBUTTONDOWN
CASE K_LDBLCLK
TBMOUSE( oBrw, MRow(), MCol() )
EXIT
#endif
#ifndef HB_C52_STRICT
CASE K_MWFORWARD
#endif
CASE K_UP
IF lAppend
lRefresh := .T.
ELSE
oBrw:Up()
ENDIF
EXIT
#ifndef HB_C52_STRICT
CASE K_MWBACKWARD
#endif
CASE K_DOWN
IF lAppend
oBrw:HitBottom( .T. )
ELSE
oBrw:Down()
ENDIF
EXIT
CASE K_PGUP
IF lAppend
lRefresh := .T.
ELSE
oBrw:PageUp()
ENDIF
EXIT
CASE K_PGDN
IF lAppend
oBrw:HitBottom( .T. )
ELSE
oBrw:PageDown()
ENDIF
EXIT
CASE K_CTRL_PGUP
IF lAppend
lRefresh := .T.
ELSE
oBrw:GoTop()
ENDIF
EXIT
CASE K_CTRL_PGDN
IF lAppend
lRefresh := .T.
ELSE
oBrw:GoBottom()
ENDIF
EXIT
CASE K_LEFT
oBrw:Left()
EXIT
CASE K_RIGHT
oBrw:Right()
EXIT
CASE K_HOME
oBrw:Home()
EXIT
CASE K_END
oBrw:End()
EXIT
CASE K_CTRL_LEFT
oBrw:panLeft()
EXIT
CASE K_CTRL_RIGHT
oBrw:panRight()
EXIT
CASE K_CTRL_HOME
oBrw:panHome()
EXIT
CASE K_CTRL_END
oBrw:panEnd()
EXIT
CASE K_INS
IF lAppend
SetCursor( IIF( ReadInsert( ! ReadInsert() ), ;
SC_NORMAL, SC_INSERT ) )
ENDIF
EXIT
CASE K_DEL
IF RecNo() != LastRec() + 1
IF Deleted()
DbRecall()
ELSE
DbDelete()
ENDIF
ENDIF
EXIT
CASE K_ENTER
IF lAppend .OR. RecNo() != LastRec() + 1
lKeyPressed := ( nKey := DoGet( oBrw, lAppend ) ) != 0
ELSE
nKey := K_DOWN
lKeyPressed := .T.
ENDIF
EXIT
CASE K_ESC
lExit := .t.
EXIT
OTHERWISE
IF nKey >= 32 .AND. nKey <= 255
KEYBOARD Chr( nKey )
nKey := K_ENTER
lKeyPressed := .T.
ENDIF
EXIT
ENDSWITCH
IF lRefresh
lRefresh := lAppend := .F.
FreshOrder( oBrw )
SetCursor( SC_NONE )
ENDIF
ENDDO
RestScreen( nTop, nLeft, nBottom, nRight, cOldScreen )
SetCursor( nOldCursor )
RETURN .T.
| browse.prg | 57 |
| STATIC PROCEDURE | StatLine( oBrw, lAppend )
STATIC PROCEDURE StatLine( oBrw, lAppend )
LOCAL nTop := oBrw:nTop - 1
LOCAL nRight := oBrw:nRight
DispOutAt( nTop, nRight - 27, "Record " )
IF LastRec() == 0 .AND. ! lAppend
DispOutAt( nTop, nRight - 20, " " )
ELSEIF RecNo() == LastRec() + 1
DispOutAt( nTop, nRight - 40, " " )
DispOutAt( nTop, nRight - 20, " " )
ELSE
DispOutAt( nTop, nRight - 40, IIF( Deleted(), "", " " ) )
DispOutAt( nTop, nRight - 20, PadR( LTrim( Str( RecNo() ) ) + "/" + ;
LTrim( Str( LastRec() ) ), 16 ) + ;
IIF( oBrw:HitTop(), "", " " ) )
ENDIF
RETURN
| browse.prg | 291 |
| STATIC FUNCTION | DoGet( oBrw, lAppend )
STATIC FUNCTION DoGet( oBrw, lAppend )
LOCAL lScore, lExit, bIns, nCursor
LOCAL oCol, oGet
LOCAL cIndexKey, cForExp, xKeyValue
LOCAL lSuccess, nKey, xValue
oBrw:HitTop( .F. )
StatLine( oBrw, lAppend )
oBrw:ForceStable()
lScore := Set( _SET_SCOREBOARD, .F. )
lExit := Set( _SET_EXIT, .T. )
bIns := SetKey( K_INS, {|| SetCursor( IIF( ReadInsert( ! ReadInsert() ), ;
SC_NORMAL, SC_INSERT ) ) } )
nCursor := SetCursor( IIF( ReadInsert(), SC_INSERT, SC_NORMAL ) )
IF !Empty( cIndexKey := IndexKey( 0 ) )
xKeyValue := &cIndexKey
ENDIF
oCol := oBrw:GetColumn( oBrw:ColPos )
xValue := Eval( oCol:Block )
oGet := GetNew( Row(), Col(), ;
{ |xNewVal| IIF( PCount() == 0, xValue, xValue := xNewVal ) }, ;
"mGetVar", NIL, oBrw:ColorSpec )
lSuccess := .F.
IF ReadModal( { oGet } )
IF lAppend .AND. RecNo() == LastRec() + 1
dbAppend()
ENDIF
Eval( oCol:Block, xValue )
IF !lAppend .AND. !Empty( cForExp := OrdFor( IndexOrd() ) ) .AND. ;
! &cForExp
dbGoTop()
ENDIF
IF !lAppend .AND. !Empty( cIndexKey ) .AND. ! xKeyValue == &cIndexKey
lSuccess := .T.
ENDIF
ENDIF
IF lSuccess
FreshOrder( oBrw )
nKey := 0
ELSE
oBrw:RefreshCurrent()
nKey := ExitKey( lAppend )
ENDIF
IF lAppend
oBrw:ColorRect( { oBrw:rowpos, 1, oBrw:rowpos, oBrw:colcount }, ;
{ 2, 2 } )
ENDIF
SetCursor( nCursor )
SetKey( K_INS, bIns )
Set( _SET_EXIT, lExit )
Set( _SET_SCOREBOARD, lScore )
RETURN nKey
| browse.prg | 312 |
| STATIC FUNCTION | ExitKey( lAppend )
STATIC FUNCTION ExitKey( lAppend )
LOCAL nKey := LastKey()
SWITCH nKey
CASE K_PGDN
nKey := IIF( lAppend, 0, K_DOWN )
EXIT
CASE K_PGUP
nKey := IIF( lAppend, 0, K_UP )
CASE K_DOWN
CASE K_UP
EXIT
OTHERWISE
nKey := IIF( nKey == 13 .OR. ;
( nKey >= 32 .AND. nKey <= 255 ), K_RIGHT, 0 )
EXIT
ENDSWITCH
RETURN nKey
| browse.prg | 373 |
| STATIC PROCEDURE | FreshOrder( oBrw )
STATIC PROCEDURE FreshOrder( oBrw )
LOCAL nRec := RecNo()
oBrw:RefreshAll()
oBrw:ForceStable()
IF nRec != LastRec() + 1
DO WHILE RecNo() != nRec .AND. !BOF()
oBrw:Up()
oBrw:ForceStable()
ENDDO
ENDIF
RETURN
| browse.prg | 397 |
| STATIC FUNCTION | Skipped( nRecs, lAppend )
STATIC FUNCTION Skipped( nRecs, lAppend )
LOCAL nSkipped := 0
IF LastRec() != 0
IF nRecs == 0
dbSkip( 0 )
ELSEIF nRecs > 0 .AND. RecNo() != LastRec() + 1
DO WHILE nSkipped < nRecs
dbSkip()
IF Eof()
IF lAppend
nSkipped++
ELSE
dbSkip( -1 )
ENDIF
EXIT
ENDIF
nSkipped++
ENDDO
ELSEIF nRecs < 0
DO WHILE nSkipped > nRecs
dbSkip( -1 )
IF Bof()
EXIT
ENDIF
nSkipped--
ENDDO
ENDIF
ENDIF
RETURN nSkipped
| browse.prg | 413 |
| checkbox.prg |
| Type | Function | Source | Line |
|---|
| METHOD | display()
METHOD display()
| checkbox.prg | 75 |
| METHOD | hitTest( nMRow, nMCol )
METHOD hitTest( nMRow, nMCol )
| checkbox.prg | 76 |
| METHOD | killFocus()
METHOD killFocus()
| checkbox.prg | 77 |
| METHOD | select()
METHOD select()
| checkbox.prg | 78 |
| METHOD | setFocus()
METHOD setFocus()
| checkbox.prg | 79 |
| METHOD | bitmaps( aBitmaps ) SETGET
METHOD bitmaps( aBitmaps ) SETGET
| checkbox.prg | 81 |
| METHOD | buffer() SETGET
METHOD buffer() SETGET
| checkbox.prg | 82 |
| METHOD | capCol( nCapCol ) SETGET
METHOD capCol( nCapCol ) SETGET
| checkbox.prg | 83 |
| METHOD | capRow( nCapRow ) SETGET
METHOD capRow( nCapRow ) SETGET
| checkbox.prg | 84 |
| METHOD | caption( cCaption ) SETGET
METHOD caption( cCaption ) SETGET
| checkbox.prg | 85 |
| METHOD | col( nCol ) SETGET
METHOD col( nCol ) SETGET
| checkbox.prg | 86 |
| METHOD | colorSpec( cColorSpec ) SETGET
METHOD colorSpec( cColorSpec ) SETGET
| checkbox.prg | 87 |
| METHOD | fBlock( bFBlock ) SETGET
METHOD fBlock( bFBlock ) SETGET
| checkbox.prg | 88 |
| METHOD | hasFocus() SETGET
METHOD hasFocus() SETGET
| checkbox.prg | 89 |
| METHOD | message( cMessage ) SETGET
METHOD message( cMessage ) SETGET
| checkbox.prg | 90 |
| METHOD | row( nRow ) SETGET
METHOD row( nRow ) SETGET
| checkbox.prg | 91 |
| METHOD | sBlock( bSBlock ) SETGET
METHOD sBlock( bSBlock ) SETGET
| checkbox.prg | 92 |
| METHOD | style( cStyle ) SETGET
METHOD style( cStyle ) SETGET
| checkbox.prg | 93 |
| METHOD | typeOut() SETGET
METHOD typeOut() SETGET
| checkbox.prg | 94 |
| METHOD | New( nRow, nCol, cCaption )
METHOD New( nRow, nCol, cCaption ) /* NOTE: This method is a Harbour extension [vszakats] */
PROTECTED:
VAR aBitmaps INIT { "check_f.bmu", "check_e.bmu" }
VAR lBuffer INIT .F.
VAR nCapCol
VAR nCapRow
VAR cCaption
VAR nCol
VAR cColorSpec
VAR bFBlock
VAR lHasFocus INIT .F.
VAR cMessage INIT ""
VAR nRow
VAR bSBlock
VAR cStyle INIT "[" + Chr( 251 ) + " ]"
VAR nCursor
ENDCLASS
| checkbox.prg | 96 |
| CHECKBOX:METHOD | setFocus() CLASS CHECKBOX
METHOD setFocus() CLASS CHECKBOX
IF !::lHasFocus
::nCursor := SetCursor( SC_NONE )
::lHasFocus := .T.
::display()
IF ISBLOCK( ::bFBlock )
Eval( ::bFBlock )
ENDIF
ENDIF
RETURN Self
| checkbox.prg | 118 |
| CHECKBOX:METHOD | select( lState ) CLASS CHECKBOX
METHOD select( lState ) CLASS CHECKBOX
LOCAL lOldState := ::lBuffer
::lBuffer := iif( ISLOGICAL( lState ), lState, !::lBuffer )
IF lOldState != ::lBuffer
::display()
IF ISBLOCK( ::bSBlock )
Eval( ::bSBlock )
ENDIF
ENDIF
RETURN Self
| checkbox.prg | 132 |
| CHECKBOX:METHOD | killFocus() CLASS CHECKBOX
METHOD killFocus() CLASS CHECKBOX
IF ::lHasFocus
::lHasFocus := .F.
IF ISBLOCK( ::bFBlock )
Eval( ::bFBlock )
ENDIF
::display()
SetCursor( ::nCursor )
ENDIF
RETURN Self
| checkbox.prg | 148 |
| CHECKBOX:METHOD | hitTest( nMRow, nMCol ) CLASS CHECKBOX
METHOD hitTest( nMRow, nMCol ) CLASS CHECKBOX
LOCAL nPosAccel
LOCAL nLenCaption
IF nMRow == ::nRow .AND. ;
nMCol >= ::nCol .AND. ;
nMCol < ::nCol + 3
RETURN HTCLIENT
ENDIF
nLenCaption := Len( ::cCaption )
IF ( nPosAccel := At( "&", ::cCaption ) ) > 0 .AND. ;
nPosAccel < nLenCaption
nLenCaption--
ENDIF
IF nMRow == ::nCapRow .AND. ;
nMCol >= ::nCapCol .AND. ;
nMCol < ::nCapCol + nLenCaption
RETURN HTCAPTION
ENDIF
RETURN HTNOWHERE
| checkbox.prg | 164 |
| CHECKBOX:METHOD | display() CLASS CHECKBOX
METHOD display() CLASS CHECKBOX
LOCAL cOldColor := SetColor()
LOCAL nOldRow := Row()
LOCAL nOldCol := Col()
LOCAL lOldMCur := MSetCursor( .F. )
LOCAL cStyle := ::cStyle
LOCAL cCaption
LOCAL nPos
DispBegin()
DispOutAt( ::nRow, ::nCol + 1, iif( ::lBuffer, SubStr( cStyle, 2, 1 ), SubStr( cStyle, 3, 1 ) ),;
hb_ColorIndex( ::cColorSpec, iif( ::lHasFocus, 1, 0 ) ) )
SetColor( hb_ColorIndex( ::cColorSpec, 2 ) )
DispOutAt( ::nRow, ::nCol, Left( cStyle, 1 ) )
DispOutAt( ::nRow, ::nCol + 2, Right( cStyle, 1 ) )
IF !Empty( cCaption := ::cCaption )
IF ( nPos := At( "&", cCaption ) ) == 0
ELSEIF nPos == Len( cCaption )
nPos := 0
ELSE
cCaption := Stuff( cCaption, nPos, 1, "" )
ENDIF
IF ::lHasFocus
SetColor( hb_ColorIndex( ::cColorSpec, 3 ) )
ENDIF
DispOutAt( ::nCapRow, ::nCapCol, cCaption )
IF !::lHasFocus .AND. nPos != 0
DispOutAt( ::nCapRow, ::nCapCol + nPos - 1, SubStr( cCaption, nPos, 1 ), hb_ColorIndex( ::cColorSpec, 3 ) )
ENDIF
ENDIF
DispEnd()
MSetCursor( lOldMCur )
SetColor( cOldColor )
SetPos( nOldRow, nOldCol )
RETURN Self
| checkbox.prg | 190 |
| CHECKBOX:METHOD | bitmaps( aBitmaps ) CLASS CHECKBOX
METHOD bitmaps( aBitmaps ) CLASS CHECKBOX
IF aBitmaps != NIL
::aBitmaps := __eInstVar53( Self, "BITMAPS", aBitmaps, "A", 1001 )
ENDIF
RETURN ::aBitmaps
| checkbox.prg | 239 |
| CHECKBOX:METHOD | buffer() CLASS CHECKBOX
METHOD buffer() CLASS CHECKBOX
RETURN ::lBuffer
| checkbox.prg | 247 |
| CHECKBOX:METHOD | capCol( nCapCol ) CLASS CHECKBOX
METHOD capCol( nCapCol ) CLASS CHECKBOX
IF nCapCol != NIL
::nCapCol := __eInstVar53( Self, "CAPCOL", nCapCol, "N", 1001 )
ENDIF
RETURN ::nCapCol
| checkbox.prg | 250 |
| CHECKBOX:METHOD | capRow( nCapRow ) CLASS CHECKBOX
METHOD capRow( nCapRow ) CLASS CHECKBOX
IF nCapRow != NIL
::nCapRow := __eInstVar53( Self, "CAPROW", nCapRow, "N", 1001 )
ENDIF
RETURN ::nCapRow
| checkbox.prg | 258 |
| CHECKBOX:METHOD | caption( cCaption ) CLASS CHECKBOX
METHOD caption( cCaption ) CLASS CHECKBOX
IF cCaption != NIL
::cCaption := __eInstVar53( Self, "CAPTION", cCaption, "C", 1001 )
ENDIF
RETURN ::cCaption
| checkbox.prg | 266 |
| CHECKBOX:METHOD | col( nCol ) CLASS CHECKBOX
METHOD col( nCol ) CLASS CHECKBOX
IF nCol != NIL
::nCol := __eInstVar53( Self, "COL", nCol, "N", 1001 )
ENDIF
RETURN ::nCol
| checkbox.prg | 274 |
| CHECKBOX:METHOD | colorSpec( cColorSpec ) CLASS CHECKBOX
METHOD colorSpec( cColorSpec ) CLASS CHECKBOX
IF cColorSpec != NIL
::cColorSpec := __eInstVar53( Self, "COLORSPEC", cColorSpec, "C", 1001,;
{|| !Empty( hb_ColorIndex( cColorSpec, 3 ) ) .AND. Empty( hb_ColorIndex( cColorSpec, 4 ) ) } )
ENDIF
RETURN ::cColorSpec
| checkbox.prg | 282 |
| CHECKBOX:METHOD | fBlock( bFBlock ) CLASS CHECKBOX
METHOD fBlock( bFBlock ) CLASS CHECKBOX
IF PCount() > 0
::bFBlock := iif( bFBlock == NIL, NIL, __eInstVar53( Self, "FBLOCK", bFBlock, "B", 1001 ) )
ENDIF
RETURN ::bFBlock
| checkbox.prg | 291 |
| CHECKBOX:METHOD | hasFocus() CLASS CHECKBOX
METHOD hasFocus() CLASS CHECKBOX
RETURN ::lHasFocus
| checkbox.prg | 299 |
| CHECKBOX:METHOD | message( cMessage ) CLASS CHECKBOX
METHOD message( cMessage ) CLASS CHECKBOX
IF cMessage != NIL
::cMessage := __eInstVar53( Self, "MESSAGE", cMessage, "C", 1001 )
ENDIF
RETURN ::cMessage
| checkbox.prg | 302 |
| CHECKBOX:METHOD | row( nRow ) CLASS CHECKBOX
METHOD row( nRow ) CLASS CHECKBOX
IF nRow != NIL
::nRow := __eInstVar53( Self, "ROW", nRow, "N", 1001 )
ENDIF
RETURN ::nRow
| checkbox.prg | 310 |
| CHECKBOX:METHOD | sBlock( bSBlock ) CLASS CHECKBOX
METHOD sBlock( bSBlock ) CLASS CHECKBOX
IF PCount() > 0
::bSBlock := iif( bSBlock == NIL, NIL, __eInstVar53( Self, "SBLOCK", bSBlock, "B", 1001 ) )
ENDIF
RETURN ::bSBlock
| checkbox.prg | 318 |
| CHECKBOX:METHOD | style( cStyle ) CLASS CHECKBOX
METHOD style( cStyle ) CLASS CHECKBOX
IF cStyle != NIL
::cStyle := __eInstVar53( Self, "STYLE", cStyle, "C", 1001, {|| Len( cStyle ) == 0 .OR. Len( cStyle ) == 4 } )
ENDIF
RETURN ::cStyle
| checkbox.prg | 326 |
| CHECKBOX:METHOD | typeOut() CLASS CHECKBOX
METHOD typeOut() CLASS CHECKBOX
RETURN .F.
| checkbox.prg | 334 |
| CHECKBOX:METHOD | New( nRow, nCol, cCaption ) CLASS CHECKBOX
METHOD New( nRow, nCol, cCaption ) CLASS CHECKBOX
LOCAL cColor
DEFAULT cCaption TO ""
::caption := cCaption
::capRow := nRow
::capCol := nCol + 3 + 1
::row := nRow
::col := nCol
IF IsDefColor()
::cColorSpec := "W/N,W+/N,W/N,W+/N"
ELSE
cColor := SetColor()
::cColorSpec := hb_ColorIndex( cColor, CLR_UNSELECTED ) + "," +;
hb_ColorIndex( cColor, CLR_ENHANCED ) + "," +;
hb_ColorIndex( cColor, CLR_STANDARD ) + "," +;
hb_ColorIndex( cColor, CLR_BACKGROUND )
ENDIF
RETURN Self
| checkbox.prg | 337 |
| FUNCTION | _CHECKBOX_( lState, cCaption, cMessage, cColorSpec, bFBlock, bSBlock, cStyle, aBitmaps )
FUNCTION _CHECKBOX_( lState, cCaption, cMessage, cColorSpec, bFBlock, bSBlock, cStyle, aBitmaps )
LOCAL o := HBCheckBox():New( Row(), Col(), cCaption )
o:select( lState )
o:caption := cCaption
o:message := cMessage
o:colorSpec := cColorSpec
o:fBlock := bFBlock
o:sBlock := bSBlock
o:style := cStyle
o:bitmaps := aBitmaps
RETURN o
| checkbox.prg | 361 |
| FUNCTION | CheckBox( nRow, nCol, cCaption )
FUNCTION CheckBox( nRow, nCol, cCaption )
RETURN HBCheckBox():New( nRow, nCol, cCaption )
| checkbox.prg | 375 |
| color53.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | GetClrPair( cColor, nColor )
FUNCTION GetClrPair( cColor, nColor )
LOCAL nPos
IF ( nPos := GetPairPos( cColor, nColor ) ) == 0
RETURN ""
ENDIF
RETURN SubStr( cColor, nPos, GetPairLen( cColor, nColor ) )
| color53.prg | 57 |
| FUNCTION | SetClrPair( cColor, nColor, cNewColor )
FUNCTION SetClrPair( cColor, nColor, cNewColor )
LOCAL nPos
IF ( nPos := GetPairPos( cColor, nColor ) ) == 0
RETURN ""
ENDIF
RETURN Stuff( cColor, nPos, GetPairLen( cColor, nColor ), cNewColor )
| color53.prg | 66 |
| FUNCTION | GetPairPos( cColor, nColor )
FUNCTION GetPairPos( cColor, nColor )
LOCAL nPos := 1
LOCAL nSep
LOCAL n
FOR n := 2 TO nColor
IF ( nSep := At( ",", SubStr( cColor, nPos ) ) ) == 0
RETURN 0
ENDIF
nPos += nSep
NEXT
RETURN nPos
| color53.prg | 75 |
| FUNCTION | GetPairLen( cColor, nColor )
FUNCTION GetPairLen( cColor, nColor )
LOCAL nPos := GetPairPos( cColor, nColor )
LOCAL nLen
IF nPos == 0
RETURN 0
ENDIF
nLen := At( ",", SubStr( cColor, nPos ) )
RETURN iif( nLen == 0, Len( cColor ) - nPos + 1, nLen - 1 )
| color53.prg | 89 |
| FUNCTION | GetClrFore( cColor )
FUNCTION GetClrFore( cColor )
LOCAL nPos
IF ( nPos := At( "/", cColor ) ) == 0
RETURN ""
ENDIF
RETURN SubStr( cColor, 1, nPos - 1 )
| color53.prg | 101 |
| FUNCTION | GetClrBack( cColor )
FUNCTION GetClrBack( cColor )
LOCAL nPos
IF ( nPos := At( "/", cColor ) ) == 0
RETURN ""
ENDIF
RETURN SubStr( cColor, nPos + 1 )
| color53.prg | 110 |
| FUNCTION | RADGRDefCo( cColor )
FUNCTION RADGRDefCo( cColor )
RETURN iif( IsDefColor(),;
ApplyDefau( cColor, "W/N", "W/N", "W+/N" ),;
ApplyDefau( cColor, 3, 1, 4 ) )
| color53.prg | 119 |
| FUNCTION | RADITDefCo( cColor )
FUNCTION RADITDefCo( cColor )
RETURN iif( IsDefColor(),;
ApplyDefau( cColor, "W/N", "W+/N", "W+/N", "N/W", "W/N", "W/N", "W+/N" ),;
ApplyDefau( cColor, 5, 5, 2, 2, 1, 1, 4 ) )
| color53.prg | 124 |
| FUNCTION | LISTBDefCo( cColor )
FUNCTION LISTBDefCo( cColor )
RETURN iif( IsDefColor(),;
ApplyDefau( cColor, "W/N", "W+/N", "W+/N", "N/W", "W/N", "W/N", "W+/N" ),;
ApplyDefau( cColor, 5, 5, 5, 2, 3, 1, 4 ) )
| color53.prg | 129 |
| FUNCTION | COMBODefCo( cColor )
FUNCTION COMBODefCo( cColor )
RETURN iif( IsDefColor(),;
ApplyDefau( cColor, "W/N", "W+/N", "W+/N", "N/W", "W/N", "W/N", "W+/N", "W/N" ),;
ApplyDefau( cColor, 5, 5, 5, 2, 3, 1, 4, 1 ) )
| color53.prg | 134 |
| FUNCTION | CHECKDefCo( cColor )
FUNCTION CHECKDefCo( cColor )
RETURN iif( IsDefColor(),;
ApplyDefau( cColor, "W/N", "W+/N", "W/N", "W+/N" ),;
ApplyDefau( cColor, 5, 2, 1, 4 ) )
| color53.prg | 139 |
| FUNCTION | BUTTNDefCo( cColor )
FUNCTION BUTTNDefCo( cColor )
RETURN iif( IsDefColor(),;
ApplyDefau( cColor, "W/N", "N/W", "W+/N", "W+/N" ),;
ApplyDefau( cColor, 5, 2, 1, 4 ) )
| color53.prg | 144 |
| FUNCTION | MENUDefCol( cColor )
FUNCTION MENUDefCol( cColor )
RETURN iif( IsDefColor(),;
ApplyDefau( cColor, "N/W", "W/N", "W+/W", "W+/N", "N+/W", "W/N" ),;
ApplyDefau( cColor, 5, 2, 4, 2, 1, 3 ) )
| color53.prg | 149 |
| FUNCTION | ApplyDefau( cColor, xClr1, xClr2, xClr3, xClr4, xClr5, xClr6, xClr7, xClr8 )
FUNCTION ApplyDefau( cColor, xClr1, xClr2, xClr3, xClr4, xClr5, xClr6, xClr7, xClr8 )
LOCAL cSetColor
LOCAL aSetColor
LOCAL aNewcolor
LOCAL nColors
LOCAL cClrDefa
LOCAL cClrToSet
LOCAL cClrFore
LOCAL cClrBack
LOCAL xNewColor
LOCAL n
IF PCount() == 0
RETURN ""
ELSEIF PCount() == 1
RETURN cColor
ENDIF
cSetColor := SetColor()
aSetColor := {;
GetClrPair( cSetColor, 1 ) ,;
GetClrPair( cSetColor, 2 ) ,;
GetClrPair( cSetColor, 3 ) ,;
GetClrPair( cSetColor, 4 ) ,;
GetClrPair( cSetColor, 5 ) }
aNewColor := {;
xClr1 ,;
xClr2 ,;
xClr3 ,;
xClr4 ,;
xClr5 ,;
xClr6 ,;
xClr7 ,;
xClr8 }
nColors := PCount() - 1
cClrDefa := cColor
FOR n := 1 TO nColors
xNewColor := aNewColor[ n ]
cClrToSet := GetClrPair( cClrDefa, n )
IF "/" $ cClrToSet
IF ( cClrFore := GetClrFore( cClrToSet ) ) == ""
cClrFore := GetClrFore( iif( ISNUMBER( xNewColor ), aSetColor[ xNewColor ], xNewColor ) )
ENDIF
IF ( cClrBack := GetClrBack( cClrToSet ) ) == ""
cClrBack := GetClrBack( iif( ISNUMBER( xNewColor ), aSetColor[ xNewColor ], xNewColor ) )
ENDIF
cClrDefa := SetClrPair( cClrDefa, n, cClrFore + "/" + cClrBack )
ELSE
cClrDefa := SetClrPair( cClrDefa, n, iif( ISNUMBER( xNewColor ), aSetColor[ xNewColor ], xNewColor ) )
ENDIF
NEXT
RETURN cClrDefa
| color53.prg | 154 |
| dbedit.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | DBEDIT( nTop, nLeft, nBottom, nRight, acColumns, xUserFunc, xColumnSayPictures, xColumnHeaders, xHeadingSeparators, xColumnSeparators, xFootingSeparators, xColumnFootings )
FUNCTION DBEDIT( nTop, nLeft, nBottom, nRight, ;
acColumns, xUserFunc, ;
xColumnSayPictures, xColumnHeaders, ;
xHeadingSeparators, xColumnSeparators, ;
xFootingSeparators, xColumnFootings )
LOCAL nOldCUrsor, nKey, lContinue, nPos, nAliasPos, nColCount
LOCAL lDoIdleCall, lAppend, lFlag
LOCAL cHeading, cBlock
LOCAL bBlock
LOCAL oBrowse
LOCAL oColumn
LOCAL aCol
IF !Used()
RETURN .F.
ELSEIF EOF()
dbGoBottom()
ENDIF
IF !ISNUMBER( nTop ) .OR. nTop < 0
nTop := 0
ENDIF
IF !ISNUMBER( nLeft ) .OR. nLeft < 0
nLeft := 0
ENDIF
IF !ISNUMBER( nBottom ) .OR. nBottom > MaxRow() .OR. nBottom < nTop
nBottom := MaxRow()
ENDIF
IF !ISNUMBER( nRight ) .OR. nRight > MaxCol() .OR. nRight < nLeft
nRight := MaxCol()
ENDIF
oBrowse := TBrowseDb( nTop, nLeft, nBottom, nRight )
oBrowse:headSep := iif( ISCHARACTER( xHeadingSeparators ), xHeadingSeparators, Chr( 205 ) + Chr( 209 ) + Chr( 205 ) )
oBrowse:colSep := iif( ISCHARACTER( xColumnSeparators ), xColumnSeparators, " " + Chr( 179 ) + " " )
oBrowse:footSep := iif( ISCHARACTER( xFootingSeparators ), xFootingSeparators, "" )
oBrowse:skipBlock := {| nRecs | Skipped( nRecs, lAppend ) }
oBrowse:autoLite := .F. /* Set to .F. just like in CA-Cl*pper. [vszakats] */
IF ISARRAY( acColumns )
nColCount := 0
FOR EACH aCol IN acColumns
IF ISCHARACTER( aCol ) .AND. !Empty( aCol )
nColCount++
ELSE
EXIT
ENDIF
NEXT
ELSE
nColCount := FCount()
ENDIF
IF nColCount == 0
RETURN .F.
ENDIF
/* Generate the TBrowse columns */
FOR nPos := 1 TO nColCount
IF ISARRAY( acColumns )
cBlock := acColumns[ nPos ]
IF ( nAliasPos := At( "->", cBlock ) ) > 0
cHeading := SubStr( cBlock, 1, nAliasPos - 1 ) + "->;" + ;
SubStr( cBlock, nAliasPos + 2 )
ELSE
cHeading := cBlock
ENDIF
ELSE
cBlock := FieldName( nPos )
cHeading := cBlock
ENDIF
/* Simplified logic compared to CA-Cl*pper. In the latter there
is logic to detect several typical cBlock types (memvar,
aliased field, field) and using MemvarBlock()/FieldWBlock()/FieldBlock()
calls to create codeblocks for them if possible. In Harbour,
simple macro compilation will result in faster code for all
situations. As Maurilio Longo has pointed, there is no point in
creating codeblocks which are able to _assign_ values, as dbEdit()
is a read-only function. [vszakats] */
bBlock := iif( Type( cBlock ) == "M", {|| " " }, &( "{||" + cBlock + "}" ) )
/* ; */
IF ISARRAY( xColumnHeaders ) .AND. Len( xColumnHeaders ) >= nPos .AND. ISCHARACTER( xColumnHeaders[ nPos ] )
cHeading := xColumnHeaders[ nPos ]
ELSEIF ISCHARACTER( xColumnHeaders )
cHeading := xColumnHeaders
ENDIF
oColumn := TBColumnNew( cHeading, bBlock )
IF ISARRAY( xColumnSayPictures ) .AND. nPos <= Len( xColumnSayPictures ) .AND. ISCHARACTER( xColumnSayPictures[ nPos ] ) .AND. !Empty( xColumnSayPictures[ nPos ] )
oColumn:picture := xColumnSayPictures[ nPos ]
ELSEIF ISCHARACTER( xColumnSayPictures ) .AND. !Empty( xColumnSayPictures )
oColumn:picture := xColumnSayPictures
ENDIF
IF ISARRAY( xColumnFootings ) .AND. nPos <= Len( xColumnFootings ) .AND. ISCHARACTER( xColumnFootings[ nPos ] )
oColumn:footing := xColumnFootings[ nPos ]
ELSEIF ISCHARACTER( xColumnFootings )
oColumn:footing := xColumnFootings
ENDIF
IF ISARRAY( xHeadingSeparators ) .AND. nPos <= Len( xHeadingSeparators ) .AND. ISCHARACTER( xHeadingSeparators[ nPos ] )
oColumn:headSep := xHeadingSeparators[ nPos ]
ENDIF
IF ISARRAY( xColumnSeparators ) .AND. nPos <= Len( xColumnSeparators ) .AND. ISCHARACTER( xColumnSeparators[ nPos ] )
oColumn:colSep := xColumnSeparators[ nPos ]
ENDIF
IF ISARRAY( xFootingSeparators ) .AND. nPos <= Len( xFootingSeparators ) .AND. ISCHARACTER( xFootingSeparators[ nPos ] )
oColumn:footSep := xFootingSeparators[ nPos ]
ENDIF
oBrowse:addColumn( oColumn )
NEXT
nOldCUrsor := SetCursor( SC_NONE )
/* --------------------------- */
/* Go into the processing loop */
/* --------------------------- */
lAppend := .F.
lFlag := .T.
lDoIdleCall := .T.
lContinue := .T.
WHILE lContinue
WHILE ! oBrowse:stabilize()
nKey := Nextkey()
#ifdef HB_COMPAT_C53
IF nKey != 0 .AND. nKey != K_MOUSEMOVE
#else
IF nKey != 0
#endif
EXIT
ENDIF
ENDDO
IF ( nKey := Inkey() ) == 0
IF lDoIdleCall
lContinue := CallUser( oBrowse, xUserFunc, 0, @lAppend, @lFlag )
oBrowse:forceStable()
ENDIF
IF lContinue .AND. lFlag
oBrowse:hiLite()
#ifdef HB_COMPAT_C53
WHILE ( nKey := Inkey( 0 ) ) == K_MOUSEMOVE
ENDDO
#else
nKey := Inkey( 0 )
#endif
oBrowse:deHilite()
IF ( bBlock := SetKey( nKey ) ) != NIL
Eval( bBlock, ProcName( 1 ), ProcLine( 1 ), "" )
LOOP
ENDIF
ELSE
lFlag := .T.
ENDIF
ENDIF
lDoIdleCall := .T.
IF nKey != 0
#ifdef HB_C52_UNDOC
IF lAppend
SWITCH nKey
CASE K_DOWN
CASE K_PGDN
CASE K_CTRL_PGDN
oBrowse:hitBottom := .T.
LOOP
CASE K_UP
CASE K_PGUP
CASE K_CTRL_PGUP
oBrowse:hitTop := .T.
LOOP
ENDSWITCH
ENDIF
#endif
SWITCH nKey
#ifdef HB_COMPAT_C53
CASE K_LBUTTONDOWN
CASE K_LDBLCLK
TBMouse( oBrowse, MRow(), MCol() )
EXIT
#endif
CASE K_DOWN ; oBrowse:down() ; EXIT
CASE K_UP ; oBrowse:up() ; EXIT
CASE K_PGDN ; oBrowse:pageDown() ; EXIT
CASE K_PGUP ; oBrowse:pageUp() ; EXIT
CASE K_CTRL_PGUP ; oBrowse:goTop() ; EXIT
CASE K_CTRL_PGDN ; oBrowse:goBottom() ; EXIT
CASE K_RIGHT ; oBrowse:right() ; EXIT
CASE K_LEFT ; oBrowse:left() ; EXIT
CASE K_HOME ; oBrowse:home() ; EXIT
CASE K_END ; oBrowse:end() ; EXIT
CASE K_CTRL_LEFT ; oBrowse:panLeft() ; EXIT
CASE K_CTRL_RIGHT ; oBrowse:panRight() ; EXIT
CASE K_CTRL_HOME ; oBrowse:panHome() ; EXIT
CASE K_CTRL_END ; oBrowse:panEnd() ; EXIT
OTHERWISE
lContinue := CallUser( oBrowse, xUserFunc, nKey, @lAppend, @lFlag )
lDoIdleCall := .F.
EXIT
ENDSWITCH
ENDIF
ENDDO
SetCursor( nOldCUrsor )
RETURN .T.
| dbedit.prg | 67 |
| STATIC FUNCTION | CallUser( oBrowse, xUserFunc, nKey, lAppend, lFlag )
STATIC FUNCTION CallUser( oBrowse, xUserFunc, nKey, lAppend, lFlag )
LOCAL nPrevRecNo
LOCAL nAction
LOCAL nMode := IIF( nKey != 0, DE_EXCEPT, ;
IIF( !lAppend .AND. IsDbEmpty(), DE_EMPTY, ;
IIF( oBrowse:hitBottom, DE_HITBOTTOM, ;
IIF( oBrowse:hitTop, DE_HITTOP, DE_IDLE ) ) ) )
oBrowse:forceStable()
nPrevRecNo := RecNo()
/* NOTE: CA-Cl*pper won't check the type of the return value here,
and will crash if it's a non-NIL, non-numeric type. We're
replicating this behavior. */
nAction := IIF( ISBLOCK( xUserFunc ), ;
Eval( xUserFunc, nMode, oBrowse:colPos ), ;
IIF( ISCHARACTER( xUserFunc ) .AND. !Empty( xUserFunc ), ;
&xUserFunc( nMode, oBrowse:colPos ), ;
IIF( nKey == K_ENTER .OR. nKey == K_ESC, DE_ABORT, DE_CONT ) ) )
IF !lAppend .AND. EOF() .AND. !IsDbEmpty()
dbSkip( -1 )
ENDIF
#ifdef HB_C52_UNDOC
IF nAction == DE_APPEND
IF ( lAppend := !( lAppend .AND. EOF() ) )
dbGoBottom()
oBrowse:down()
ELSE
oBrowse:refreshAll():forceStable()
ENDIF
lFlag := .F.
RETURN .T.
ENDIF
#endif
IF nAction == DE_REFRESH .OR. nPrevRecNo != RecNo()
IF nAction != DE_ABORT
lAppend := .F.
IF ( Set( _SET_DELETED ) .AND. Deleted() ) .OR. ;
( !Empty( dbfilter() ) .AND. !&( dbFilter() ) )
dbSkip()
ENDIF
IF EOF()
dbGoBottom()
ENDIF
nPrevRecNo := RecNo()
oBrowse:refreshAll():forceStable()
WHILE nPrevRecNo != RecNo()
oBrowse:Up():forceStable()
ENDDO
lFlag := .F.
ENDIF
ELSE
oBrowse:refreshCurrent()
ENDIF
RETURN nAction != DE_ABORT
| dbedit.prg | 294 |
| STATIC FUNCTION | IsDbEmpty()
STATIC FUNCTION IsDbEmpty()
RETURN LastRec() == 0 .OR. ;
( BOF() .AND. ( EOF() .OR. RecNo() == LastRec() + 1 ) )
| dbedit.prg | 368 |
| STATIC FUNCTION | Skipped( nRecs, lAppend )
STATIC FUNCTION Skipped( nRecs, lAppend )
LOCAL nSkipped := 0
IF LastRec() != 0
IF nRecs == 0
IF EOF() .AND. !lAppend
dbSkip( -1 )
nSkipped := -1
ELSE
dbSkip( 0 )
ENDIF
ELSEIF nRecs > 0 .AND. RecNo() != LastRec() + 1
DO WHILE nSkipped < nRecs
dbSkip()
IF Eof()
IF lAppend
nSkipped++
ELSE
dbSkip( -1 )
ENDIF
EXIT
ENDIF
nSkipped++
ENDDO
ELSEIF nRecs < 0
DO WHILE nSkipped > nRecs
dbSkip( -1 )
IF Bof()
EXIT
ENDIF
nSkipped--
ENDDO
ENDIF
ENDIF
RETURN nSkipped
| dbedit.prg | 374 |
| devoutp.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | DevOutPict( xValue, cPicture, cColor )
PROCEDURE DevOutPict( xValue, cPicture, cColor )
IF Valtype( xValue ) $ "CMNDL"
DevOut( Transform( xValue, cPicture ), cColor )
ENDIF
RETURN
| devoutp.prg | 53 |
| dircmd.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | __Dir( cFileMask )
PROCEDURE __Dir( cFileMask )
LOCAL cPath
LOCAL cName
LOCAL cExt
IF Empty( cFileMask )
/* NOTE: Although Cl*pper has this string in the national language
modul, it will not use it from there.
This is hard wired to English. So this is a small
incompatibility. */
#ifdef HB_C52_STRICT
QOut( "Database Files # Records Last Update Size" )
#else
QOut( __NatMsg( _DIR_HEADER ) )
#endif
AEval( Directory( hb_FNameMerge( Set( _SET_DEFAULT ), "*", ".dbf" ) ),;
{| aDirEntry | PutDbf( aDirEntry ) } )
ELSE
hb_FNameSplit( LTrim( cFileMask ), @cPath, @cName, @cExt )
IF Empty( cPath )
cPath := Set( _SET_DEFAULT )
ENDIF
AEval( Directory( hb_FNameMerge( cPath, cName, cExt ) ),;
{| aDirEntry | PutNormal( aDirEntry ) } )
ENDIF
QOut()
RETURN
| dircmd.prg | 58 |
| STATIC PROCEDURE | PutDBF( aDirEntry )
STATIC PROCEDURE PutDBF( aDirEntry )
LOCAL fhnd
LOCAL buffer
LOCAL nRecCount := 0
LOCAL dLastUpdate := hb_SToD( "" )
IF ( fhnd := FOpen( aDirEntry[ F_NAME ] ) ) != F_ERROR
buffer := Replicate( Chr( 0 ), 8 )
IF FRead( fhnd, @buffer, 8 ) == 8 .AND. ;
AScan( { 0x03, 0x06, 0x30, 0x31, 0x83, 0x86, 0xE5, 0xE6, 0xF5, 0xF6 }, ;
Asc( buffer ) ) != 0
nRecCount := Bin2L( SubStr( buffer, 5, 4 ) )
dLastUpdate := hb_SToD( StrZero( ASC( SubStr( buffer, 2, 1 ) ) + 1900, 4 ) +;
StrZero( ASC( SubStr( buffer, 3, 1 ) ), 2 ) +;
StrZero( ASC( SubStr( buffer, 4, 1 ) ), 2 ) )
ENDIF
FClose( fhnd )
ENDIF
QOut( PadR( aDirEntry[ F_NAME ], 15 ) +;
Str( nRecCount, 12 ) + " " +;
DToC( dLastUpdate ) +;
Str( aDirEntry[ F_SIZE ], 12 ) )
RETURN
| dircmd.prg | 93 |
| STATIC PROCEDURE | PutNormal( aDirEntry )
STATIC PROCEDURE PutNormal( aDirEntry )
LOCAL cName
LOCAL cExt
hb_FNameSplit( aDirEntry[ F_NAME ], NIL, @cName, @cExt )
QOut( PadR( cName, 8 ) + " " +;
PadR( cExt, 3 ) + " " +;
Str( aDirEntry[ F_SIZE ], 8 ) + " " +;
DToC( aDirEntry[ F_DATE ] ) )
RETURN
| dircmd.prg | 125 |
| dirscan.prg |
| Type | Function | Source | Line |
|---|
| STATIC FUNCTION | HB_doScan( cPath, cMask, cAttr, cPathSep )
STATIC FUNCTION HB_doScan( cPath, cMask, cAttr, cPathSep )
LOCAL aFile
LOCAL lMatch
LOCAL aResult := {}
FOR EACH aFile IN Directory( cPath + hb_osFileMask(), cAttr + "D" )
lMatch = HB_FileMatch( aFile[ 1 ], cMask )
IF "D" $ aFile[ 5 ]
IF lMatch .AND. "D" $ cAttr
AAdd( aResult, aFile )
ENDIF
IF !( aFile[ 1 ] == "." .OR. aFile[ 1 ] == ".." .OR. aFile[ 1 ] == "" )
AEval( HB_DoScan( cPath + aFile[ 1 ] + cPathSep, cMask, cAttr, cPathSep ), ;
{ |x| x[ 1 ] := aFile[ 1 ] + cPathSep + x[ 1 ], ;
AAdd( aResult, x ) } )
ENDIF
ELSEIF lMatch
AAdd( aResult, aFile )
ENDIF
NEXT
RETURN aResult
| dirscan.prg | 53 |
| FUNCTION | HB_DirScan( cPath, cFileMask, cAttr )
FUNCTION HB_DirScan( cPath, cFileMask, cAttr )
LOCAL cFilePath
LOCAL cPathSep := hb_osPathSeparator()
IF Empty( cPath )
cFilePath := ""
ELSE
cFilePath := cPath
IF !Right( cPath, 1 ) $ hb_osPathDelimiters()
cFilePath += cPathSep
ENDIF
ENDIF
RETURN HB_DoScan( cFilePath, ;
IIF( Empty( cFileMask ), hb_osFileMask(), cFileMask ), ;
IIF( ValType( cAttr ) $ "CM", cAttr, "" ), ;
cPathSep )
| dirscan.prg | 77 |
| einstv52.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __eInstVar52( oVar, cMethod, xValue, cType, nSubCode, xMin, xMax )
FUNCTION __eInstVar52( oVar, cMethod, xValue, cType, nSubCode, xMin, xMax )
LOCAL oError
LOCAL lError
IF VALTYPE( xValue ) == cType
lError := .F.
IF xMin != NIL
lError := !( xValue >= xMin )
ENDIF
/* NOTE: In CA-Cl*pper 5.2, xMin validation result is
ignored when xMax != NIL. Harbour is doing the same. */
IF xMax != NIL
lError := !( xValue <= xMax )
ENDIF
ELSE
lError := .T.
ENDIF
IF lError
oError := ErrorNew()
oError:description := HB_LANGERRMSG( 1 )
oError:gencode := 1
oError:severity := 2
oError:cansubstitute := .T.
oError:subsystem := oVar:className
#ifdef HB_C52_STRICT
HB_SYMBOL_UNUSED( cMethod )
#else
oError:operation := cMethod
#endif
oError:subcode := nSubCode
oError:args := { xValue }
xValue := EVAL( ERRORBLOCK(), oError )
IF !( VALTYPE( xValue ) == cType )
__errInHandler()
ENDIF
ENDIF
RETURN xValue
| einstv52.prg | 58 |
| einstvar.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __eInstVar53( oVar, cMethod, xValue, cType, nSubCode, bValid )
FUNCTION __eInstVar53( oVar, cMethod, xValue, cType, nSubCode, bValid )
LOCAL oError
IF !( VALTYPE( xValue ) == cType ) .OR. ;
( bValid != NIL .AND. !EVAL( bValid, oVar, xValue ) )
oError := ErrorNew()
oError:description := HB_LANGERRMSG( 1 )
oError:gencode := 1
oError:severity := 2
oError:cansubstitute := .T.
oError:subsystem := oVar:className
#ifdef HB_C52_STRICT
HB_SYMBOL_UNUSED( cMethod )
#else
oError:operation := cMethod
#endif
oError:subcode := nSubCode
oError:args := { xValue }
xValue := EVAL( ERRORBLOCK(), oError )
IF !( VALTYPE( xValue ) == cType )
__errInHandler()
ENDIF
ENDIF
RETURN xValue
| einstvar.prg | 58 |
| einstvau.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | _eInstVar( ... )
FUNCTION _eInstVar( ... )
#ifdef HB_COMPAT_C53
RETURN __eInstVar53( ... )
#else
RETURN __eInstVar52( ... )
| einstvau.prg | 56 |
| errorsys.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | ErrorSys()
PROCEDURE ErrorSys()
ErrorBlock( { | oError | DefError( oError ) } )
RETURN
| errorsys.prg | 56 |
| STATIC FUNCTION | DefError( oError )
STATIC FUNCTION DefError( oError )
LOCAL cMessage
LOCAL cDOSError
LOCAL aOptions
LOCAL nChoice
LOCAL n
// By default, division by zero results in zero
IF oError:genCode == EG_ZERODIV .AND. ;
oError:canSubstitute
RETURN 0
ENDIF
// By default, retry on RDD lock error failure */
IF oError:genCode == EG_LOCK .AND. ;
oError:canRetry
// oError:tries++
RETURN .T.
ENDIF
// Set NetErr() of there was a database open error
IF oError:genCode == EG_OPEN .AND. ;
oError:osCode == 32 .AND. ;
oError:canDefault
NetErr( .T. )
RETURN .F.
ENDIF
// Set NetErr() if there was a lock error on dbAppend()
IF oError:genCode == EG_APPENDLOCK .AND. ;
oError:canDefault
NetErr( .T. )
RETURN .F.
ENDIF
cMessage := ErrorMessage( oError )
IF ! Empty( oError:osCode )
cDOSError := "(DOS Error " + LTrim( Str( oError:osCode ) ) + ")"
ENDIF
// Build buttons
aOptions := {}
AAdd( aOptions, "Quit" )
IF oError:canRetry
AAdd( aOptions, "Retry" )
ENDIF
IF oError:canDefault
AAdd( aOptions, "Default" )
ENDIF
// Show alert box
nChoice := 0
DO WHILE nChoice == 0
IF ISNIL( cDOSError )
nChoice := Alert( cMessage, aOptions )
ELSE
nChoice := Alert( cMessage + ";" + cDOSError, aOptions )
ENDIF
ENDDO
IF ! Empty( nChoice )
DO CASE
CASE aOptions[ nChoice ] == "Break"
Break( oError )
CASE aOptions[ nChoice ] == "Retry"
RETURN .T.
CASE aOptions[ nChoice ] == "Default"
RETURN .F.
ENDCASE
ENDIF
// "Quit" selected
IF ! ISNIL( cDOSError )
cMessage += " " + cDOSError
ENDIF
OutErr( hb_OSNewLine() )
OutErr( cMessage )
n := 1
DO WHILE ! Empty( ProcName( ++n ) )
OutErr( hb_OSNewLine() )
OutErr( "Called from " + ProcName( n ) + ;
"(" + LTrim( Str( ProcLine( n ) ) ) + ") " )
ENDDO
ErrorLevel( 1 )
QUIT
RETURN .F.
| errorsys.prg | 62 |
| STATIC FUNCTION | ErrorMessage( oError )
STATIC FUNCTION ErrorMessage( oError )
// start error message
LOCAL cMessage := iif( oError:severity > ES_WARNING, "Error", "Warning" ) + " "
// add subsystem name if available
IF ISCHARACTER( oError:subsystem )
cMessage += oError:subsystem()
ELSE
cMessage += "???"
ENDIF
// add subsystem's error code if available
IF ISNUMBER( oError:subCode )
cMessage += "/" + LTrim( Str( oError:subCode ) )
ELSE
cMessage += "/???"
ENDIF
// add error description if available
IF ISCHARACTER( oError:description )
cMessage += " " + oError:description
ENDIF
// add either filename or operation
DO CASE
CASE !Empty( oError:filename )
cMessage += ": " + oError:filename
CASE !Empty( oError:operation )
cMessage += ": " + oError:operation
ENDCASE
RETURN cMessage
| errorsys.prg | 165 |
| fieldbl.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | FIELDBLOCK( cFieldName )
FUNCTION FIELDBLOCK( cFieldName )
IF ISCHARACTER( cFieldName )
RETURN {| x | iif( x == NIL, FieldGet( FieldPos( cFieldName ) ),;
FieldPut( FieldPos( cFieldName ), x ) ) }
ENDIF
RETURN NIL
| fieldbl.prg | 55 |
| FUNCTION | FIELDWBLOCK( cFieldName, nWorkArea )
FUNCTION FIELDWBLOCK( cFieldName, nWorkArea )
IF ISCHARACTER( cFieldName ) .AND. ISNUMBER( nWorkArea )
RETURN {| x | iif( x == NIL, ( nWorkArea )->( FieldGet( FieldPos( cFieldName ) ) ),;
( nWorkArea )->( FieldPut( FieldPos( cFieldName ), x ) ) ) }
ENDIF
RETURN NIL
| fieldbl.prg | 64 |
| getlist.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | __GetListSetActive( oGetList )
PROCEDURE __GetListSetActive( oGetList )
IF s_oGetListActive != NIL
s_oGetListActive:HasFocus := .F.
ENDIF
s_oGetListActive := oGetList
IF s_oGetListActive != NIL
s_oGetListActive:HasFocus := .T.
ENDIF
RETURN
| getlist.prg | 57 |
| FUNCTION | __GetListActive()
FUNCTION __GetListActive()
RETURN s_oGetListActive
| getlist.prg | 73 |
| FUNCTION | __GetListLast( oGetListLast )
FUNCTION __GetListLast( oGetListLast )
THREAD STATIC s_oGetListLast
IF oGetListLast != NIL
s_oGetListLast := oGetListLast
ENDIF
RETURN s_oGetListLast
| getlist.prg | 76 |
| getsys.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | ReadModal( GetList, nPos, oMenu, nMsgRow, nMsgLeft, nMsgRight, cMsgColor )
FUNCTION ReadModal( GetList, nPos, oMenu, nMsgRow, nMsgLeft, nMsgRight, cMsgColor )
| getsys.prg | 72 |
| FUNCTION | ReadModal( GetList )
FUNCTION ReadModal( GetList )
#endif
LOCAL oGetList
LOCAL oSaveGetList
IF Empty( GetList )
SetPos( MaxRow() - 1, 0 )
RETURN .F.
ENDIF
oGetList := HBGetList():New( GetList )
oSaveGetList := __GetListActive( )
#ifdef HB_COMPAT_C53
// oSaveGetList:ReadStats( SLUPDATED, .F. )
// oSaveGetList:ReadStats( SXREADVAR, ReadVar( "" ) )
// oSaveGetList:ReadStats( SOACTIVEGET, GetActive( NIL ) )
#endif
__GetListSetActive( oGetList )
__GetListLast( oGetList )
#ifdef HB_COMPAT_C53
oGetList:ReadModal( nPos, oMenu, nMsgRow, nMsgLeft, nMsgRight, cMsgColor )
#else
oGetList:ReadModal()
#endif
__GetListSetActive( oSaveGetList )
#ifdef HB_COMPAT_C53
// oSaveGetList:ReadStats( SLUPDATED, oGetList:Updated() )
// ReadVar( oSaveGetList:ReadStats( SXREADVAR ) )
// GetActive( oSaveGetList:ReadStats( SOACTIVEGET ) )
#endif
SetPos( MaxRow() - 1, 0 )
RETURN oGetList:Updated()
| getsys.prg | 74 |
| PROCEDURE | GetReader( oGet, oGetList, oMenu, aMsg )
PROCEDURE GetReader( oGet, oGetList, oMenu, aMsg )
HB_SYMBOL_UNUSED( oGetList )
oGet:Reader( oMenu, aMsg )
RETURN
| getsys.prg | 115 |
| PROCEDURE | GetReader( oGet )
PROCEDURE GetReader( oGet )
oGet:Reader()
RETURN
| getsys.prg | 123 |
| FUNCTION | GetActive( oGet )
FUNCTION GetActive( oGet )
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
IF PCount() > 0
RETURN oGetList:GetActive( oGet )
ELSE
RETURN oGetList:GetActive()
ENDIF
ENDIF
RETURN NIL
| getsys.prg | 130 |
| PROCEDURE | GetDoSetKey( bKeyBlock, oGet )
PROCEDURE GetDoSetKey( bKeyBlock, oGet )
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
oGetList:GetDoSetKey( bKeyBlock, oGet )
ENDIF
RETURN
| getsys.prg | 143 |
| PROCEDURE | GetApplyKey( oGet, nKey, oGetList, oMenu, aMsg )
PROCEDURE GetApplyKey( oGet, nKey, oGetList, oMenu, aMsg )
IF !ISOBJECT( oGetList )
oGetList := __GetListActive()
ENDIF
| getsys.prg | 153 |
| PROCEDURE | GetApplyKey( oGet, nKey )
PROCEDURE GetApplyKey( oGet, nKey )
LOCAL oGetList := __GetListActive()
#endif
IF oGetList != NIL
#ifdef HB_COMPAT_C53
oGetList:GetApplyKey( nKey, oGet, oMenu, aMsg )
#else
oGetList:GetApplyKey( nKey, oGet )
#endif
ENDIF
RETURN
| getsys.prg | 158 |
| FUNCTION | GetPreValidate( oGet, aMsg )
FUNCTION GetPreValidate( oGet, aMsg )
| getsys.prg | 173 |
| FUNCTION | GetPreValidate( oGet )
FUNCTION GetPreValidate( oGet )
#endif
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
#ifdef HB_COMPAT_C53
RETURN oGetList:GetPreValidate( oGet, aMsg )
#else
RETURN oGetList:GetPreValidate( oGet )
#endif
ENDIF
RETURN .F.
| getsys.prg | 175 |
| FUNCTION | GetPostValidate( oGet, aMsg )
FUNCTION GetPostValidate( oGet, aMsg )
| getsys.prg | 190 |
| FUNCTION | GetPostValidate( oGet )
FUNCTION GetPostValidate( oGet )
#endif
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
#ifdef HB_COMPAT_C53
RETURN oGetList:GetPostValidate( oGet, aMsg )
#else
RETURN oGetList:GetPostValidate( oGet )
#endif
ENDIF
RETURN .F.
| getsys.prg | 192 |
| FUNCTION | ReadExit( lExit )
FUNCTION ReadExit( lExit )
RETURN Set( _SET_EXIT, lExit )
| getsys.prg | 206 |
| FUNCTION | ReadInsert( lInsert )
FUNCTION ReadInsert( lInsert )
RETURN Set( _SET_INSERT, lInsert )
| getsys.prg | 209 |
| FUNCTION | Updated()
FUNCTION Updated()
LOCAL oGetList := __GetListLast()
RETURN iif( oGetList != NIL, oGetList:Updated(), .F. )
| getsys.prg | 212 |
| PROCEDURE | __KillRead()
PROCEDURE __KillRead()
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
oGetList:KillRead( .T. )
ENDIF
RETURN
| getsys.prg | 217 |
| FUNCTION | ReadUpdated( lUpdated )
FUNCTION ReadUpdated( lUpdated )
LOCAL oGetList := __GetListLast()
IF oGetList != NIL
IF PCount() > 0
RETURN oGetList:ReadUpdated( lUpdated )
ELSE
RETURN oGetList:ReadUpdated()
ENDIF
ENDIF
RETURN .F.
| getsys.prg | 226 |
| FUNCTION | ReadKill( lKill )
FUNCTION ReadKill( lKill )
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
IF PCount() > 0
RETURN oGetList:KillRead( lKill )
ELSE
RETURN oGetList:KillRead()
ENDIF
ENDIF
RETURN .F.
| getsys.prg | 239 |
| FUNCTION | ReadFormat( bFormat )
FUNCTION ReadFormat( bFormat )
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
IF PCount() > 0
RETURN oGetList:SetFormat( bFormat )
ELSE
RETURN oGetList:SetFormat()
ENDIF
ENDIF
RETURN NIL
| getsys.prg | 252 |
| PROCEDURE | __SetFormat( bFormat )
PROCEDURE __SetFormat( bFormat )
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
IF ISBLOCK( bFormat )
oGetList:SetFormat( bFormat )
ELSE
oGetList:SetFormat()
ENDIF
ENDIF
RETURN
| getsys.prg | 265 |
| FUNCTION | RangeCheck( oGet, xDummy, xLow, xHigh )
FUNCTION RangeCheck( oGet, xDummy, xLow, xHigh )
LOCAL xValue
LOCAL cMessage
LOCAL nOldRow
LOCAL nOldCol
HB_SYMBOL_UNUSED( xDummy )
IF !oGet:changed
RETURN .T.
ENDIF
xValue := oGet:varGet()
IF xValue >= xLow .AND. xValue <= xHigh
RETURN .T.
ENDIF
IF Set( _SET_SCOREBOARD )
cMessage := Left( __NatMsg( _GET_RANGE_FROM ) + LTrim( Transform( xLow, "" ) ) + ;
__NatMsg( _GET_RANGE_TO ) + LTrim( Transform( xHigh, "" ) ), MaxCol() )
nOldRow := Row()
nOldCol := Col()
DispOutAt( SCORE_ROW, Min( 60, MaxCol() - Len( cMessage ) ), cMessage )
SetPos( nOldRow, nOldCol )
DO WHILE NextKey() == 0
ENDDO
DispOutAt( SCORE_ROW, Min( 60, MaxCol() - Len( cMessage ) ), Space( Len( cMessage ) ) )
SetPos( nOldRow, nOldCol )
ENDIF
RETURN .F.
| getsys.prg | 284 |
| FUNCTION | hb_GetReadVar( oGet )
FUNCTION hb_GetReadVar( oGet )
LOCAL cName := Upper( oGet:name )
LOCAL n
IF oGet:subScript != NIL
FOR n := 1 TO Len( oGet:subScript )
cName += "[" + LTrim( Str( oGet:subScript[ n ] ) ) + "]"
NEXT
ENDIF
RETURN cName
| getsys.prg | 323 |
| getsys53.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | GUIReader( oGet, oGetlist, oMenu, aMsg )
PROCEDURE GUIReader( oGet, oGetlist, oMenu, aMsg )
IF !ISOBJECT( oGetList )
oGetList := __GetListActive()
ENDIF
IF oGetList != NIL
oGetlist:GUIReader( oGet, oMenu, aMsg )
ENDIF
RETURN
| getsys53.prg | 68 |
| PROCEDURE | GUIApplyKey( oGet, oGUI, oGetList, nKey, oMenu, aMsg )
PROCEDURE GUIApplyKey( oGet, oGUI, oGetList, nKey, oMenu, aMsg )
IF !ISOBJECT( oGetList )
oGetList := __GetListActive()
ENDIF
IF oGetList != NIL
oGetList:GUIApplyKey( oGet, oGUI, nKey, oMenu, aMsg )
ENDIF
RETURN
| getsys53.prg | 80 |
| FUNCTION | GUIPreValidate( oGet, oGUI, aMsg )
FUNCTION GUIPreValidate( oGet, oGUI, aMsg )
LOCAL oGetList := __GetListActive()
RETURN iif( oGetList != NIL, oGetList:GUIPreValidate( oGet, oGUI, aMsg ), .F. )
| getsys53.prg | 92 |
| FUNCTION | GUIPostValidate( oGet, oGUI, aMsg )
FUNCTION GUIPostValidate( oGet, oGUI, aMsg )
LOCAL oGetList := __GetListActive()
RETURN iif( oGetList != NIL, oGetList:GUIPostValidate( oGet, oGUI, aMsg ), .F. )
| getsys53.prg | 97 |
| PROCEDURE | TBReader( oGet, oGetList, oMenu, aMsg )
PROCEDURE TBReader( oGet, oGetList, oMenu, aMsg )
IF !ISOBJECT( oGetList )
oGetList := __GetListActive()
ENDIF
IF oGetList != NIL
oGetlist:TBReader( oGet, oMenu, aMsg )
ENDIF
RETURN
| getsys53.prg | 102 |
| PROCEDURE | TBApplyKey( oGet, oTB, oGetList, nKey, aMsg )
PROCEDURE TBApplyKey( oGet, oTB, oGetList, nKey, aMsg )
IF !ISOBJECT( oGetList )
oGetList := __GetListActive()
ENDIF
IF oGetList != NIL
oGetList:TBApplyKey( oGet, oTB, nKey, aMsg )
ENDIF
RETURN
| getsys53.prg | 114 |
| FUNCTION | Accelerator( oGetList, nKey, aMsg )
FUNCTION Accelerator( oGetList, nKey, aMsg )
IF !ISOBJECT( oGetList )
oGetList := __GetListActive()
ENDIF
RETURN iif( oGetList != NIL, oGetlist:Accelerator( nKey, aMsg ), 0 )
| getsys53.prg | 126 |
| FUNCTION | HitTest( oGetList, nMRow, nMCol, aMsg )
FUNCTION HitTest( oGetList, nMRow, nMCol, aMsg )
IF !ISOBJECT( oGetList )
oGetList := __GetListActive()
ENDIF
RETURN iif( oGetList != NIL, oGetlist:hitTest( nMRow, nMCol, aMsg ), 0 )
| getsys53.prg | 134 |
| PROCEDURE | ShowGetMsg( oGet, aMsg )
PROCEDURE ShowGetMsg( oGet, aMsg )
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
oGetList:ShowGetMsg( oGet, aMsg )
ENDIF
RETURN
| getsys53.prg | 142 |
| PROCEDURE | EraseGetMsg( oGet, aMsg )
PROCEDURE EraseGetMsg( oGet, aMsg )
LOCAL oGetList := __GetListActive()
HB_SYMBOL_UNUSED( oGet )
IF oGetList != NIL
oGetList:EraseGetMsg( aMsg )
ENDIF
RETURN
| getsys53.prg | 151 |
| FUNCTION | ReadStats( nElement, xNewValue )
FUNCTION ReadStats( nElement, xNewValue )
LOCAL oGetList := __GetListActive()
IF oGetList != NIL
IF PCount() > 1
RETURN oGetList:ReadStats( nElement, xNewValue )
ELSE
RETURN oGetList:ReadStats( nElement )
ENDIF
ENDIF
RETURN NIL
| getsys53.prg | 162 |
| gui.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | _IsGraphic()
FUNCTION _IsGraphic()
RETURN Set( _SET_VIDEOMODE ) != NIL .AND. ;
Set( _SET_VIDEOMODE ) != 0 .AND. ;
Set( _SET_VIDEOMODE ) != LLG_VIDEO_TXT
| gui.prg | 59 |
| FUNCTION | _SetVideoMode( nMode )
FUNCTION _SetVideoMode( nMode )
HB_SYMBOL_UNUSED( nMode )
RETURN 0
| gui.prg | 64 |
| FUNCTION | _GetNumCol( cColor )
FUNCTION _GetNumCol( cColor )
LOCAL nPos
IF ( nPos := At( "/", cColor ) ) > 0
cColor := Left( cColor, nPos - 1 )
ENDIF
IF ( nPos := At( ",", cColor ) ) > 0
cColor := Left( cColor, nPos - 1 )
ENDIF
RETURN AScan( { "B", "G", "BG", "R", "RB", "GR", "W", "N+", "B+", "G+", "BG+", "R+", "RB+", "GR+", "W+" }, {| tmp | tmp == cColor } )
| gui.prg | 74 |
| FUNCTION | __GUIColor( cColor, nPos )
FUNCTION __GUIColor( cColor, nPos )
RETURN hb_ColorIndex( cColor, nPos - 1 )
| gui.prg | 86 |
| FUNCTION | IsDefColor()
FUNCTION IsDefColor()
RETURN SetColor() == "W/N,N/W,N/N,N/N,N/W" /* NOTE: Color must match with the one in set.c */
| gui.prg | 89 |
| FUNCTION | __Caption( cCaption )
FUNCTION __Caption( cCaption )
LOCAL nPos
RETURN iif( ( nPos := At( "&", cCaption ) ) > 0, Stuff( cCaption, nPos, 1, "" ), cCaption )
| gui.prg | 93 |
| FUNCTION | __CapLength( cCaption )
FUNCTION __CapLength( cCaption )
LOCAL nCaptionLen := Len( cCaption )
LOCAL nPos
RETURN iif( ( nPos := At( "&", cCaption ) ) > 0 .AND. nPos < nCaptionLen, nCaptionLen - 1, nCaptionLen )
| gui.prg | 98 |
| FUNCTION | __CapMetrics( o )
FUNCTION __CapMetrics( o )
RETURN __CapLength( o:caption ) + iif( o:isPopup(), 3, 2 )
| gui.prg | 104 |
| hbini.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | hb_IniSetComment( cLc, cHlc )
PROCEDURE hb_IniSetComment( cLc, cHlc )
s_cLineComment := cLc
s_cHalfLineComment := cHlc
RETURN
| hbini.prg | 85 |
| FUNCTION | HB_IniNew( lAutoMain )
FUNCTION HB_IniNew( lAutoMain )
LOCAL hIni := hb_Hash()
IF lAutoMain
hIni[ "MAIN" ] := hb_Hash()
ENDIF
RETURN hIni
| hbini.prg | 92 |
| FUNCTION | hb_IniRead( cFileSpec, lKeyCaseSens, cSplitters, lAutoMain )
FUNCTION hb_IniRead( cFileSpec, lKeyCaseSens, cSplitters, lAutoMain )
LOCAL hIni := hb_Hash()
/* Default case sensitiveness for keys */
DEFAULT lKeyCaseSens TO .T.
DEFAULT cSplitters TO "="
DEFAULT lAutoMain TO .T.
hb_HCaseMatch( hIni, lKeyCaseSens )
IF lAutoMain
hIni[ "MAIN" ] := hb_Hash()
ENDIF
RETURN hb_IniRdLow( hIni, cFileSpec, lKeyCaseSens, cSplitters, lAutoMain )
| hbini.prg | 102 |
| STATIC FUNCTION | hb_IniRdLow( hIni, cFileSpec, lKeyCaseSens, cSplitters, lAutoMain )
STATIC FUNCTION hb_IniRdLow( hIni, cFileSpec, lKeyCaseSens, cSplitters, lAutoMain )
LOCAL cFile, nLen
LOCAL aKeyVal, hCurrentSection
LOCAL hFile, nLineEnd
LOCAL cData, cLine
LOCAL reComment, reInclude, reSection, reSplitters
LOCAL aFiles := hb_aTokens( cFileSpec, hb_OSPathListSeparator() )
IF Empty( aFiles )
aFiles := { cFileSpec }
ENDIF
hFile := F_ERROR
FOR EACH cFile IN aFiles
IF ! Empty( cFile ) .AND. File( cFile )
IF ( hFile := FOpen( cFile ) ) != F_ERROR
EXIT
ENDIF
ENDIF
NEXT
IF hFile == F_ERROR
RETURN NIL
ENDIF
reComment := hb_RegexComp( s_cHalfLineComment + "|^[ \t]*" + s_cLineComment )
reInclude := hb_RegexComp( "include (.*)" )
reSection := hb_RegexComp( "[[](.*)[]]" )
reSplitters := hb_RegexComp( cSplitters )
/* we'll read the whole file, then we'll break it in lines. */
cData := Space( FSeek( hFile, 0, FS_END ) )
FSeek( hFile, 0, FS_SET )
nLen := FRead( hFile, @cData, Len( cData ) )
cData := Left( cData, nLen )
FClose( hFile )
/* Always begin with the MAIN section */
IF lAutoMain
hCurrentSection := hIni[ "MAIN" ]
ELSE
hCurrentSection := hIni
ENDIF
cLine := ""
DO WHILE Len( cData ) > 0
nLen := 2
nLineEnd := At( Chr( 13 ) + Chr( 10 ), cData )
IF nLineEnd == 0
nLineEnd := At( Chr( 10 ) + Chr( 13 ), cData )
IF nLineEnd == 0
nLen := 1
nLineEnd := At( Chr( 10 ), cData )
IF nLineEnd == 0
nLineEnd := At( Chr( 13 ), cData )
IF nLineEnd == 0
nLineEnd := Len( cData )
ENDIF
ENDIF
ENDIF
ENDIF
/* Get the current line */
cLine += AllTrim( SubStr( cData, 1, nLineEnd - 1 ) )
/* remove current line */
cData := SubStr( cData, nLineEnd + nLen )
/* Skip void lines */
IF Empty( cLine )
LOOP
ENDIF
/* Sum up lines terminating with "||" ...*/
IF Len( cLine ) > 3 .AND. SubStr( cLine, -3, 3 ) == " ||"
cLine := SubStr( cLine, 1, Len( cLine ) - 2 )
/* ... but proceed if stream over */
IF Len( cData ) > 0
LOOP
ENDIF
ENDIF
/* remove eventual comments */
aKeyVal := hb_RegexSplit( reComment, cLine )
IF ! Empty( aKeyVal )
cLine := AllTrim( aKeyVal[ 1 ] )
ENDIF
/* Skip all comment lines */
IF Empty( cLine )
LOOP
ENDIF
/* Is it an "INCLUDE" statement ? */
aKeyVal := hb_RegEx( reInclude, cLine )
IF ! Empty( aKeyVal )
/* ignore void includes */
aKeyVal[ 2 ] := AllTrim( aKeyVal[ 2 ] )
IF Len( aKeyVal[ 2 ] ) == 0
LOOP
ENDIF
hb_IniRdLow( hIni, aKeyVal[ 2 ], lKeyCaseSens, cSplitters, lAutoMain )
cLine := ""
LOOP
ENDIF
/* Is it a NEW section? */
aKeyVal := hb_Regex( reSection, cLine )
IF ! Empty( aKeyVal )
cLine := AllTrim( aKeyVal[ 2 ] )
IF Len( cLine ) != 0
hCurrentSection := hb_Hash()
IF ! lKeyCaseSens
cLine := Upper( cLine )
ENDIF
hIni[ cLine ] := hCurrentSection
ENDIF
cLine := ""
LOOP
ENDIF
/* Is it a valid key */
aKeyVal := hb_RegexSplit( reSplitters, cLine,,, 2 )
IF Len( aKeyVal ) == 1
/* TODO: Signal error */
cLine := ""
LOOP
ENDIF
/* If not case sensitive, use upper keys */
IF ! lKeyCaseSens
aKeyVal[ 1 ] := Upper( aKeyVal[ 1 ] )
ENDIF
hCurrentSection[ AllTrim( aKeyVal[ 1 ] ) ] := AllTrim( aKeyVal[ 2 ] )
cLine := ""
ENDDO
RETURN hIni
| hbini.prg | 118 |
| FUNCTION | hb_IniWrite( xFileName, hIni, cCommentBegin, cCommentEnd, lAutoMain )
FUNCTION hb_IniWrite( xFileName, hIni, cCommentBegin, cCommentEnd, lAutoMain )
LOCAL hFile
LOCAL lClose
LOCAL cNewLine := hb_OSNewLine()
LOCAL cSection
LOCAL cBuffer
IF ISCHARACTER( xFileName )
hFile := FCreate( xFileName )
lClose := .T.
ELSEIF ISNUMBER( xFileName )
hFile := xFileName
lClose := .F.
ELSE
RETURN .F.
ENDIF
IF hFile == F_ERROR
RETURN .F.
ENDIF
IF ! Empty( cCommentBegin )
cBuffer := cCommentBegin + cNewLine
IF FWrite( hFile, cBuffer ) != Len( cBuffer )
IF lClose
FClose( hFile )
ENDIF
RETURN .F.
ENDIF
ENDIF
DEFAULT lAutoMain TO .T.
/* Write toplevel section */
IF lAutoMain
/* When automain is on, write the main section */
hb_HEval( hIni[ "MAIN" ], ;
{ |cKey, xVal| FWrite( hFile, hb_CStr( cKey ) + " = " + ;
hb_CStr( xVal ) + cNewLine ) } )
ELSE
/* When automain is off, just write all the toplevel variables. */
hb_HEval( hIni, { |cKey, xVal| IIF( ! hb_IsHash( xVal ),;
FWrite( hFile, hb_CStr( cKey ) + " = " + ;
hb_CStr( xVal ) + cNewLine ), /* nothing */ ) } )
ENDIF
FOR EACH cSection IN hIni
/* Avoid re-processing main section */
IF lAutoMain
/* When automain is on, skip section named MAIN */
IF cSection:__enumKey == "MAIN"
LOOP
ENDIF
ELSE
/* When automain is off, skip all the toplevel variables. */
IF ! hb_IsHash( cSection )
LOOP
ENDIF
ENDIF
cBuffer := cNewLine + "[" + hb_CStr( cSection:__enumKey ) + "]" + cNewLine
IF FWrite( hFile, cBuffer ) != Len( cBuffer )
IF lClose
FClose( hFile )
ENDIF
RETURN .F.
ENDIF
hb_HEval( cSection, ;
{ |cKey, xVal| FWrite( hFile, hb_CStr( cKey ) + "=" + ;
hb_CStr( xVal ) + cNewLine ) } )
NEXT
IF ! Empty( cCommentEnd )
cBuffer := cCommentEnd + cNewLine
IF FWrite( hFile, cBuffer ) != Len( cBuffer )
IF lClose
FClose( hFile )
ENDIF
RETURN .F.
ENDIF
ENDIF
IF lClose
FClose( hFile )
ENDIF
RETURN .T.
| hbini.prg | 260 |
| input.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __Input( xPrompt )
FUNCTION __Input( xPrompt )
LOCAL cString := __Accept( xPrompt )
RETURN iif( Empty( cString ), NIL, &cString )
| input.prg | 55 |
| listbox.prg |
| Type | Function | Source | Line |
|---|
| METHOD | addItem( cText, cData )
METHOD addItem( cText, cData )
| listbox.prg | 82 |
| METHOD | close()
METHOD close()
| listbox.prg | 83 |
| METHOD | delItem( nPos )
METHOD delItem( nPos )
| listbox.prg | 84 |
| METHOD | display()
METHOD display()
| listbox.prg | 85 |
| METHOD | findText( cText, nPos, lCaseSensitive, lExact )
METHOD findText( cText, nPos, lCaseSensitive, lExact )
| listbox.prg | 86 |
| METHOD | findData( cData, nPos, lCaseSensitive, lExact )
METHOD findData( cData, nPos, lCaseSensitive, lExact ) /* NOTE: Undocumented CA-Cl*pper method. */
| listbox.prg | 87 |
| METHOD | getData( nPos )
METHOD getData( nPos )
| listbox.prg | 88 |
| METHOD | getItem( nPos )
METHOD getItem( nPos )
| listbox.prg | 89 |
| METHOD | getText( nPos )
METHOD getText( nPos )
| listbox.prg | 90 |
| METHOD | hitTest( nMRow, nMCol )
METHOD hitTest( nMRow, nMCol )
| listbox.prg | 91 |
| METHOD | insItem( nPos, cText, cData )
METHOD insItem( nPos, cText, cData )
| listbox.prg | 92 |
| METHOD | killFocus()
METHOD killFocus()
| listbox.prg | 93 |
| METHOD | nextItem()
METHOD nextItem()
| listbox.prg | 94 |
| METHOD | open()
METHOD open()
| listbox.prg | 95 |
| METHOD | prevItem()
METHOD prevItem()
| listbox.prg | 96 |
| METHOD | scroll( n )
METHOD scroll( n )
| listbox.prg | 97 |
| METHOD | select( nValue )
METHOD select( nValue )
| listbox.prg | 98 |
| METHOD | setData( nPos, cData )
METHOD setData( nPos, cData )
| listbox.prg | 99 |
| METHOD | setFocus()
METHOD setFocus()
| listbox.prg | 100 |
| METHOD | setItem( nPos, aItem )
METHOD setItem( nPos, aItem )
| listbox.prg | 101 |
| METHOD | setText( nPos, cText )
METHOD setText( nPos, cText )
| listbox.prg | 102 |
| METHOD | bitmap( cBitmap ) SETGET
METHOD bitmap( cBitmap ) SETGET
| listbox.prg | 104 |
| METHOD | bottom( nBottom ) SETGET
METHOD bottom( nBottom ) SETGET
| listbox.prg | 105 |
| METHOD | buffer() SETGET
METHOD buffer() SETGET
| listbox.prg | 106 |
| METHOD | capCol( nCapCol ) SETGET
METHOD capCol( nCapCol ) SETGET
| listbox.prg | 107 |
| METHOD | capRow( nCapRow ) SETGET
METHOD capRow( nCapRow ) SETGET
| listbox.prg | 108 |
| METHOD | caption( cCaption ) SETGET
METHOD caption( cCaption ) SETGET
| listbox.prg | 109 |
| METHOD | coldBox( cColdBox ) SETGET
METHOD coldBox( cColdBox ) SETGET
| listbox.prg | 110 |
| METHOD | colorSpec( cColorSpec ) SETGET
METHOD colorSpec( cColorSpec ) SETGET
| listbox.prg | 111 |
| METHOD | dropDown( lDropDown ) SETGET
METHOD dropDown( lDropDown ) SETGET
| listbox.prg | 112 |
| METHOD | fBlock( bFBlock ) SETGET
METHOD fBlock( bFBlock ) SETGET
| listbox.prg | 113 |
| METHOD | hasFocus() SETGET
METHOD hasFocus() SETGET
| listbox.prg | 114 |
| METHOD | hotBox( cHotBox ) SETGET
METHOD hotBox( cHotBox ) SETGET
| listbox.prg | 115 |
| METHOD | isOpen() SETGET
METHOD isOpen() SETGET
| listbox.prg | 116 |
| METHOD | itemCount() SETGET
METHOD itemCount() SETGET
| listbox.prg | 117 |
| METHOD | left( nLeft ) SETGET
METHOD left( nLeft ) SETGET
| listbox.prg | 118 |
| METHOD | message( cMessage ) SETGET
METHOD message( cMessage ) SETGET
| listbox.prg | 119 |
| METHOD | right( nRight ) SETGET
METHOD right( nRight ) SETGET
| listbox.prg | 120 |
| METHOD | sBlock( bSBlock ) SETGET
METHOD sBlock( bSBlock ) SETGET
| listbox.prg | 121 |
| METHOD | style( cStyle ) SETGET
METHOD style( cStyle ) SETGET /* NOTE: Undocumented CA-Cl*pper method. */
| listbox.prg | 122 |
| METHOD | textValue() SETGET
METHOD textValue() SETGET /* NOTE: Undocumented CA-Cl*pper method. */
| listbox.prg | 123 |
| METHOD | top( nTop ) SETGET
METHOD top( nTop ) SETGET
| listbox.prg | 124 |
| METHOD | topItem( nTopItem ) SETGET
METHOD topItem( nTopItem ) SETGET
| listbox.prg | 125 |
| METHOD | typeOut() SETGET
METHOD typeOut() SETGET
| listbox.prg | 126 |
| METHOD | value() SETGET
METHOD value() SETGET /* NOTE: Undocumented CA-Cl*pper method. */
| listbox.prg | 127 |
| METHOD | vScroll( oVScroll ) SETGET
METHOD vScroll( oVScroll ) SETGET
| listbox.prg | 128 |
| METHOD | New( nTop, nLeft, nBottom, nRight, lDrop )
METHOD New( nTop, nLeft, nBottom, nRight, lDrop ) /* NOTE: This method is a Harbour extension [vszakats] */
PROTECTED:
VAR cBitmap INIT "dropbox.bmu"
VAR nBottom
VAR xBuffer
VAR nCapCol
VAR nCapRow
VAR cCaption INIT ""
VAR cColdBox INIT Chr( 218 ) + Chr( 196 ) + Chr( 191 ) + Chr( 179 ) + Chr( 217 ) + Chr( 196 ) + Chr( 192 ) + Chr( 179 )
VAR cColorSpec
VAR lDropDown
VAR bFBlock
VAR lHasFocus INIT .F.
VAR cHotBox INIT Chr( 201 ) + Chr( 205 ) + Chr( 187 ) + Chr( 186 ) + Chr( 188 ) + Chr( 205 ) + Chr( 200 ) + Chr( 186 )
VAR lIsOpen
VAR nItemCount INIT 0
VAR nLeft
VAR cMessage INIT ""
VAR nRight
VAR bSBlock
VAR cStyle INIT Chr( 31 )
VAR cTextValue INIT ""
VAR nTop
VAR nTopItem INIT 0
VAR nValue INIT 0
VAR oVScroll
VAR aItems INIT {}
VAR aSaveScr
VAR nCursor
| listbox.prg | 130 |
| METHOD | changeItem( nOldPos, nNewPos )
METHOD changeItem( nOldPos, nNewPos )
| listbox.prg | 163 |
| METHOD | scrollbarPos()
METHOD scrollbarPos()
ENDCLASS
| listbox.prg | 164 |
| LISTBOX:METHOD | addItem( cText, cData ) CLASS LISTBOX
METHOD addItem( cText, cData ) CLASS LISTBOX
IF ISCHARACTER( cText ) .AND. Valtype( cData ) $ "CU"
AAdd( ::aItems, { cText, cData } )
::nItemCount++
IF ::nItemCount == 1
::nTopItem := 1
IF ::oVScroll != NIL
::oVScroll:total := ( ::nItemCount - ( ::nBottom - ::nTop - 2 ) )
ENDIF
ENDIF
ENDIF
RETURN Self
| listbox.prg | 168 |
| LISTBOX:METHOD | close() CLASS LISTBOX
METHOD close() CLASS LISTBOX
IF ::lIsOpen
RestScreen( ::aSaveScr[ 1 ], ::aSaveScr[ 2 ], ::aSaveScr[ 3 ], ::aSaveScr[ 4 ], ::aSaveScr[ 5 ] )
::lIsOpen := .F.
::aSaveScr := NIL
ENDIF
RETURN Self
| listbox.prg | 186 |
| LISTBOX:METHOD | delItem( nPos )
METHOD delItem( nPos )
IF nPos >= 1 .AND. nPos <= ::nItemCount
ADel( ::aItems, nPos )
ASize( ::aItems, --::nItemCount )
IF ::nValue > ::nItemCount
::nValue := ::nItemCount
::cTextValue := iif( ::nValue == 0, "", _LISTBOX_ITEMDATA( ::aItems[ ::nItemCount ] ) )
IF ::xBuffer == NIL
ELSEIF ISNUMBER( ::xBuffer )
::xBuffer := ::nItemCount
ELSEIF ::nValue > 0
::xBuffer := ::cTextValue
ENDIF
ENDIF
IF ::nTopItem > ::nItemCount
::nTopItem := ::nItemCount
ENDIF
IF ::oVScroll != NIL
::oVScroll:total := ::nItemCount - ( ::nBottom - ::nTop - 2 )
ENDIF
ENDIF
RETURN Self
| listbox.prg | 196 |
| LISTBOX:METHOD | display() CLASS LISTBOX
METHOD display() CLASS LISTBOX
LOCAL cOldColor := SetColor()
LOCAL nOldRow := Row()
LOCAL nOldCol := Col()
LOCAL lOldMCur := MSetCursor( .F. )
LOCAL nItem
LOCAL nEnd
LOCAL cColor4
LOCAL cColor3
LOCAL cColorAny
LOCAL nTop := ::nTop
LOCAL nLeft := ::nLeft
LOCAL nSize := ::nRight - nLeft + 1
LOCAL cHotBox
LOCAL cCaption
LOCAL nPos
IF ::lHasFocus
cHotBox := ::cHotBox
cColor3 := hb_ColorIndex( ::cColorSpec, 2 )
cColor4 := hb_ColorIndex( ::cColorSpec, 3 )
cColorAny := iif( ::lIsOpen, hb_ColorIndex( ::cColorSpec, 1 ), hb_ColorIndex( ::cColorSpec, 3 ) )
ELSE
cHotBox := ::cColdBox
cColor3 := hb_ColorIndex( ::cColorSpec, 0 )
cColor4 := hb_ColorIndex( ::cColorSpec, 1 )
cColorAny := hb_ColorIndex( ::cColorSpec, 1 )
ENDIF
DispBegin()
nEnd := ::nTopItem + ::nBottom - ::nTop
IF ::lDropDown
DispOutAt( nTop++, nLeft,;
iif( ::nValue == 0, Space( nSize - 1 ), PadR( ::aItems[ ::nValue ][ _ITEM_cTEXT ], nSize - 1 ) ),;
cColorAny )
DispOut( ::cStyle, hb_ColorIndex( ::cColorSpec, 7 ) )
nEnd--
ENDIF
IF ::lIsOpen
IF !Empty( cHotBox )
SetColor( hb_ColorIndex( ::cColorSpec, 4 ) )
Scroll( nTop, nLeft, ::nBottom, ::nRight )
DispBox( nTop, nLeft, ::nBottom, ::nRight, cHotBox )
IF ::oVScroll != NIL
::oVScroll:display()
ENDIF
nTop++
nLeft++
nSize -= 2
nEnd -= 2
ENDIF
IF nEnd > ::nItemCount
nEnd := ::nItemCount
ENDIF
FOR nItem := ::nTopItem TO nEnd
DispOutAt( nTop++, nLeft, PadR( ::aItems[ nItem ][ _ITEM_cTEXT ], nSize ), iif( nItem == ::nValue, cColor4, cColor3 ) )
NEXT
ENDIF
IF !Empty( cCaption := ::cCaption )
IF ( nPos := At( "&", cCaption ) ) == 0
ELSEIF nPos == Len( cCaption )
nPos := 0
ELSE
cCaption := Stuff( cCaption, nPos, 1, "" )
ENDIF
DispOutAt( ::nCapRow, ::nCapCol - 1, cCaption, hb_ColorIndex( ::cColorSpec, 5 ) )
IF nPos != 0
DispOutAt( ::nCapRow, ::nCapCol + nPos - 2, SubStr( cCaption, nPos, 1 ), hb_ColorIndex( ::cColorSpec, 6 ) )
ENDIF
ENDIF
DispEnd()
MSetCursor( lOldMCur )
SetColor( cOldColor )
SetPos( nOldRow, nOldCol )
RETURN Self
| listbox.prg | 228 |
| LISTBOX:METHOD | findText( cText, nPos, lCaseSensitive, lExact ) CLASS LISTBOX
METHOD findText( cText, nPos, lCaseSensitive, lExact ) CLASS LISTBOX
LOCAL nPosFound
LOCAL nPass
LOCAL nPasses
LOCAL nSize
LOCAL lOldExact
IF !ISCHARACTER( cText )
RETURN 0
ENDIF
IF !ISNUMBER( nPos )
nPos := 1
ENDIF
IF !ISLOGICAL( lCaseSensitive )
lCaseSensitive := .T.
ENDIF
IF !lCaseSensitive
cText := Lower( cText )
ENDIF
IF ISLOGICAL( lExact )
lOldExact := Set( _SET_EXACT, lExact )
ENDIF
nSize := Len( ::aItems ) - nPos + 1
nPasses := iif( nPos > 1, 2, 1 )
FOR nPass := 1 TO nPasses
/* NOTE: Intentionally using "=" comparison to honor the _SET_EXACT setting. */
IF ( nPosFound := AScan( ::aItems, iif( lCaseSensitive,;
{ | aItem | aItem[ _ITEM_cTEXT ] = cText },;
{ | aItem | Lower( aItem[ _ITEM_cTEXT ] ) = cText } ), nPos, nSize ) ) > 0
EXIT
ENDIF
nSize := nPos - 1
nPos := 1
NEXT
IF lOldExact != NIL
Set( _SET_EXACT, lOldExact )
ENDIF
RETURN nPosFound
| listbox.prg | 326 |
| LISTBOX:METHOD | findData( cData, nPos, lCaseSensitive, lExact ) CLASS LISTBOX
METHOD findData( cData, nPos, lCaseSensitive, lExact ) CLASS LISTBOX
LOCAL nPosFound
LOCAL nPass
LOCAL nPasses
LOCAL nSize
LOCAL lOldExact
IF !ISCHARACTER( cData )
RETURN 0
ENDIF
IF !ISNUMBER( nPos )
nPos := 1
ENDIF
IF !ISLOGICAL( lCaseSensitive )
lCaseSensitive := .T.
ENDIF
IF !lCaseSensitive
cData := Lower( cData )
ENDIF
IF ISLOGICAL( lExact )
lOldExact := Set( _SET_EXACT, lExact )
ENDIF
nSize := Len( ::aItems ) - nPos + 1
nPasses := iif( nPos > 1, 2, 1 )
FOR nPass := 1 TO nPasses
/* NOTE: Intentionally using "=" comparison to honor the _SET_EXACT setting. */
IF ( nPosFound := AScan( ::aItems, iif( lCaseSensitive,;
{ | aItem | _LISTBOX_ITEMDATA( aItem ) = cData },;
{ | aItem | Lower( _LISTBOX_ITEMDATA( aItem ) ) = cData } ), nPos, nSize ) ) > 0
EXIT
ENDIF
nSize := nPos - 1
nPos := 1
NEXT
IF lOldExact != NIL
Set( _SET_EXACT, lOldExact )
ENDIF
RETURN nPosFound
| listbox.prg | 372 |
| LISTBOX:METHOD | getData( nPos ) CLASS LISTBOX
METHOD getData( nPos ) CLASS LISTBOX
RETURN iif( nPos >= 1 .AND. nPos <= ::nItemCount, ::aItems[ nPos ][ _ITEM_cDATA ], NIL )
| listbox.prg | 418 |
| LISTBOX:METHOD | getItem( nPos ) CLASS LISTBOX
METHOD getItem( nPos ) CLASS LISTBOX
RETURN iif( nPos >= 1 .AND. nPos <= ::nItemCount, ::aItems[ nPos ], NIL )
| listbox.prg | 421 |
| LISTBOX:METHOD | getText( nPos ) CLASS LISTBOX
METHOD getText( nPos ) CLASS LISTBOX
RETURN iif( nPos >= 1 .AND. nPos <= ::nItemCount, ::aItems[ nPos ][ _ITEM_cTEXT ], NIL )
| listbox.prg | 424 |
| LISTBOX:METHOD | hitTest( nMRow, nMCol ) CLASS LISTBOX
METHOD hitTest( nMRow, nMCol ) CLASS LISTBOX
LOCAL nRet
LOCAL nTop
LOCAL nHit := 0
/* Check hit on the scrollbar */
IF ::lIsOpen .AND. ;
::oVScroll != NIL .AND. ;
( nHit := ::oVScroll:hitTest( nMRow, nMCol ) ) != 0
RETURN nHit
ENDIF
IF ! ::lIsOpen .OR. Empty( ::cHotBox + ::cColdBox )
nRet := 0
ELSE
nTop := ::nTop
IF ::lDropDown
nTop++
ENDIF
DO CASE
CASE nMRow == nTop
IF nMCol == ::nLeft
RETURN HTTOPLEFT
ELSEIF nMCol == ::nRight
RETURN HTTOPRIGHT
ELSEIF nMCol >= ::nLeft .AND. nMCol <= ::nRight
RETURN HTTOP
ENDIF
CASE nMRow == ::nBottom
IF nMCol == ::nLeft
RETURN HTBOTTOMLEFT
ELSEIF nMCol == ::nRight
RETURN HTBOTTOMRIGHT
ELSEIF nMCol >= ::nLeft .AND. nMCol <= ::nRight
RETURN HTBOTTOM
ENDIF
CASE nMCol == ::nLeft
IF nMRow >= ::nTop .AND. nMRow <= ::nBottom
RETURN HTLEFT
ELSE
RETURN HTNOWHERE
ENDIF
CASE nMCol == ::nRight
IF nMRow >= ::nTop .AND. nMRow <= ::nBottom
RETURN HTRIGHT
ELSE
RETURN HTNOWHERE
ENDIF
ENDCASE
nRet := 1
ENDIF
DO CASE
CASE ! ::lIsOpen
CASE nMRow < nTop + nRet
CASE nMRow > ::nBottom - nRet
CASE nMCol < ::nLeft + nRet
CASE nMCol <= ::nRight - nRet
RETURN ::nTopItem + nMRow - ( nTop + nRet )
ENDCASE
DO CASE
CASE ! ::lDropDown
CASE nMRow != ::nTop
CASE nMCol < ::nLeft
CASE nMCol < ::nRight
RETURN HTCLIENT
CASE nMCol == ::nRight
RETURN HTDROPBUTTON
ENDCASE
DO CASE
CASE Empty( ::cCaption )
CASE nMRow != ::nCapRow
CASE nMCol < ::nCapCol
CASE nMCol < ::nCapCol + __CapLength( ::cCaption )
RETURN HTCAPTION
ENDCASE
RETURN 0
| listbox.prg | 427 |
| LISTBOX:METHOD | insItem( nPos, cText, cData )
METHOD insItem( nPos, cText, cData )
IF ISCHARACTER( cText ) .AND. ;
ISNUMBER( nPos ) .AND. ;
nPos < ::nItemCount
ASize( ::aItems, ++::nItemCount )
AIns( ::aItems, nPos )
::aItems[ nPos ] := { cText, cData }
IF ::nItemCount == 1
::nTopItem := 1
ENDIF
IF ::oVScroll != NIL
::oVScroll:total := ::nItemCount - ( ::nBottom - ::nTop - 2 )
ENDIF
ENDIF
RETURN Self
| listbox.prg | 511 |
| LISTBOX:METHOD | killFocus() CLASS LISTBOX
METHOD killFocus() CLASS LISTBOX
LOCAL nOldMCur
IF ::lHasFocus
::lHasFocus := .F.
IF ISBLOCK( ::bFBlock )
Eval( ::bFBlock )
ENDIF
nOldMCur := MSetCursor( .F. )
DispBegin()
IF ::lDropDown .AND. ::lIsOpen
::close()
ENDIF
::display()
DispEnd()
MSetCursor( nOldMCur )
SetCursor( ::nCursor )
ENDIF
RETURN Self
| listbox.prg | 532 |
| LISTBOX:METHOD | nextItem() CLASS LISTBOX
METHOD nextItem() CLASS LISTBOX
LOCAL nOldValue
IF ::lHasFocus .AND. ::nItemCount > 0
::changeItem( nOldValue := ::nValue, iif( nOldValue == ::nItemCount, nOldValue, nOldValue + 1 ) )
ENDIF
RETURN Self
| listbox.prg | 558 |
| LISTBOX:METHOD | open() CLASS LISTBOX
METHOD open() CLASS LISTBOX
IF ! ::lIsOpen
::aSaveScr := { ::nTop + 1,;
::nLeft,;
::nBottom,;
::nRight,;
Savescreen( ::nTop + 1, ::nLeft, ::nBottom, ::nRight ) }
::lIsOpen := .T.
::display()
ENDIF
RETURN Self
| listbox.prg | 568 |
| LISTBOX:METHOD | prevItem() CLASS LISTBOX
METHOD prevItem() CLASS LISTBOX
LOCAL nOldValue
IF ::lHasFocus .AND. ::nItemCount > 0
IF ( nOldValue := ::nValue ) == 0
::changeItem( nOldValue, 1 )
ELSEIF nOldValue > 1
::changeItem( nOldValue, nOldValue - 1 )
ENDIF
ENDIF
RETURN Self
| listbox.prg | 583 |
| LISTBOX:METHOD | scroll( nMethod ) CLASS LISTBOX
METHOD scroll( nMethod ) CLASS LISTBOX
LOCAL nPos
LOCAL nTopItem
LOCAL nItemCount
LOCAL nThumbPos
LOCAL nCurrent
LOCAL nBarLength
LOCAL nTotal
LOCAL nSize
LOCAL nMRow
LOCAL nPrevMRow
LOCAL nKey
LOCAL nCount
DO CASE
CASE nMethod == HTSCROLLTHUMBDRAG
nPrevMRow := MRow()
DO WHILE ( ( nKey := Inkey( 0 ) ) != K_LBUTTONUP )
IF nKey == K_MOUSEMOVE
nMRow := MRow()
IF nMRow <= ::oVScroll:start()
nMRow := ::oVScroll:start() + 1
ENDIF
IF nMRow >= ::oVScroll:end()
nMRow := ::oVScroll:end() - 1
ENDIF
IF nMRow != nPrevMRow
nThumbPos := ::oVScroll:thumbPos() + ( nMRow - nPrevMRow )
nBarLength := ::oVScroll:barLength()
nTotal := ::oVScroll:total()
nSize := Min( Max( ( nThumbPos * ( nTotal - nBarLength - 2 ) + 2 * nBarLength + 1 - nTotal ) / ( nBarLength - 1 ), 1 ), nTotal )
nCurrent := ::oVScroll:current()
IF nSize - nCurrent > 0
FOR nCount := 1 TO nSize - nCurrent
::scroll( HTSCROLLUNITINC )
NEXT
ELSE
FOR nCount := 1 TO nCurrent - nSize
::scroll( HTSCROLLUNITDEC )
NEXT
ENDIF
nPrevMRow := nMRow
ENDIF
ENDIF
ENDDO
CASE nMethod == HTSCROLLUNITDEC
IF ::nTopItem > 1
::nTopItem--
::oVScroll:current := ::scrollbarPos()
::display()
ENDIF
CASE nMethod == HTSCROLLUNITINC
IF ( ::nTopItem + ::nBottom - ::nTop ) <= ::nItemCount + 1
::nTopItem++
::oVScroll:current := ::scrollbarPos()
::display()
ENDIF
CASE nMethod == HTSCROLLBLOCKDEC
nPos := ::nBottom - ::nTop - iif( ::lDropDown, 2, 1 )
nTopItem := ::nTopItem - nPos
IF ::nTopItem > 1
::nTopItem := Max( nTopItem, 1 )
::oVScroll:current := ::scrollbarPos()
::display()
ENDIF
CASE nMethod == HTSCROLLBLOCKINC
nPos := ::nBottom - ::nTop - 1
nItemCount := ::nItemCount
nTopItem := ::nTopItem + nPos
IF ::nTopItem < nItemCount - nPos + 1
IF nTopItem + nPos - 1 > nItemCount
nTopItem := nItemCount - nPos + 1
ENDIF
::nTopItem := nTopItem
::oVScroll:current := ::scrollbarPos()
::display()
ENDIF
ENDCASE
RETURN Self
| listbox.prg | 598 |
| LISTBOX:METHOD | select( xPos ) CLASS LISTBOX
METHOD select( xPos ) CLASS LISTBOX
LOCAL nValue
LOCAL nPos
LOCAL cType := Valtype( xPos )
DO CASE
CASE cType == "C"
nPos := ::findData( xPos )
IF !( Valtype( ::xBuffer ) $ "CU" )
::xBuffer := nPos
ELSEIF ::nValue == 0
::xBuffer := xPos
ELSE
::xBuffer := _LISTBOX_ITEMDATA( ::aItems[ nPos ] )
ENDIF
CASE !( cType == "N" )
RETURN ::nValue
CASE xPos < 1
RETURN ::nValue
CASE xPos > ::nItemCount
RETURN ::nValue
CASE xPos == ::nValue
RETURN ::nValue
OTHERWISE
nPos := xPos
IF Valtype( ::xBuffer ) $ "NU"
::xBuffer := nPos
ELSEIF nPos == 0
::xBuffer := ""
ELSE
::xBuffer := _LISTBOX_ITEMDATA( ::aItems[ nPos ] )
ENDIF
ENDCASE
::nValue := nPos
::cTextValue := iif( nPos == 0, "", _LISTBOX_ITEMDATA( ::aItems[ nPos ] ) )
nPos := iif( Empty( ::cHotBox + ::cColdBox ), 0, 2 )
nValue := ::nValue - ( ::nBottom - ::nTop - nPos )
IF ::nTopItem <= nValue
::nTopItem := nValue
IF ::oVScroll != NIL
::oVScroll:current := ::scrollbarPos()
ENDIF
ELSEIF ::nValue != 0 .AND. ::nTopItem > ::nValue
::nTopItem := ::nValue
IF ::oVScroll != NIL
::oVScroll:current := ::scrollbarPos()
ENDIF
ENDIF
::display()
IF ISBLOCK( ::bSBlock )
Eval( ::bSBlock )
ENDIF
RETURN ::nValue
| listbox.prg | 696 |
| LISTBOX:METHOD | setData( nPos, cData ) CLASS LISTBOX
METHOD setData( nPos, cData ) CLASS LISTBOX
IF nPos >= 1 .AND. nPos <= ::nItemCount
::aItems[ nPos ][ _ITEM_cDATA ] := cData
ENDIF
RETURN Self
| listbox.prg | 757 |
| LISTBOX:METHOD | setFocus() CLASS LISTBOX
METHOD setFocus() CLASS LISTBOX
IF ! ::lHasFocus
::nCursor := SetCursor( SC_NONE )
::lHasFocus := .T.
::display()
IF ISBLOCK( ::bFBlock )
Eval( ::bFBlock )
ENDIF
ENDIF
RETURN Self
| listbox.prg | 765 |
| LISTBOX:METHOD | setItem( nPos, aItem ) CLASS LISTBOX
METHOD setItem( nPos, aItem ) CLASS LISTBOX
IF nPos >= 1 .AND. nPos <= ::nItemCount .AND. ;
Len( aItem ) == 2 .AND. ;
ISCHARACTER( aItem[ _ITEM_cTEXT ] )
::aItems[ nPos ] := aItem
ENDIF
RETURN Self
| listbox.prg | 782 |
| LISTBOX:METHOD | setText( nPos, cText ) CLASS LISTBOX
METHOD setText( nPos, cText ) CLASS LISTBOX
IF nPos >= 1 .AND. nPos <= ::nItemCount
::aItems[ nPos ][ _ITEM_cTEXT ] := cText
ENDIF
RETURN Self
| listbox.prg | 793 |
| LISTBOX:METHOD | changeItem( nOldPos, nNewPos ) CLASS LISTBOX
METHOD changeItem( nOldPos, nNewPos ) CLASS LISTBOX
LOCAL nValue
IF nOldPos != nNewPos
::nValue := nNewPos
::cTextValue := iif( ::nValue == 0, "", _LISTBOX_ITEMDATA( ::aItems[ ::nValue ] ) )
IF ::xBuffer == NIL
ELSEIF ISNUMBER( ::xBuffer )
::xBuffer := ::nValue
ELSEIF ::nValue > 0
::xBuffer := ::cTextValue
ENDIF
IF ::nTopItem > ::nValue
::nTopItem := ::nValue
IF ::oVScroll != NIL
::oVScroll:current := ::scrollbarPos()
ENDIF
ELSE
nValue := ::nValue - ( ::nBottom - ::nTop - iif( Empty( ::cHotBox + ::cColdBox ), 0, 2 ) + iif( ::lDropDown, 1, 0 ) )
IF ::nTopItem <= nValue
::nTopItem := nValue
IF ::oVScroll != NIL
::oVScroll:current := ::scrollbarPos()
ENDIF
ENDIF
ENDIF
::display()
IF ISBLOCK( ::bSBlock )
Eval( ::bSBlock )
ENDIF
ENDIF
RETURN Self
| listbox.prg | 803 |
| LISTBOX:METHOD | scrollbarPos() CLASS LISTBOX
METHOD scrollbarPos() CLASS LISTBOX
LOCAL nSize := ::nBottom - ::nTop - iif( ::lDropDown, 2, 1 )
LOCAL nCount := ::nItemCount
LOCAL nLength := ::oVScroll:barLength
RETURN ( ( nCount - nLength ) * ::nTopItem + nLength - nSize ) / ( nCount - nSize )
| listbox.prg | 844 |
| LISTBOX:METHOD | bitmap( cBitmap ) CLASS LISTBOX
METHOD bitmap( cBitmap ) CLASS LISTBOX
IF cBitmap != NIL .AND. ::lDropDown
::cBitmap := __eInstVar53( Self, "BITMAP", cBitmap, "C", 1001 )
ENDIF
RETURN ::cBitmap
| listbox.prg | 854 |
| LISTBOX:METHOD | bottom( nBottom ) CLASS LISTBOX
METHOD bottom( nBottom ) CLASS LISTBOX
IF nBottom != NIL
::nBottom := __eInstVar53( Self, "BOTTOM", nBottom, "N", 1001 )
IF ::oVScroll != NIL
::oVScroll:end := ::nBottom - 1
ENDIF
ENDIF
RETURN ::nBottom
| listbox.prg | 862 |
| LISTBOX:METHOD | buffer() CLASS LISTBOX
METHOD buffer() CLASS LISTBOX
RETURN ::xBuffer
| listbox.prg | 873 |
| LISTBOX:METHOD | capCol( nCapCol ) CLASS LISTBOX
METHOD capCol( nCapCol ) CLASS LISTBOX
IF nCapCol != NIL
::nCapCol := __eInstVar53( Self, "CAPCOL", nCapCol, "N", 1001 )
ENDIF
RETURN ::nCapCol
| listbox.prg | 876 |
| LISTBOX:METHOD | capRow( nCapRow ) CLASS LISTBOX
METHOD capRow( nCapRow ) CLASS LISTBOX
IF nCapRow != NIL
::nCapRow := __eInstVar53( Self, "CAPROW", nCapRow, "N", 1001 )
ENDIF
RETURN ::nCapRow
| listbox.prg | 884 |
| LISTBOX:METHOD | caption( cCaption ) CLASS LISTBOX
METHOD caption( cCaption ) CLASS LISTBOX
IF cCaption != NIL
::cCaption := __eInstVar53( Self, "CAPTION", cCaption, "C", 1001 )
IF ::nCapCol == NIL
::nCapRow := ::nTop
::nCapCol := ::nLeft - Len( ::cCaption )
ENDIF
ENDIF
RETURN ::cCaption
| listbox.prg | 892 |
| LISTBOX:METHOD | coldBox( cColdBox ) CLASS LISTBOX
METHOD coldBox( cColdBox ) CLASS LISTBOX
IF cColdBox != NIL
::cColdBox := __eInstVar53( Self, "COLDBOX", cColdBox, "C", 1001, {|| Len( cColdBox ) == 0 .OR. Len( cColdBox ) == 8 } )
ENDIF
RETURN ::cColdBox
| listbox.prg | 904 |
| LISTBOX:METHOD | colorSpec( cColorSpec ) CLASS LISTBOX
METHOD colorSpec( cColorSpec ) CLASS LISTBOX
IF cColorSpec != NIL
::cColorSpec := __eInstVar53( Self, "COLORSPEC", cColorSpec, "C", 1001,;
iif( ::lDropDown,;
{|| !Empty( hb_ColorIndex( cColorSpec, 7 ) ) .AND. Empty( hb_ColorIndex( cColorSpec, 8 ) ) },;
{|| !Empty( hb_ColorIndex( cColorSpec, 6 ) ) .AND. Empty( hb_ColorIndex( cColorSpec, 7 ) ) } ) )
ENDIF
RETURN ::cColorSpec
| listbox.prg | 912 |
| LISTBOX:METHOD | dropDown( lDropDown ) CLASS LISTBOX
METHOD dropDown( lDropDown ) CLASS LISTBOX
IF lDropDown != NIL
::lDropDown := __eInstVar53( Self, "DROPDOWN", lDropDown, "L", 1001 )
IF !::lDropDown .AND. !::lIsOpen
::lIsOpen := .T.
ENDIF
::display()
ENDIF
RETURN ::lDropDown
| listbox.prg | 923 |
| LISTBOX:METHOD | fBlock( bFBlock ) CLASS LISTBOX
METHOD fBlock( bFBlock ) CLASS LISTBOX
IF PCount() > 0
::bFBlock := iif( bFBlock == NIL, NIL, __eInstVar53( Self, "FBLOCK", bFBlock, "B", 1001 ) )
ENDIF
RETURN ::bFBlock
| listbox.prg | 938 |
| LISTBOX:METHOD | hasFocus() CLASS LISTBOX
METHOD hasFocus() CLASS LISTBOX
RETURN ::lHasFocus
| listbox.prg | 946 |
| LISTBOX:METHOD | hotBox( cHotBox ) CLASS LISTBOX
METHOD hotBox( cHotBox ) CLASS LISTBOX
IF cHotBox != NIL
::cHotBox := __eInstVar53( Self, "HOTBOX", cHotBox, "C", 1001, {|| Len( cHotBox ) == 0 .OR. Len( cHotBox ) == 8 } )
ENDIF
RETURN ::cHotBox
| listbox.prg | 949 |
| LISTBOX:METHOD | isOpen() CLASS LISTBOX
METHOD isOpen() CLASS LISTBOX
RETURN ::lIsOpen
| listbox.prg | 957 |
| LISTBOX:METHOD | itemCount() CLASS LISTBOX
METHOD itemCount() CLASS LISTBOX
RETURN ::nItemCount
| listbox.prg | 960 |
| LISTBOX:METHOD | left( nLeft ) CLASS LISTBOX
METHOD left( nLeft ) CLASS LISTBOX
IF nLeft != NIL
::nLeft := __eInstVar53( Self, "LEFT", nLeft, "N", 1001 )
ENDIF
RETURN ::nLeft
| listbox.prg | 963 |
| LISTBOX:METHOD | message( cMessage ) CLASS LISTBOX
METHOD message( cMessage ) CLASS LISTBOX
IF cMessage != NIL
::cMessage := __eInstVar53( Self, "MESSAGE", cMessage, "C", 1001 )
ENDIF
RETURN ::cMessage
| listbox.prg | 971 |
| LISTBOX:METHOD | right( nRight ) CLASS LISTBOX
METHOD right( nRight ) CLASS LISTBOX
IF nRight != NIL
::nRight := __eInstVar53( Self, "RIGHT", nRight, "N", 1001 )
IF ::oVScroll != NIL
::oVScroll:offset := ::nRight
ENDIF
ENDIF
RETURN ::nRight
| listbox.prg | 979 |
| LISTBOX:METHOD | sBlock( bSBlock ) CLASS LISTBOX
METHOD sBlock( bSBlock ) CLASS LISTBOX
IF PCount() > 0
::bSBlock := iif( bSBlock == NIL, NIL, __eInstVar53( Self, "SBLOCK", bSBlock, "B", 1001 ) )
ENDIF
RETURN ::bSBlock
| listbox.prg | 990 |
| LISTBOX:METHOD | style( cStyle ) CLASS LISTBOX
METHOD style( cStyle ) CLASS LISTBOX
IF cStyle != NIL
::cStyle := __eInstVar53( Self, "STYLE", cStyle, "C", 1001, {|| Len( cStyle ) == 1 } )
ENDIF
RETURN ::cStyle
| listbox.prg | 998 |
| LISTBOX:METHOD | textValue() CLASS LISTBOX
METHOD textValue() CLASS LISTBOX
RETURN ::cTextValue
| listbox.prg | 1006 |
| LISTBOX:METHOD | top( nTop ) CLASS LISTBOX
METHOD top( nTop ) CLASS LISTBOX
IF nTop != NIL
::nTop := __eInstVar53( Self, "TOP", nTop, "N", 1001 )
IF ::oVScroll != NIL
::oVScroll:start := ::nTop + 1
ENDIF
ENDIF
RETURN ::nTop
| listbox.prg | 1009 |
| LISTBOX:METHOD | topItem( nTopItem ) CLASS LISTBOX
METHOD topItem( nTopItem ) CLASS LISTBOX
IF nTopItem != NIL
__eInstVar53( Self, "TOPITEM", nTopItem, "N", 1001, {|| nTopItem > 0 .AND. nTopItem <= ::nItemCount } )
nTopItem := Min( nTopItem, ::nItemCount - ( ::nBottom - ::nTop - iif( Empty( ::cHotBox + ::cColdBox ), 0, 2 ) ) )
IF ::nTopItem != nTopItem
::nTopItem := nTopItem
IF ::oVScroll != NIL
::oVScroll:current := ::scrollbarPos()
ENDIF
::display()
ENDIF
ENDIF
RETURN ::nTopItem
| listbox.prg | 1020 |
| LISTBOX:METHOD | typeOut() CLASS LISTBOX
METHOD typeOut() CLASS LISTBOX
RETURN ::nItemCount == 0
| listbox.prg | 1041 |
| LISTBOX:METHOD | value() CLASS LISTBOX
METHOD value() CLASS LISTBOX
RETURN ::nValue
| listbox.prg | 1044 |
| LISTBOX:METHOD | vScroll( oVScroll ) CLASS LISTBOX
METHOD vScroll( oVScroll ) CLASS LISTBOX
IF PCount() > 0
IF oVScroll == NIL
::oVScroll := NIL
ELSE
::oVScroll := __eInstVar53( Self, "VSCROLL", oVScroll, "O", 1001, {|| oVScroll:ClassName() == "SCROLLBAR" .AND. oVScroll:orient == SCROLL_VERTICAL } )
::oVScroll:total := ::nItemCount
ENDIF
ENDIF
RETURN ::oVScroll
| listbox.prg | 1047 |
| LISTBOX:METHOD | New( nTop, nLeft, nBottom, nRight, lDropDown )
METHOD New( nTop, nLeft, nBottom, nRight, lDropDown )
LOCAL cColor
IF !ISNUMBER( nTop ) .OR. ;
!ISNUMBER( nLeft ) .OR. ;
!ISNUMBER( nBottom ) .OR. ;
!ISNUMBER( nRight )
RETURN NIL
ENDIF
DEFAULT lDropDown TO .F.
::nBottom := nBottom
::nRight := nRight
::nTop := nTop
::nLeft := nLeft
::nCapCol := nLeft
::nCapRow := nTop
::lIsOpen := !lDropDown
::lDropDown := lDropDown
::aSaveScr := { nTop + 1, nleft, nBottom, nRight, SaveScreen( nTop + 1, nLeft, nBottom, nRight ) }
IF IsDefColor()
::cColorSpec := "W/N,W+/N,W+/N,N/W,W/N,W/N,W+/N,W/N"
ELSE
cColor := SetColor()
::cColorSpec := hb_ColorIndex( cColor, CLR_UNSELECTED ) + "," +;
hb_ColorIndex( cColor, CLR_UNSELECTED ) + "," +;
hb_ColorIndex( cColor, CLR_UNSELECTED ) + "," +;
hb_ColorIndex( cColor, CLR_ENHANCED ) + "," +;
hb_ColorIndex( cColor, CLR_BORDER ) + "," +;
hb_ColorIndex( cColor, CLR_STANDARD ) + "," +;
hb_ColorIndex( cColor, CLR_BACKGROUND )
ENDIF
RETURN Self
| listbox.prg | 1062 |
| FUNCTION | ListBox( nTop, nLeft, nBottom, nRight, lDropDown )
FUNCTION ListBox( nTop, nLeft, nBottom, nRight, lDropDown )
RETURN HBListBox():New( nTop, nLeft, nBottom, nRight, lDropDown )
| listbox.prg | 1100 |
| FUNCTION | _LISTBOX_( nTop, nLeft, nBottom, nRight, nSelect, aItems, cCaption, cMessage, cColorSpec, bFBlock, bSBlock, lDropDown, lIsOpen, cBitmap )
FUNCTION _LISTBOX_( nTop, nLeft, nBottom, nRight, nSelect, aItems, cCaption,;
cMessage, cColorSpec, bFBlock, bSBlock, lDropDown, lIsOpen, cBitmap )
LOCAL o := HBListBox():New( nTop, nLeft, nBottom, nRight, lDropDown )
LOCAL nPos
LOCAL nLen
LOCAL xItem
IF o != NIL
IF ISCHARACTER( cCaption )
o:caption := cCaption
o:capCol := nLeft - __CapLength( cCaption )
ENDIF
o:colorSpec := cColorSpec
o:message := cMessage
o:fBlock := bFBlock
o:sBlock := bSBlock
o:isOpen := lIsOpen
nLen := Len( aItems )
FOR nPos := 1 TO nLen
xItem := aItems[ nPos ]
IF ! ISARRAY( xItem )
o:addItem( xItem )
ELSEIF Len( xItem ) == _ITEM_cTEXT
o:addItem( xItem[ _ITEM_cTEXT ] )
ELSE
o:addItem( xItem[ _ITEM_cTEXT ], xItem[ _ITEM_cDATA ] )
ENDIF
NEXT
IF ISLOGICAL( lIsOpen ) .AND. lIsOpen
IF ISLOGICAL( lDropDown ) .AND. lDropDown
nTop++
ENDIF
o:VScroll := ScrollBar( nTop + 1, nBottom - 1, nRight,, SCROLL_VERTICAL )
ENDIF
IF ISCHARACTER( cBitmap )
o:bitmap := cBitmap
ENDIF
o:select( nSelect )
ENDIF
RETURN o
| listbox.prg | 1103 |
| memoedit.prg |
| Type | Function | Source | Line |
|---|
| METHOD | MemoInit( xUserFunction )
METHOD MemoInit( xUserFunction ) // This method is called after ::New() returns to perform ME_INIT actions
| memoedit.prg | 64 |
| METHOD | Edit()
METHOD Edit() // Calls super:Edit( nKey ) but is needed to handle configurable keys
| memoedit.prg | 65 |
| METHOD | KeyboardHook( nKey )
METHOD KeyboardHook( nKey ) // Gets called every time there is a key not handled directly by HBEditor
| memoedit.prg | 66 |
| METHOD | IdleHook()
METHOD IdleHook() // Gets called every time there are no more keys to hanlde
| memoedit.prg | 67 |
| METHOD | HandleUserKey( nKey, nUserKey )
METHOD HandleUserKey( nKey, nUserKey ) // Handles keys returned to MemoEdit() by user function
| memoedit.prg | 69 |
| METHOD | xDo( nStatus )
METHOD xDo( nStatus ) // Calls xUserFunction saving and restoring cursor position and shape
| memoedit.prg | 70 |
| METHOD | MoveCursor( nKey )
METHOD MoveCursor( nKey ) // Redefined to properly managed CTRL-W
ENDCLASS
| memoedit.prg | 72 |
| HBMEMOEDITOR:METHOD | MemoInit( xUserFunction ) CLASS HBMemoEditor
METHOD MemoInit( xUserFunction ) CLASS HBMemoEditor
LOCAL nKey
// Save/Init object internal representation of user function
::xUserFunction := xUserFunction
IF ISCHARACTER( ::xUserFunction )
// Keep calling user function until it returns ME_DEFAULT
DO WHILE ( nKey := ::xDo( ME_INIT ) ) != ME_DEFAULT
// At this time there is no input from user of MemoEdit() only handling
// of values returned by ::xUserFunction, so I pass these value on both
// parameters of ::HandleUserKey()
::HandleUserKey( nKey, nKey )
ENDDO
ENDIF
RETURN Self
| memoedit.prg | 76 |
| HBMEMOEDITOR:METHOD | Edit() CLASS HBMemoEditor
METHOD Edit() CLASS HBMemoEditor
LOCAL nKey
// NOTE: K_ALT_W is not compatible with clipper exit memo and save key, but I cannot discriminate
// K_CTRL_W and K_CTRL_END from harbour code.
LOCAL aConfigurableKeys := { K_CTRL_Y, K_CTRL_T, K_CTRL_B, K_CTRL_V, K_ALT_W, K_ESC }
LOCAL bKeyBlock
// If I have an user function I need to trap configurable keys and ask to
// user function if handle them the standard way or not
IF ::lEditAllow .AND. ISCHARACTER( ::xUserFunction )
DO WHILE ! ::lExitEdit
// I need to test this condition here since I never block inside HBEditor:Edit()
// if there is an user function
IF NextKey() == 0
::IdleHook()
ENDIF
nKey := Inkey( 0 )
IF ( bKeyBlock := SetKey( nKey ) ) != NIL
Eval( bKeyBlock )
LOOP
ENDIF
// Is it a configurable key ?
IF AScan( aConfigurableKeys, nKey ) > 0
::HandleUserKey( nKey, ::xDo( iif( ::lDirty, ME_UNKEYX, ME_UNKEY ) ) )
ELSE
::super:Edit( nKey )
ENDIF
ENDDO
ELSE
// If I can't edit text buffer or there is not a user function enter standard HBEditor
// ::Edit() method which is able to handle everything
::super:Edit()
ENDIF
RETURN Self
| memoedit.prg | 98 |
| HBMEMOEDITOR:METHOD | KeyboardHook( nKey ) CLASS HBMemoEditor
METHOD KeyboardHook( nKey ) CLASS HBMemoEditor
LOCAL nYesNoKey
LOCAL cBackScr
LOCAL nRow
LOCAL nCol
IF ISCHARACTER( ::xUserFunction )
::HandleUserKey( nKey, ::xDo( iif( ::lDirty, ME_UNKEYX, ME_UNKEY ) ) )
ELSE
IF nKey == K_ESC
IF ::lDirty .AND. Set( _SET_SCOREBOARD )
cBackScr := SaveScreen( ::nTop, ::nRight - 18, ::nTop, ::nRight )
nRow := Row()
nCol := Col()
@ ::nTop, ::nRight - 18 SAY "Abort Edit? (Y/N)"
nYesNoKey := Inkey( 0 )
RestScreen( ::nTop, ::nRight - 18, ::nTop, ::nRight, cBackScr )
SetPos( nRow, nCol )
IF Upper( Chr( nYesNoKey ) ) == "Y"
::lSaved := .F.
::lExitEdit := .T.
ENDIF
ELSE
::lExitEdit := .T.
ENDIF
ENDIF
ENDIF
RETURN Self
| memoedit.prg | 143 |
| HBMEMOEDITOR:METHOD | IdleHook() CLASS HBMemoEditor
METHOD IdleHook() CLASS HBMemoEditor
IF ISCHARACTER( ::xUserFunction )
::xDo( ME_IDLE )
ENDIF
RETURN Self
| memoedit.prg | 178 |
| HBMEMOEDITOR:METHOD | HandleUserKey( nKey, nUserKey ) CLASS HBMemoEditor
METHOD HandleUserKey( nKey, nUserKey ) CLASS HBMemoEditor
// HBEditor does not handle these keys and would call ::KeyboardHook() causing infinite loop
LOCAL aUnHandledKeys := { K_CTRL_J, K_CTRL_K, K_CTRL_L, K_CTRL_N, K_CTRL_O,;
K_CTRL_P, K_CTRL_Q, K_CTRL_T, K_CTRL_U, K_F1 }
DO CASE
// I won't reach this point during ME_INIT since ME_DEFAULT ends initialization phase of MemoEdit()
CASE nUserKey == ME_DEFAULT
// HBEditor is not able to handle keys with a value higher than 256, but I have to tell him
// that user wants to save text
IF ( nKey <= 256 .OR. nKey == K_ALT_W ) .AND. AScan( aUnHandledKeys, nKey ) == 0
::super:Edit( nKey )
ENDIF
// TOFIX: Not clipper compatible, see teditor.prg
CASE ( nUserKey >= 1 .AND. nUserKey <= 31 ) .OR. nUserKey == K_ALT_W
IF AScan( aUnHandledKeys, nUserKey ) == 0
::super:Edit( nUserKey )
ENDIF
CASE nUserKey == ME_DATA
IF nKey <= 256 .AND. AScan( aUnHandledKeys, nKey ) == 0
::super:Edit( nKey )
ENDIF
CASE nUserKey == ME_TOGGLEWRAP
::lWordWrap := !::lWordWrap
CASE nUserKey == ME_TOGGLESCROLL
// TODO: HBEditor does not support vertical scrolling of text inside window without moving cursor position
CASE nUserKey == ME_WORDRIGHT
::MoveCursor( K_CTRL_RIGHT )
CASE nUserKey == ME_BOTTOMRIGHT
::MoveCursor( K_CTRL_END )
#ifdef HB_COMPAT_XPP
CASE nUserKey == ME_PASTE
// TODO
#endif
OTHERWISE
// Do nothing
ENDCASE
RETURN Self
| memoedit.prg | 186 |
| HBMEMOEDITOR:METHOD | xDo( nStatus ) CLASS HBMemoEditor
METHOD xDo( nStatus ) CLASS HBMemoEditor
LOCAL nOldRow := ::Row()
LOCAL nOldCol := ::Col()
LOCAL nOldCur := SetCursor()
LOCAL xResult := Do( ::xUserFunction, nStatus, ::nRow, ::nCol - 1 )
IF ! ISNUMBER( xResult )
xResult := ME_DEFAULT
ENDIF
::SetPos( nOldRow, nOldCol )
SetCursor( nOldCur )
RETURN xResult
| memoedit.prg | 236 |
| HBMEMOEDITOR:METHOD | MoveCursor( nKey ) CLASS HBMemoEditor
METHOD MoveCursor( nKey ) CLASS HBMemoEditor
IF nKey == K_CTRL_END // same value as CTRL-W
::lSaved := .T.
::lExitEdit := .T.
ELSE
RETURN ::Super:MoveCursor( nKey )
ENDIF
RETURN .f.
| memoedit.prg | 253 |
| FUNCTION | MemoEdit( cString, nTop, nLeft, nBottom, nRight, lEditMode, xUserFunction, nLineLength, nTabSize, nTextBuffRow, nTextBuffColumn, nWindowRow, nWindowColumn )
FUNCTION MemoEdit( cString,;
nTop,;
nLeft,;
nBottom,;
nRight,;
lEditMode,;
xUserFunction,;
nLineLength,;
nTabSize,;
nTextBuffRow,;
nTextBuffColumn,;
nWindowRow,;
nWindowColumn )
LOCAL oEd
DEFAULT nTop TO 0
DEFAULT nLeft TO 0
DEFAULT nBottom TO MaxRow()
DEFAULT nRight TO MaxCol()
DEFAULT lEditMode TO .T.
DEFAULT nLineLength TO nRight - nLeft
DEFAULT nTabSize TO 4
DEFAULT nTextBuffRow TO 1
DEFAULT nTextBuffColumn TO 0
DEFAULT nWindowRow TO 0
DEFAULT nWindowColumn TO nTextBuffColumn
DEFAULT cString TO ""
// Original MemoEdit() converts Tabs into spaces;
oEd := HBMemoEditor():New( StrTran( cString, Chr( K_TAB ), Space( 1 ) ), nTop, nLeft, nBottom, nRight, lEditMode, nLineLength, nTabSize, nTextBuffRow, nTextBuffColumn, nWindowRow, nWindowColumn )
oEd:MemoInit( xUserFunction )
oEd:display()
IF ! ISLOGICAL( xUserFunction ) .OR. xUserFunction == .T.
oEd:Edit()
IF oEd:Changed()
cString := oEd:GetText()
// dbu tests for LastKey() == K_CTRL_END, so I try to make it happy
HB_SetLastKey( K_CTRL_END )
ENDIF
ENDIF
RETURN cString
| memoedit.prg | 266 |
| memvarbl.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | MEMVARBLOCK( cMemvar )
FUNCTION MEMVARBLOCK( cMemvar )
IF ISCHARACTER( cMemvar ) .AND. __mvEXIST( cMemvar )
RETURN {| x | iif( x == NIL, __mvGET( cMemvar ), __mvPUT( cMemvar, x ) ) }
ENDIF
RETURN NIL
| memvarbl.prg | 57 |
| menusys.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | MenuModal( oTopMenu, nSelection, nMsgRow, nMsgLeft, nMsgRight, cMsgColor, GetList )
FUNCTION MenuModal( oTopMenu, nSelection, nMsgRow, nMsgLeft, nMsgRight, cMsgColor, GetList )
RETURN HBMenuSys():New( oTopMenu ):modal( nSelection, nMsgRow, nMsgLeft, nMsgRight, cMsgColor, GetList )
| menusys.prg | 66 |
| FUNCTION | ShowMsg( aMsg, lMode )
FUNCTION ShowMsg( aMsg, lMode )
HB_SYMBOL_UNUSED( aMsg )
HB_SYMBOL_UNUSED( lMode )
RETURN .F.
| menusys.prg | 70 |
| FUNCTION | IsShortCut( oMenu, nKey, nID )
FUNCTION IsShortCut( oMenu, nKey, nID )
LOCAL nItem
LOCAL nTotal
LOCAL nShortCut
LOCAL oItem
LOCAL i
// Test for top menu item not a TopBar Menu:
IF !( oMenu:ClassName() == "TOPBARMENU" )
RETURN IsQuick( oMenu, nKey, @nID )
// Test and assign top menu item shortCut, enabled, and !PopUp:
// Changed by enclosing assignment before ':Enabled':
ELSEIF ( nShortCut := oMenu:getShortCt( nKey ) ) > 0 .AND. ;
( oItem := oMenu:getItem( nShortcut ) ):enabled .AND. ;
!oItem:isPopUp()
oMenu:select( nShortCut )
Eval( oItem:data, oItem )
nID := oItem:ID
RETURN .T.
// Test and assignment for TopBar MenuItem:
ELSEIF nShortCut == 0
nTotal := oMenu:itemCount
nItem := oMenu:current
IF nItem == 0
nItem := 1
ENDIF
// Loop to wrap around through TopMenu from Current Item:
FOR i := 1 TO nTotal
IF ( oItem := oMenu:getItem( nItem ) ):enabled .AND. ;
oItem:isPopUp() .AND. ;
IsQuick( oItem:data, nKey, @nID )
RETURN .T.
ENDIF
IF ++nItem > nTotal
nItem := 1
ENDIF
NEXT
ENDIF
RETURN .F.
| menusys.prg | 82 |
| FUNCTION | IsQuick( oMenu, nKey, nID )
FUNCTION IsQuick( oMenu, nKey, nID )
LOCAL nItem
LOCAL nTotal
LOCAL nShortCut
LOCAL oItem
IF ( nShortCut := oMenu:getShortCt( nKey ) ) == 0
nTotal := oMenu:itemCount
FOR nItem := 1 TO nTotal
IF ( oItem := oMenu:getItem( nItem ) ):enabled .AND. ;
oItem:isPopUp() .AND. ;
IsQuick( oItem:data, nKey, @nID )
RETURN .T.
ENDIF
NEXT
ELSEIF !( oItem := oMenu:getItem( nShortCut ) ):isPopUp() .AND. oItem:enabled
oMenu:select( nShortCut )
Eval( oItem:data, oItem )
nID := oItem:ID
RETURN .T.
ENDIF
RETURN .F.
| menusys.prg | 141 |
| menuto.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __AtPrompt( nRow, nCol, cPrompt, cMsg, cColor )
FUNCTION __AtPrompt( nRow, nCol, cPrompt, cMsg, cColor )
IF s_nPointer < 1
s_nPointer := 1
ENDIF
// add the current level empty array.
DO WHILE Len( s_aLevel ) < s_nPointer
AAdd( s_aLevel, {} )
ENDDO
// add to the static array
AAdd( s_aLevel[ s_nPointer ], { nRow, nCol, cPrompt, cMsg, cColor } )
// put this prompt on the screen right now
DispOutAt( nRow, nCol, cPrompt, cColor )
RETURN .F.
| menuto.prg | 27 |
| FUNCTION | __MenuTo( bBlock, cVariable )
FUNCTION __MenuTo( bBlock, cVariable )
LOCAL nKey
LOCAL y
LOCAL q
LOCAL n
LOCAL lExit
LOCAL nArrLen
LOCAL xMsg
LOCAL nMsgCol
LOCAL nMsgRow
LOCAL lMsgCenter
LOCAL nSaveCursor
LOCAL |
