#include "precomp.hpp"

#include "persistence.hpp"

char* icv_itoa( int _val, char* buffer, int /*radix*/ )

{

const int radix = 10;

char* ptr=buffer + 23 /* enough even for 64-bit integers */;

unsigned val = abs(_val);

*ptr = '\0';

do

{

unsigned r = val / radix;

*--ptr = (char)(val - (r*radix) + '0');

val = r;

}

while( val != 0 );

if( _val < 0 )

*--ptr = '-';

return ptr;

}

void icvPuts( CvFileStorage* fs, const char* str )

}

char* icvGets( CvFileStorage* fs, char* str, int maxCount )

{

if( fs->strbuf )

{

size_t i = fs->strbufpos, len = fs->strbufsize;

int j = 0;

const char* instr = fs->strbuf;

while( i < len && j < maxCount-1 )

{

char c = instr[i++];

if( c == '\0' )

break;

str[j++] = c;

if( c == '\n' )

break;

}

str[j++] = '\0';

fs->strbufpos = i;

if (maxCount > 256 && !(fs->flags & cv::FileStorage::BASE64))

CV_Assert(j < maxCount - 1 && "OpenCV persistence doesn't support very long lines");

return j > 1 ? str : 0;

}

if( fs->file )

{

char* ptr = fgets( str, maxCount, fs->file );

if (ptr && maxCount > 256 && !(fs->flags & cv::FileStorage::BASE64))

{

size_t sz = strnlen(ptr, maxCount);

CV_Assert(sz < (size_t)(maxCount - 1) && "OpenCV persistence doesn't support very long lines");

}

return ptr;

}

#if USE_ZLIB

if( fs->gzfile )

{

char* ptr = gzgets( fs->gzfile, str, maxCount );

if (ptr && maxCount > 256 && !(fs->flags & cv::FileStorage::BASE64))

{

size_t sz = strnlen(ptr, maxCount);

CV_Assert(sz < (size_t)(maxCount - 1) && "OpenCV persistence doesn't support very long lines");

}

return ptr;

}

#endif

CV_Error(CV_StsError, "The storage is not opened");

}

int icvEof( CvFileStorage* fs )

}

void icvCloseFile( CvFileStorage* fs )

}

void icvRewind( CvFileStorage* fs )

}

CvGenericHash* cvCreateMap( int flags, int header_size, int elem_size, CvMemStorage* storage, int start_tab_size )

{

if( header_size < (int)sizeof(CvGenericHash) )

CV_Error( CV_StsBadSize, "Too small map header_size" );

if( start_tab_size <= 0 )

start_tab_size = 16;

CvGenericHash* map = (CvGenericHash*)cvCreateSet( flags, header_size, elem_size, storage );

map->tab_size = start_tab_size;

start_tab_size *= sizeof(map->table[0]);

map->table = (void**)cvMemStorageAlloc( storage, start_tab_size );

memset( map->table, 0, start_tab_size );

return map;

}

void icvParseError( CvFileStorage* fs, const char* func_name,

}

void icvFSCreateCollection( CvFileStorage* fs, int tag, CvFileNode* collection )

}

static char* icvFSDoResize( CvFileStorage* fs, char* ptr, int len )

{

char* new_ptr = 0;

int written_len = (int)(ptr - fs->buffer_start);

int new_size = (int)((fs->buffer_end - fs->buffer_start)*3/2);

new_size = MAX( written_len + len, new_size );

new_ptr = (char*)cvAlloc( new_size + 256 );

fs->buffer = new_ptr + (fs->buffer - fs->buffer_start);

if( written_len > 0 )

memcpy( new_ptr, fs->buffer_start, written_len );

fs->buffer_start = new_ptr;

fs->buffer_end = fs->buffer_start + new_size;

new_ptr += written_len;

return new_ptr;

}

char* icvFSResizeWriteBuffer( CvFileStorage* fs, char* ptr, int len )

{

return ptr + len < fs->buffer_end ? ptr : icvFSDoResize( fs, ptr, len );

}

char* icvFSFlush( CvFileStorage* fs )

{

char* ptr = fs->buffer;

int indent;

if( ptr > fs->buffer_start + fs->space )

{

ptr[0] = '\n';

ptr[1] = '\0';

icvPuts( fs, fs->buffer_start );

fs->buffer = fs->buffer_start;

}

indent = fs->struct_indent;

if( fs->space != indent )

{

memset( fs->buffer_start, ' ', indent );

fs->space = indent;

}

ptr = fs->buffer = fs->buffer_start + fs->space;

return ptr;

}

void icvClose( CvFileStorage* fs, cv::String* out )

}

char* icvDoubleToString( char* buf, double value )

{

Cv64suf val;

unsigned ieee754_hi;

val.f = value;

ieee754_hi = (unsigned)(val.u >> 32);

if( (ieee754_hi & 0x7ff00000) != 0x7ff00000 )

{

int ivalue = cvRound(value);

if( ivalue == value )

sprintf( buf, "%d.", ivalue );

else

{

static const char* fmt = "%.16e";

char* ptr = buf;

sprintf( buf, fmt, value );

if( *ptr == '+' || *ptr == '-' )

ptr++;

for( ; cv_isdigit(*ptr); ptr++ )

;

if( *ptr == ',' )

*ptr = '.';

}

}

else

{

unsigned ieee754_lo = (unsigned)val.u;

if( (ieee754_hi & 0x7fffffff) + (ieee754_lo != 0) > 0x7ff00000 )

strcpy( buf, ".Nan" );

else

strcpy( buf, (int)ieee754_hi < 0 ? "-.Inf" : ".Inf" );

}

return buf;

}

char* icvFloatToString( char* buf, float value )

{

Cv32suf val;

unsigned ieee754;

val.f = value;

ieee754 = val.u;

if( (ieee754 & 0x7f800000) != 0x7f800000 )

{

int ivalue = cvRound(value);

if( ivalue == value )

sprintf( buf, "%d.", ivalue );

else

{

static const char* fmt = "%.8e";

char* ptr = buf;

sprintf( buf, fmt, value );

if( *ptr == '+' || *ptr == '-' )

ptr++;

for( ; cv_isdigit(*ptr); ptr++ )

;

if( *ptr == ',' )

*ptr = '.';

}

}

else

{

if( (ieee754 & 0x7fffffff) != 0x7f800000 )

strcpy( buf, ".Nan" );

else

strcpy( buf, (int)ieee754 < 0 ? "-.Inf" : ".Inf" );

}

return buf;

}

static void icvProcessSpecialDouble( CvFileStorage* fs, char* buf, double* value, char** endptr )

}

double icv_strtod( CvFileStorage* fs, char* ptr, char** endptr )

}

void switch_to_Base64_state( CvFileStorage* fs, base64::fs::State state )

}

void check_if_write_struct_is_delayed( CvFileStorage* fs, bool change_type_to_base64 )

}

void make_write_struct_delayed( CvFileStorage* fs, const char* key, int struct_flags, const char* type_name )

}

static const char symbols[9] = "ucwsifdr";

char icvTypeSymbol(int depth)

}

static int icvSymbolToType(char c)

}

char* icvEncodeFormat( int elem_type, char* dt )

{

sprintf( dt, "%d%c", CV_MAT_CN(elem_type), icvTypeSymbol(CV_MAT_DEPTH(elem_type)) );

return dt + ( dt[2] == '\0' && dt[0] == '1' );

}

int icvDecodeFormat( const char* dt, int* fmt_pairs, int max_len )

}

int icvCalcElemSize( const char* dt, int initial_size )

}

int icvCalcStructSize( const char* dt, int initial_size )

}

int icvDecodeSimpleFormat( const char* dt )

}

void icvWriteCollection( CvFileStorage* fs, const CvFileNode* node )

}

void icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node )

}