sei que existe essa função "HB_JSONDecode()" em harbour e xharbour mais versões mais novas, mais como tenho o meu sistema em xharbour 0.99 e não estou podendo mudar para as mais novas, até mudei mais tive problemas com a gtwvw e não está legal ainda, ai consegui achar o código fonte mais não dou conta de usa-lo no xharbour, gostaria de ajuda para deixar essa função usual no xharobur.
REQUEST HB_JSONENCODE
REQUEST HB_JSONDECODE
#ifndef HB_JSON_H_
#define HB_JSON_H_
#include "hbapi.h"
HB_EXTERN_BEGIN
extern char * hb_jsonEncode( PHB_ITEM pValue, HB_SIZE * pnLen, HB_BOOL fHuman );
extern HB_SIZE hb_jsonDecode( const char * szSource, PHB_ITEM pValue );
HB_EXTERN_END
#endif /* HB_JSON_H_ */
#include <math.h>
#include "hbapi.h"
#include "hbapiitm.h"
#include "hbapistr.h"
typedef struct
{
char * pBuffer;
char * pHead;
HB_SIZE nAlloc;
void ** pId;
HB_SIZE nAllocId;
HB_BOOL fHuman;
} HB_JSON_ENCODE_CTX, * PHB_JSON_ENCODE_CTX;
#if defined( HB_OS_UNIX ) && !defined( HB_EOL_CRLF )
static const char s_szEol[ 2 ] = { HB_CHAR_LF, 0 };
static const int s_iEolLen = 1;
#else
static const char s_szEol[ 3 ] = { HB_CHAR_CR, HB_CHAR_LF, 0 };
static const int s_iEolLen = 2;
#endif
#define INDENT_SIZE 2
static void _hb_jsonCtxAdd( PHB_JSON_ENCODE_CTX pCtx, const char * szString, HB_SIZE nLen )
{
if( pCtx->pHead + nLen >= pCtx->pBuffer + pCtx->nAlloc )
{
HB_SIZE nSize = pCtx->pHead - pCtx->pBuffer;
pCtx->nAlloc += ( pCtx->nAlloc << 1 ) + nLen;
pCtx->pBuffer = ( char * ) hb_xrealloc( pCtx->pBuffer, pCtx->nAlloc );
pCtx->pHead = pCtx->pBuffer + nSize;
}
if( szString )
{
hb_xmemcpy( pCtx->pHead, szString, nLen );
pCtx->pHead += nLen;
}
}
static void _hb_jsonCtxAddIndent( PHB_JSON_ENCODE_CTX pCtx, HB_SIZE nCount )
{
if( nCount > 0 )
{
if( pCtx->pHead + nCount >= pCtx->pBuffer + pCtx->nAlloc )
{
HB_SIZE nSize = pCtx->pHead - pCtx->pBuffer;
pCtx->nAlloc += ( pCtx->nAlloc << 1 ) + nCount;
pCtx->pBuffer = ( char * ) hb_xrealloc( pCtx->pBuffer, pCtx->nAlloc );
pCtx->pHead = pCtx->pBuffer + nSize;
}
hb_xmemset( pCtx->pHead, ' ', nCount );
pCtx->pHead += nCount;
}
}
static void _hb_jsonEncode( PHB_ITEM pValue, PHB_JSON_ENCODE_CTX pCtx, HB_SIZE nLevel )
{
if( nLevel >= pCtx->nAllocId )
{
pCtx->nAllocId += 8;
pCtx->pId = ( void ** ) hb_xrealloc( pCtx->pId, sizeof( void * ) * pCtx->nAllocId );
}
/* Protection against recursive structures */
if( HB_IS_ARRAY( pValue ) || HB_IS_HASH( pValue ) )
{
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 )
{
_hb_jsonCtxAdd( pCtx, "null", 4 );
return;
}
}
pCtx->pId[ nLevel ] = id;
}
if( HB_IS_STRING( pValue ) )
{
const char * szString = hb_itemGetCPtr( pValue );
HB_SIZE nPos, nPos2, nLen = hb_itemGetCLen( pValue );
_hb_jsonCtxAdd( pCtx, "\"", 1 );
nPos = 0;
while( nPos < nLen )
{
nPos2 = nPos;
while( * ( ( const unsigned char * ) szString + nPos2 ) >= ' ' &&
szString[ nPos2 ] != '\\' && szString[ nPos2 ] != '\"' )
nPos2++;
if( nPos2 > nPos )
{
_hb_jsonCtxAdd( pCtx, szString + nPos, nPos2 - nPos );
nPos = nPos2;
continue;
}
switch( szString[ nPos ] )
{
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:
{
char buf[ 8 ];
hb_snprintf( buf, sizeof( buf ), "\\u00%02X", ( unsigned char ) szString[ nPos ] );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
}
nPos++;
}
_hb_jsonCtxAdd( pCtx, "\"", 1 );
}
else if( HB_IS_NUMINT( pValue ) )
{
char buf[ 32 ];
hb_snprintf( buf, sizeof( buf ), "%" PFHL "d", hb_itemGetNInt( pValue ) );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
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, s_szEol, s_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 );
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, s_szEol, s_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, s_szEol, s_iEolLen );
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
}
_hb_jsonEncode( pKey, pCtx, nLevel + 1 );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, " : ", 3 );
if( ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) && hb_itemSize( pItem ) > 0 )
_hb_jsonCtxAdd( pCtx, s_szEol, s_iEolLen );
}
else
_hb_jsonCtxAdd( pCtx, ":", 1 );
_hb_jsonEncode( pItem, pCtx, nLevel + 1 );
}
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, s_szEol, s_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 const char * _skipws( const char * szSource )
{
while( *szSource == ' ' || *szSource == '\t' || *szSource == '\n' || *szSource == '\r') szSource++;
return szSource;
}
static const char * _hb_jsonDecode( const char * szSource, PHB_ITEM pValue )
{
if( *szSource == '\"' )
{
char * szDest, * szHead;
HB_SIZE nAlloc = 16;
szHead = szDest = ( char * ) hb_xgrab( nAlloc );
szSource++;
while( *szSource != '\"' )
{
if( szHead + 6 >= szDest + nAlloc )
{
HB_SIZE nLen = szHead - szDest;
nAlloc += nAlloc << 1;
szDest = ( char * ) hb_xrealloc( szDest, nAlloc );
szHead = szDest + nLen;
}
if( *szSource == '\\' )
{
szSource++;
switch( *szSource )
{
case '\"':
*szHead++ = '\"';
break;
case '\\':
*szHead++ = '\\';
break;
case '/':
*szHead++ = '/';
break;
case 'b':
*szHead++ = '\b';
break;
case 'f':
*szHead++ = '\f';
break;
case 'n':
*szHead++ = '\n';
break;
case 'r':
*szHead++ = '\r';
break;
case 't':
*szHead++ = '\t';
break;
case 'u':
{
HB_WCHAR wc = 0;
int i;
for( i = 0; i < 4; i++ )
{
char c = *++szSource;
wc <<= 4;
if( c >= '0' && c <= '9' )
wc += c - '0';
else if( c >= 'A' && c <= 'F' )
wc += c - 'A' + 10;
else if( c >= 'a' && c <= 'f' )
wc += c - 'a' + 10;
else
{
hb_xfree( szDest );
return NULL;
}
}
szHead += hb_cdpU16ToStr( hb_vmCDP(), HB_CDP_ENDIAN_NATIVE,
&wc, 1,
szHead, szDest + nAlloc - szHead );
break;
}
default:
{
hb_xfree( szDest );
return NULL;
}
}
szSource++;
}
else if( * ( const unsigned char * ) szSource >= ' ' )
*szHead++ = *szSource++;
else
{
hb_xfree( szDest );
return NULL;
}
}
hb_itemPutCL( pValue, szDest, szHead - szDest );
hb_xfree( szDest );
return szSource + 1;
}
else if( *szSource == '-' || ( *szSource >= '0' && *szSource <= '9' ) )
{
/* NOTE: this function is much less strict to number format than
JSON syntax definition. This is allowed behaviour [Mindaugas] */
HB_MAXINT nValue = 0;
double dblValue = 0;
HB_BOOL fNeg, fDbl = HB_FALSE;
fNeg = *szSource == '-';
if( fNeg )
szSource++;
while( *szSource >= '0' && *szSource <= '9' )
{
nValue = nValue * 10 + *szSource - '0';
szSource++;
}
if( *szSource == '.' )
{
double mult = 1;
dblValue = ( double ) nValue;
fDbl = HB_TRUE;
szSource++;
while( *szSource >= '0' && *szSource <= '9' )
{
mult /= 10;
dblValue += ( ( double ) ( *szSource - '0' ) ) * mult;
szSource++;
}
}
if( *szSource == 'e' || *szSource == 'E' )
{
HB_BOOL fNegExp;
int iExp = 0;
szSource++;
fNegExp = *szSource == '-';
if( fNegExp )
szSource++;
szSource++;
while( *szSource >= '0' && *szSource <= '9' )
{
iExp = iExp * 10 + *szSource - '0';
szSource++;
}
if( ! fDbl )
{
dblValue = ( double ) nValue;
fDbl = HB_TRUE;
}
dblValue *= pow( 10.0, ( double ) ( fNegExp ? -iExp : iExp ) );
}
if( fDbl )
hb_itemPutND( pValue, fNeg ? -dblValue : dblValue );
else
hb_itemPutNInt( pValue, fNeg ? -nValue : nValue);
return szSource;
}
else if( ! strncmp( szSource, "null", 4 ) )
{
hb_itemClear( pValue );
return szSource + 4;
}
else if( ! strncmp( szSource, "true", 4 ) )
{
hb_itemPutL( pValue, HB_TRUE );
return szSource + 4;
}
else if( ! strncmp( szSource, "false", 5 ) )
{
hb_itemPutL( pValue, HB_FALSE );
return szSource + 5;
}
else if( *szSource == '[' )
{
hb_arrayNew( pValue, 0 );
szSource = _skipws( szSource + 1 );
if( *szSource != ']' )
{
PHB_ITEM pItem = hb_itemNew( NULL );
for( ;; )
{
szSource = _hb_jsonDecode( szSource, pItem );
if( ! szSource )
{
hb_itemRelease( pItem );
return NULL;
}
hb_arrayAddForward( pValue, pItem );
szSource = _skipws( szSource );
if( *szSource == ',' )
{
szSource = _skipws( szSource + 1 );
continue;
}
else if( *szSource == ']' )
break;
else
{
hb_itemRelease( pItem );
return NULL;
}
}
hb_itemRelease( pItem );
}
return szSource + 1;
}
else if( *szSource == '{' )
{
hb_hashNew( pValue );
hb_hashSetFlags( pValue, HB_HASH_KEEPORDER );
szSource = _skipws( szSource + 1 );
if( *szSource != '}' )
{
PHB_ITEM pItemKey = hb_itemNew( NULL );
PHB_ITEM pItemValue = hb_itemNew( NULL );
for( ;; )
{
if( ( szSource = _hb_jsonDecode( szSource, pItemKey ) ) == NULL ||
! HB_IS_STRING( pItemKey ) ||
* ( szSource = _skipws( szSource ) ) != ':' ||
( szSource = _hb_jsonDecode( _skipws( szSource + 1 ), pItemValue ) ) == NULL)
/* Do we need to check if key does not exist yet? */
{
hb_itemRelease( pItemKey );
hb_itemRelease( pItemValue );
return NULL;
}
hb_hashAdd( pValue, pItemKey, pItemValue );
szSource = _skipws( szSource );
if( *szSource == ',' )
{
szSource = _skipws( szSource + 1 );
continue;
}
else if( *szSource == '}' )
break;
else
{
hb_itemRelease( pItemKey );
hb_itemRelease( pItemValue );
return NULL;
}
}
hb_itemRelease( pItemKey );
hb_itemRelease( pItemValue );
}
return szSource + 1;
}
return NULL;
}
/* C level API functions */
char * hb_jsonEncode( PHB_ITEM pValue, HB_SIZE * pnLen, HB_BOOL fHuman )
{
PHB_JSON_ENCODE_CTX pCtx;
char * szRet;
HB_SIZE nLen;
pCtx = ( PHB_JSON_ENCODE_CTX ) hb_xgrab( sizeof( HB_JSON_ENCODE_CTX ) );
pCtx->nAlloc = 16;
pCtx->pHead = pCtx->pBuffer = ( char * ) hb_xgrab( pCtx->nAlloc );
pCtx->nAllocId = 8;
pCtx->pId = ( void ** ) hb_xgrab( sizeof( void * ) * pCtx->nAllocId );
pCtx->fHuman = fHuman;
_hb_jsonEncode( pValue, pCtx, 0 );
nLen = pCtx->pHead - pCtx->pBuffer;
szRet = ( char * ) hb_xrealloc( pCtx->pBuffer, nLen + 1 );
szRet[ nLen ] = '\0';
hb_xfree( pCtx->pId );
hb_xfree( pCtx );
if( pnLen )
*pnLen = nLen;
return szRet;
}
HB_SIZE hb_jsonDecode( const char * szSource, PHB_ITEM pValue )
{
PHB_ITEM pItem = pValue ? pValue : hb_itemNew( NULL );
const char * sz;
sz = szSource ? _hb_jsonDecode( _skipws( szSource ), pItem ) : NULL;
if( ! pValue )
hb_itemRelease( pItem );
if( sz )
return sz - szSource;
return 0;
}
/* Harbour level API functions */
HB_FUNC( HB_JSONENCODE )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( pItem )
{
HB_SIZE nLen;
char * szRet = hb_jsonEncode( pItem, &nLen, hb_parl( 2 ) );
hb_retclen_buffer( szRet, nLen );
}
}
HB_FUNC( HB_JSONDECODE )
{
PHB_ITEM pItem = hb_itemNew( NULL );
hb_retns( ( HB_ISIZ ) hb_jsonDecode( hb_parc( 1 ), pItem ) );
hb_itemParamStoreForward( 2, pItem );
hb_itemRelease( pItem );
}
