static void s_GetFileName( HB_BOOL fSave )
{
void * hInitDir, * hTitle, * hDefExt;
LPTSTR lpstrFilter;
OPENFILENAME ofn;
memset( &ofn, 0, sizeof( ofn ) );
#if defined( OPENFILENAME_SIZE_VERSION_400 )
ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
#else
ofn.lStructSize = sizeof( ofn );
#endif
ofn.hwndOwner = GetActiveWindow();
ofn.hInstance = GetModuleHandle( NULL );
ofn.nFilterIndex = hbwapi_par_DWORD( 6 );
ofn.lpstrFilter = lpstrFilter = s_dialogPairs( 5, &ofn.nFilterIndex );
ofn.nMaxFile = hbwapi_par_DWORD( 7 );
if( ofn.nMaxFile < 0x400 )
ofn.nMaxFile = ofn.nMaxFile == 0 ? 0x10000 : 0x400;
ofn.lpstrFile = ( LPTSTR )
memset( hb_xgrab( ofn.nMaxFile * sizeof( TCHAR ) ),
0, ofn.nMaxFile * sizeof( TCHAR ) );
ofn.lpstrInitialDir = HB_PARSTR( 3, &hInitDir, NULL );
ofn.lpstrTitle = HB_PARSTR( 2, &hTitle, NULL );
ofn.Flags = HB_ISNUM( 1 ) ? hbwapi_par_DWORD( 1 ) :
( OFN_EXPLORER | OFN_ALLOWMULTISELECT |
OFN_HIDEREADONLY | OFN_NOCHANGEDIR );
ofn.lpstrDefExt = HB_PARSTR( 4, &hDefExt, NULL );
if( ofn.lpstrDefExt && ofn.lpstrDefExt[ 0 ] == '.' )
++ofn.lpstrDefExt;
HB_ITEMCOPYSTR( hb_param( 8, HB_IT_ANY ), ofn.lpstrFile, ofn.nMaxFile );
if( fSave ? GetSaveFileName( &ofn ) : GetOpenFileName( &ofn ) )
{
HB_SIZE nLen;
for( nLen = 0; nLen < ofn.nMaxFile; ++nLen )
{
if( ofn.lpstrFile[ nLen ] == 0 &&
( nLen + 1 == ofn.nMaxFile || ofn.lpstrFile[ nLen + 1 ] == 0 ) )
break;
}
hb_stornint( ofn.Flags, 1 );
hb_stornint( ofn.nFilterIndex, 6 );
HB_RETSTRLEN( ofn.lpstrFile, nLen );
}
else
hb_retc_null();
hb_xfree( ofn.lpstrFile );
if( lpstrFilter )
hb_xfree( lpstrFilter );
hb_strfree( hInitDir );
hb_strfree( hTitle );
hb_strfree( hDefExt );
}
static HB_ERRCODE ocilibExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
OCI_Statement * st = OCI_StatementCreate( ( ( SDDCONN * ) pConnection->pSDDConn )->pConn );
void * hStatement;
char * szError;
HB_ERRCODE errCode;
if( ! st )
{
szError = ocilibGetError( &errCode );
hb_errRT_OCIDD( EG_OPEN, ESQLDD_STMTALLOC, szError, hb_itemGetCPtr( pItem ), errCode );
hb_xfree( szError );
return HB_FAILURE;
}
if( OCI_ExecuteStmt( st, M_HB_ITEMGETSTR( pItem, &hStatement, NULL ) ) )
{
hb_strfree( hStatement );
/* TODO: new id */
hb_rddsqlSetError( 0, NULL, hb_itemGetCPtr( pItem ), NULL, ( unsigned long ) OCI_GetAffectedRows( st ) );
OCI_StatementFree( st );
return HB_SUCCESS;
}
else
hb_strfree( hStatement );
szError = ocilibGetError( &errCode );
hb_rddsqlSetError( errCode, szError, hb_itemGetCPtr( pItem ), NULL, 0 );
hb_xfree( szError );
OCI_StatementFree( st );
return HB_FAILURE;
}
static HB_ERRCODE sqlite3Execute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
sqlite3 * pDb = ( ( SDDCONN * ) pConnection->pSDDConn )->pDb;
HB_ERRCODE errCode;
int iRow, iCol;
void * hStatement;
char ** pResult = NULL;
char * pszErrMsg = NULL;
if( sqlite3_get_table( pDb, S_HB_ITEMGETSTR( pItem, &hStatement, NULL ), &pResult, &iRow, &iCol, &pszErrMsg ) != SQLITE_OK )
{
hb_strfree( hStatement );
hb_xfree( sqlite3GetError( pDb, &errCode ) );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_STMTALLOC, pszErrMsg, hb_itemGetCPtr( pItem ), errCode );
hb_xfree( pszErrMsg );
return HB_FAILURE;
}
else
hb_strfree( hStatement );
sqlite3_free_table( pResult );
/* TODO: new id */
hb_rddsqlSetError( 0, NULL, hb_itemGetCPtr( pItem ), NULL, ( unsigned long ) iRow );
return HB_SUCCESS;
}
static HB_ERRCODE odbcExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
SDDCONN * pSDDConn = ( SDDCONN * ) pConnection->pSDDConn;
void * hStatement;
SQLHSTMT hStmt;
SQLLEN iCount;
char * szError;
HB_ERRCODE errCode;
#if ODBCVER >= 0x0300
if( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) )
#else
if( ! SQL_SUCCEEDED( SQLAllocStmt( pSDDConn->hConn, &hStmt ) ) )
#endif
{
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, SQL_NULL_HSTMT, &errCode );
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTALLOC, szError, hb_itemGetCPtr( pItem ), errCode );
hb_xfree( szError );
return HB_FAILURE;
}
if( SQL_SUCCEEDED( SQLExecDirect( hStmt,
( SQLTCHAR * ) O_HB_ITEMGETSTR( pItem, &hStatement, NULL ),
( SQLINTEGER ) hb_itemGetCLen( pItem ) ) ) )
{
hb_strfree( hStatement );
if( SQL_SUCCEEDED( SQLRowCount( hStmt, &iCount ) ) )
{
/* TODO: new id */
hb_rddsqlSetError( 0, NULL, hb_itemGetCPtr( pItem ), NULL, ( unsigned long ) iCount );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
return HB_SUCCESS;
}
}
else
hb_strfree( hStatement );
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode );
hb_rddsqlSetError( errCode, szError, hb_itemGetCPtr( pItem ), NULL, errCode );
hb_xfree( szError );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
return HB_FAILURE;
}
static const char * save_cb( mxml_node_t * node, int where )
{
HB_CBS_VAR * pCbs = ( HB_CBS_VAR * ) hb_stackTestTSD( &s_cbs_var );
if( node != NULL && pCbs != NULL )
{
PHB_ITEM pCallback = pCbs->save_cb;
if( pCbs->hText )
{
hb_strfree( pCbs->hText );
pCbs->hText = NULL;
}
if( pCallback && hb_vmRequestReenter() )
{
const char * pszResult;
hb_vmPushEvalSym();
hb_vmPush( pCallback );
mxml_node_push( node, 0 );
hb_vmPushInteger( where );
hb_vmSend( 2 );
pszResult = hb_itemGetStrUTF8( hb_param( -1, HB_IT_ANY ), &pCbs->hText, NULL );
hb_vmRequestRestore();
return pszResult;
}
}
return NULL;
}
static char * custom_save_cb( mxml_node_t * node )
{
HB_CUSTOM_CBS_VAR * pCCbs = ( HB_CUSTOM_CBS_VAR * ) hb_stackTestTSD( &s_custom_cbs_var );
if( node != NULL && pCCbs != NULL )
{
PHB_ITEM pCallback = pCCbs->save_cb;
if( pCallback && hb_vmRequestReenter() )
{
char * pszResult;
const char * pszText;
void * hText;
hb_vmPushEvalSym();
hb_vmPush( pCallback );
mxml_node_push( node, 0 );
hb_vmSend( 1 );
pszText = hb_parstr_utf8( -1, &hText, NULL );
pszResult = pszText ? strdup( pszText ) : NULL;
hb_strfree( hText );
hb_vmRequestRestore();
return pszResult;
}
}
return NULL;
}
void hbwapi_strfree_DOCINFO( void ** h )
{
if( h )
{
int i;
for( i = 0; i < 3; ++i )
hb_strfree( h[ i ] );
}
}
static HB_ERRCODE ocilibConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
OCI_Connection * cn;
void * hConn;
void * hUser;
void * hPass;
cn = OCI_ConnectionCreate( ( mtext * ) M_HB_ARRAYGETSTR( pItem, 2, &hConn, NULL ),
( mtext * ) M_HB_ARRAYGETSTR( pItem, 3, &hUser, NULL ),
( mtext * ) M_HB_ARRAYGETSTR( pItem, 4, &hPass, NULL ), OCI_SESSION_DEFAULT );
hb_strfree( hConn );
hb_strfree( hUser );
hb_strfree( hPass );
if( cn )
{
pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) );
( ( SDDCONN * ) pConnection->pSDDConn )->pConn = cn;
return HB_SUCCESS;
}
return HB_FAILURE;
}
static HB_ERRCODE sqlite3Connect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
sqlite3 * db;
void * hConn;
if( sqlite3_open( S_HB_ARRAYGETSTR( pItem, 2, &hConn, NULL ), &db ) == SQLITE_OK )
{
pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) );
( ( SDDCONN * ) pConnection->pSDDConn )->pDb = db;
}
else
sqlite3_close( db );
hb_strfree( hConn );
return db ? HB_SUCCESS : HB_FAILURE;
}
static void s_getPathName( _HB_GETPATHNAME getPathName )
{
void * hLongPath;
DWORD length = 0;
LPCTSTR lpszLongPath = HB_PARSTR( 1, &hLongPath, NULL );
if( lpszLongPath )
{
if( HB_ISBYREF( 2 ) )
{
TCHAR buffer[ HB_PATH_MAX ];
DWORD cchBuffer = ( DWORD ) HB_SIZEOFARRAY( buffer );
LPTSTR lpszShortPath = buffer;
HB_BOOL fSize = HB_ISNUM( 3 );
if( fSize ) /* the size of buffer is limited by user */
{
cchBuffer = ( DWORD ) hb_parnl( 3 );
if( cchBuffer == 0 )
lpszShortPath = NULL;
else if( cchBuffer > ( DWORD ) HB_SIZEOFARRAY( buffer ) )
lpszShortPath = ( LPTSTR ) hb_xgrab( cchBuffer * sizeof( TCHAR ) );
}
length = getPathName( lpszLongPath, lpszShortPath, cchBuffer );
if( ! fSize && length > cchBuffer ) /* default buffer size was too small */
{
cchBuffer = length;
lpszShortPath = ( LPTSTR ) hb_xgrab( cchBuffer * sizeof( TCHAR ) );
length = getPathName( lpszLongPath, lpszShortPath, cchBuffer );
}
hbwapi_SetLastError( GetLastError() );
HB_STORSTRLEN( lpszShortPath, length > cchBuffer ? 0 : length, 2 );
if( lpszShortPath && lpszShortPath != buffer )
hb_xfree( lpszShortPath );
}
else if( getPathName )
{
length = getPathName( lpszLongPath, NULL, 0 );
hbwapi_SetLastError( GetLastError() );
}
}
hb_retnl( length );
hb_strfree( hLongPath );
}
HB_EXTERN_END
#endif
HB_FUNC( HB_BLATSEND )
{
if( HB_ISCHAR( 1 ) )
{
#if defined( HBMK_HAS_BLAT )
void * hCmdLine = NULL;
hb_retni( cSend( HB_PARSTR( 1, &hCmdLine, NULL ) ) );
hb_strfree( hCmdLine );
#else
hb_retni( cSend( hb_parc( 1 ) ) );
#endif
}
else
hb_errRT_BASE_SubstR( EG_ARG, 0, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
/* HB_TRACE( HB_TR_ALWAYS, ("fieldcount=%d", iNameLen) ); */
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO pFieldInfo;
PHB_ITEM pName;
int iDataType;
int iSize;
int iDec;
pName = S_HB_ITEMPUTSTR( NULL, sqlite3_column_name( st, uiIndex ) );
pFieldInfo.atomName = hb_itemGetCPtr( pName );
iDataType = sqlite3_column_type( st, uiIndex );
iSize = sqlite3_column_bytes( st, uiIndex );
iDec = 0;
pFieldInfo.uiLen = ( HB_USHORT ) iSize;
pFieldInfo.uiDec = ( HB_USHORT ) iDec;
/* HB_TRACE( HB_TR_ALWAYS, ("field: name=%s type=%d len=%d dec=%d nullable=%d", pFieldInfo.atomName, iDataType, iSize, iDec ) ); */
switch( iDataType )
{
case SQLITE_TEXT:
pFieldInfo.uiType = HB_FT_STRING;
break;
case SQLITE_FLOAT:
case SQLITE_INTEGER:
pFieldInfo.uiType = HB_FT_LONG;
break;
case SQLITE_BLOB:
pFieldInfo.uiType = HB_FT_BLOB;
break;
default:
/* HB_TRACE( HB_TR_ALWAYS, ("new sql type=%d", iDataType) ); */
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) iDataType;
pFieldInfo.uiType = 0;
pFieldInfo.uiType = HB_FT_STRING;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCLPtr( NULL, pStr, pFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen );
else
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
hb_itemRelease( pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", uiFields ) );
#endif
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO pFieldInfo;
int iDataType = sqlite3_column_type( st, uiIndex );
PHB_ITEM pName = S_HB_ITEMPUTSTR( NULL, sqlite3_column_name( st, uiIndex ) );
HB_USHORT uiNameLen = ( HB_USHORT ) hb_itemGetCLen( pName );
if( ( ( AREAP ) pArea )->uiMaxFieldNameLength < uiNameLen )
( ( AREAP ) pArea )->uiMaxFieldNameLength = uiNameLen;
pFieldInfo.atomName = hb_itemGetCPtr( pName );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d", pFieldInfo.atomName, iDataType, sqlite3_column_bytes( st, uiIndex ) ) );
#endif
/* There are no field length limits stored in the SQLite3 database,
so we're resorting to setting some arbitrary default values to
make apps relying on these (f.e. Browse()/GET) to behave somewhat
better. For better results, update apps to untie UI metrics from
any database field/value widths. [vszakats] */
pFieldInfo.uiLen = 10;
pFieldInfo.uiDec = 0;
switch( iDataType )
{
case SQLITE3_TEXT:
pFieldInfo.uiType = HB_FT_STRING;
break;
case SQLITE_FLOAT:
pFieldInfo.uiType = HB_FT_LONG;
pFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
pFieldInfo.uiLen += pFieldInfo.uiDec + 1;
break;
case SQLITE_INTEGER:
pFieldInfo.uiType = HB_FT_LONG;
break;
case SQLITE_BLOB:
case SQLITE_NULL:
pFieldInfo.uiType = HB_FT_BLOB;
break;
default:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) );
#endif
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) iDataType;
pFieldInfo.uiType = 0;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCLPtr( NULL, pStr, pFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen );
else
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
hb_itemRelease( pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
/* --- SDD METHODS --- */
static HB_ERRCODE odbcConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
SQLHENV hEnv = NULL;
SQLHDBC hConnect = NULL;
char * szError;
HB_ERRCODE errCode;
#if ODBCVER >= 0x0300
if( SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv ) ) )
#else
if( SQL_SUCCEEDED( SQLAllocEnv( &hEnv ) ) )
#endif
{
#if ODBCVER >= 0x0300
SQLSetEnvAttr( hEnv, SQL_ATTR_ODBC_VERSION, ( SQLPOINTER ) SQL_OV_ODBC3, SQL_IS_UINTEGER );
#endif
#if ODBCVER >= 0x0300
if( SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_DBC, hEnv, &hConnect ) ) )
#else
if( SQL_SUCCEEDED( SQLAllocConnect( hEnv, &hConnect ) ) )
#endif
{
const O_HB_CHAR * pchConStr;
void * hConnStr;
HB_SIZE nConnLen;
SQLTCHAR cBuffer[ 1024 ];
SQLSMALLINT iLen = HB_SIZEOFARRAY( cBuffer );
cBuffer[ 0 ] = '\0';
pchConStr = O_HB_ARRAYGETSTR( pItem, 2, &hConnStr, &nConnLen );
if( SQL_SUCCEEDED( SQLDriverConnect( hConnect,
NULL,
( SQLTCHAR * ) HB_UNCONST( pchConStr ),
( SQLSMALLINT ) nConnLen,
cBuffer,
HB_SIZEOFARRAY( cBuffer ),
&iLen,
SQL_DRIVER_NOPROMPT ) ) )
{
hb_strfree( hConnStr );
pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) );
( ( SDDCONN * ) pConnection->pSDDConn )->hConn = hConnect;
( ( SDDCONN * ) pConnection->pSDDConn )->hEnv = hEnv;
return HB_SUCCESS;
}
else
{
hb_strfree( hConnStr );
szError = odbcGetError( hEnv, hConnect, SQL_NULL_HSTMT, &errCode );
hb_rddsqlSetError( errCode, szError, NULL, NULL, 0 );
hb_xfree( szError );
}
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_DBC, hConnect );
#else
SQLFreeConnect( hConnect );
#endif
}
else
{
szError = odbcGetError( hEnv, SQL_NULL_HDBC, SQL_NULL_HSTMT, &errCode );
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_CONNALLOC, szError, hb_arrayGetCPtr( pItem, 2 ), errCode );
hb_xfree( szError );
}
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_ENV, hEnv );
#else
SQLFreeEnv( hEnv );
#endif
}
else
{
szError = odbcGetError( SQL_NULL_HENV, SQL_NULL_HDBC, SQL_NULL_HSTMT, &errCode );
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_ENVALLOC, szError, hb_arrayGetCPtr( pItem, 2 ), errCode );
hb_xfree( szError );
}
return HB_FAILURE;
}
static void _hb_jsonEncode( PHB_ITEM pValue, PHB_JSON_ENCODE_CTX pCtx,
HB_SIZE nLevel, HB_BOOL fEOL, PHB_CODEPAGE cdp )
{
/* Protection against recursive structures */
if( ( HB_IS_ARRAY( pValue ) || HB_IS_HASH( pValue ) ) && hb_itemSize( pValue ) > 0 )
{
void * id = HB_IS_HASH( pValue ) ? hb_hashId( pValue ) : hb_arrayId( pValue );
HB_SIZE nIndex;
for( nIndex = 0; nIndex < nLevel; nIndex++ )
{
if( pCtx->pId[ nIndex ] == id )
{
if( ! fEOL && pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "null", 4 );
return;
}
}
if( nLevel >= pCtx->nAllocId )
{
pCtx->nAllocId += 8;
pCtx->pId = ( void ** ) hb_xrealloc( pCtx->pId, sizeof( void * ) * pCtx->nAllocId );
}
pCtx->pId[ nLevel ] = id;
}
if( fEOL )
{
--pCtx->pHead;
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
}
if( HB_IS_STRING( pValue ) )
{
HB_SIZE nPos, nLen;
const char * szString;
void * hString = NULL;
char buf[ 8 ];
if( cdp )
{
szString = hb_itemGetStr( pValue, cdp, &hString, &nLen );
}
else
{
szString = hb_itemGetCPtr( pValue );
nLen = hb_itemGetCLen( pValue );
}
_hb_jsonCtxAdd( pCtx, "\"", 1 );
nPos = 0;
while( nPos < nLen )
{
unsigned char uch = szString[ nPos ];
HB_SIZE nPos2 = nPos;
while( uch >= ' ' && uch != '\\' && uch != '\"' )
uch = szString[ ++nPos2 ];
if( nPos2 > nPos )
{
_hb_jsonCtxAdd( pCtx, szString + nPos, nPos2 - nPos );
if( nPos2 >= nLen )
break;
nPos = nPos2;
}
switch( uch )
{
case '\\':
_hb_jsonCtxAdd( pCtx, "\\\\", 2 );
break;
case '\"':
_hb_jsonCtxAdd( pCtx, "\\\"", 2 );
break;
case '\b':
_hb_jsonCtxAdd( pCtx, "\\b", 2 );
break;
case '\f':
_hb_jsonCtxAdd( pCtx, "\\f", 2 );
break;
case '\n':
_hb_jsonCtxAdd( pCtx, "\\n", 2 );
break;
case '\r':
_hb_jsonCtxAdd( pCtx, "\\r", 2 );
break;
case '\t':
_hb_jsonCtxAdd( pCtx, "\\t", 2 );
break;
default:
hb_snprintf( buf, sizeof( buf ), "\\u00%02X", uch );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
nPos++;
}
_hb_jsonCtxAdd( pCtx, "\"", 1 );
hb_strfree( hString );
}
else if( HB_IS_NUMINT( pValue ) )
{
char buf[ 24 ];
HB_MAXINT nVal = hb_itemGetNInt( pValue );
HB_BOOL fNeg = nVal < 0;
int i = 0;
if( fNeg )
nVal = -nVal;
do
buf[ sizeof( buf ) - ++i ] = ( nVal % 10 ) + '0';
while( ( nVal /= 10 ) != 0 );
if( fNeg )
buf[ sizeof( buf ) - ++i ] = '-';
_hb_jsonCtxAdd( pCtx, &buf[ sizeof( buf ) - i ], i );
}
else if( HB_IS_NUMERIC( pValue ) )
{
char buf[ 64 ];
int iDec;
double dblValue = hb_itemGetNDDec( pValue, &iDec );
hb_snprintf( buf, sizeof( buf ), "%.*f", iDec, dblValue );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
else if( HB_IS_NIL( pValue ) )
{
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
else if( HB_IS_LOGICAL( pValue ) )
{
if( hb_itemGetL( pValue ) )
_hb_jsonCtxAdd( pCtx, "true", 4 );
else
_hb_jsonCtxAdd( pCtx, "false", 5 );
}
else if( HB_IS_DATE( pValue ) )
{
char szBuffer[ 10 ];
hb_itemGetDS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 9 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 10 );
}
else if( HB_IS_TIMESTAMP( pValue ) )
{
char szBuffer[ 19 ];
hb_itemGetTS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 18 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 19 );
}
else if( HB_IS_ARRAY( pValue ) )
{
HB_SIZE nLen = hb_itemSize( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "[", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pItem = hb_arrayGetItemPtr( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
if( pCtx->fHuman &&
! ( ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) &&
hb_itemSize( pItem ) > 0 ) )
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
_hb_jsonEncode( pItem, pCtx, nLevel + 1, HB_FALSE, cdp );
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "]", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "[]", 2 );
}
else if( HB_IS_HASH( pValue ) )
{
HB_SIZE nLen = hb_hashLen( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "{", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pValue, nIndex );
if( HB_IS_STRING( pKey ) )
{
PHB_ITEM pItem = hb_hashGetValueAt( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
}
_hb_jsonEncode( pKey, pCtx, nLevel + 1, HB_FALSE, cdp );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, ": ", 2 );
fEOL = ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) && hb_itemSize( pItem ) > 0;
}
else
{
_hb_jsonCtxAdd( pCtx, ":", 1 );
fEOL = HB_FALSE;
}
_hb_jsonEncode( pItem, pCtx, nLevel + 1, fEOL, cdp );
}
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "}", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "{}", 2 );
}
else
{
/* All unsupported types are replacd by null */
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
}
static int hb_zipStoreFile( zipFile hZip, int iParamFileName, int iParamZipName, const char * szPassword, int iParamComment, HB_BOOL fUnicode )
{
const char * szFileName = hb_parc( iParamFileName );
const char * szName = hb_parc( iParamZipName );
char * pString;
HB_FHANDLE hFile;
HB_SIZE nLen;
HB_FATTR ulExtAttr;
zip_fileinfo zfi;
int iResult;
HB_BOOL fError;
HB_BOOL fText;
HB_U32 ulCRC;
uLong flags = 0;
void * hZipName = NULL;
void * hComment = NULL;
char * szZipName;
const char * szComment;
memset( &zfi, 0, sizeof( zfi ) );
fError = HB_FALSE;
ulExtAttr = 0;
#if defined( HB_OS_WIN )
{
LPTSTR lpFileNameFree;
LPCTSTR lpFileName = HB_FSNAMECONV( szFileName, &lpFileNameFree );
DWORD attr = GetFileAttributes( lpFileName );
if( attr != INVALID_FILE_ATTRIBUTES )
{
ulExtAttr = hb_translateExtAttr( szFileName, attr &
( FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY |
FILE_ATTRIBUTE_ARCHIVE ) );
}
else
fError = HB_TRUE;
if( lpFileNameFree )
hb_xfree( lpFileNameFree );
}
#elif defined( HB_OS_UNIX )
{
struct stat statbuf;
struct tm st;
time_t ftime;
char * pszFree;
if( stat( hb_fsNameConv( szFileName, &pszFree ), &statbuf ) == 0 )
{
if( S_ISDIR( statbuf.st_mode ) )
{
ulExtAttr |= 0x40000000;
ulExtAttr |= 0x10; /* FILE_ATTRIBUTE_DIRECTORY */
}
else
{
ulExtAttr |= 0x80000000;
ulExtAttr |= 0x20; /* FILE_ATTRIBUTE_ARCHIVE */
}
ulExtAttr |= ( ( statbuf.st_mode & S_IXOTH ) ? 0x00010000 : 0 ) |
( ( statbuf.st_mode & S_IWOTH ) ? 0x00020000 : 0 ) |
( ( statbuf.st_mode & S_IROTH ) ? 0x00040000 : 0 ) |
( ( statbuf.st_mode & S_IXGRP ) ? 0x00080000 : 0 ) |
( ( statbuf.st_mode & S_IWGRP ) ? 0x00100000 : 0 ) |
( ( statbuf.st_mode & S_IRGRP ) ? 0x00200000 : 0 ) |
( ( statbuf.st_mode & S_IXUSR ) ? 0x00400000 : 0 ) |
( ( statbuf.st_mode & S_IWUSR ) ? 0x00800000 : 0 ) |
( ( statbuf.st_mode & S_IRUSR ) ? 0x01000000 : 0 );
ftime = statbuf.st_mtime;
# if defined( HB_HAS_LOCALTIME_R )
localtime_r( &ftime, &st );
# else
st = *localtime( &ftime );
# endif
zfi.tmz_date.tm_sec = st.tm_sec;
zfi.tmz_date.tm_min = st.tm_min;
zfi.tmz_date.tm_hour = st.tm_hour;
zfi.tmz_date.tm_mday = st.tm_mday;
zfi.tmz_date.tm_mon = st.tm_mon;
zfi.tmz_date.tm_year = st.tm_year;
}
else
fError = HB_TRUE;
if( pszFree )
hb_xfree( pszFree );
}
#elif defined( HB_OS_DOS )
{
# if defined( __DJGPP__ ) || defined( __RSX32__ ) || defined( __GNUC__ )
int attr;
char * pszFree;
attr = _chmod( hb_fsNameConv( szFileName, &pszFree ), 0, 0 );
if( pszFree )
hb_xfree( pszFree );
if( attr != -1 )
# else
HB_FATTR attr;
if( hb_fsGetAttr( szFileName, &attr ) )
# endif
{
ulExtAttr = attr & ( HB_FA_READONLY | HB_FA_HIDDEN | HB_FA_SYSTEM |
HB_FA_DIRECTORY | HB_FA_ARCHIVE );
ulExtAttr = hb_translateExtAttr( szFileName, ulExtAttr );
}
else
fError = HB_TRUE;
}
#elif defined( HB_OS_OS2 )
{
FILESTATUS3 fs3;
APIRET ulrc;
HB_FATTR ulAttr;
char * pszFree;
ulrc = DosQueryPathInfo( ( PCSZ ) hb_fsNameConv( szFileName, &pszFree ), FIL_STANDARD, &fs3, sizeof( fs3 ) );
if( pszFree )
hb_xfree( pszFree );
if( ulrc == NO_ERROR )
{
ulAttr = 0;
if( fs3.attrFile & FILE_READONLY )
ulAttr |= HB_FA_READONLY;
if( fs3.attrFile & FILE_HIDDEN )
ulAttr |= HB_FA_HIDDEN;
if( fs3.attrFile & FILE_SYSTEM )
ulAttr |= HB_FA_SYSTEM;
if( fs3.attrFile & FILE_DIRECTORY )
ulAttr |= HB_FA_DIRECTORY;
if( fs3.attrFile & FILE_ARCHIVED )
ulAttr |= HB_FA_ARCHIVE;
ulExtAttr = hb_translateExtAttr( szFileName, ulAttr );
zfi.tmz_date.tm_sec = fs3.ftimeLastWrite.twosecs * 2;
zfi.tmz_date.tm_min = fs3.ftimeLastWrite.minutes;
zfi.tmz_date.tm_hour = fs3.ftimeLastWrite.hours;
zfi.tmz_date.tm_mday = fs3.fdateLastWrite.day;
zfi.tmz_date.tm_mon = fs3.fdateLastWrite.month;
zfi.tmz_date.tm_year = fs3.fdateLastWrite.year + 1980;
}
else
fError = HB_TRUE;
}
#else
{
HB_FATTR attr;
if( ! hb_fsGetAttr( szFileName, &attr ) )
ulExtAttr = 0x81B60020; /* FILE_ATTRIBUTE_ARCHIVE | rw-rw-rw- */
else
{
ulExtAttr = attr & ( HB_FA_READONLY | HB_FA_HIDDEN | HB_FA_SYSTEM |
HB_FA_DIRECTORY | HB_FA_ARCHIVE );
ulExtAttr = hb_translateExtAttr( szFileName, ulExtAttr );
}
}
#endif
if( fError )
return -200;
if( ! HB_ISCHAR( iParamZipName ) )
iParamZipName = iParamFileName;
if( fUnicode )
{
szZipName = hb_strdup( hb_parstr_utf8( iParamZipName, &hZipName, NULL ) );
szComment = hb_parstr_utf8( iParamComment, &hComment, NULL );
flags |= _ZIP_FLAG_UNICODE;
}
else
{
szZipName = hb_strdup( hb_parc( iParamZipName ) );
szComment = hb_parc( iParamComment );
}
if( szName )
{
/* change path separators to '/' */
nLen = strlen( szZipName );
pString = szZipName;
while( nLen-- )
{
if( pString[ nLen ] == '\\' )
pString[ nLen ] = '/';
}
}
else
{
/* get file name */
szZipName = hb_strdup( szFileName );
nLen = strlen( szZipName );
pString = szZipName;
while( nLen-- )
{
if( pString[ nLen ] == '/' || pString[ nLen ] == '\\' )
{
memmove( szZipName, &pString[ nLen + 1 ], strlen( szZipName ) - nLen );
break;
}
}
}
fText = HB_FALSE;
ulCRC = 0;
zfi.external_fa = ulExtAttr;
/* TODO: zip.exe test: 0 for binary file, 1 for text. Does not depend on
extension. We should analyse content of file to determine this??? */
zfi.internal_fa = 0;
if( ulExtAttr & 0x40000000 )
{
iResult = zipOpenNewFileInZip4( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC, _version_made_by( fUnicode ), flags );
if( iResult == 0 )
zipCloseFileInZip( hZip );
}
else
{
hFile = hb_fsOpen( szFileName, FO_READ );
if( hFile != FS_ERROR )
{
#if defined( HB_OS_WIN )
{
FILETIME ftutc, ft;
SYSTEMTIME st;
if( GetFileTime( ( HANDLE ) hb_fsGetOsHandle( hFile ), NULL, NULL, &ftutc ) &&
FileTimeToLocalFileTime( &ftutc, &ft ) &&
FileTimeToSystemTime( &ft, &st ) )
{
zfi.tmz_date.tm_sec = st.wSecond;
zfi.tmz_date.tm_min = st.wMinute;
zfi.tmz_date.tm_hour = st.wHour;
zfi.tmz_date.tm_mday = st.wDay;
zfi.tmz_date.tm_mon = st.wMonth - 1;
zfi.tmz_date.tm_year = st.wYear;
}
}
#endif
if( szPassword )
{
if( hb_zipGetFileInfo( szFileName, &ulCRC, &fText ) )
zfi.internal_fa = fText ? 1 : 0;
}
iResult = zipOpenNewFileInZip4( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC, _version_made_by( fUnicode ), flags );
if( iResult == 0 )
{
pString = ( char * ) hb_xgrab( HB_Z_IOBUF_SIZE );
while( ( nLen = hb_fsReadLarge( hFile, pString, HB_Z_IOBUF_SIZE ) ) > 0 )
zipWriteInFileInZip( hZip, pString, ( unsigned ) nLen );
hb_xfree( pString );
zipCloseFileInZip( hZip );
}
hb_fsClose( hFile );
}
else
iResult = -200 - hb_fsError();
}
hb_xfree( szZipName );
if( fUnicode )
{
hb_strfree( hZipName );
hb_strfree( hComment );
}
return iResult;
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem, pName = NULL;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( &pArea->area, uiFields );
errCode = 0;
bError = HB_FALSE;
pItemEof = hb_itemArrayNew( uiFields );
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO dbFieldInfo;
memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) );
pName = S_HB_ITEMPUTSTR( pName, sqlite3_column_name( st, uiIndex ) );
dbFieldInfo.atomName = hb_itemGetCPtr( pName );
dbFieldInfo.uiType = sqlite3DeclType( st, uiIndex );
pItem = hb_arrayGetItemPtr( pItemEof, uiIndex + 1 );
switch( dbFieldInfo.uiType )
{
case HB_FT_STRING:
{
int iSize = sqlite3_column_bytes( st, uiIndex );
char * pStr;
dbFieldInfo.uiLen = ( HB_USHORT ) HB_MAX( iSize, 10 );
pStr = ( char * ) hb_xgrab( ( HB_SIZE ) dbFieldInfo.uiLen + 1 );
memset( pStr, ' ', dbFieldInfo.uiLen );
hb_itemPutCLPtr( pItem, pStr, dbFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
dbFieldInfo.uiLen = 4;
hb_itemPutC( pItem, NULL );
break;
case HB_FT_INTEGER:
dbFieldInfo.uiLen = 8;
hb_itemPutNInt( pItem, 0 );
break;
case HB_FT_LONG:
dbFieldInfo.uiLen = 20;
dbFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
hb_itemPutNDDec( pItem, 0.0, dbFieldInfo.uiDec );
break;
case HB_FT_ANY:
dbFieldInfo.uiLen = 6;
break;
default:
bError = HB_TRUE;
}
if( ! bError )
bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE );
if( bError )
break;
}
hb_itemRelease( pName );
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
static HB_ERRCODE ocilibOpen( SQLBASEAREAP pArea )
{
OCI_Statement * st = OCI_StatementCreate( ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn );
OCI_Resultset * rs;
SDDDATA * pSDDData;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
if( ! st )
{
szError = ocilibGetError( &errCode );
hb_errRT_OCIDD( EG_OPEN, ESQLDD_STMTALLOC, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
pItem = hb_itemPutC( NULL, pArea->szQuery );
if( ! OCI_ExecuteStmt( st, M_HB_ITEMGETSTR( pItem, &hQuery, NULL ) ) )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = ocilibGetError( &errCode );
OCI_StatementFree( st );
hb_errRT_OCIDD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
rs = OCI_GetResultset( st );
uiFields = ( HB_USHORT ) OCI_GetColumnCount( rs );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
pItem = hb_itemNew( NULL );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", iNameLen ) );
#endif
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO pFieldInfo;
PHB_ITEM pName;
OCI_Column * col = OCI_GetColumn( rs, uiIndex + 1 );
unsigned int uiDataType;
unsigned int uiSize;
int iDec;
HB_BOOL bNullable;
if( ! col )
{
hb_itemRelease( pItemEof );
hb_itemRelease( pItem );
szError = ocilibGetError( NULL );
OCI_StatementFree( st );
hb_errRT_OCIDD( EG_OPEN, ESQLDD_STMTDESCR + 1001, szError, pArea->szQuery, 0 );
hb_xfree( szError );
return HB_FAILURE;
}
pName = D_HB_ITEMPUTSTR( NULL, OCI_ColumnGetName( col ) );
pFieldInfo.atomName = hb_itemGetCPtr( pName );
uiDataType = OCI_ColumnGetType( col );
uiSize = OCI_ColumnGetSize( col );
iDec = OCI_ColumnGetPrecision( col );
bNullable = ( HB_BOOL ) OCI_ColumnGetNullable( col );
if( bNullable )
pFieldInfo.uiFlags |= HB_FF_NULLABLE;
pFieldInfo.uiLen = ( HB_USHORT ) uiSize;
pFieldInfo.uiDec = ( HB_USHORT ) iDec;
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d nullable=%d %d %d %d %d", pFieldInfo.atomName, uiDataType, uiSize, iDec, bNullable, OCI_ColumnGetScale( col ), OCI_ColumnGetPrecision( col ), OCI_ColumnGetFractionalPrecision( col ), OCI_ColumnGetLeadingPrecision( col ) ) );
#endif
switch( uiDataType )
{
case OCI_CDT_TEXT:
pFieldInfo.uiType = HB_FT_STRING;
break;
case OCI_CDT_NUMERIC:
pFieldInfo.uiType = HB_FT_LONG;
/* For plain 'NUMERIC', precision is zero and scale is -127 */
if( OCI_ColumnGetPrecision( col ) > 0 )
pFieldInfo.uiLen = ( HB_USHORT ) OCI_ColumnGetPrecision( col );
if( OCI_ColumnGetScale( col ) >= 0 )
pFieldInfo.uiDec = ( HB_USHORT ) OCI_ColumnGetScale( col );
else
pFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
break;
case OCI_CDT_LONG:
pFieldInfo.uiType = HB_FT_VARLENGTH;
break;
case OCI_CDT_RAW:
pFieldInfo.uiType = HB_FT_BLOB;
break;
case OCI_CDT_DATETIME:
case OCI_CDT_TIMESTAMP:
case OCI_CDT_INTERVAL:
pFieldInfo.uiType = HB_FT_TIME;
break;
default:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", uiDataType ) );
#endif
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) uiDataType;
pFieldInfo.uiType = 0;
pFieldInfo.uiType = HB_FT_STRING;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
hb_itemPutCLPtr( pItem, pStr, pFieldInfo.uiLen );
break;
}
case HB_FT_MEMO:
case HB_FT_VARLENGTH:
case HB_FT_BLOB:
hb_itemPutC( pItem, NULL );
break;
case HB_FT_INTEGER:
hb_itemPutNI( pItem, 0 );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
hb_itemPutNLLen( pItem, 0, pFieldInfo.uiLen );
else
hb_itemPutNDLen( pItem, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_DOUBLE:
hb_itemPutNDLen( pItem, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_LOGICAL:
hb_itemPutL( pItem, HB_FALSE );
break;
case HB_FT_DATE:
hb_itemPutDL( pItem, 0 );
break;
case HB_FT_TIME:
case HB_FT_TIMESTAMP:
hb_itemPutTDT( pItem, 0, 0 );
break;
default:
hb_itemClear( pItem );
bError = HB_TRUE;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
hb_itemRelease( pItem );
if( bError )
{
hb_itemRelease( pItemEof );
OCI_StatementFree( st );
hb_errRT_OCIDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea )
{
SDDCONN * pSDDConn = ( SDDCONN * ) pArea->pConnection->pSDDConn;
SDDDATA * pSDDData;
void * hQuery;
SQLHSTMT hStmt;
SQLSMALLINT iNameLen;
PHB_ITEM pItemEof, pItem;
HB_BOOL bError;
HB_USHORT uiFields, uiIndex;
HB_ERRCODE errCode;
char * szError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
#if ODBCVER >= 0x0300
if( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) )
#else
if( ! SQL_SUCCEEDED( SQLAllocStmt( pSDDConn->hConn, &hStmt ) ) )
#endif
{
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, SQL_NULL_HSTMT, &errCode );
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTALLOC, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
pItem = hb_itemPutC( NULL, pArea->szQuery );
if( ! SQL_SUCCEEDED( SQLExecDirect( hStmt,
( SQLTCHAR * ) O_HB_ITEMGETSTR( pItem, &hQuery, NULL ),
( SQLINTEGER ) hb_itemGetCLen( pItem ) ) ) )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( ! SQL_SUCCEEDED( SQLNumResultCols( hStmt, &iNameLen ) ) )
{
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTDESCR + 1000, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) iNameLen;
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", iNameLen ) );
#endif
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; uiIndex++ )
{
DBFIELDINFO pFieldInfo;
PHB_ITEM pName;
SQLTCHAR cName[ 256 ];
SQLULEN uiSize;
SQLSMALLINT iDataType, iDec, iNull;
if( ! SQL_SUCCEEDED( SQLDescribeCol( hStmt, ( SQLSMALLINT ) uiIndex + 1, ( SQLTCHAR * ) cName, HB_SIZEOFARRAY( cName ), &iNameLen, &iDataType, &uiSize, &iDec, &iNull ) ) )
{
hb_itemRelease( pItemEof );
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, NULL );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTDESCR + 1001, szError, pArea->szQuery, 0 );
hb_xfree( szError );
return HB_FAILURE;
}
pName = O_HB_ITEMPUTSTRLEN( NULL, ( O_HB_CHAR * ) cName, iNameLen );
pFieldInfo.atomName = hb_itemGetCPtr( pName );
/*
We do mapping of many SQL types to one Harbour field type here, so, we need store
real SQL type in uiTypeExtended. SQL types are signed, so, HB_USHORT type casting
is a little hacky. We need to remember use this casting also in expressions like
this:
if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT )
or introduce our own unsigned SQL types.
[Mindaugas]
*/
pFieldInfo.uiTypeExtended = ( HB_USHORT ) iDataType;
pFieldInfo.uiLen = ( HB_USHORT ) uiSize;
pFieldInfo.uiDec = iDec;
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d null=%d", pFieldInfo.atomName, iDataType, uiSize, iDec, iNull ) );
#endif
switch( iDataType )
{
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_LONGVARCHAR:
case SQL_WCHAR:
case SQL_WVARCHAR:
case SQL_WLONGVARCHAR:
pFieldInfo.uiType = HB_FT_STRING;
break;
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiFlags = HB_FF_BINARY;
break;
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_BIGINT:
pFieldInfo.uiType = HB_FT_INTEGER;
break;
case SQL_DECIMAL:
case SQL_NUMERIC:
pFieldInfo.uiType = HB_FT_LONG;
break;
case SQL_REAL:
case SQL_FLOAT:
case SQL_DOUBLE:
pFieldInfo.uiType = HB_FT_DOUBLE;
break;
case SQL_BIT:
pFieldInfo.uiType = HB_FT_LOGICAL;
break;
case SQL_DATE:
#if ODBCVER >= 0x0300
case SQL_TYPE_DATE:
#endif
pFieldInfo.uiType = HB_FT_DATE;
break;
case SQL_TIME:
#if ODBCVER >= 0x0300
case SQL_TYPE_TIME:
#endif
pFieldInfo.uiType = HB_FT_DATE;
break;
/* SQL_DATETIME = SQL_DATE = 9 */
case SQL_TIMESTAMP:
#if ODBCVER >= 0x0300
case SQL_TYPE_TIMESTAMP:
#endif
pFieldInfo.uiType = HB_FT_TIMESTAMP;
break;
default:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) );
#endif
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) iDataType;
pFieldInfo.uiType = 0;
pFieldInfo.uiType = HB_FT_STRING;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_INTEGER:
pItem = hb_itemPutNI( NULL, 0 );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen );
else
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_DOUBLE:
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_LOGICAL:
pItem = hb_itemPutL( NULL, HB_FALSE );
break;
case HB_FT_DATE:
pItem = hb_itemPutDL( NULL, 0 );
break;
case HB_FT_TIME:
pItem = hb_itemPutTDT( NULL, 0, 0 );
break;
case HB_FT_TIMESTAMP:
pItem = hb_itemPutTDT( NULL, 0, 0 );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
hb_itemRelease( pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->hStmt = hStmt;
return HB_SUCCESS;
}
PHB_ITEM hb_libLoad( PHB_ITEM pLibName, PHB_ITEM pArgs )
{
void * hDynLib = NULL;
if( hb_itemGetCLen( pLibName ) > 0 )
{
int argc = pArgs ? ( int ) hb_arrayLen( pArgs ) : 0, i;
const char ** argv = NULL;
if( argc > 0 )
{
argv = ( const char ** ) hb_xgrab( sizeof( char * ) * argc );
for( i = 0; i < argc; ++i )
argv[ i ] = hb_arrayGetCPtr( pArgs, i + 1 );
}
if( hb_vmLockModuleSymbols() )
{
/* use stack address as first level marker */
hb_vmBeginSymbolGroup( ( void * ) hb_stackId(), HB_TRUE );
#if defined( HB_OS_WIN )
{
void * hFileName;
hDynLib = ( void * ) LoadLibraryEx( HB_ITEMGETSTR( pLibName, &hFileName, NULL ), NULL, LOAD_WITH_ALTERED_SEARCH_PATH );
hb_strfree( hFileName );
}
#elif defined( HB_OS_OS2 )
{
HB_UCHAR LoadError[ 256 ] = ""; /* Area for load failure information */
HMODULE hDynModule;
if( DosLoadModule( ( PSZ ) LoadError, sizeof( LoadError ),
( PCSZ ) hb_itemGetCPtr( pLibName ), &hDynModule ) == NO_ERROR )
hDynLib = ( void * ) hDynModule;
}
#elif defined( HB_HAS_DLFCN )
hDynLib = ( void * ) dlopen( hb_itemGetCPtr( pLibName ), RTLD_LAZY | RTLD_GLOBAL );
if( ! hDynLib )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_libLoad(): dlopen(): %s", dlerror() ) );
}
#elif defined( HB_CAUSEWAY_DLL )
hDynLib = LoadLibrary( hb_itemGetCPtr( pLibName ) );
#else
{
int iTODO;
}
#endif
/* set real marker */
hb_vmInitSymbolGroup( hDynLib, argc, argv );
hb_vmUnlockModuleSymbols();
}
if( argv )
hb_xfree( ( void * ) argv );
}
if( hDynLib )
{
void ** pLibPtr = ( void ** ) hb_gcAllocate( sizeof( void * ), &s_gcDynlibFuncs );
*pLibPtr = hDynLib;
return hb_itemPutPtrGC( NULL, pLibPtr );
}
return NULL;
}
LOGFONT * hbwapi_par_LOGFONT( LOGFONT * p, int iParam, HB_BOOL bMandatory )
{
PHB_ITEM pStru = hb_param( iParam, HB_IT_ANY );
void * hfFaceName;
LPCTSTR pfFaceName;
HB_SIZE nLen;
memset( p, 0, sizeof( LOGFONT ) );
if( pStru && HB_IS_HASH( pStru ) )
{
p->lfHeight = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfHeight" ) );
p->lfWidth = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfWidth" ) );
p->lfEscapement = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfEscapement" ) );
p->lfOrientation = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfOrientation" ) );
p->lfWeight = ( LONG ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "lfWeight" ) );
p->lfItalic = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfItalic" ) );
p->lfUnderline = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfUnderline" ) );
p->lfStrikeOut = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfStrikeOut" ) );
p->lfCharSet = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfCharSet" ) );
p->lfOutPrecision = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfOutPrecision" ) );
p->lfClipPrecision = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfClipPrecision" ) );
p->lfQuality = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfQuality" ) );
p->lfPitchAndFamily = ( BYTE ) hb_itemGetNI( hb_hashGetCItemPtr( pStru, "lfPitchAndFamily" ) );
pfFaceName = HB_ITEMGETSTR( hb_hashGetCItemPtr( pStru, "lfFaceName" ), &hfFaceName, &nLen );
if( nLen > ( LF_FACESIZE - 1 ) )
nLen = LF_FACESIZE - 1;
memcpy( p->lfFaceName, pfFaceName, nLen * sizeof( TCHAR ) );
p->lfFaceName[ nLen ] = TEXT( '\0' );
hb_strfree( hfFaceName );
return p;
}
else if( pStru && HB_IS_ARRAY( pStru ) && hb_arrayLen( pStru ) >= 14 )
{
p->lfHeight = ( LONG ) hb_arrayGetNL( pStru, 1 );
p->lfWidth = ( LONG ) hb_arrayGetNL( pStru, 2 );
p->lfEscapement = ( LONG ) hb_arrayGetNL( pStru, 3 );
p->lfOrientation = ( LONG ) hb_arrayGetNL( pStru, 4 );
p->lfWeight = ( LONG ) hb_arrayGetNL( pStru, 5 );
p->lfItalic = ( BYTE ) hb_arrayGetNI( pStru, 6 );
p->lfUnderline = ( BYTE ) hb_arrayGetNI( pStru, 7 );
p->lfStrikeOut = ( BYTE ) hb_arrayGetNI( pStru, 8 );
p->lfCharSet = ( BYTE ) hb_arrayGetNI( pStru, 9 );
p->lfOutPrecision = ( BYTE ) hb_arrayGetNI( pStru, 10 );
p->lfClipPrecision = ( BYTE ) hb_arrayGetNI( pStru, 11 );
p->lfQuality = ( BYTE ) hb_arrayGetNI( pStru, 12 );
p->lfPitchAndFamily = ( BYTE ) hb_arrayGetNI( pStru, 13 );
pfFaceName = HB_ARRAYGETSTR( pStru, 14, &hfFaceName, &nLen );
if( nLen > ( LF_FACESIZE - 1 ) )
nLen = LF_FACESIZE - 1;
memcpy( p->lfFaceName, pfFaceName, nLen * sizeof( TCHAR ) );
p->lfFaceName[ nLen ] = TEXT( '\0' );
hb_strfree( hfFaceName );
return p;
}
else if( bMandatory )
return p;
return NULL;
}
static int hb_gt_gui_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions,
int iClrNorm, int iClrHigh, double dDelay )
{
void * hText;
LPCTSTR lpText = HB_ITEMGETSTR( pMessage, &hText, NULL );
int iRet, iOptions = pOptions ? ( int ) hb_arrayLen( pOptions ) : 0;
if( lpText && iOptions > 0 )
{
int i, iType = 0;
UINT uType;
for( i = 1; i <= iOptions; ++i )
iType |= hb_gt_gui_optionId( hb_arrayGetCPtr( pOptions, i ) );
switch( iType )
{
case 0x01:
uType = MB_OK;
break;
case 0x03:
uType = MB_OKCANCEL;
break;
case 0x06:
uType = MB_RETRYCANCEL;
break;
case 0x0E:
#ifdef MB_CANCELTRYCONTINUE
uType = hb_iswin2k() ? MB_CANCELTRYCONTINUE : MB_ABORTRETRYIGNORE;
#else
uType = MB_ABORTRETRYIGNORE;
#endif
break;
case 0x12:
uType = MB_OKCANCEL;
break;
case 0x21:
uType = MB_YESNO;
break;
case 0x30:
uType = MB_YESNO;
break;
case 0x32:
uType = MB_YESNOCANCEL;
break;
default:
uType = MB_OK;
break;
}
iRet = MessageBox( NULL, lpText, TEXT( "" ), uType );
iRet = hb_gt_gui_optionPos( iRet, iType, pOptions );
}
else
iRet = HB_GTSUPER_ALERT( pGT, pMessage, pOptions, iClrNorm,
iClrHigh, dDelay );
hb_strfree( hText );
return iRet;
}
static int hb_zipStoreFileHandle( zipFile hZip, HB_FHANDLE hFile, int iParamZipName, const char * szPassword, int iParamComment, HB_BOOL fUnicode )
{
HB_SIZE nLen;
zip_fileinfo zfi;
int iResult;
HB_BOOL fText;
HB_U32 ulCRC;
uLong flags = 0;
void * hZipName = NULL;
void * hComment = NULL;
char * szZipName;
const char * szComment;
if( hFile == FS_ERROR )
return -200;
if( fUnicode )
{
szZipName = hb_strdup( hb_parstr_utf8( iParamZipName, &hZipName, NULL ) );
szComment = hb_parstr_utf8( iParamComment, &hComment, NULL );
flags |= _ZIP_FLAG_UNICODE;
}
else
{
szZipName = hb_strdup( hb_parc( iParamZipName ) );
szComment = hb_parc( iParamComment );
}
/* change path separators to '/' */
nLen = strlen( szZipName );
while( nLen-- )
{
if( szZipName[ nLen ] == '\\' )
szZipName[ nLen ] = '/';
}
memset( &zfi, 0, sizeof( zfi ) );
zfi.external_fa = 0x81B60020;
zfi.tmz_date.tm_sec = 0;
zfi.tmz_date.tm_min = 0;
zfi.tmz_date.tm_hour = 0;
zfi.tmz_date.tm_mday = 1;
zfi.tmz_date.tm_mon = 0;
zfi.tmz_date.tm_year = 0;
ulCRC = 0;
fText = HB_FALSE;
if( szPassword && hb_zipGetFileInfoFromHandle( hFile, &ulCRC, &fText ) )
zfi.internal_fa = fText ? 1 : 0;
else
/* TODO: zip.exe test: 0 for binary file, 1 for text. Does not depend on
extension. We should analyse content of file to determine this??? */
zfi.internal_fa = 0;
iResult = zipOpenNewFileInZip4( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC, _version_made_by( fUnicode ), flags );
if( iResult == 0 )
{
char * pString = ( char * ) hb_xgrab( HB_Z_IOBUF_SIZE );
hb_fsSeek( hFile, 0, FS_SET );
while( ( nLen = hb_fsReadLarge( hFile, pString, HB_Z_IOBUF_SIZE ) ) > 0 )
zipWriteInFileInZip( hZip, pString, ( unsigned ) nLen );
hb_xfree( pString );
zipCloseFileInZip( hZip );
}
hb_xfree( szZipName );
if( fUnicode )
{
hb_strfree( hZipName );
hb_strfree( hComment );
}
return iResult;
}
