From b075fccaaf58126f5f73ee71a613809cd59cff04 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Przemys=C5=82aw=20Czerpak?= Date: Mon, 3 Jul 2017 18:36:42 +0200 Subject: [PATCH] 2017-07-03 18:36 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) * contrib/hbwin/olecore.c ! reverted order of indexes and dimensions in conversions of multidimensional arrays. This modification affects both conversions (1) from Harbour array to OLE variant SafeArray and (2) from OLE variant SafeArray to Harbour array. The first one is new Harbour extension of __oleVariantNew() so here above modification should not create any backward compatibility problems but the second interacts with code which existed in Harbour from early OLE implementation so if someone already encoded hacks to revert array indexes and dimensions at .prg level then now he has to remove it. Please not that above modification affects only for multidimensional OLE typed arrays. It does not change anything for single dimension arrays or single dimension arrays of variants which contains other similar arrays in their items. --- ChangeLog.txt | 17 +++++++++++++++++ contrib/hbwin/olecore.c | 40 ++++++++++++++++++++-------------------- 2 files changed, 37 insertions(+), 20 deletions(-) diff --git a/ChangeLog.txt b/ChangeLog.txt index 965802e6e8..75d05c304d 100644 --- a/ChangeLog.txt +++ b/ChangeLog.txt @@ -10,6 +10,23 @@ * Change, ! Fix, % Optimization, + Addition, - Removal, ; Comment */ +2017-07-03 18:36 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) + * contrib/hbwin/olecore.c + ! reverted order of indexes and dimensions in conversions of + multidimensional arrays. + This modification affects both conversions (1) from Harbour array + to OLE variant SafeArray and (2) from OLE variant SafeArray to Harbour + array. The first one is new Harbour extension of __oleVariantNew() so + here above modification should not create any backward compatibility + problems but the second interacts with code which existed in Harbour + from early OLE implementation so if someone already encoded hacks + to revert array indexes and dimensions at .prg level then now he has + to remove it. + Please not that above modification affects only for multidimensional + OLE typed arrays. It does not change anything for single dimension + arrays or single dimension arrays of variants which contains other + similar arrays in their items. + 2017-06-27 12:37 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) * contrib/hbwin/olecore.c + added support for multidimensional typed OLE arrays, now diff --git a/contrib/hbwin/olecore.c b/contrib/hbwin/olecore.c index f5ab2b0722..61b1534fb2 100644 --- a/contrib/hbwin/olecore.c +++ b/contrib/hbwin/olecore.c @@ -568,7 +568,7 @@ static void hb_oleVariantRef( VARIANT * pVariant, VARIANT * pVarRef ) static HB_BOOL hb_oleSafeArrayFill( SAFEARRAY * pSafeArray, VARTYPE vt, PHB_ITEM pItem, - int iDims, long * plSize, long * plIndex ) + int iDims, int iDim, long * plSize, long * plIndex ) { const char * pStr; void * pData; @@ -590,21 +590,21 @@ static HB_BOOL hb_oleSafeArrayFill( SAFEARRAY * pSafeArray, VARTYPE vt, PHB_ITEM else return HB_FALSE; - cElements = ( UINT ) plSize[ --iDims ]; + cElements = ( UINT ) plSize[ iDim - 1 ]; if( uiPos < cElements ) cElements = uiPos; - if( iDims > 0 ) + if( iDim < iDims ) { if( pStr ) return HB_FALSE; for( uiPos = 1; uiPos <= cElements; ++uiPos ) { - plIndex[ iDims ] = ( long ) ( uiPos - 1 ); + plIndex[ iDim - 1 ] = ( long ) ( uiPos - 1 ); if( ! hb_oleSafeArrayFill( pSafeArray, vt, hb_arrayGetItemPtr( pItem, uiPos ), - iDims, plSize, plIndex ) ) + iDims, iDim + 1, plSize, plIndex ) ) return HB_FALSE; } return HB_TRUE; @@ -752,7 +752,7 @@ static HB_BOOL hb_oleSafeArrayFill( SAFEARRAY * pSafeArray, VARTYPE vt, PHB_ITEM if( ptr != NULL ) { - plIndex[ 0 ] = ( long ) ( uiPos - 1 ); + plIndex[ iDim - 1 ] = ( long ) ( uiPos - 1 ); SafeArrayPutElement( pSafeArray, plIndex, ptr ); if( vt == VT_VARIANT ) VariantClear( &v ); @@ -806,7 +806,7 @@ static SAFEARRAY * hb_oleSafeArrayFromItem( PHB_ITEM pItem, VARTYPE vt, if( pSafeArray && pItem && iDims && plSize[ 0 ] ) { if( ! hb_oleSafeArrayFill( pSafeArray, vt, pItem, - iDims, plSize, plIndex ) ) + iDims, 1, plSize, plIndex ) ) { SafeArrayDestroy( pSafeArray ); pSafeArray = NULL; @@ -1122,7 +1122,7 @@ void hb_oleItemToVariantEx( VARIANT * pVariant, PHB_ITEM pItem, static void hb_oleSafeArrayToItem( PHB_ITEM pItem, SAFEARRAY * pSafeArray, - int iDim, long * plIndex, VARTYPE vt, + int iDims, int iDim, long * plIndex, VARTYPE vt, HB_USHORT uiClass ) { long lFrom, lTo; @@ -1134,13 +1134,13 @@ static void hb_oleSafeArrayToItem( PHB_ITEM pItem, SAFEARRAY * pSafeArray, HB_SIZE ul = 0; hb_arrayNew( pItem, lTo - lFrom + 1 ); - if( --iDim == 0 ) + if( iDim == iDims ) { VARIANT vItem; VariantInit( &vItem ); do { - plIndex[ iDim ] = lFrom; + plIndex[ iDim - 1 ] = lFrom; /* hack: for non VT_VARIANT arrays create VARIANT dynamically * using pointer to union in variant structure which * holds all variant values except VT_DECIMAL which is @@ -1163,9 +1163,9 @@ static void hb_oleSafeArrayToItem( PHB_ITEM pItem, SAFEARRAY * pSafeArray, { do { - plIndex[ iDim ] = lFrom; + plIndex[ iDim - 1 ] = lFrom; hb_oleSafeArrayToItem( hb_arrayGetItemPtr( pItem, ++ul ), - pSafeArray, iDim, plIndex, vt, uiClass ); + pSafeArray, iDims, iDim + 1, plIndex, vt, uiClass ); } while( ++lFrom <= lTo ); } @@ -1461,15 +1461,15 @@ void hb_oleVariantToItemEx( PHB_ITEM pItem, VARIANT * pVariant, HB_USHORT uiClas V_ARRAY( pVariant ); if( pSafeArray ) { - int iDim = ( int ) SafeArrayGetDim( pSafeArray ); + int iDims = ( int ) SafeArrayGetDim( pSafeArray ); - if( iDim >= 1 ) + if( iDims >= 1 ) { - if( iDim > 1 || ! hb_oleSafeArrayToString( pItem, pSafeArray ) ) + if( iDims > 1 || ! hb_oleSafeArrayToString( pItem, pSafeArray ) ) { - long * plIndex = ( long * ) hb_xgrab( iDim * sizeof( long ) ); + long * plIndex = ( long * ) hb_xgrab( iDims * sizeof( long ) ); - hb_oleSafeArrayToItem( pItem, pSafeArray, iDim, plIndex, + hb_oleSafeArrayToItem( pItem, pSafeArray, iDims, 1, plIndex, ( VARTYPE ) ( V_VT( pVariant ) & ~( VT_ARRAY | VT_BYREF ) ), uiClass ); hb_xfree( plIndex ); @@ -2827,10 +2827,10 @@ HB_FUNC( __OLEVARIANTNEW ) --iPCount; while( iPCount > 0 ) { - plSize[ iDims - iPCount ] = hb_parnl( iPCount + 2 ); - if( plSize[ iDims - iPCount ] <= 0 ) - break; --iPCount; + plSize[ iPCount ] = hb_parnl( iPCount + 3 ); + if( plSize[ iPCount ] <= 0 ) + break; } if( iPCount <= 0 )