vcs.maemo.org Git - opencv/blob - src/cxcore/cxpersistence.cpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                           License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
  15 // Third party copyrights are property of their respective owners.
  16 //
  17 // Redistribution and use in source and binary forms, with or without modification,
  18 // are permitted provided that the following conditions are met:
  19 //
  20 //   * Redistribution's of source code must retain the above copyright notice,
  21 //     this list of conditions and the following disclaimer.
  22 //
  23 //   * Redistribution's in binary form must reproduce the above copyright notice,
  24 //     this list of conditions and the following disclaimer in the documentation
  25 //     and/or other materials provided with the distribution.
  26 //
  27 //   * The name of the copyright holders may not be used to endorse or promote products
  28 //     derived from this software without specific prior written permission.
  29 //
  30 // This software is provided by the copyright holders and contributors "as is" and
  31 // any express or implied warranties, including, but not limited to, the implied
  32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  33 // In no event shall the Intel Corporation or contributors be liable for any direct,
  34 // indirect, incidental, special, exemplary, or consequential damages
  35 // (including, but not limited to, procurement of substitute goods or services;
  36 // loss of use, data, or profits; or business interruption) however caused
  37 // and on any theory of liability, whether in contract, strict liability,
  38 // or tort (including negligence or otherwise) arising in any way out of
  39 // the use of this software, even if advised of the possibility of such damage.
  40 //
  41 //M*/
  42
  43 #include "_cxcore.h"
  44 #include <ctype.h>
  45 #include <wchar.h>
  46 #include <zlib.h>
  47
  48 /****************************************************************************************\
  49 *                            Common macros and type definitions                          *
  50 \****************************************************************************************/
  51
  52 #define cv_isprint(c)     ((signed char)(c) >= (signed char)' ')
  53 #define cv_isprint_or_tab(c)  ((signed char)(c) >= (signed char)' ' || (c) == '\t')
  54
  55 static char* icv_itoa( int _val, char* buffer, int /*radix*/ )
  56 {
  57     const int radix = 10;
  58     char* ptr=buffer + 23 /* enough even for 64-bit integers */;
  59     unsigned val = abs(_val);
  60
  61     *ptr = '\0';
  62     do
  63     {
  64         unsigned r = val / radix;
  65         *--ptr = (char)(val - (r*radix) + '0');
  66         val = r;
  67     }
  68     while( val != 0 );
  69
  70     if( _val < 0 )
  71         *--ptr = '-';
  72
  73     return ptr;
  74 }
  75
  76 cv::string cv::FileStorage::getDefaultObjectName(const string& _filename)
  77 {
  78     static const char* stubname = "unnamed";
  79     const char* filename = _filename.c_str();
  80     const char* ptr2 = filename + _filename.size();
  81     const char* ptr = ptr2 - 1;
  82     cv::AutoBuffer<char> name_buf(_filename.size()+1);
  83
  84     while( ptr >= filename && *ptr != '\\' && *ptr != '/' && *ptr != ':' )
  85     {
  86         if( *ptr == '.' && (!*ptr2 || strncmp(ptr2, ".gz", 3) == 0) )
  87             ptr2 = ptr;
  88         ptr--;
  89     }
  90     ptr++;
  91     if( ptr == ptr2 )
  92         CV_Error( CV_StsBadArg, "Invalid filename" );
  93
  94     char* name = name_buf;
  95
  96     // name must start with letter or '_'
  97     if( !isalpha(*ptr) && *ptr!= '_' ){
  98         *name++ = '_';
  99     }
 100
 101     while( ptr < ptr2 )
 102     {
 103         char c = *ptr++;
 104         if( !isalnum(c) && c != '-' && c != '_' )
 105             c = '_';
 106         *name++ = c;
 107     }
 108     *name = '\0';
 109     name = name_buf;
 110     if( strcmp( name, "_" ) == 0 )
 111         strcpy( name, stubname );
 112     return cv::string(name);
 113 }
 114
 115 namespace cv
 116 {
 117
 118 string fromUtf16(const WString& str)
 119 {
 120     cv::AutoBuffer<char> _buf(str.size()*4 + 1);
 121     char* buf = _buf;
 122
 123     size_t sz = wcstombs(buf, str.c_str(), str.size());
 124     if( sz == (size_t)-1 )
 125         return string();
 126     buf[sz] = '\0';
 127     return string(buf);
 128 }
 129
 130 WString toUtf16(const string& str)
 131 {
 132     cv::AutoBuffer<wchar_t> _buf(str.size() + 1);
 133     wchar_t* buf = _buf;
 134
 135     size_t sz = mbstowcs(buf, str.c_str(), str.size());
 136     if( sz == (size_t)-1 )
 137         return WString();
 138     buf[sz] = '\0';
 139     return WString(buf);
 140 }
 141
 142 }
 143
 144 typedef struct CvGenericHash
 145 {
 146     CV_SET_FIELDS()
 147     int tab_size;
 148     void** table;
 149 }
 150 CvGenericHash;
 151
 152 typedef CvGenericHash CvStringHash;
 153
 154 typedef struct CvFileMapNode
 155 {
 156     CvFileNode value;
 157     const CvStringHashNode* key;
 158     struct CvFileMapNode* next;
 159 }
 160 CvFileMapNode;
 161
 162 typedef struct CvXMLStackRecord
 163 {
 164     CvMemStoragePos pos;
 165     CvString struct_tag;
 166     int struct_indent;
 167     int struct_flags;
 168 }
 169 CvXMLStackRecord;
 170
 171 #define CV_XML_OPENING_TAG 1
 172 #define CV_XML_CLOSING_TAG 2
 173 #define CV_XML_EMPTY_TAG 3
 174 #define CV_XML_HEADER_TAG 4
 175 #define CV_XML_DIRECTIVE_TAG 5
 176
 177 //typedef void (*CvParse)( struct CvFileStorage* fs );
 178 typedef void (*CvStartWriteStruct)( struct CvFileStorage* fs, const char* key,
 179                                     int struct_flags, const char* type_name );
 180 typedef void (*CvEndWriteStruct)( struct CvFileStorage* fs );
 181 typedef void (*CvWriteInt)( struct CvFileStorage* fs, const char* key, int value );
 182 typedef void (*CvWriteReal)( struct CvFileStorage* fs, const char* key, double value );
 183 typedef void (*CvWriteString)( struct CvFileStorage* fs, const char* key,
 184                                const char* value, int quote );
 185 typedef void (*CvWriteComment)( struct CvFileStorage* fs, const char* comment, int eol_comment );
 186 typedef void (*CvStartNextStream)( struct CvFileStorage* fs );
 187
 188 typedef struct CvFileStorage
 189 {
 190     int flags;
 191     int is_xml;
 192     int write_mode;
 193     int is_first;
 194     CvMemStorage* memstorage;
 195     CvMemStorage* dststorage;
 196     CvMemStorage* strstorage;
 197     CvStringHash* str_hash;
 198     CvSeq* roots;
 199     CvSeq* write_stack;
 200     int struct_indent;
 201     int struct_flags;
 202     CvString struct_tag;
 203     int space;
 204     char* filename;
 205     FILE* file;
 206     gzFile gzfile;
 207     char* buffer;
 208     char* buffer_start;
 209     char* buffer_end;
 210     int wrap_margin;
 211     int lineno;
 212     int dummy_eof;
 213     const char* errmsg;
 214     char errmsgbuf[128];
 215
 216     CvStartWriteStruct start_write_struct;
 217     CvEndWriteStruct end_write_struct;
 218     CvWriteInt write_int;
 219     CvWriteReal write_real;
 220     CvWriteString write_string;
 221     CvWriteComment write_comment;
 222     CvStartNextStream start_next_stream;
 223     //CvParse parse;
 224 }
 225 CvFileStorage;
 226
 227 static void icvPuts( CvFileStorage* fs, const char* str )
 228 {
 229     CV_Assert( fs->file || fs->gzfile );
 230     if( fs->file )
 231         fputs( str, fs->file );
 232     else
 233         gzputs( fs->gzfile, str );
 234 }
 235
 236 static char* icvGets( CvFileStorage* fs, char* str, int maxCount )
 237 {
 238     CV_Assert( fs->file || fs->gzfile );
 239     if( fs->file )
 240         return fgets( str, maxCount, fs->file );
 241     return gzgets( fs->gzfile, str, maxCount );
 242 }
 243
 244 static int icvEof( CvFileStorage* fs )
 245 {
 246     CV_Assert( fs->file || fs->gzfile );
 247     if( fs->file )
 248         return feof(fs->file);
 249     return gzeof(fs->gzfile);
 250 }
 251
 252 static void icvClose( CvFileStorage* fs )
 253 {
 254     if( fs->file )
 255         fclose( fs->file );
 256     if( fs->gzfile )
 257         gzclose( fs->gzfile );
 258     fs->file = 0;
 259     fs->gzfile = 0;
 260 }
 261
 262 static void icvRewind( CvFileStorage* fs )
 263 {
 264     CV_Assert( fs->file || fs->gzfile );
 265     if( fs->file )
 266         rewind(fs->file);
 267     else
 268         gzrewind(fs->gzfile);
 269 }
 270
 271 #define CV_YML_INDENT  3
 272 #define CV_XML_INDENT  2
 273 #define CV_YML_INDENT_FLOW  1
 274 #define CV_FS_MAX_LEN 4096
 275
 276 #define CV_FILE_STORAGE ('Y' + ('A' << 8) + ('M' << 16) + ('L' << 24))
 277 #define CV_IS_FILE_STORAGE(fs) ((fs) != 0 && (fs)->flags == CV_FILE_STORAGE)
 278
 279 #define CV_CHECK_FILE_STORAGE(fs)                       \
 280 {                                                       \
 281     if( !CV_IS_FILE_STORAGE(fs) )                       \
 282         CV_Error( (fs) ? CV_StsBadArg : CV_StsNullPtr,  \
 283                   "Invalid pointer to file storage" );  \
 284 }
 285
 286 #define CV_CHECK_OUTPUT_FILE_STORAGE(fs)                \
 287 {                                                       \
 288     CV_CHECK_FILE_STORAGE(fs);                          \
 289     if( !fs->write_mode )                               \
 290         CV_Error( CV_StsError, "The file storage is opened for reading" ); \
 291 }
 292
 293 CV_IMPL const char*
 294 cvAttrValue( const CvAttrList* attr, const char* attr_name )
 295 {
 296     while( attr && attr->attr )
 297     {
 298         int i;
 299         for( i = 0; attr->attr[i*2] != 0; i++ )
 300         {
 301             if( strcmp( attr_name, attr->attr[i*2] ) == 0 )
 302                 return attr->attr[i*2+1];
 303         }
 304         attr = attr->next;
 305     }
 306
 307     return 0;
 308 }
 309
 310
 311 static CvGenericHash*
 312 cvCreateMap( int flags, int header_size, int elem_size,
 313              CvMemStorage* storage, int start_tab_size )
 314 {
 315     if( header_size < (int)sizeof(CvGenericHash) )
 316         CV_Error( CV_StsBadSize, "Too small map header_size" );
 317
 318     if( start_tab_size <= 0 )
 319         start_tab_size = 16;
 320
 321     CvGenericHash* map = (CvGenericHash*)cvCreateSet( flags, header_size, elem_size, storage );
 322
 323     map->tab_size = start_tab_size;
 324     start_tab_size *= sizeof(map->table[0]);
 325     map->table = (void**)cvMemStorageAlloc( storage, start_tab_size );
 326     memset( map->table, 0, start_tab_size );
 327
 328     return map;
 329 }
 330
 331 #ifdef __GNUC__
 332 #define CV_PARSE_ERROR( errmsg )                                    \
 333     icvParseError( fs, __func__, (errmsg), __FILE__, __LINE__ )
 334 #else
 335 #define CV_PARSE_ERROR( errmsg )                                    \
 336     icvParseError( fs, "", (errmsg), __FILE__, __LINE__ )
 337 #endif
 338
 339 static void
 340 icvParseError( CvFileStorage* fs, const char* func_name,
 341                const char* err_msg, const char* source_file, int source_line )
 342 {
 343     char buf[1<<10];
 344     sprintf( buf, "%s(%d): %s", fs->filename, fs->lineno, err_msg );
 345     cvError( CV_StsParseError, func_name, buf, source_file, source_line );
 346 }
 347
 348
 349 static void
 350 icvFSCreateCollection( CvFileStorage* fs, int tag, CvFileNode* collection )
 351 {
 352     if( CV_NODE_IS_MAP(tag) )
 353     {
 354         if( collection->tag != CV_NODE_NONE )
 355         {
 356             assert( fs->is_xml != 0 );
 357             CV_PARSE_ERROR( "Sequence element should not have name (use <_></_>)" );
 358         }
 359
 360         collection->data.map = cvCreateMap( 0, sizeof(CvFileNodeHash),
 361                             sizeof(CvFileMapNode), fs->memstorage, 16 );
 362     }
 363     else
 364     {
 365         CvSeq* seq;
 366         seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvFileNode), fs->memstorage );
 367
 368         // if <collection> contains some scalar element, add it to the newly created collection
 369         if( CV_NODE_TYPE(collection->tag) != CV_NODE_NONE )
 370             cvSeqPush( seq, collection );
 371
 372         collection->data.seq = seq;
 373     }
 374
 375     collection->tag = tag;
 376     cvSetSeqBlockSize( collection->data.seq, 8 );
 377 }
 378
 379
 380 /*static void
 381 icvFSReleaseCollection( CvSeq* seq )
 382 {
 383     if( seq )
 384     {
 385         int is_map = CV_IS_SET(seq);
 386         CvSeqReader reader;
 387         int i, total = seq->total;
 388         cvStartReadSeq( seq, &reader, 0 );
 389
 390         for( i = 0; i < total; i++ )
 391         {
 392             CvFileNode* node = (CvFileNode*)reader.ptr;
 393
 394             if( (!is_map || CV_IS_SET_ELEM( node )) && CV_NODE_IS_COLLECTION(node->tag) )
 395             {
 396                 if( CV_NODE_IS_USER(node->tag) && node->info && node->data.obj.decoded )
 397                     cvRelease( (void**)&node->data.obj.decoded );
 398                 if( !CV_NODE_SEQ_IS_SIMPLE( node->data.seq ))
 399                     icvFSReleaseCollection( node->data.seq );
 400             }
 401             CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
 402         }
 403     }
 404 }*/
 405
 406
 407 static char*
 408 icvFSDoResize( CvFileStorage* fs, char* ptr, int len )
 409 {
 410     char* new_ptr = 0;
 411     int written_len = (int)(ptr - fs->buffer_start);
 412     int new_size = (int)((fs->buffer_end - fs->buffer_start)*3/2);
 413     new_size = MAX( written_len + len, new_size );
 414     new_ptr = (char*)cvAlloc( new_size + 256 );
 415     fs->buffer = new_ptr + (fs->buffer - fs->buffer_start);
 416     if( written_len > 0 )
 417         memcpy( new_ptr, fs->buffer_start, written_len );
 418     fs->buffer_start = new_ptr;
 419     fs->buffer_end = fs->buffer_start + new_size;
 420     new_ptr += written_len;
 421     return new_ptr;
 422 }
 423
 424
 425 inline char* icvFSResizeWriteBuffer( CvFileStorage* fs, char* ptr, int len )
 426 {
 427     return ptr + len < fs->buffer_end ? ptr : icvFSDoResize( fs, ptr, len );
 428 }
 429
 430
 431 static char*
 432 icvFSFlush( CvFileStorage* fs )
 433 {
 434     char* ptr = fs->buffer;
 435     int indent;
 436
 437     if( ptr > fs->buffer_start + fs->space )
 438     {
 439         ptr[0] = '\n';
 440         ptr[1] = '\0';
 441         icvPuts( fs, fs->buffer_start );
 442         fs->buffer = fs->buffer_start;
 443     }
 444
 445     indent = fs->struct_indent;
 446
 447     if( fs->space != indent )
 448     {
 449         if( fs->space < indent )
 450             memset( fs->buffer_start + fs->space, ' ', indent - fs->space );
 451         fs->space = indent;
 452     }
 453
 454     ptr = fs->buffer = fs->buffer_start + fs->space;
 455
 456     return ptr;
 457 }
 458
 459
 460 /* closes file storage and deallocates buffers */
 461 CV_IMPL  void
 462 cvReleaseFileStorage( CvFileStorage** p_fs )
 463 {
 464     if( !p_fs )
 465         CV_Error( CV_StsNullPtr, "NULL double pointer to file storage" );
 466
 467     if( *p_fs )
 468     {
 469         CvFileStorage* fs = *p_fs;
 470         *p_fs = 0;
 471
 472         if( fs->write_mode && (fs->file || fs->gzfile) )
 473         {
 474             if( fs->write_stack )
 475             {
 476                 while( fs->write_stack->total > 0 )
 477                     cvEndWriteStruct(fs);
 478             }
 479             icvFSFlush(fs);
 480             if( fs->is_xml )
 481                 icvPuts( fs, "</opencv_storage>\n" );
 482         }
 483
 484         //icvFSReleaseCollection( fs->roots ); // delete all the user types recursively
 485
 486         icvClose(fs);
 487
 488         cvReleaseMemStorage( &fs->strstorage );
 489
 490         cvFree( &fs->buffer_start );
 491         cvReleaseMemStorage( &fs->memstorage );
 492
 493         memset( fs, 0, sizeof(*fs) );
 494         cvFree( &fs );
 495     }
 496 }
 497
 498
 499 #define CV_HASHVAL_SCALE 33
 500
 501 CV_IMPL CvStringHashNode*
 502 cvGetHashedKey( CvFileStorage* fs, const char* str, int len, int create_missing )
 503 {
 504     CvStringHashNode* node = 0;
 505     unsigned hashval = 0;
 506     int i, tab_size;
 507     CvStringHash* map = fs->str_hash;
 508
 509     if( !fs )
 510         return 0;
 511
 512     if( len < 0 )
 513     {
 514         for( i = 0; str[i] != '\0'; i++ )
 515             hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
 516         len = i;
 517     }
 518     else for( i = 0; i < len; i++ )
 519         hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
 520
 521     hashval &= INT_MAX;
 522     tab_size = map->tab_size;
 523     if( (tab_size & (tab_size - 1)) == 0 )
 524         i = (int)(hashval & (tab_size - 1));
 525     else
 526         i = (int)(hashval % tab_size);
 527
 528     for( node = (CvStringHashNode*)(map->table[i]); node != 0; node = node->next )
 529     {
 530         if( node->hashval == hashval &&
 531             node->str.len == len &&
 532             memcmp( node->str.ptr, str, len ) == 0 )
 533             break;
 534     }
 535
 536     if( !node && create_missing )
 537     {
 538         node = (CvStringHashNode*)cvSetNew( (CvSet*)map );
 539         node->hashval = hashval;
 540         node->str = cvMemStorageAllocString( map->storage, str, len );
 541         node->next = (CvStringHashNode*)(map->table[i]);
 542         map->table[i] = node;
 543     }
 544
 545     return node;
 546 }
 547
 548
 549 CV_IMPL CvFileNode*
 550 cvGetFileNode( CvFileStorage* fs, CvFileNode* _map_node,
 551                const CvStringHashNode* key,
 552                int create_missing )
 553 {
 554     CvFileNode* value = 0;
 555     int k = 0, attempts = 1;
 556
 557     if( !fs )
 558         return 0;
 559
 560     CV_CHECK_FILE_STORAGE(fs);
 561
 562     if( !key )
 563         CV_Error( CV_StsNullPtr, "Null key element" );
 564
 565     if( _map_node )
 566     {
 567         if( !fs->roots )
 568             return 0;
 569         attempts = fs->roots->total;
 570     }
 571
 572     for( k = 0; k < attempts; k++ )
 573     {
 574         int i, tab_size;
 575         CvFileNode* map_node = _map_node;
 576         CvFileMapNode* another;
 577         CvFileNodeHash* map;
 578
 579         if( !map_node )
 580             map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
 581
 582         if( !CV_NODE_IS_MAP(map_node->tag) )
 583         {
 584             if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
 585                 CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
 586                 CV_Error( CV_StsError, "The node is neither a map nor an empty collection" );
 587             return 0;
 588         }
 589
 590         map = map_node->data.map;
 591         tab_size = map->tab_size;
 592
 593         if( (tab_size & (tab_size - 1)) == 0 )
 594             i = (int)(key->hashval & (tab_size - 1));
 595         else
 596             i = (int)(key->hashval % tab_size);
 597
 598         for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
 599             if( another->key == key )
 600             {
 601                 if( !create_missing )
 602                 {
 603                     value = &another->value;
 604                     return value;
 605                 }
 606                 CV_PARSE_ERROR( "Duplicated key" );
 607             }
 608
 609         if( k == attempts - 1 && create_missing )
 610         {
 611             CvFileMapNode* node = (CvFileMapNode*)cvSetNew( (CvSet*)map );
 612             node->key = key;
 613
 614             node->next = (CvFileMapNode*)(map->table[i]);
 615             map->table[i] = node;
 616             value = (CvFileNode*)node;
 617         }
 618     }
 619
 620     return value;
 621 }
 622
 623
 624 CV_IMPL CvFileNode*
 625 cvGetFileNodeByName( const CvFileStorage* fs, const CvFileNode* _map_node, const char* str )
 626 {
 627     CvFileNode* value = 0;
 628     int i, len, tab_size;
 629     unsigned hashval = 0;
 630     int k = 0, attempts = 1;
 631
 632     if( !fs )
 633         return 0;
 634
 635     CV_CHECK_FILE_STORAGE(fs);
 636
 637     if( !str )
 638         CV_Error( CV_StsNullPtr, "Null element name" );
 639
 640     for( i = 0; str[i] != '\0'; i++ )
 641         hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
 642     hashval &= INT_MAX;
 643     len = i;
 644
 645     if( !_map_node )
 646     {
 647         if( !fs->roots )
 648             return 0;
 649         attempts = fs->roots->total;
 650     }
 651
 652     for( k = 0; k < attempts; k++ )
 653     {
 654         CvFileNodeHash* map;
 655         const CvFileNode* map_node = _map_node;
 656         CvFileMapNode* another;
 657
 658         if( !map_node )
 659             map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
 660
 661         if( !CV_NODE_IS_MAP(map_node->tag) )
 662         {
 663             if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
 664                 CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
 665                 CV_Error( CV_StsError, "The node is neither a map nor an empty collection" );
 666             return 0;
 667         }
 668
 669         map = map_node->data.map;
 670         tab_size = map->tab_size;
 671
 672         if( (tab_size & (tab_size - 1)) == 0 )
 673             i = (int)(hashval & (tab_size - 1));
 674         else
 675             i = (int)(hashval % tab_size);
 676
 677         for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
 678         {
 679             const CvStringHashNode* key = another->key;
 680
 681             if( key->hashval == hashval &&
 682                 key->str.len == len &&
 683                 memcmp( key->str.ptr, str, len ) == 0 )
 684             {
 685                 value = &another->value;
 686                 return value;
 687             }
 688         }
 689     }
 690
 691     return value;
 692 }
 693
 694
 695 CV_IMPL CvFileNode*
 696 cvGetRootFileNode( const CvFileStorage* fs, int stream_index )
 697 {
 698     CV_CHECK_FILE_STORAGE(fs);
 699
 700     if( !fs->roots || (unsigned)stream_index >= (unsigned)fs->roots->total )
 701         return 0;
 702
 703     return (CvFileNode*)cvGetSeqElem( fs->roots, stream_index );
 704 }
 705
 706
 707 /* returns the sequence element by its index */
 708 /*CV_IMPL CvFileNode*
 709 cvGetFileNodeFromSeq( CvFileStorage* fs,
 710                       CvFileNode* seq_node, int index )
 711 {
 712     CvFileNode* value = 0;
 713     CvSeq* seq;
 714
 715     if( !seq_node )
 716         seq = fs->roots;
 717     else if( !CV_NODE_IS_SEQ(seq_node->tag) )
 718     {
 719         if( CV_NODE_IS_MAP(seq_node->tag) )
 720             CV_Error( CV_StsError, "The node is map. Use cvGetFileNodeFromMap()." );
 721         if( CV_NODE_TYPE(seq_node->tag) == CV_NODE_NONE )
 722             CV_Error( CV_StsError, "The node is an empty object (None)." );
 723         if( index != 0 && index != -1 )
 724             CV_Error( CV_StsOutOfRange, "" );
 725         value = seq_node;
 726         EXIT;
 727     }
 728     else
 729         seq = seq_node->data.seq;
 730
 731     if( !seq )
 732         CV_Error( CV_StsNullPtr, "The file storage is empty" );
 733
 734     value = (CvFileNode*)cvGetSeqElem( seq, index, 0 );
 735
 736
 737
 738     return value;
 739 }*/
 740
 741
 742 static char*
 743 icvDoubleToString( char* buf, double value )
 744 {
 745     Cv64suf val;
 746     unsigned ieee754_hi;
 747
 748     val.f = value;
 749     ieee754_hi = (unsigned)(val.u >> 32);
 750
 751     if( (ieee754_hi & 0x7ff00000) != 0x7ff00000 )
 752     {
 753         int ivalue = cvRound(value);
 754         if( ivalue == value )
 755             sprintf( buf, "%d.", ivalue );
 756         else
 757         {
 758             static const char* fmt[] = {"%.16e", "%.16f"};
 759             double avalue = fabs(value);
 760             char* ptr = buf;
 761             sprintf( buf, fmt[0.01 <= avalue && avalue < 1000], value );
 762             if( *ptr == '+' || *ptr == '-' )
 763                 ptr++;
 764             for( ; isdigit(*ptr); ptr++ )
 765                 ;
 766             if( *ptr == ',' )
 767                 *ptr = '.';
 768         }
 769     }
 770     else
 771     {
 772         unsigned ieee754_lo = (unsigned)val.u;
 773         if( (ieee754_hi & 0x7fffffff) + (ieee754_lo != 0) > 0x7ff00000 )
 774             strcpy( buf, ".Nan" );
 775         else
 776             strcpy( buf, (int)ieee754_hi < 0 ? "-.Inf" : ".Inf" );
 777     }
 778
 779     return buf;
 780 }
 781
 782
 783 static char*
 784 icvFloatToString( char* buf, float value )
 785 {
 786     Cv32suf val;
 787     unsigned ieee754;
 788     val.f = value;
 789     ieee754 = val.u;
 790
 791     if( (ieee754 & 0x7f800000) != 0x7f800000 )
 792     {
 793         int ivalue = cvRound(value);
 794         if( ivalue == value )
 795             sprintf( buf, "%d.", ivalue );
 796         else
 797         {
 798             static const char* fmt[] = {"%.8e", "%.8f"};
 799             double avalue = fabs((double)value);
 800             char* ptr = buf;
 801             sprintf( buf, fmt[0.01 <= avalue && avalue < 1000], value );
 802             if( *ptr == '+' || *ptr == '-' )
 803                 ptr++;
 804             for( ; isdigit(*ptr); ptr++ )
 805                 ;
 806             if( *ptr == ',' )
 807                 *ptr = '.';
 808         }
 809     }
 810     else
 811     {
 812         if( (ieee754 & 0x7fffffff) != 0x7f800000 )
 813             strcpy( buf, ".Nan" );
 814         else
 815             strcpy( buf, (int)ieee754 < 0 ? "-.Inf" : ".Inf" );
 816     }
 817
 818     return buf;
 819 }
 820
 821
 822 static void
 823 icvProcessSpecialDouble( CvFileStorage* fs, char* buf, double* value, char** endptr )
 824 {
 825     char c = buf[0];
 826     int inf_hi = 0x7ff00000;
 827
 828     if( c == '-' || c == '+' )
 829     {
 830         inf_hi = c == '-' ? 0xfff00000 : 0x7ff00000;
 831         c = *++buf;
 832     }
 833
 834     if( c != '.' )
 835         CV_PARSE_ERROR( "Bad format of floating-point constant" );
 836
 837     if( toupper(buf[1]) == 'I' && toupper(buf[2]) == 'N' && toupper(buf[3]) == 'F' )
 838         *(uint64*)value = ((uint64)inf_hi << 32);
 839     else if( toupper(buf[1]) == 'N' && toupper(buf[2]) == 'A' && toupper(buf[3]) == 'N' )
 840         *(uint64*)value = (uint64)-1;
 841     else
 842         CV_PARSE_ERROR( "Bad format of floating-point constant" );
 843
 844     *endptr = buf + 4;
 845 }
 846
 847
 848 static double icv_strtod( CvFileStorage* fs, char* ptr, char** endptr )
 849 {
 850     double fval = strtod( ptr, endptr );
 851     if( **endptr == '.' )
 852     {
 853         char* dot_pos = *endptr;
 854         *dot_pos = ',';
 855         double fval2 = strtod( ptr, endptr );
 856         *dot_pos = '.';
 857         if( *endptr > dot_pos )
 858             fval = fval2;
 859         else
 860             *endptr = dot_pos;
 861     }
 862
 863     if( *endptr == ptr || isalpha(**endptr) )
 864         icvProcessSpecialDouble( fs, ptr, &fval, endptr );
 865
 866     return fval;
 867 }
 868
 869
 870 /****************************************************************************************\
 871 *                                       YAML Parser                                      *
 872 \****************************************************************************************/
 873
 874 static char*
 875 icvYMLSkipSpaces( CvFileStorage* fs, char* ptr, int min_indent, int max_comment_indent )
 876 {
 877     for(;;)
 878     {
 879         while( *ptr == ' ' )
 880             ptr++;
 881         if( *ptr == '#' )
 882         {
 883             if( ptr - fs->buffer_start > max_comment_indent )
 884                 return ptr;
 885             *ptr = '\0';
 886         }
 887         else if( cv_isprint(*ptr) )
 888         {
 889             if( ptr - fs->buffer_start < min_indent )
 890                 CV_PARSE_ERROR( "Incorrect indentation" );
 891             break;
 892         }
 893         else if( *ptr == '\0' || *ptr == '\n' || *ptr == '\r' )
 894         {
 895             int max_size = (int)(fs->buffer_end - fs->buffer_start);
 896             ptr = icvGets( fs, fs->buffer_start, max_size );
 897             if( !ptr )
 898             {
 899                 // emulate end of stream
 900                 ptr = fs->buffer_start;
 901                 ptr[0] = ptr[1] = ptr[2] = '.';
 902                 ptr[3] = '\0';
 903                 fs->dummy_eof = 1;
 904                 break;
 905             }
 906             else
 907             {
 908                 int l = (int)strlen(ptr);
 909                 if( ptr[l-1] != '\n' && ptr[l-1] != '\r' && !icvEof(fs) )
 910                     CV_PARSE_ERROR( "Too long string or a last string w/o newline" );
 911             }
 912
 913             fs->lineno++;
 914         }
 915         else
 916             CV_PARSE_ERROR( *ptr == '\t' ? "Tabs are prohibited in YAML!" : "Invalid character" );
 917     }
 918
 919     return ptr;
 920 }
 921
 922
 923 static char*
 924 icvYMLParseKey( CvFileStorage* fs, char* ptr,
 925                 CvFileNode* map_node, CvFileNode** value_placeholder )
 926 {
 927     char c;
 928     char *endptr = ptr - 1, *saveptr;
 929     CvStringHashNode* str_hash_node;
 930
 931     if( *ptr == '-' )
 932         CV_PARSE_ERROR( "Key may not start with \'-\'" );
 933
 934     do c = *++endptr;
 935     while( cv_isprint(c) && c != ':' );
 936
 937     if( c != ':' )
 938         CV_PARSE_ERROR( "Missing \':\'" );
 939
 940     saveptr = endptr + 1;
 941     do c = *--endptr;
 942     while( c == ' ' );
 943
 944     ++endptr;
 945     if( endptr == ptr )
 946         CV_PARSE_ERROR( "An empty key" );
 947
 948     str_hash_node = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 );
 949     *value_placeholder = cvGetFileNode( fs, map_node, str_hash_node, 1 );
 950     ptr = saveptr;
 951
 952     return ptr;
 953 }
 954
 955
 956 static char*
 957 icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
 958                   int parent_flags, int min_indent )
 959 {
 960     char buf[CV_FS_MAX_LEN + 1024];
 961     char* endptr = 0;
 962     char c = ptr[0], d = ptr[1];
 963     int is_parent_flow = CV_NODE_IS_FLOW(parent_flags);
 964     int value_type = CV_NODE_NONE;
 965     int len;
 966
 967     memset( node, 0, sizeof(*node) );
 968
 969     if( c == '!' ) // handle explicit type specification
 970     {
 971         if( d == '!' || d == '^' )
 972         {
 973             ptr++;
 974             value_type |= CV_NODE_USER;
 975         }
 976
 977         endptr = ptr++;
 978         do d = *++endptr;
 979         while( cv_isprint(d) && d != ' ' );
 980         len = (int)(endptr - ptr);
 981         if( len == 0 )
 982             CV_PARSE_ERROR( "Empty type name" );
 983         d = *endptr;
 984         *endptr = '\0';
 985
 986         if( len == 3 && !CV_NODE_IS_USER(value_type) )
 987         {
 988             if( memcmp( ptr, "str", 3 ) == 0 )
 989                 value_type = CV_NODE_STRING;
 990             else if( memcmp( ptr, "int", 3 ) == 0 )
 991                 value_type = CV_NODE_INT;
 992             else if( memcmp( ptr, "seq", 3 ) == 0 )
 993                 value_type = CV_NODE_SEQ;
 994             else if( memcmp( ptr, "map", 3 ) == 0 )
 995                 value_type = CV_NODE_MAP;
 996         }
 997         else if( len == 5 && !CV_NODE_IS_USER(value_type) )
 998         {
 999             if( memcmp( ptr, "float", 5 ) == 0 )
1000                 value_type = CV_NODE_REAL;
1001         }
1002         else if( CV_NODE_IS_USER(value_type) )
1003         {
1004             node->info = cvFindType( ptr );
1005             if( !node->info )
1006                 node->tag &= ~CV_NODE_USER;
1007         }
1008
1009         *endptr = d;
1010         ptr = icvYMLSkipSpaces( fs, endptr, min_indent, INT_MAX );
1011
1012         c = *ptr;
1013
1014         if( !CV_NODE_IS_USER(value_type) )
1015         {
1016             if( value_type == CV_NODE_STRING && c != '\'' && c != '\"' )
1017                 goto force_string;
1018             if( value_type == CV_NODE_INT )
1019                 goto force_int;
1020             if( value_type == CV_NODE_REAL )
1021                 goto force_real;
1022         }
1023     }
1024
1025     if( isdigit(c) ||
1026         ((c == '-' || c == '+') && (isdigit(d) || d == '.')) ||
1027         (c == '.' && isalnum(d))) // a number
1028     {
1029         double fval;
1030         int ival;
1031         endptr = ptr + (c == '-' || c == '+');
1032         while( isdigit(*endptr) )
1033             endptr++;
1034         if( *endptr == '.' || *endptr == 'e' )
1035         {
1036 force_real:
1037             fval = icv_strtod( fs, ptr, &endptr );
1038             /*if( endptr == ptr || isalpha(*endptr) )
1039                 icvProcessSpecialDouble( fs, endptr, &fval, &endptr ));*/
1040
1041             node->tag = CV_NODE_REAL;
1042             node->data.f = fval;
1043         }
1044         else
1045         {
1046 force_int:
1047             ival = (int)strtol( ptr, &endptr, 0 );
1048             node->tag = CV_NODE_INT;
1049             node->data.i = ival;
1050         }
1051
1052         if( !endptr || endptr == ptr )
1053             CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" );
1054
1055         ptr = endptr;
1056     }
1057     else if( c == '\'' || c == '\"' ) // an explicit string
1058     {
1059         node->tag = CV_NODE_STRING;
1060         if( c == '\'' )
1061             for( len = 0; len < CV_FS_MAX_LEN; )
1062             {
1063                 c = *++ptr;
1064                 if( isalnum(c) || (c != '\'' && cv_isprint(c)))
1065                     buf[len++] = c;
1066                 else if( c == '\'' )
1067                 {
1068                     c = *++ptr;
1069                     if( c != '\'' )
1070                         break;
1071                     buf[len++] = c;
1072                 }
1073                 else
1074                     CV_PARSE_ERROR( "Invalid character" );
1075             }
1076         else
1077             for( len = 0; len < CV_FS_MAX_LEN; )
1078             {
1079                 c = *++ptr;
1080                 if( isalnum(c) || (c != '\\' && c != '\"' && cv_isprint(c)))
1081                     buf[len++] = c;
1082                 else if( c == '\"' )
1083                 {
1084                     ++ptr;
1085                     break;
1086                 }
1087                 else if( c == '\\' )
1088                 {
1089                     d = *++ptr;
1090                     if( d == '\'' )
1091                         buf[len++] = d;
1092                     else if( d == '\"' || d == '\\' || d == '\'' )
1093                         buf[len++] = d;
1094                     else if( d == 'n' )
1095                         buf[len++] = '\n';
1096                     else if( d == 'r' )
1097                         buf[len++] = '\r';
1098                     else if( d == 't' )
1099                         buf[len++] = '\t';
1100                     else if( d == 'x' || (isdigit(d) && d < '8') )
1101                     {
1102                         int val, is_hex = d == 'x';
1103                         c = ptr[3];
1104                         ptr[3] = '\0';
1105                         val = strtol( ptr + is_hex, &endptr, is_hex ? 8 : 16 );
1106                         ptr[3] = c;
1107                         if( endptr == ptr + is_hex )
1108                             buf[len++] = 'x';
1109                         else
1110                         {
1111                             buf[len++] = (char)val;
1112                             ptr = endptr;
1113                         }
1114                     }
1115                 }
1116                 else
1117                     CV_PARSE_ERROR( "Invalid character" );
1118             }
1119
1120         if( len >= CV_FS_MAX_LEN )
1121             CV_PARSE_ERROR( "Too long string literal" );
1122
1123         node->data.str = cvMemStorageAllocString( fs->memstorage, buf, len );
1124     }
1125     else if( c == '[' || c == '{' ) // collection as a flow
1126     {
1127         int new_min_indent = min_indent + !is_parent_flow;
1128         int struct_flags = CV_NODE_FLOW + (c == '{' ? CV_NODE_MAP : CV_NODE_SEQ);
1129         int is_simple = 1;
1130
1131         icvFSCreateCollection( fs, CV_NODE_TYPE(struct_flags) +
1132                                         (node->info ? CV_NODE_USER : 0), node );
1133
1134         d = c == '[' ? ']' : '}';
1135
1136         for( ++ptr ;;)
1137         {
1138             CvFileNode* elem = 0;
1139
1140             ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX );
1141             if( *ptr == '}' || *ptr == ']' )
1142             {
1143                 if( *ptr != d )
1144                     CV_PARSE_ERROR( "The wrong closing bracket" );
1145                 ptr++;
1146                 break;
1147             }
1148
1149             if( node->data.seq->total != 0 )
1150             {
1151                 if( *ptr != ',' )
1152                     CV_PARSE_ERROR( "Missing , between the elements" );
1153                 ptr = icvYMLSkipSpaces( fs, ptr + 1, new_min_indent, INT_MAX );
1154             }
1155
1156             if( CV_NODE_IS_MAP(struct_flags) )
1157             {
1158                 ptr = icvYMLParseKey( fs, ptr, node, &elem );
1159                 ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX );
1160             }
1161             else
1162             {
1163                 if( *ptr == ']' )
1164                     break;
1165                 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1166             }
1167             ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, new_min_indent );
1168             if( CV_NODE_IS_MAP(struct_flags) )
1169                 elem->tag |= CV_NODE_NAMED;
1170             is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
1171         }
1172         node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
1173     }
1174     else
1175     {
1176         int indent, struct_flags, is_simple;
1177
1178         if( is_parent_flow || c != '-' )
1179         {
1180             // implicit (one-line) string or nested block-style collection
1181             if( !is_parent_flow )
1182             {
1183                 if( c == '?' )
1184                     CV_PARSE_ERROR( "Complex keys are not supported" );
1185                 if( c == '|' || c == '>' )
1186                     CV_PARSE_ERROR( "Multi-line text literals are not supported" );
1187             }
1188
1189 force_string:
1190             endptr = ptr - 1;
1191
1192             do c = *++endptr;
1193             while( cv_isprint(c) &&
1194                    (!is_parent_flow || (c != ',' && c != '}' && c != ']')) &&
1195                    (is_parent_flow || c != ':' || value_type == CV_NODE_STRING));
1196
1197             if( endptr == ptr )
1198                 CV_PARSE_ERROR( "Invalid character" );
1199
1200             if( is_parent_flow || c != ':' )
1201             {
1202                 char* str_end = endptr;
1203                 node->tag = CV_NODE_STRING;
1204                 // strip spaces in the end of string
1205                 do c = *--str_end;
1206                 while( str_end > ptr && c == ' ' );
1207                 str_end++;
1208                 node->data.str = cvMemStorageAllocString( fs->memstorage, ptr, (int)(str_end - ptr) );
1209                 ptr = endptr;
1210                 return ptr;
1211             }
1212             struct_flags = CV_NODE_MAP;
1213         }
1214         else
1215             struct_flags = CV_NODE_SEQ;
1216
1217         icvFSCreateCollection( fs, struct_flags +
1218                     (node->info ? CV_NODE_USER : 0), node );
1219
1220         indent = (int)(ptr - fs->buffer_start);
1221         is_simple = 1;
1222
1223         for(;;)
1224         {
1225             CvFileNode* elem = 0;
1226
1227             if( CV_NODE_IS_MAP(struct_flags) )
1228             {
1229                 ptr = icvYMLParseKey( fs, ptr, node, &elem );
1230             }
1231             else
1232             {
1233                 c = *ptr++;
1234                 if( c != '-' )
1235                     CV_PARSE_ERROR( "Block sequence elements must be preceded with \'-\'" );
1236
1237                 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1238             }
1239
1240             ptr = icvYMLSkipSpaces( fs, ptr, indent + 1, INT_MAX );
1241             ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, indent + 1 );
1242             if( CV_NODE_IS_MAP(struct_flags) )
1243                 elem->tag |= CV_NODE_NAMED;
1244             is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
1245
1246             ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX );
1247             if( ptr - fs->buffer_start != indent )
1248             {
1249                 if( ptr - fs->buffer_start < indent )
1250                     break;
1251                 else
1252                     CV_PARSE_ERROR( "Incorrect indentation" );
1253             }
1254             if( memcmp( ptr, "...", 3 ) == 0 )
1255                 break;
1256         }
1257
1258         node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
1259     }
1260
1261     return ptr;
1262 }
1263
1264
1265 static void
1266 icvYMLParse( CvFileStorage* fs )
1267 {
1268     char* ptr = fs->buffer_start;
1269     int is_first = 1;
1270
1271     for(;;)
1272     {
1273         // 0. skip leading comments and directives  and ...
1274         // 1. reach the first item
1275         for(;;)
1276         {
1277             ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX );
1278             if( !ptr )
1279                 return;
1280
1281             if( *ptr == '%' )
1282             {
1283                 if( memcmp( ptr, "%YAML:", 6 ) == 0 &&
1284                     memcmp( ptr, "%YAML:1.", 8 ) != 0 )
1285                     CV_PARSE_ERROR( "Unsupported YAML version (it must be 1.x)" );
1286                 *ptr = '\0';
1287             }
1288             else if( *ptr == '-' )
1289             {
1290                 if( memcmp(ptr, "---", 3) == 0 )
1291                 {
1292                     ptr += 3;
1293                     break;
1294                 }
1295                 else if( is_first )
1296                     break;
1297             }
1298             else if( isalnum(*ptr) || *ptr=='_')
1299             {
1300                 if( !is_first )
1301                     CV_PARSE_ERROR( "The YAML streams must start with '---', except the first one" );
1302                 break;
1303             }
1304             else
1305                 CV_PARSE_ERROR( "Invalid or unsupported syntax" );
1306         }
1307
1308         ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX );
1309         if( memcmp( ptr, "...", 3 ) != 0 )
1310         {
1311             // 2. parse the collection
1312             CvFileNode* root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 );
1313
1314             ptr = icvYMLParseValue( fs, ptr, root_node, CV_NODE_NONE, 0 );
1315             if( !CV_NODE_IS_COLLECTION(root_node->tag) )
1316                 CV_PARSE_ERROR( "Only collections as YAML streams are supported by this parser" );
1317
1318             // 3. parse until the end of file or next collection
1319             ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX );
1320             if( !ptr )
1321                 return;
1322         }
1323
1324         if( fs->dummy_eof )
1325             break;
1326         ptr += 3;
1327         is_first = 0;
1328     }
1329 }
1330
1331
1332 /****************************************************************************************\
1333 *                                       YAML Emitter                                     *
1334 \****************************************************************************************/
1335
1336 static void
1337 icvYMLWrite( CvFileStorage* fs, const char* key, const char* data )
1338 {
1339     int i, keylen = 0;
1340     int datalen = 0;
1341     int struct_flags;
1342     char* ptr;
1343
1344     struct_flags = fs->struct_flags;
1345
1346     if( key && key[0] == '\0' )
1347         key = 0;
1348
1349     if( CV_NODE_IS_COLLECTION(struct_flags) )
1350     {
1351         if( (CV_NODE_IS_MAP(struct_flags) ^ (key != 0)) )
1352             CV_Error( CV_StsBadArg, "An attempt to add element without a key to a map, "
1353                                     "or add element with key to sequence" );
1354     }
1355     else
1356     {
1357         fs->is_first = 0;
1358         struct_flags = CV_NODE_EMPTY | (key ? CV_NODE_MAP : CV_NODE_SEQ);
1359     }
1360
1361     if( key )
1362     {
1363         keylen = (int)strlen(key);
1364         if( keylen == 0 )
1365             CV_Error( CV_StsBadArg, "The key is an empty" );
1366
1367         if( keylen > CV_FS_MAX_LEN )
1368             CV_Error( CV_StsBadArg, "The key is too long" );
1369     }
1370
1371     if( data )
1372         datalen = (int)strlen(data);
1373
1374     if( CV_NODE_IS_FLOW(struct_flags) )
1375     {
1376         int new_offset;
1377         ptr = fs->buffer;
1378         if( !CV_NODE_IS_EMPTY(struct_flags) )
1379             *ptr++ = ',';
1380         new_offset = (int)(ptr - fs->buffer_start) + keylen + datalen;
1381         if( new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10 )
1382         {
1383             fs->buffer = ptr;
1384             ptr = icvFSFlush(fs);
1385         }
1386         else
1387             *ptr++ = ' ';
1388     }
1389     else
1390     {
1391         ptr = icvFSFlush(fs);
1392         if( !CV_NODE_IS_MAP(struct_flags) )
1393         {
1394             *ptr++ = '-';
1395             if( data )
1396                 *ptr++ = ' ';
1397         }
1398     }
1399
1400     if( key )
1401     {
1402         if( !isalpha(key[0]) && key[0] != '_' )
1403             CV_Error( CV_StsBadArg, "Key must start with a letter or _" );
1404
1405         ptr = icvFSResizeWriteBuffer( fs, ptr, keylen );
1406
1407         for( i = 0; i < keylen; i++ )
1408         {
1409             int c = key[i];
1410
1411             ptr[i] = (char)c;
1412             if( !isalnum(c) && c != '-' && c != '_' && c != ' ' )
1413                 CV_Error( CV_StsBadArg, "Key names may only contain alphanumeric characters [a-zA-Z0-9], '-', '_' and ' '" );
1414         }
1415
1416         ptr += keylen;
1417         *ptr++ = ':';
1418         if( !CV_NODE_IS_FLOW(struct_flags) && data )
1419             *ptr++ = ' ';
1420     }
1421
1422     if( data )
1423     {
1424         ptr = icvFSResizeWriteBuffer( fs, ptr, datalen );
1425         memcpy( ptr, data, datalen );
1426         ptr += datalen;
1427     }
1428
1429     fs->buffer = ptr;
1430     fs->struct_flags = struct_flags & ~CV_NODE_EMPTY;
1431 }
1432
1433
1434 static void
1435 icvYMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
1436                         const char* type_name CV_DEFAULT(0))
1437 {
1438     int parent_flags;
1439     char buf[CV_FS_MAX_LEN + 1024];
1440     const char* data = 0;
1441
1442     struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY;
1443     if( !CV_NODE_IS_COLLECTION(struct_flags))
1444         CV_Error( CV_StsBadArg,
1445         "Some collection type - CV_NODE_SEQ or CV_NODE_MAP, must be specified" );
1446
1447     if( CV_NODE_IS_FLOW(struct_flags) )
1448     {
1449         char c = CV_NODE_IS_MAP(struct_flags) ? '{' : '[';
1450         struct_flags |= CV_NODE_FLOW;
1451
1452         if( type_name )
1453             sprintf( buf, "!!%s %c", type_name, c );
1454         else
1455         {
1456             buf[0] = c;
1457             buf[1] = '\0';
1458         }
1459         data = buf;
1460     }
1461     else if( type_name )
1462     {
1463         sprintf( buf, "!!%s", type_name );
1464         data = buf;
1465     }
1466
1467     icvYMLWrite( fs, key, data );
1468
1469     parent_flags = fs->struct_flags;
1470     cvSeqPush( fs->write_stack, &parent_flags );
1471     fs->struct_flags = struct_flags;
1472
1473     if( !CV_NODE_IS_FLOW(parent_flags) )
1474         fs->struct_indent += CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags);
1475 }
1476
1477
1478 static void
1479 icvYMLEndWriteStruct( CvFileStorage* fs )
1480 {
1481     int parent_flags = 0, struct_flags;
1482     char* ptr;
1483
1484     struct_flags = fs->struct_flags;
1485     if( fs->write_stack->total == 0 )
1486         CV_Error( CV_StsError, "EndWriteStruct w/o matching StartWriteStruct" );
1487
1488     cvSeqPop( fs->write_stack, &parent_flags );
1489
1490     if( CV_NODE_IS_FLOW(struct_flags) )
1491     {
1492         ptr = fs->buffer;
1493         if( ptr > fs->buffer_start + fs->struct_indent && !CV_NODE_IS_EMPTY(struct_flags) )
1494             *ptr++ = ' ';
1495         *ptr++ = CV_NODE_IS_MAP(struct_flags) ? '}' : ']';
1496         fs->buffer = ptr;
1497     }
1498     else if( CV_NODE_IS_EMPTY(struct_flags) )
1499     {
1500         ptr = icvFSFlush(fs);
1501         memcpy( ptr, CV_NODE_IS_MAP(struct_flags) ? "{}" : "[]", 2 );
1502         fs->buffer = ptr + 2;
1503     }
1504
1505     if( !CV_NODE_IS_FLOW(parent_flags) )
1506         fs->struct_indent -= CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags);
1507     assert( fs->struct_indent >= 0 );
1508
1509     fs->struct_flags = parent_flags;
1510 }
1511
1512
1513 static void
1514 icvYMLStartNextStream( CvFileStorage* fs )
1515 {
1516     if( !fs->is_first )
1517     {
1518         while( fs->write_stack->total > 0 )
1519             icvYMLEndWriteStruct(fs);
1520
1521         fs->struct_indent = 0;
1522         icvFSFlush(fs);
1523         icvPuts( fs, "...\n" );
1524         icvPuts( fs, "---\n" );
1525         fs->buffer = fs->buffer_start;
1526     }
1527 }
1528
1529
1530 static void
1531 icvYMLWriteInt( CvFileStorage* fs, const char* key, int value )
1532 {
1533     char buf[128];
1534     icvYMLWrite( fs, key, icv_itoa( value, buf, 10 ));
1535 }
1536
1537
1538 static void
1539 icvYMLWriteReal( CvFileStorage* fs, const char* key, double value )
1540 {
1541     char buf[128];
1542     icvYMLWrite( fs, key, icvDoubleToString( buf, value ));
1543 }
1544
1545
1546 static void
1547 icvYMLWriteString( CvFileStorage* fs, const char* key,
1548                    const char* str, int quote CV_DEFAULT(0))
1549 {
1550     char buf[CV_FS_MAX_LEN*4+16];
1551     char* data = (char*)str;
1552     int i, len;
1553
1554     if( !str )
1555         CV_Error( CV_StsNullPtr, "Null string pointer" );
1556
1557     len = (int)strlen(str);
1558     if( len > CV_FS_MAX_LEN )
1559         CV_Error( CV_StsBadArg, "The written string is too long" );
1560
1561     if( quote || len == 0 || str[0] != str[len-1] || (str[0] != '\"' && str[0] != '\'') )
1562     {
1563         int need_quote = quote || len == 0;
1564         data = buf;
1565         *data++ = '\"';
1566         for( i = 0; i < len; i++ )
1567         {
1568             char c = str[i];
1569
1570             if( !need_quote && !isalnum(c) && c != '_' && c != ' ' && c != '-' &&
1571                 c != '(' && c != ')' && c != '/' && c != '+' && c != ';' )
1572                 need_quote = 1;
1573
1574             if( !isalnum(c) && (!cv_isprint(c) || c == '\\' || c == '\'' || c == '\"') )
1575             {
1576                 *data++ = '\\';
1577                 if( cv_isprint(c) )
1578                     *data++ = c;
1579                 else if( c == '\n' )
1580                     *data++ = 'n';
1581                 else if( c == '\r' )
1582                     *data++ = 'r';
1583                 else if( c == '\t' )
1584                     *data++ = 't';
1585                 else
1586                 {
1587                     sprintf( data, "x%02x", c );
1588                     data += 3;
1589                 }
1590             }
1591             else
1592                 *data++ = c;
1593         }
1594         if( !need_quote && (isdigit(str[0]) ||
1595             str[0] == '+' || str[0] == '-' || str[0] == '.' ))
1596             need_quote = 1;
1597
1598         if( need_quote )
1599             *data++ = '\"';
1600         *data++ = '\0';
1601         data = buf + !need_quote;
1602     }
1603
1604     icvYMLWrite( fs, key, data );
1605 }
1606
1607
1608 static void
1609 icvYMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
1610 {
1611     int len; //, indent;
1612     int multiline;
1613     const char* eol;
1614     char* ptr;
1615
1616     if( !comment )
1617         CV_Error( CV_StsNullPtr, "Null comment" );
1618
1619     len = (int)strlen(comment);
1620     eol = strchr(comment, '\n');
1621     multiline = eol != 0;
1622     ptr = fs->buffer;
1623
1624     if( !eol_comment || multiline ||
1625         fs->buffer_end - ptr < len || ptr == fs->buffer_start )
1626         ptr = icvFSFlush( fs );
1627     else
1628         *ptr++ = ' ';
1629
1630     while( comment )
1631     {
1632         *ptr++ = '#';
1633         *ptr++ = ' ';
1634         if( eol )
1635         {
1636             ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 );
1637             memcpy( ptr, comment, eol - comment + 1 );
1638             fs->buffer = ptr + (eol - comment);
1639             comment = eol + 1;
1640             eol = strchr( comment, '\n' );
1641         }
1642         else
1643         {
1644             len = (int)strlen(comment);
1645             ptr = icvFSResizeWriteBuffer( fs, ptr, len );
1646             memcpy( ptr, comment, len );
1647             fs->buffer = ptr + len;
1648             comment = 0;
1649         }
1650         ptr = icvFSFlush( fs );
1651     }
1652 }
1653
1654
1655 /****************************************************************************************\
1656 *                                       XML Parser                                       *
1657 \****************************************************************************************/
1658
1659 #define CV_XML_INSIDE_COMMENT 1
1660 #define CV_XML_INSIDE_TAG 2
1661 #define CV_XML_INSIDE_DIRECTIVE 3
1662
1663 static char*
1664 icvXMLSkipSpaces( CvFileStorage* fs, char* ptr, int mode )
1665 {
1666     int level = 0;
1667
1668     for(;;)
1669     {
1670         char c;
1671         ptr--;
1672
1673         if( mode == CV_XML_INSIDE_COMMENT )
1674         {
1675             do c = *++ptr;
1676             while( cv_isprint_or_tab(c) && (c != '-' || ptr[1] != '-' || ptr[2] != '>') );
1677
1678             if( c == '-' )
1679             {
1680                 assert( ptr[1] == '-' && ptr[2] == '>' );
1681                 mode = 0;
1682                 ptr += 3;
1683             }
1684         }
1685         else if( mode == CV_XML_INSIDE_DIRECTIVE )
1686         {
1687             // !!!NOTE!!! This is not quite correct, but should work in most cases
1688             do
1689             {
1690                 c = *++ptr;
1691                 level += c == '<';
1692                 level -= c == '>';
1693                 if( level < 0 )
1694                     return ptr;
1695             } while( cv_isprint_or_tab(c) );
1696         }
1697         else
1698         {
1699             do c = *++ptr;
1700             while( c == ' ' || c == '\t' );
1701
1702             if( c == '<' && ptr[1] == '!' && ptr[2] == '-' && ptr[3] == '-' )
1703             {
1704                 if( mode != 0 )
1705                     CV_PARSE_ERROR( "Comments are not allowed here" );
1706                 mode = CV_XML_INSIDE_COMMENT;
1707                 ptr += 4;
1708             }
1709             else if( cv_isprint(c) )
1710                 break;
1711         }
1712
1713         if( !cv_isprint(*ptr) )
1714         {
1715             int max_size = (int)(fs->buffer_end - fs->buffer_start);
1716             if( *ptr != '\0' && *ptr != '\n' && *ptr != '\r' )
1717                 CV_PARSE_ERROR( "Invalid character in the stream" );
1718             ptr = icvGets( fs, fs->buffer_start, max_size );
1719             if( !ptr )
1720             {
1721                 ptr = fs->buffer_start;
1722                 *ptr = '\0';
1723                 fs->dummy_eof = 1;
1724                 break;
1725             }
1726             else
1727             {
1728                 int l = (int)strlen(ptr);
1729                 if( ptr[l-1] != '\n' && ptr[l-1] != '\r' && !icvEof(fs) )
1730                     CV_PARSE_ERROR( "Too long string or a last string w/o newline" );
1731             }
1732             fs->lineno++;
1733         }
1734     }
1735     return ptr;
1736 }
1737
1738
1739 static char*
1740 icvXMLParseTag( CvFileStorage* fs, char* ptr, CvStringHashNode** _tag,
1741                 CvAttrList** _list, int* _tag_type );
1742
1743 static char*
1744 icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
1745                   int value_type CV_DEFAULT(CV_NODE_NONE))
1746 {
1747     CvFileNode *elem = node;
1748     int have_space = 1, is_simple = 1;
1749     int is_user_type = CV_NODE_IS_USER(value_type);
1750     memset( node, 0, sizeof(*node) );
1751
1752     value_type = CV_NODE_TYPE(value_type);
1753
1754     for(;;)
1755     {
1756         char c = *ptr, d;
1757         char* endptr;
1758
1759         if( isspace(c) || c == '\0' || (c == '<' && ptr[1] == '!' && ptr[2] == '-') )
1760         {
1761             ptr = icvXMLSkipSpaces( fs, ptr, 0 );
1762             have_space = 1;
1763             c = *ptr;
1764         }
1765
1766         d = ptr[1];
1767
1768         if( c =='<' )
1769         {
1770             CvStringHashNode *key = 0, *key2 = 0;
1771             CvAttrList* list = 0;
1772             CvTypeInfo* info = 0;
1773             int tag_type = 0;
1774             int is_noname = 0;
1775             const char* type_name = 0;
1776             int elem_type = CV_NODE_NONE;
1777
1778             if( d == '/' )
1779                 break;
1780
1781             ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type );
1782
1783             if( tag_type == CV_XML_DIRECTIVE_TAG )
1784                 CV_PARSE_ERROR( "Directive tags are not allowed here" );
1785             if( tag_type == CV_XML_EMPTY_TAG )
1786                 CV_PARSE_ERROR( "Empty tags are not supported" );
1787
1788             assert( tag_type == CV_XML_OPENING_TAG );
1789
1790             type_name = list ? cvAttrValue( list, "type_id" ) : 0;
1791             if( type_name )
1792             {
1793                 if( strcmp( type_name, "str" ) == 0 )
1794                     elem_type = CV_NODE_STRING;
1795                 else if( strcmp( type_name, "map" ) == 0 )
1796                     elem_type = CV_NODE_MAP;
1797                 else if( strcmp( type_name, "seq" ) == 0 )
1798                     elem_type = CV_NODE_SEQ;
1799                 else
1800                 {
1801                     info = cvFindType( type_name );
1802                     if( info )
1803                         elem_type = CV_NODE_USER;
1804                 }
1805             }
1806
1807             is_noname = key->str.len == 1 && key->str.ptr[0] == '_';
1808             if( !CV_NODE_IS_COLLECTION(node->tag) )
1809             {
1810                 icvFSCreateCollection( fs, is_noname ? CV_NODE_SEQ : CV_NODE_MAP, node );
1811             }
1812             else if( is_noname ^ CV_NODE_IS_SEQ(node->tag) )
1813                 CV_PARSE_ERROR( is_noname ? "Map element should have a name" :
1814                               "Sequence element should not have name (use <_></_>)" );
1815
1816             if( is_noname )
1817                 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1818             else
1819                 elem = cvGetFileNode( fs, node, key, 1 );
1820
1821             ptr = icvXMLParseValue( fs, ptr, elem, elem_type);
1822             if( !is_noname )
1823                 elem->tag |= CV_NODE_NAMED;
1824             is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
1825             elem->info = info;
1826             ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type );
1827             if( tag_type != CV_XML_CLOSING_TAG || key2 != key )
1828                 CV_PARSE_ERROR( "Mismatched closing tag" );
1829             have_space = 1;
1830         }
1831         else
1832         {
1833             if( !have_space )
1834                 CV_PARSE_ERROR( "There should be space between literals" );
1835
1836             elem = node;
1837             if( node->tag != CV_NODE_NONE )
1838             {
1839                 if( !CV_NODE_IS_COLLECTION(node->tag) )
1840                     icvFSCreateCollection( fs, CV_NODE_SEQ, node );
1841
1842                 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1843                 elem->info = 0;
1844             }
1845
1846             if( value_type != CV_NODE_STRING &&
1847                 (isdigit(c) || ((c == '-' || c == '+') &&
1848                 (isdigit(d) || d == '.')) || (c == '.' && isalnum(d))) ) // a number
1849             {
1850                 double fval;
1851                 int ival;
1852                 endptr = ptr + (c == '-' || c == '+');
1853                 while( isdigit(*endptr) )
1854                     endptr++;
1855                 if( *endptr == '.' || *endptr == 'e' )
1856                 {
1857                     fval = icv_strtod( fs, ptr, &endptr );
1858                     /*if( endptr == ptr || isalpha(*endptr) )
1859                         icvProcessSpecialDouble( fs, ptr, &fval, &endptr ));*/
1860                     elem->tag = CV_NODE_REAL;
1861                     elem->data.f = fval;
1862                 }
1863                 else
1864                 {
1865                     ival = (int)strtol( ptr, &endptr, 0 );
1866                     elem->tag = CV_NODE_INT;
1867                     elem->data.i = ival;
1868                 }
1869
1870                 if( endptr == ptr )
1871                     CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" );
1872
1873                 ptr = endptr;
1874             }
1875             else
1876             {
1877                 // string
1878                 char buf[CV_FS_MAX_LEN+16];
1879                 int i = 0, len, is_quoted = 0;
1880                 elem->tag = CV_NODE_STRING;
1881                 if( c == '\"' )
1882                     is_quoted = 1;
1883                 else
1884                     --ptr;
1885
1886                 for( ;; )
1887                 {
1888                     c = *++ptr;
1889                     if( !isalnum(c) )
1890                     {
1891                         if( c == '\"' )
1892                         {
1893                             if( !is_quoted )
1894                                 CV_PARSE_ERROR( "Literal \" is not allowed within a string. Use &quot;" );
1895                             ++ptr;
1896                             break;
1897                         }
1898                         else if( !cv_isprint(c) || c == '<' || (!is_quoted && isspace(c)))
1899                         {
1900                             if( is_quoted )
1901                                 CV_PARSE_ERROR( "Closing \" is expected" );
1902                             break;
1903                         }
1904                         else if( c == '\'' || c == '>' )
1905                         {
1906                             CV_PARSE_ERROR( "Literal \' or > are not allowed. Use &apos; or &gt;" );
1907                         }
1908                         else if( c == '&' )
1909                         {
1910                             if( *ptr == '#' )
1911                             {
1912                                 int val;
1913                                 ptr++;
1914                                 val = (int)strtol( ptr, &endptr, 0 );
1915                                 if( (unsigned)val > (unsigned)255 ||
1916                                     !endptr || *endptr != ';' )
1917                                     CV_PARSE_ERROR( "Invalid numeric value in the string" );
1918                                 c = (char)val;
1919                             }
1920                             else
1921                             {
1922                                 endptr = ptr++;
1923                                 do c = *++endptr;
1924                                 while( isalnum(c) );
1925                                 if( c != ';' )
1926                                     CV_PARSE_ERROR( "Invalid character in the symbol entity name" );
1927                                 len = (int)(endptr - ptr);
1928                                 if( len == 2 && memcmp( ptr, "lt", len ) == 0 )
1929                                     c = '<';
1930                                 else if( len == 2 && memcmp( ptr, "gt", len ) == 0 )
1931                                     c = '>';
1932                                 else if( len == 3 && memcmp( ptr, "amp", len ) == 0 )
1933                                     c = '&';
1934                                 else if( len == 4 && memcmp( ptr, "apos", len ) == 0 )
1935                                     c = '\'';
1936                                 else if( len == 4 && memcmp( ptr, "quot", len ) == 0 )
1937                                     c = '\"';
1938                                 else
1939                                 {
1940                                     memcpy( buf + i, ptr-1, len + 2 );
1941                                     i += len + 2;
1942                                 }
1943                             }
1944                             ptr = endptr;
1945                         }
1946                     }
1947                     buf[i++] = c;
1948                     if( i >= CV_FS_MAX_LEN )
1949                         CV_PARSE_ERROR( "Too long string literal" );
1950                 }
1951                 elem->data.str = cvMemStorageAllocString( fs->memstorage, buf, i );
1952             }
1953
1954             if( !CV_NODE_IS_COLLECTION(value_type) && value_type != CV_NODE_NONE )
1955                 break;
1956             have_space = 0;
1957         }
1958     }
1959
1960     if( (CV_NODE_TYPE(node->tag) == CV_NODE_NONE ||
1961         (CV_NODE_TYPE(node->tag) != value_type &&
1962         !CV_NODE_IS_COLLECTION(node->tag))) &&
1963         CV_NODE_IS_COLLECTION(value_type) )
1964     {
1965         icvFSCreateCollection( fs, CV_NODE_IS_MAP(value_type) ?
1966                                         CV_NODE_MAP : CV_NODE_SEQ, node );
1967     }
1968
1969     if( value_type != CV_NODE_NONE &&
1970         value_type != CV_NODE_TYPE(node->tag) )
1971         CV_PARSE_ERROR( "The actual type is different from the specified type" );
1972
1973     if( CV_NODE_IS_COLLECTION(node->tag) && is_simple )
1974             node->data.seq->flags |= CV_NODE_SEQ_SIMPLE;
1975
1976     node->tag |= is_user_type ? CV_NODE_USER : 0;
1977     return ptr;
1978 }
1979
1980
1981 static char*
1982 icvXMLParseTag( CvFileStorage* fs, char* ptr, CvStringHashNode** _tag,
1983                 CvAttrList** _list, int* _tag_type )
1984 {
1985     int tag_type = 0;
1986     CvStringHashNode* tagname = 0;
1987     CvAttrList *first = 0, *last = 0;
1988     int count = 0, max_count = 4;
1989     int attr_buf_size = (max_count*2 + 1)*sizeof(char*) + sizeof(CvAttrList);
1990     char* endptr;
1991     char c;
1992     int have_space;
1993
1994     if( *ptr != '<' )
1995         CV_PARSE_ERROR( "Tag should start with \'<\'" );
1996
1997     ptr++;
1998     if( isalnum(*ptr) || *ptr == '_' )
1999         tag_type = CV_XML_OPENING_TAG;
2000     else if( *ptr == '/' )
2001     {
2002         tag_type = CV_XML_CLOSING_TAG;
2003         ptr++;
2004     }
2005     else if( *ptr == '?' )
2006     {
2007         tag_type = CV_XML_HEADER_TAG;
2008         ptr++;
2009     }
2010     else if( *ptr == '!' )
2011     {
2012         tag_type = CV_XML_DIRECTIVE_TAG;
2013         assert( ptr[1] != '-' || ptr[2] != '-' );
2014         ptr++;
2015     }
2016     else
2017         CV_PARSE_ERROR( "Unknown tag type" );
2018
2019     for(;;)
2020     {
2021         CvStringHashNode* attrname;
2022
2023         if( !isalpha(*ptr) && *ptr != '_' )
2024             CV_PARSE_ERROR( "Name should start with a letter or underscore" );
2025
2026         endptr = ptr - 1;
2027         do c = *++endptr;
2028         while( isalnum(c) || c == '_' || c == '-' );
2029
2030         attrname = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 );
2031         ptr = endptr;
2032
2033         if( !tagname )
2034             tagname = attrname;
2035         else
2036         {
2037             if( tag_type == CV_XML_CLOSING_TAG )
2038                 CV_PARSE_ERROR( "Closing tag should not contain any attributes" );
2039
2040             if( !last || count >= max_count )
2041             {
2042                 CvAttrList* chunk;
2043
2044                 chunk = (CvAttrList*)cvMemStorageAlloc( fs->memstorage, attr_buf_size );
2045                 memset( chunk, 0, attr_buf_size );
2046                 chunk->attr = (const char**)(chunk + 1);
2047                 count = 0;
2048                 if( !last )
2049                     first = last = chunk;
2050                 else
2051                     last = last->next = chunk;
2052             }
2053             last->attr[count*2] = attrname->str.ptr;
2054         }
2055
2056         if( last )
2057         {
2058             CvFileNode stub;
2059
2060             if( *ptr != '=' )
2061             {
2062                 ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG );
2063                 if( *ptr != '=' )
2064                     CV_PARSE_ERROR( "Attribute name should be followed by \'=\'" );
2065             }
2066
2067             c = *++ptr;
2068             if( c != '\"' && c != '\'' )
2069             {
2070                 ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG );
2071                 if( *ptr != '\"' && *ptr != '\'' )
2072                     CV_PARSE_ERROR( "Attribute value should be put into single or double quotes" );
2073             }
2074
2075             ptr = icvXMLParseValue( fs, ptr, &stub, CV_NODE_STRING );
2076             assert( stub.tag == CV_NODE_STRING );
2077             last->attr[count*2+1] = stub.data.str.ptr;
2078             count++;
2079         }
2080
2081         c = *ptr;
2082         have_space = isspace(c) || c == '\0';
2083
2084         if( c != '>' )
2085         {
2086             ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG );
2087             c = *ptr;
2088         }
2089
2090         if( c == '>' )
2091         {
2092             if( tag_type == CV_XML_HEADER_TAG )
2093                 CV_PARSE_ERROR( "Invalid closing tag for <?xml ..." );
2094             ptr++;
2095             break;
2096         }
2097         else if( c == '?' && tag_type == CV_XML_HEADER_TAG )
2098         {
2099             if( ptr[1] != '>'  )
2100                 CV_PARSE_ERROR( "Invalid closing tag for <?xml ..." );
2101             ptr += 2;
2102             break;
2103         }
2104         else if( c == '/' && ptr[1] == '>' && tag_type == CV_XML_OPENING_TAG )
2105         {
2106             tag_type = CV_XML_EMPTY_TAG;
2107             ptr += 2;
2108             break;
2109         }
2110
2111         if( !have_space )
2112             CV_PARSE_ERROR( "There should be space between attributes" );
2113     }
2114
2115     *_tag = tagname;
2116     *_tag_type = tag_type;
2117     *_list = first;
2118
2119     return ptr;
2120 }
2121
2122
2123 static void
2124 icvXMLParse( CvFileStorage* fs )
2125 {
2126     char* ptr = fs->buffer_start;
2127     CvStringHashNode *key = 0, *key2 = 0;
2128     CvAttrList* list = 0;
2129     int tag_type = 0;
2130
2131     // CV_XML_INSIDE_TAG is used to prohibit leading comments
2132     ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG );
2133
2134     if( memcmp( ptr, "<?xml", 5 ) != 0 )
2135         CV_PARSE_ERROR( "Valid XML should start with \'<?xml ...?>\'" );
2136
2137     ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type );
2138
2139     /*{
2140         const char* version = cvAttrValue( list, "version" );
2141         if( version && strncmp( version, "1.", 2 ) != 0 )
2142             CV_Error( CV_StsParseError, "Unsupported version of XML" );
2143     }*/
2144     {
2145         const char* encoding = cvAttrValue( list, "encoding" );
2146         if( encoding && strcmp( encoding, "ASCII" ) != 0 )
2147             CV_PARSE_ERROR( "Unsupported encoding" );
2148     }
2149
2150     while( *ptr != '\0' )
2151     {
2152         ptr = icvXMLSkipSpaces( fs, ptr, 0 );
2153
2154         if( *ptr != '\0' )
2155         {
2156             CvFileNode* root_node;
2157             ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type );
2158             if( tag_type != CV_XML_OPENING_TAG ||
2159                 strcmp(key->str.ptr,"opencv_storage") != 0 )
2160                 CV_PARSE_ERROR( "<opencv_storage> tag is missing" );
2161
2162             root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 );
2163             ptr = icvXMLParseValue( fs, ptr, root_node, CV_NODE_NONE );
2164             ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type );
2165             if( tag_type != CV_XML_CLOSING_TAG || key != key2 )
2166                 CV_PARSE_ERROR( "</opencv_storage> tag is missing" );
2167             ptr = icvXMLSkipSpaces( fs, ptr, 0 );
2168         }
2169     }
2170
2171     assert( fs->dummy_eof != 0 );
2172 }
2173
2174
2175 /****************************************************************************************\
2176 *                                       XML Emitter                                      *
2177 \****************************************************************************************/
2178
2179 #define icvXMLFlush icvFSFlush
2180
2181 static void
2182 icvXMLWriteTag( CvFileStorage* fs, const char* key, int tag_type, CvAttrList list )
2183 {
2184     char* ptr = fs->buffer;
2185     int i, len = 0;
2186     int struct_flags = fs->struct_flags;
2187
2188     if( key && key[0] == '\0' )
2189         key = 0;
2190
2191     if( tag_type == CV_XML_OPENING_TAG || tag_type == CV_XML_EMPTY_TAG )
2192     {
2193         if( CV_NODE_IS_COLLECTION(struct_flags) )
2194         {
2195             if( CV_NODE_IS_MAP(struct_flags) ^ (key != 0) )
2196                 CV_Error( CV_StsBadArg, "An attempt to add element without a key to a map, "
2197                                         "or add element with key to sequence" );
2198         }
2199         else
2200         {
2201             struct_flags = CV_NODE_EMPTY + (key ? CV_NODE_MAP : CV_NODE_SEQ);
2202             fs->is_first = 0;
2203         }
2204
2205         if( !CV_NODE_IS_EMPTY(struct_flags) )
2206             ptr = icvXMLFlush(fs);
2207     }
2208
2209     if( !key )
2210         key = "_";
2211     else if( key[0] == '_' && key[1] == '\0' )
2212         CV_Error( CV_StsBadArg, "A single _ is a reserved tag name" );
2213
2214     len = (int)strlen( key );
2215     *ptr++ = '<';
2216     if( tag_type == CV_XML_CLOSING_TAG )
2217     {
2218         if( list.attr )
2219             CV_Error( CV_StsBadArg, "Closing tag should not include any attributes" );
2220         *ptr++ = '/';
2221     }
2222
2223     if( !isalpha(key[0]) && key[0] != '_' )
2224         CV_Error( CV_StsBadArg, "Key should start with a letter or _" );
2225
2226     ptr = icvFSResizeWriteBuffer( fs, ptr, len );
2227     for( i = 0; i < len; i++ )
2228     {
2229         char c = key[i];
2230         if( !isalnum(c) && c != '_' && c != '-' )
2231             CV_Error( CV_StsBadArg, "Key name may only contain alphanumeric characters [a-zA-Z0-9], '-' and '_'" );
2232         ptr[i] = c;
2233     }
2234     ptr += len;
2235
2236     for(;;)
2237     {
2238         const char** attr = list.attr;
2239
2240         for( ; attr && attr[0] != 0; attr += 2 )
2241         {
2242             int len0 = (int)strlen(attr[0]);
2243             int len1 = (int)strlen(attr[1]);
2244
2245             ptr = icvFSResizeWriteBuffer( fs, ptr, len0 + len1 + 4 );
2246             *ptr++ = ' ';
2247             memcpy( ptr, attr[0], len0 );
2248             ptr += len0;
2249             *ptr++ = '=';
2250             *ptr++ = '\"';
2251             memcpy( ptr, attr[1], len1 );
2252             ptr += len1;
2253             *ptr++ = '\"';
2254         }
2255         if( !list.next )
2256             break;
2257         list = *list.next;
2258     }
2259
2260     if( tag_type == CV_XML_EMPTY_TAG )
2261         *ptr++ = '/';
2262     *ptr++ = '>';
2263     fs->buffer = ptr;
2264     fs->struct_flags = struct_flags & ~CV_NODE_EMPTY;
2265 }
2266
2267
2268 static void
2269 icvXMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
2270                         const char* type_name CV_DEFAULT(0))
2271 {
2272     CvXMLStackRecord parent;
2273     const char* attr[10];
2274     int idx = 0;
2275
2276     struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY;
2277     if( !CV_NODE_IS_COLLECTION(struct_flags))
2278         CV_Error( CV_StsBadArg,
2279         "Some collection type: CV_NODE_SEQ or CV_NODE_MAP must be specified" );
2280
2281     if( type_name )
2282     {
2283         attr[idx++] = "type_id";
2284         attr[idx++] = type_name;
2285     }
2286     attr[idx++] = 0;
2287
2288     icvXMLWriteTag( fs, key, CV_XML_OPENING_TAG, cvAttrList(attr,0) );
2289
2290     parent.struct_flags = fs->struct_flags & ~CV_NODE_EMPTY;
2291     parent.struct_indent = fs->struct_indent;
2292     parent.struct_tag = fs->struct_tag;
2293     cvSaveMemStoragePos( fs->strstorage, &parent.pos );
2294     cvSeqPush( fs->write_stack, &parent );
2295
2296     fs->struct_indent += CV_XML_INDENT;
2297     if( !CV_NODE_IS_FLOW(struct_flags) )
2298         icvXMLFlush( fs );
2299
2300     fs->struct_flags = struct_flags;
2301     if( key )
2302     {
2303         fs->struct_tag = cvMemStorageAllocString( fs->strstorage, (char*)key, -1 );
2304     }
2305     else
2306     {
2307         fs->struct_tag.ptr = 0;
2308         fs->struct_tag.len = 0;
2309     }
2310 }
2311
2312
2313 static void
2314 icvXMLEndWriteStruct( CvFileStorage* fs )
2315 {
2316     CvXMLStackRecord parent;
2317
2318     if( fs->write_stack->total == 0 )
2319         CV_Error( CV_StsError, "An extra closing tag" );
2320
2321     icvXMLWriteTag( fs, fs->struct_tag.ptr, CV_XML_CLOSING_TAG, cvAttrList(0,0) );
2322     cvSeqPop( fs->write_stack, &parent );
2323
2324     fs->struct_indent = parent.struct_indent;
2325     fs->struct_flags = parent.struct_flags;
2326     fs->struct_tag = parent.struct_tag;
2327     cvRestoreMemStoragePos( fs->strstorage, &parent.pos );
2328 }
2329
2330
2331 static void
2332 icvXMLStartNextStream( CvFileStorage* fs )
2333 {
2334     if( !fs->is_first )
2335     {
2336         while( fs->write_stack->total > 0 )
2337             icvXMLEndWriteStruct(fs);
2338
2339         fs->struct_indent = 0;
2340         icvXMLFlush(fs);
2341         /* XML does not allow multiple top-level elements,
2342            so we just put a comment and continue
2343            the current (and the only) "stream" */
2344         icvPuts( fs, "\n<!-- next stream -->\n" );
2345         /*fputs( "</opencv_storage>\n", fs->file );
2346         fputs( "<opencv_storage>\n", fs->file );*/
2347         fs->buffer = fs->buffer_start;
2348     }
2349 }
2350
2351
2352 static void
2353 icvXMLWriteScalar( CvFileStorage* fs, const char* key, const char* data, int len )
2354 {
2355     if( CV_NODE_IS_MAP(fs->struct_flags) ||
2356         (!CV_NODE_IS_COLLECTION(fs->struct_flags) && key) )
2357     {
2358         icvXMLWriteTag( fs, key, CV_XML_OPENING_TAG, cvAttrList(0,0) );
2359         char* ptr = icvFSResizeWriteBuffer( fs, fs->buffer, len );
2360         memcpy( ptr, data, len );
2361         fs->buffer = ptr + len;
2362         icvXMLWriteTag( fs, key, CV_XML_CLOSING_TAG, cvAttrList(0,0) );
2363     }
2364     else
2365     {
2366         char* ptr = fs->buffer;
2367         int new_offset = (int)(ptr - fs->buffer_start) + len;
2368
2369         if( key )
2370             CV_Error( CV_StsBadArg, "elements with keys can not be written to sequence" );
2371
2372         fs->struct_flags = CV_NODE_SEQ;
2373
2374         if( (new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10) ||
2375             (ptr > fs->buffer_start && ptr[-1] == '>' && !CV_NODE_IS_EMPTY(fs->struct_flags)) )
2376         {
2377             ptr = icvXMLFlush(fs);
2378         }
2379         else if( ptr > fs->buffer_start + fs->struct_indent && ptr[-1] != '>' )
2380             *ptr++ = ' ';
2381
2382         memcpy( ptr, data, len );
2383         fs->buffer = ptr + len;
2384     }
2385 }
2386
2387
2388 static void
2389 icvXMLWriteInt( CvFileStorage* fs, const char* key, int value )
2390 {
2391     char buf[128], *ptr = icv_itoa( value, buf, 10 );
2392     int len = (int)strlen(ptr);
2393     icvXMLWriteScalar( fs, key, ptr, len );
2394 }
2395
2396
2397 static void
2398 icvXMLWriteReal( CvFileStorage* fs, const char* key, double value )
2399 {
2400     char buf[128];
2401     int len = (int)strlen( icvDoubleToString( buf, value ));
2402     icvXMLWriteScalar( fs, key, buf, len );
2403 }
2404
2405
2406 static void
2407 icvXMLWriteString( CvFileStorage* fs, const char* key, const char* str, int quote )
2408 {
2409     char buf[CV_FS_MAX_LEN*6+16];
2410     char* data = (char*)str;
2411     int i, len;
2412
2413     if( !str )
2414         CV_Error( CV_StsNullPtr, "Null string pointer" );
2415
2416     len = (int)strlen(str);
2417     if( len > CV_FS_MAX_LEN )
2418         CV_Error( CV_StsBadArg, "The written string is too long" );
2419
2420     if( quote || len == 0 || str[0] != '\"' || str[0] != str[len-1] )
2421     {
2422         int need_quote = quote || len == 0;
2423         data = buf;
2424         *data++ = '\"';
2425         for( i = 0; i < len; i++ )
2426         {
2427             char c = str[i];
2428
2429             if( !isalnum(c) && (!cv_isprint(c) || c == '<' || c == '>' ||
2430                 c == '&' || c == '\'' || c == '\"') )
2431             {
2432                 *data++ = '&';
2433                 if( c == '<' )
2434                 {
2435                     memcpy(data, "lt", 2);
2436                     data += 2;
2437                 }
2438                 else if( c == '>' )
2439                 {
2440                     memcpy(data, "gt", 2);
2441                     data += 2;
2442                 }
2443                 else if( c == '&' )
2444                 {
2445                     memcpy(data, "amp", 3);
2446                     data += 3;
2447                 }
2448                 else if( c == '\'' )
2449                 {
2450                     memcpy(data, "apos", 4);
2451                     data += 4;
2452                 }
2453                 else if( c == '\"' )
2454                 {
2455                     memcpy( data, "quot", 4);
2456                     data += 4;
2457                 }
2458                 else
2459                 {
2460                     sprintf( data, "#x%02x", c );
2461                     data += 4;
2462                 }
2463                 *data++ = ';';
2464             }
2465             else
2466             {
2467                 if( c == ' ' )
2468                     need_quote = 1;
2469                 *data++ = c;
2470             }
2471         }
2472         if( !need_quote && (isdigit(str[0]) ||
2473             str[0] == '+' || str[0] == '-' || str[0] == '.' ))
2474             need_quote = 1;
2475
2476         if( need_quote )
2477             *data++ = '\"';
2478         len = (int)(data - buf) - !need_quote;
2479         *data++ = '\0';
2480         data = buf + !need_quote;
2481     }
2482
2483     icvXMLWriteScalar( fs, key, data, len );
2484 }
2485
2486
2487 static void
2488 icvXMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
2489 {
2490     int len;
2491     int multiline;
2492     const char* eol;
2493     char* ptr;
2494
2495     if( !comment )
2496         CV_Error( CV_StsNullPtr, "Null comment" );
2497
2498     if( strstr(comment, "--") != 0 )
2499         CV_Error( CV_StsBadArg, "Double hyphen \'--\' is not allowed in the comments" );
2500
2501     len = (int)strlen(comment);
2502     eol = strchr(comment, '\n');
2503     multiline = eol != 0;
2504     ptr = fs->buffer;
2505
2506     if( multiline || !eol_comment || fs->buffer_end - ptr < len + 5 )
2507         ptr = icvXMLFlush( fs );
2508     else if( ptr > fs->buffer_start + fs->struct_indent )
2509         *ptr++ = ' ';
2510
2511     if( !multiline )
2512     {
2513         ptr = icvFSResizeWriteBuffer( fs, ptr, len + 9 );
2514         sprintf( ptr, "<!-- %s -->", comment );
2515         len = (int)strlen(ptr);
2516     }
2517     else
2518     {
2519         strcpy( ptr, "<!--" );
2520         len = 4;
2521     }
2522
2523     fs->buffer = ptr + len;
2524     ptr = icvXMLFlush(fs);
2525
2526     if( multiline )
2527     {
2528         while( comment )
2529         {
2530             if( eol )
2531             {
2532                 ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 );
2533                 memcpy( ptr, comment, eol - comment + 1 );
2534                 ptr += eol - comment;
2535                 comment = eol + 1;
2536                 eol = strchr( comment, '\n' );
2537             }
2538             else
2539             {
2540                 len = (int)strlen(comment);
2541                 ptr = icvFSResizeWriteBuffer( fs, ptr, len );
2542                 memcpy( ptr, comment, len );
2543                 ptr += len;
2544                 comment = 0;
2545             }
2546             fs->buffer = ptr;
2547             ptr = icvXMLFlush( fs );
2548         }
2549         sprintf( ptr, "-->" );
2550         fs->buffer = ptr + 3;
2551         icvXMLFlush( fs );
2552     }
2553 }
2554
2555
2556 /****************************************************************************************\
2557 *                              Common High-Level Functions                               *
2558 \****************************************************************************************/
2559
2560 CV_IMPL CvFileStorage*
2561 cvOpenFileStorage( const char* filename, CvMemStorage* dststorage, int flags )
2562 {
2563     CvFileStorage* fs = 0;
2564     char* xml_buf = 0;
2565     int default_block_size = 1 << 18;
2566     bool append = (flags & 3) == CV_STORAGE_APPEND;
2567     bool isGZ = false;
2568
2569     if( !filename )
2570         CV_Error( CV_StsNullPtr, "NULL filename" );
2571
2572     fs = (CvFileStorage*)cvAlloc( sizeof(*fs) );
2573     memset( fs, 0, sizeof(*fs));
2574
2575     fs->memstorage = cvCreateMemStorage( default_block_size );
2576     fs->dststorage = dststorage ? dststorage : fs->memstorage;
2577
2578     int fnamelen = (int)strlen(filename);
2579     if( !fnamelen )
2580         CV_Error( CV_StsError, "Empty filename" );
2581
2582     fs->filename = (char*)cvMemStorageAlloc( fs->memstorage, fnamelen+1 );
2583     strcpy( fs->filename, filename );
2584
2585     char* dot_pos = strrchr(fs->filename, '.');
2586     char compression = '\0';
2587
2588     if( dot_pos && dot_pos[1] == 'g' && dot_pos[2] == 'z' &&
2589         (dot_pos[3] == '\0' || (isdigit(dot_pos[3]) && dot_pos[4] == '\0')) )
2590     {
2591         if( append )
2592             CV_Error(CV_StsNotImplemented, "Appending data to compressed file is not implemented" );
2593         isGZ = true;
2594         compression = dot_pos[3];
2595         if( compression )
2596             dot_pos[3] = '\0', fnamelen--;
2597     }
2598
2599     fs->flags = CV_FILE_STORAGE;
2600     fs->write_mode = (flags & 3) != 0;
2601
2602     if( !isGZ )
2603     {
2604         fs->file = fopen(fs->filename, !fs->write_mode ? "rt" : !append ? "wt" : "a+t" );
2605         if( !fs->file )
2606             goto _exit_;
2607     }
2608     else
2609     {
2610         char mode[] = { fs->write_mode ? 'w' : 'r', 'b', compression ? compression : '3', '\0' };
2611         fs->gzfile = gzopen(fs->filename, mode);
2612         if( !fs->gzfile )
2613             goto _exit_;
2614     }
2615
2616     fs->roots = 0;
2617     fs->struct_indent = 0;
2618     fs->struct_flags = 0;
2619     fs->wrap_margin = 71;
2620
2621     if( fs->write_mode )
2622     {
2623         // we use factor=6 for XML (the longest characters (' and ") are encoded with 6 bytes (&apos; and &quot;)
2624         // and factor=4 for YAML ( as we use 4 bytes for non ASCII characters (e.g. \xAB))
2625         int buf_size = CV_FS_MAX_LEN*(fs->is_xml ? 6 : 4) + 1024;
2626
2627         dot_pos = fs->filename + fnamelen - (isGZ ? 7 : 4);
2628         fs->is_xml = dot_pos > fs->filename && (memcmp( dot_pos, ".xml", 4) == 0 ||
2629                       memcmp(dot_pos, ".XML", 4) == 0 || memcmp(dot_pos, ".Xml", 4) == 0);
2630
2631         if( append )
2632             fseek( fs->file, 0, SEEK_END );
2633
2634         fs->write_stack = cvCreateSeq( 0, sizeof(CvSeq), fs->is_xml ?
2635                 sizeof(CvXMLStackRecord) : sizeof(int), fs->memstorage );
2636         fs->is_first = 1;
2637         fs->struct_indent = 0;
2638         fs->struct_flags = CV_NODE_EMPTY;
2639         fs->buffer_start = fs->buffer = (char*)cvAlloc( buf_size + 1024 );
2640         fs->buffer_end = fs->buffer_start + buf_size;
2641         if( fs->is_xml )
2642         {
2643             int file_size = fs->file ? (int)ftell( fs->file ) : 0;
2644             fs->strstorage = cvCreateChildMemStorage( fs->memstorage );
2645             if( !append || file_size == 0 )
2646             {
2647                 icvPuts( fs, "<?xml version=\"1.0\"?>\n" );
2648                 icvPuts( fs, "<opencv_storage>\n" );
2649             }
2650             else
2651             {
2652                 int xml_buf_size = 1 << 10;
2653                 char substr[] = "</opencv_storage>";
2654                 int last_occurence = -1;
2655                 xml_buf_size = MIN(xml_buf_size, file_size);
2656                 fseek( fs->file, -xml_buf_size, SEEK_END );
2657                 xml_buf = (char*)cvAlloc( xml_buf_size+2 );
2658                 // find the last occurence of </opencv_storage>
2659                 for(;;)
2660                 {
2661                     int line_offset = ftell( fs->file );
2662                     char* ptr0 = icvGets( fs, xml_buf, xml_buf_size ), *ptr;
2663                     if( !ptr0 )
2664                         break;
2665                     ptr = ptr0;
2666                     for(;;)
2667                     {
2668                         ptr = strstr( ptr, substr );
2669                         if( !ptr )
2670                             break;
2671                         last_occurence = line_offset + (int)(ptr - ptr0);
2672                         ptr += strlen(substr);
2673                     }
2674                 }
2675                 if( last_occurence < 0 )
2676                     CV_Error( CV_StsError, "Could not find </opencv_storage> in the end of file.\n" );
2677                 icvClose( fs );
2678                 fs->file = fopen( fs->filename, "r+t" );
2679                 fseek( fs->file, last_occurence, SEEK_SET );
2680                 // replace the last "</opencv_storage>" with " <!-- resumed -->", which has the same length
2681                 icvPuts( fs, " <!-- resumed -->" );
2682                 fseek( fs->file, 0, SEEK_END );
2683                 icvPuts( fs, "\n" );
2684             }
2685             fs->start_write_struct = icvXMLStartWriteStruct;
2686             fs->end_write_struct = icvXMLEndWriteStruct;
2687             fs->write_int = icvXMLWriteInt;
2688             fs->write_real = icvXMLWriteReal;
2689             fs->write_string = icvXMLWriteString;
2690             fs->write_comment = icvXMLWriteComment;
2691             fs->start_next_stream = icvXMLStartNextStream;
2692         }
2693         else
2694         {
2695             if( !append )
2696                 icvPuts( fs, "%YAML:1.0\n" );
2697             else
2698                 icvPuts( fs, "...\n---\n" );
2699             fs->start_write_struct = icvYMLStartWriteStruct;
2700             fs->end_write_struct = icvYMLEndWriteStruct;
2701             fs->write_int = icvYMLWriteInt;
2702             fs->write_real = icvYMLWriteReal;
2703             fs->write_string = icvYMLWriteString;
2704             fs->write_comment = icvYMLWriteComment;
2705             fs->start_next_stream = icvYMLStartNextStream;
2706         }
2707     }
2708     else
2709     {
2710         int buf_size = 1 << 20;
2711         const char* yaml_signature = "%YAML:";
2712         char buf[16];
2713         icvGets( fs, buf, sizeof(buf)-2 );
2714         fs->is_xml = strncmp( buf, yaml_signature, strlen(yaml_signature) ) != 0;
2715
2716         if( !isGZ )
2717         {
2718             fseek( fs->file, 0, SEEK_END );
2719             buf_size = ftell( fs->file );
2720             buf_size = MIN( buf_size, (1 << 20) );
2721             buf_size = MAX( buf_size, CV_FS_MAX_LEN*2 + 1024 );
2722         }
2723         icvRewind(fs);
2724
2725         fs->str_hash = cvCreateMap( 0, sizeof(CvStringHash),
2726                         sizeof(CvStringHashNode), fs->memstorage, 256 );
2727
2728         fs->roots = cvCreateSeq( 0, sizeof(CvSeq),
2729                         sizeof(CvFileNode), fs->memstorage );
2730
2731         fs->buffer = fs->buffer_start = (char*)cvAlloc( buf_size + 256 );
2732         fs->buffer_end = fs->buffer_start + buf_size;
2733         fs->buffer[0] = '\n';
2734         fs->buffer[1] = '\0';
2735
2736         //mode = cvGetErrMode();
2737         //cvSetErrMode( CV_ErrModeSilent );
2738         if( fs->is_xml )
2739             icvXMLParse( fs );
2740         else
2741             icvYMLParse( fs );
2742         //cvSetErrMode( mode );
2743
2744         // release resources that we do not need anymore
2745         cvFree( &fs->buffer_start );
2746         fs->buffer = fs->buffer_end = 0;
2747     }
2748 _exit_:
2749     if( fs )
2750     {
2751         if( cvGetErrStatus() < 0 || (!fs->file && !fs->gzfile) )
2752         {
2753             cvReleaseFileStorage( &fs );
2754         }
2755         else if( !fs->write_mode )
2756         {
2757             icvClose(fs);
2758         }
2759     }
2760
2761     cvFree( &xml_buf );
2762     return  fs;
2763 }
2764
2765
2766 CV_IMPL void
2767 cvStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
2768                     const char* type_name, CvAttrList /*attributes*/ )
2769 {
2770     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2771     fs->start_write_struct( fs, key, struct_flags, type_name );
2772 }
2773
2774
2775 CV_IMPL void
2776 cvEndWriteStruct( CvFileStorage* fs )
2777 {
2778     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2779     fs->end_write_struct( fs );
2780 }
2781
2782
2783 CV_IMPL void
2784 cvWriteInt( CvFileStorage* fs, const char* key, int value )
2785 {
2786     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2787     fs->write_int( fs, key, value );
2788 }
2789
2790
2791 CV_IMPL void
2792 cvWriteReal( CvFileStorage* fs, const char* key, double value )
2793 {
2794     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2795     fs->write_real( fs, key, value );
2796 }
2797
2798
2799 CV_IMPL void
2800 cvWriteString( CvFileStorage* fs, const char* key, const char* value, int quote )
2801 {
2802     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2803     fs->write_string( fs, key, value, quote );
2804 }
2805
2806
2807 CV_IMPL void
2808 cvWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
2809 {
2810     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2811     fs->write_comment( fs, comment, eol_comment );
2812 }
2813
2814
2815 CV_IMPL void
2816 cvStartNextStream( CvFileStorage* fs )
2817 {
2818     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2819     fs->start_next_stream( fs );
2820 }
2821
2822
2823 static const char icvTypeSymbol[] = "ucwsifdr";
2824 #define CV_FS_MAX_FMT_PAIRS  128
2825
2826 static char*
2827 icvEncodeFormat( int elem_type, char* dt )
2828 {
2829     sprintf( dt, "%d%c", CV_MAT_CN(elem_type), icvTypeSymbol[CV_MAT_DEPTH(elem_type)] );
2830     return dt + ( dt[2] == '\0' && dt[0] == '1' );
2831 }
2832
2833 static int
2834 icvDecodeFormat( const char* dt, int* fmt_pairs, int max_len )
2835 {
2836     int fmt_pair_count = 0;
2837     int i = 0, k = 0, len = dt ? (int)strlen(dt) : 0;
2838
2839     if( !dt || !len )
2840         return 0;
2841
2842     assert( fmt_pairs != 0 && max_len > 0 );
2843     fmt_pairs[0] = 0;
2844     max_len *= 2;
2845
2846     for( ; k < len; k++ )
2847     {
2848         char c = dt[k];
2849
2850         if( isdigit(c) )
2851         {
2852             int count = c - '0';
2853             if( isdigit(dt[k+1]) )
2854             {
2855                 char* endptr = 0;
2856                 count = (int)strtol( dt+k, &endptr, 10 );
2857                 k = (int)(endptr - dt) - 1;
2858             }
2859
2860             if( count <= 0 )
2861                 CV_Error( CV_StsBadArg, "Invalid data type specification" );
2862
2863             fmt_pairs[i] = count;
2864         }
2865         else
2866         {
2867             const char* pos = strchr( icvTypeSymbol, c );
2868             if( !pos )
2869                 CV_Error( CV_StsBadArg, "Invalid data type specification" );
2870             if( fmt_pairs[i] == 0 )
2871                 fmt_pairs[i] = 1;
2872             fmt_pairs[i+1] = (int)(pos - icvTypeSymbol);
2873             if( i > 0 && fmt_pairs[i+1] == fmt_pairs[i-1] )
2874                 fmt_pairs[i-2] += fmt_pairs[i];
2875             else
2876             {
2877                 i += 2;
2878                 if( i >= max_len )
2879                     CV_Error( CV_StsBadArg, "Too long data type specification" );
2880             }
2881             fmt_pairs[i] = 0;
2882         }
2883     }
2884
2885     fmt_pair_count = i/2;
2886     return fmt_pair_count;
2887 }
2888
2889
2890 static int
2891 icvCalcElemSize( const char* dt, int initial_size )
2892 {
2893     int size = 0;
2894     int fmt_pairs[CV_FS_MAX_FMT_PAIRS], i, fmt_pair_count;
2895     int comp_size;
2896
2897     fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
2898     fmt_pair_count *= 2;
2899     for( i = 0, size = initial_size; i < fmt_pair_count; i += 2 )
2900     {
2901         comp_size = CV_ELEM_SIZE(fmt_pairs[i+1]);
2902         size = cvAlign( size, comp_size );
2903         size += comp_size * fmt_pairs[i];
2904     }
2905     if( initial_size == 0 )
2906     {
2907         comp_size = CV_ELEM_SIZE(fmt_pairs[1]);
2908         size = cvAlign( size, comp_size );
2909     }
2910     return size;
2911 }
2912
2913
2914 static int
2915 icvDecodeSimpleFormat( const char* dt )
2916 {
2917     int elem_type = -1;
2918     int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
2919
2920     fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
2921     if( fmt_pair_count != 1 || fmt_pairs[0] > 4 )
2922         CV_Error( CV_StsError, "Too complex format for the matrix" );
2923
2924     elem_type = CV_MAKETYPE( fmt_pairs[1], fmt_pairs[0] );
2925
2926     return elem_type;
2927 }
2928
2929
2930 CV_IMPL void
2931 cvWriteRawData( CvFileStorage* fs, const void* _data, int len, const char* dt )
2932 {
2933     const char* data0 = (const char*)_data;
2934     int offset = 0;
2935     int fmt_pairs[CV_FS_MAX_FMT_PAIRS*2], k, fmt_pair_count;
2936     char buf[256] = "";
2937
2938     CV_CHECK_OUTPUT_FILE_STORAGE( fs );
2939
2940     if( !data0 )
2941         CV_Error( CV_StsNullPtr, "Null data pointer" );
2942
2943     if( len < 0 )
2944         CV_Error( CV_StsOutOfRange, "Negative number of elements" );
2945
2946     fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
2947
2948     if( !len )
2949         return;
2950
2951     if( fmt_pair_count == 1 )
2952     {
2953         fmt_pairs[0] *= len;
2954         len = 1;
2955     }
2956
2957     for(;len--;)
2958     {
2959         for( k = 0; k < fmt_pair_count; k++ )
2960         {
2961             int i, count = fmt_pairs[k*2];
2962             int elem_type = fmt_pairs[k*2+1];
2963             int elem_size = CV_ELEM_SIZE(elem_type);
2964             const char* data, *ptr;
2965
2966             offset = cvAlign( offset, elem_size );
2967             data = data0 + offset;
2968
2969             for( i = 0; i < count; i++ )
2970             {
2971                 switch( elem_type )
2972                 {
2973                 case CV_8U:
2974                     ptr = icv_itoa( *(uchar*)data, buf, 10 );
2975                     data++;
2976                     break;
2977                 case CV_8S:
2978                     ptr = icv_itoa( *(char*)data, buf, 10 );
2979                     data++;
2980                     break;
2981                 case CV_16U:
2982                     ptr = icv_itoa( *(ushort*)data, buf, 10 );
2983                     data += sizeof(ushort);
2984                     break;
2985                 case CV_16S:
2986                     ptr = icv_itoa( *(short*)data, buf, 10 );
2987                     data += sizeof(short);
2988                     break;
2989                 case CV_32S:
2990                     ptr = icv_itoa( *(int*)data, buf, 10 );
2991                     data += sizeof(int);
2992                     break;
2993                 case CV_32F:
2994                     ptr = icvFloatToString( buf, *(float*)data );
2995                     data += sizeof(float);
2996                     break;
2997                 case CV_64F:
2998                     ptr = icvDoubleToString( buf, *(double*)data );
2999                     data += sizeof(double);
3000                     break;
3001                 case CV_USRTYPE1: /* reference */
3002                     ptr = icv_itoa( (int)*(size_t*)data, buf, 10 );
3003                     data += sizeof(size_t);
3004                     break;
3005                 default:
3006                     assert(0);
3007                     return;
3008                 }
3009
3010                 if( fs->is_xml )
3011                 {
3012                     int buf_len = (int)strlen(ptr);
3013                     icvXMLWriteScalar( fs, 0, ptr, buf_len );
3014                 }
3015                 else
3016                     icvYMLWrite( fs, 0, ptr );
3017             }
3018
3019             offset = (int)(data - data0);
3020         }
3021     }
3022 }
3023
3024
3025 CV_IMPL void
3026 cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, CvSeqReader* reader )
3027 {
3028     int node_type;
3029     CV_CHECK_FILE_STORAGE( fs );
3030
3031     if( !src || !reader )
3032         CV_Error( CV_StsNullPtr, "Null pointer to source file node or reader" );
3033
3034     node_type = CV_NODE_TYPE(src->tag);
3035     if( node_type == CV_NODE_INT || node_type == CV_NODE_REAL )
3036     {
3037         // emulate reading from 1-element sequence
3038         reader->ptr = (schar*)src;
3039         reader->block_max = reader->ptr + sizeof(*src)*2;
3040         reader->block_min = reader->ptr;
3041         reader->seq = 0;
3042     }
3043     else if( node_type == CV_NODE_SEQ )
3044     {
3045         cvStartReadSeq( src->data.seq, reader, 0 );
3046     }
3047     else if( node_type == CV_NODE_NONE )
3048     {
3049         memset( reader, 0, sizeof(*reader) );
3050     }
3051     else
3052         CV_Error( CV_StsBadArg, "The file node should be a numerical scalar or a sequence" );
3053 }
3054
3055
3056 CV_IMPL void
3057 cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
3058                     int len, void* _data, const char* dt )
3059 {
3060     char* data0 = (char*)_data;
3061     int fmt_pairs[CV_FS_MAX_FMT_PAIRS*2], k = 0, fmt_pair_count;
3062     int i = 0, offset = 0, count = 0;
3063
3064     CV_CHECK_FILE_STORAGE( fs );
3065
3066     if( !reader || !data0 )
3067         CV_Error( CV_StsNullPtr, "Null pointer to reader or destination array" );
3068
3069     if( !reader->seq && len != 1 )
3070         CV_Error( CV_StsBadSize, "The readed sequence is a scalar, thus len must be 1" );
3071
3072     fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
3073
3074     for(;;)
3075     {
3076         for( k = 0; k < fmt_pair_count; k++ )
3077         {
3078             int elem_type = fmt_pairs[k*2+1];
3079             int elem_size = CV_ELEM_SIZE(elem_type);
3080             char* data;
3081
3082             count = fmt_pairs[k*2];
3083             offset = cvAlign( offset, elem_size );
3084             data = data0 + offset;
3085
3086             for( i = 0; i < count; i++ )
3087             {
3088                 CvFileNode* node = (CvFileNode*)reader->ptr;
3089                 if( CV_NODE_IS_INT(node->tag) )
3090                 {
3091                     int ival = node->data.i;
3092
3093                     switch( elem_type )
3094                     {
3095                     case CV_8U:
3096                         *(uchar*)data = CV_CAST_8U(ival);
3097                         data++;
3098                         break;
3099                     case CV_8S:
3100                         *(char*)data = CV_CAST_8S(ival);
3101                         data++;
3102                         break;
3103                     case CV_16U:
3104                         *(ushort*)data = CV_CAST_16U(ival);
3105                         data += sizeof(ushort);
3106                         break;
3107                     case CV_16S:
3108                         *(short*)data = CV_CAST_16S(ival);
3109                         data += sizeof(short);
3110                         break;
3111                     case CV_32S:
3112                         *(int*)data = ival;
3113                         data += sizeof(int);
3114                         break;
3115                     case CV_32F:
3116                         *(float*)data = (float)ival;
3117                         data += sizeof(float);
3118                         break;
3119                     case CV_64F:
3120                         *(double*)data = (double)ival;
3121                         data += sizeof(double);
3122                         break;
3123                     case CV_USRTYPE1: /* reference */
3124                         *(size_t*)data = ival;
3125                         data += sizeof(size_t);
3126                         break;
3127                     default:
3128                         assert(0);
3129                         return;
3130                     }
3131                 }
3132                 else if( CV_NODE_IS_REAL(node->tag) )
3133                 {
3134                     double fval = node->data.f;
3135                     int ival;
3136
3137                     switch( elem_type )
3138                     {
3139                     case CV_8U:
3140                         ival = cvRound(fval);
3141                         *(uchar*)data = CV_CAST_8U(ival);
3142                         data++;
3143                         break;
3144                     case CV_8S:
3145                         ival = cvRound(fval);
3146                         *(char*)data = CV_CAST_8S(ival);
3147                         data++;
3148                         break;
3149                     case CV_16U:
3150                         ival = cvRound(fval);
3151                         *(ushort*)data = CV_CAST_16U(ival);
3152                         data += sizeof(ushort);
3153                         break;
3154                     case CV_16S:
3155                         ival = cvRound(fval);
3156                         *(short*)data = CV_CAST_16S(ival);
3157                         data += sizeof(short);
3158                         break;
3159                     case CV_32S:
3160                         ival = cvRound(fval);
3161                         *(int*)data = ival;
3162                         data += sizeof(int);
3163                         break;
3164                     case CV_32F:
3165                         *(float*)data = (float)fval;
3166                         data += sizeof(float);
3167                         break;
3168                     case CV_64F:
3169                         *(double*)data = fval;
3170                         data += sizeof(double);
3171                         break;
3172                     case CV_USRTYPE1: /* reference */
3173                         ival = cvRound(fval);
3174                         *(size_t*)data = ival;
3175                         data += sizeof(size_t);
3176                         break;
3177                     default:
3178                         assert(0);
3179                         return;
3180                     }
3181                 }
3182                 else
3183                     CV_Error( CV_StsError,
3184                     "The sequence element is not a numerical scalar" );
3185
3186                 CV_NEXT_SEQ_ELEM( sizeof(CvFileNode), *reader );
3187                 if( !--len )
3188                     goto end_loop;
3189             }
3190
3191             offset = (int)(data - data0);
3192         }
3193     }
3194
3195 end_loop:
3196     if( i != count - 1 || k != fmt_pair_count - 1 )
3197         CV_Error( CV_StsBadSize,
3198         "The sequence slice does not fit an integer number of records" );
3199
3200     if( !reader->seq )
3201         reader->ptr -= sizeof(CvFileNode);
3202 }
3203
3204
3205 CV_IMPL void
3206 cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
3207                void* data, const char* dt )
3208 {
3209     CvSeqReader reader;
3210
3211     if( !src || !data )
3212         CV_Error( CV_StsNullPtr, "Null pointers to source file node or destination array" );
3213
3214     cvStartReadRawData( fs, src, &reader );
3215     cvReadRawDataSlice( fs, &reader, CV_NODE_IS_SEQ(src->tag) ?
3216                         src->data.seq->total : 1, data, dt );
3217 }
3218
3219
3220 static void
3221 icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node );
3222
3223 static void
3224 icvWriteCollection( CvFileStorage* fs, const CvFileNode* node )
3225 {
3226     int i, total = node->data.seq->total;
3227     int elem_size = node->data.seq->elem_size;
3228     int is_map = CV_NODE_IS_MAP(node->tag);
3229     CvSeqReader reader;
3230
3231     cvStartReadSeq( node->data.seq, &reader, 0 );
3232
3233     for( i = 0; i < total; i++ )
3234     {
3235         CvFileMapNode* elem = (CvFileMapNode*)reader.ptr;
3236         if( !is_map || CV_IS_SET_ELEM(elem) )
3237         {
3238             const char* name = is_map ? elem->key->str.ptr : 0;
3239             icvWriteFileNode( fs, name, &elem->value );
3240         }
3241         CV_NEXT_SEQ_ELEM( elem_size, reader );
3242     }
3243 }
3244
3245 static void
3246 icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node )
3247 {
3248     switch( CV_NODE_TYPE(node->tag) )
3249     {
3250     case CV_NODE_INT:
3251         fs->write_int( fs, name, node->data.i );
3252         break;
3253     case CV_NODE_REAL:
3254         fs->write_real( fs, name, node->data.f );
3255         break;
3256     case CV_NODE_STR:
3257         fs->write_string( fs, name, node->data.str.ptr, 0 );
3258         break;
3259     case CV_NODE_SEQ:
3260     case CV_NODE_MAP:
3261         fs->start_write_struct( fs, name, CV_NODE_TYPE(node->tag) +
3262                 (CV_NODE_SEQ_IS_SIMPLE(node->data.seq) ? CV_NODE_FLOW : 0),
3263                 node->info ? node->info->type_name : 0 );
3264         icvWriteCollection( fs, node );
3265         fs->end_write_struct( fs );
3266         break;
3267     case CV_NODE_NONE:
3268         fs->start_write_struct( fs, name, CV_NODE_SEQ, 0 );
3269         fs->end_write_struct( fs );
3270         break;
3271     default:
3272         CV_Error( CV_StsBadFlag, "Unknown type of file node" );
3273     }
3274 }
3275
3276
3277 CV_IMPL void
3278 cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
3279                  const CvFileNode* node, int embed )
3280 {
3281     CvFileStorage* dst = 0;
3282     CV_CHECK_OUTPUT_FILE_STORAGE(fs);
3283
3284     if( !node )
3285         return;
3286
3287     if( CV_NODE_IS_COLLECTION(node->tag) && embed )
3288     {
3289         icvWriteCollection( fs, node );
3290     }
3291     else
3292     {
3293         icvWriteFileNode( fs, new_node_name, node );
3294     }
3295     /*
3296     int i, stream_count;
3297     stream_count = fs->roots->total;
3298     for( i = 0; i < stream_count; i++ )
3299     {
3300         CvFileNode* node = (CvFileNode*)cvGetSeqElem( fs->roots, i, 0 );
3301         icvDumpCollection( dst, node );
3302         if( i < stream_count - 1 )
3303             dst->start_next_stream( dst );
3304     }*/
3305     cvReleaseFileStorage( &dst );
3306 }
3307
3308
3309 CV_IMPL const char*
3310 cvGetFileNodeName( const CvFileNode* file_node )
3311 {
3312     return file_node && CV_NODE_HAS_NAME(file_node->tag) ?
3313         ((CvFileMapNode*)file_node)->key->str.ptr : 0;
3314 }
3315
3316 /****************************************************************************************\
3317 *                          Reading/Writing etc. for standard types                       *
3318 \****************************************************************************************/
3319
3320 /*#define CV_TYPE_NAME_MAT "opencv-matrix"
3321 #define CV_TYPE_NAME_MATND "opencv-nd-matrix"
3322 #define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"
3323 #define CV_TYPE_NAME_IMAGE "opencv-image"
3324 #define CV_TYPE_NAME_SEQ "opencv-sequence"
3325 #define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"
3326 #define CV_TYPE_NAME_GRAPH "opencv-graph"*/
3327
3328 /******************************* CvMat ******************************/
3329
3330 static int
3331 icvIsMat( const void* ptr )
3332 {
3333     return CV_IS_MAT_HDR(ptr);
3334 }
3335
3336 static void
3337 icvWriteMat( CvFileStorage* fs, const char* name,
3338              const void* struct_ptr, CvAttrList /*attr*/ )
3339 {
3340     const CvMat* mat = (const CvMat*)struct_ptr;
3341     char dt[16];
3342     CvSize size;
3343     int y;
3344
3345     assert( CV_IS_MAT(mat) );
3346
3347     cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_MAT );
3348     cvWriteInt( fs, "rows", mat->rows );
3349     cvWriteInt( fs, "cols", mat->cols );
3350     cvWriteString( fs, "dt", icvEncodeFormat( CV_MAT_TYPE(mat->type), dt ), 0 );
3351     cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3352
3353     size = cvGetSize(mat);
3354     if( CV_IS_MAT_CONT(mat->type) )
3355     {
3356         size.width *= size.height;
3357         size.height = 1;
3358     }
3359
3360     for( y = 0; y < size.height; y++ )
3361         cvWriteRawData( fs, mat->data.ptr + y*mat->step, size.width, dt );
3362     cvEndWriteStruct( fs );
3363     cvEndWriteStruct( fs );
3364 }
3365
3366
3367 static int
3368 icvFileNodeSeqLen( CvFileNode* node )
3369 {
3370     return CV_NODE_IS_COLLECTION(node->tag) ? node->data.seq->total :
3371            CV_NODE_TYPE(node->tag) != CV_NODE_NONE;
3372 }
3373
3374
3375 static void*
3376 icvReadMat( CvFileStorage* fs, CvFileNode* node )
3377 {
3378     void* ptr = 0;
3379     CvMat* mat;
3380     const char* dt;
3381     CvFileNode* data;
3382     int rows, cols, elem_type;
3383
3384     rows = cvReadIntByName( fs, node, "rows", 0 );
3385     cols = cvReadIntByName( fs, node, "cols", 0 );
3386     dt = cvReadStringByName( fs, node, "dt", 0 );
3387
3388     if( rows == 0 || cols == 0 || dt == 0 )
3389         CV_Error( CV_StsError, "Some of essential matrix attributes are absent" );
3390
3391     elem_type = icvDecodeSimpleFormat( dt );
3392
3393     data = cvGetFileNodeByName( fs, node, "data" );
3394     if( !data )
3395         CV_Error( CV_StsError, "The matrix data is not found in file storage" );
3396
3397     if( icvFileNodeSeqLen( data ) != rows*cols*CV_MAT_CN(elem_type) )
3398         CV_Error( CV_StsUnmatchedSizes,
3399         "The matrix size does not match to the number of stored elements" );
3400
3401     mat = cvCreateMat( rows, cols, elem_type );
3402     cvReadRawData( fs, data, mat->data.ptr, dt );
3403
3404     ptr = mat;
3405     return ptr;
3406 }
3407
3408
3409 /******************************* CvMatND ******************************/
3410
3411 static int
3412 icvIsMatND( const void* ptr )
3413 {
3414     return CV_IS_MATND(ptr);
3415 }
3416
3417
3418 static void
3419 icvWriteMatND( CvFileStorage* fs, const char* name,
3420                const void* struct_ptr, CvAttrList /*attr*/ )
3421 {
3422     void* mat = (void*)struct_ptr;
3423     CvMatND stub;
3424     CvNArrayIterator iterator;
3425     int dims, sizes[CV_MAX_DIM];
3426     char dt[16];
3427
3428     assert( CV_IS_MATND(mat) );
3429
3430     cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_MATND );
3431     dims = cvGetDims( mat, sizes );
3432     cvStartWriteStruct( fs, "sizes", CV_NODE_SEQ + CV_NODE_FLOW );
3433     cvWriteRawData( fs, sizes, dims, "i" );
3434     cvEndWriteStruct( fs );
3435     cvWriteString( fs, "dt", icvEncodeFormat( cvGetElemType(mat), dt ), 0 );
3436     cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3437
3438     cvInitNArrayIterator( 1, &mat, 0, &stub, &iterator );
3439
3440     do
3441         cvWriteRawData( fs, iterator.ptr[0], iterator.size.width, dt );
3442     while( cvNextNArraySlice( &iterator ));
3443     cvEndWriteStruct( fs );
3444     cvEndWriteStruct( fs );
3445 }
3446
3447
3448 static void*
3449 icvReadMatND( CvFileStorage* fs, CvFileNode* node )
3450 {
3451     void* ptr = 0;
3452     CvMatND* mat;
3453     const char* dt;
3454     CvFileNode* data;
3455     CvFileNode* sizes_node;
3456     int sizes[CV_MAX_DIM], dims, elem_type;
3457     int i, total_size;
3458
3459     sizes_node = cvGetFileNodeByName( fs, node, "sizes" );
3460     dt = cvReadStringByName( fs, node, "dt", 0 );
3461
3462     if( !sizes_node || !dt )
3463         CV_Error( CV_StsError, "Some of essential matrix attributes are absent" );
3464
3465     dims = CV_NODE_IS_SEQ(sizes_node->tag) ? sizes_node->data.seq->total :
3466            CV_NODE_IS_INT(sizes_node->tag) ? 1 : -1;
3467
3468     if( dims <= 0 || dims > CV_MAX_DIM )
3469         CV_Error( CV_StsParseError, "Could not determine the matrix dimensionality" );
3470
3471     cvReadRawData( fs, sizes_node, sizes, "i" );
3472     elem_type = icvDecodeSimpleFormat( dt );
3473
3474     data = cvGetFileNodeByName( fs, node, "data" );
3475     if( !data )
3476         CV_Error( CV_StsError, "The matrix data is not found in file storage" );
3477
3478     for( total_size = CV_MAT_CN(elem_type), i = 0; i < dims; i++ )
3479         total_size *= sizes[i];
3480
3481     if( icvFileNodeSeqLen( data ) != total_size )
3482         CV_Error( CV_StsUnmatchedSizes,
3483         "The matrix size does not match to the number of stored elements" );
3484
3485     mat = cvCreateMatND( dims, sizes, elem_type );
3486     cvReadRawData( fs, data, mat->data.ptr, dt );
3487
3488     ptr = mat;
3489     return ptr;
3490 }
3491
3492
3493 /******************************* CvSparseMat ******************************/
3494
3495 static int
3496 icvIsSparseMat( const void* ptr )
3497 {
3498     return CV_IS_SPARSE_MAT(ptr);
3499 }
3500
3501
3502 static int
3503 icvSortIdxCmpFunc( const void* _a, const void* _b, void* userdata )
3504 {
3505     int i, dims = *(int*)userdata;
3506     const int* a = *(const int**)_a;
3507     const int* b = *(const int**)_b;
3508
3509     for( i = 0; i < dims; i++ )
3510     {
3511         int delta = a[i] - b[i];
3512         if( delta )
3513             return delta;
3514     }
3515
3516     return 0;
3517 }
3518
3519
3520 static void
3521 icvWriteSparseMat( CvFileStorage* fs, const char* name,
3522                    const void* struct_ptr, CvAttrList /*attr*/ )
3523 {
3524     CvMemStorage* memstorage = 0;
3525     const CvSparseMat* mat = (const CvSparseMat*)struct_ptr;
3526     CvSparseMatIterator iterator;
3527     CvSparseNode* node;
3528     CvSeq* elements;
3529     CvSeqReader reader;
3530     int i, dims;
3531     int *prev_idx = 0;
3532     char dt[16];
3533
3534     assert( CV_IS_SPARSE_MAT(mat) );
3535
3536     memstorage = cvCreateMemStorage();
3537
3538     cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SPARSE_MAT );
3539     dims = cvGetDims( mat, 0 );
3540
3541     cvStartWriteStruct( fs, "sizes", CV_NODE_SEQ + CV_NODE_FLOW );
3542     cvWriteRawData( fs, mat->size, dims, "i" );
3543     cvEndWriteStruct( fs );
3544     cvWriteString( fs, "dt", icvEncodeFormat( CV_MAT_TYPE(mat->type), dt ), 0 );
3545     cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3546
3547     elements = cvCreateSeq( CV_SEQ_ELTYPE_PTR, sizeof(CvSeq), sizeof(int*), memstorage );
3548
3549     node = cvInitSparseMatIterator( mat, &iterator );
3550     while( node )
3551     {
3552         int* idx = CV_NODE_IDX( mat, node );
3553         cvSeqPush( elements, &idx );
3554         node = cvGetNextSparseNode( &iterator );
3555     }
3556
3557     cvSeqSort( elements, icvSortIdxCmpFunc, &dims );
3558     cvStartReadSeq( elements, &reader, 0 );
3559
3560     for( i = 0; i < elements->total; i++ )
3561     {
3562         int* idx;
3563         void* val;
3564         int k = 0;
3565
3566         CV_READ_SEQ_ELEM( idx, reader );
3567         if( i > 0 )
3568         {
3569             for( ; idx[k] == prev_idx[k]; k++ )
3570                 assert( k < dims );
3571             if( k < dims - 1 )
3572                 fs->write_int( fs, 0, k - dims + 1 );
3573         }
3574         for( ; k < dims; k++ )
3575             fs->write_int( fs, 0, idx[k] );
3576         prev_idx = idx;
3577
3578         node = (CvSparseNode*)((uchar*)idx - mat->idxoffset );
3579         val = CV_NODE_VAL( mat, node );
3580
3581         cvWriteRawData( fs, val, 1, dt );
3582     }
3583
3584     cvEndWriteStruct( fs );
3585     cvEndWriteStruct( fs );
3586     cvReleaseMemStorage( &memstorage );
3587 }
3588
3589
3590 static void*
3591 icvReadSparseMat( CvFileStorage* fs, CvFileNode* node )
3592 {
3593     void* ptr = 0;
3594     CvSparseMat* mat;
3595     const char* dt;
3596     CvFileNode* data;
3597     CvFileNode* sizes_node;
3598     CvSeqReader reader;
3599     CvSeq* elements;
3600     int* idx;
3601     int* sizes = 0, dims, elem_type, cn;
3602     int i;
3603
3604     sizes_node = cvGetFileNodeByName( fs, node, "sizes" );
3605     dt = cvReadStringByName( fs, node, "dt", 0 );
3606
3607     if( !sizes_node || !dt )
3608         CV_Error( CV_StsError, "Some of essential matrix attributes are absent" );
3609
3610     dims = CV_NODE_IS_SEQ(sizes_node->tag) ? sizes_node->data.seq->total :
3611            CV_NODE_IS_INT(sizes_node->tag) ? 1 : -1;
3612
3613     if( dims <= 0 || dims > CV_MAX_DIM_HEAP )
3614         CV_Error( CV_StsParseError, "Could not determine sparse matrix dimensionality" );
3615
3616     sizes = (int*)cvStackAlloc( dims*sizeof(sizes[0]));
3617     cvReadRawData( fs, sizes_node, sizes, "i" );
3618     elem_type = icvDecodeSimpleFormat( dt );
3619
3620     data = cvGetFileNodeByName( fs, node, "data" );
3621     if( !data || !CV_NODE_IS_SEQ(data->tag) )
3622         CV_Error( CV_StsError, "The matrix data is not found in file storage" );
3623
3624     mat = cvCreateSparseMat( dims, sizes, elem_type );
3625
3626     cn = CV_MAT_CN(elem_type);
3627     idx = (int*)alloca( dims*sizeof(idx[0]) );
3628     elements = data->data.seq;
3629     cvStartReadRawData( fs, data, &reader );
3630
3631     for( i = 0; i < elements->total; )
3632     {
3633         CvFileNode* elem = (CvFileNode*)reader.ptr;
3634         uchar* val;
3635         int k;
3636         if( !CV_NODE_IS_INT(elem->tag ))
3637             CV_Error( CV_StsParseError, "Sparse matrix data is corrupted" );
3638         k = elem->data.i;
3639         if( i > 0 && k >= 0 )
3640             idx[dims-1] = k;
3641         else
3642         {
3643             if( i > 0 )
3644                 k = dims + k - 1;
3645             else
3646                 idx[0] = k, k = 1;
3647             for( ; k < dims; k++ )
3648             {
3649                 CV_NEXT_SEQ_ELEM( elements->elem_size, reader );
3650                 i++;
3651                 elem = (CvFileNode*)reader.ptr;
3652                 if( !CV_NODE_IS_INT(elem->tag ) || elem->data.i < 0 )
3653                     CV_Error( CV_StsParseError, "Sparse matrix data is corrupted" );
3654                 idx[k] = elem->data.i;
3655             }
3656         }
3657         CV_NEXT_SEQ_ELEM( elements->elem_size, reader );
3658         i++;
3659         val = cvPtrND( mat, idx, 0, 1, 0 );
3660         cvReadRawDataSlice( fs, &reader, cn, val, dt );
3661         i += cn;
3662     }
3663
3664     ptr = mat;
3665     return ptr;
3666 }
3667
3668
3669 /******************************* IplImage ******************************/
3670
3671 static int
3672 icvIsImage( const void* ptr )
3673 {
3674     return CV_IS_IMAGE_HDR(ptr);
3675 }
3676
3677 static void
3678 icvWriteImage( CvFileStorage* fs, const char* name,
3679                const void* struct_ptr, CvAttrList /*attr*/ )
3680 {
3681     const IplImage* image = (const IplImage*)struct_ptr;
3682     char dt_buf[16], *dt;
3683     CvSize size;
3684     int y, depth;
3685
3686     assert( CV_IS_IMAGE(image) );
3687
3688     if( image->dataOrder == IPL_DATA_ORDER_PLANE )
3689         CV_Error( CV_StsUnsupportedFormat,
3690         "Images with planar data layout are not supported" );
3691
3692     cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_IMAGE );
3693     cvWriteInt( fs, "width", image->width );
3694     cvWriteInt( fs, "height", image->height );
3695     cvWriteString( fs, "origin", image->origin == IPL_ORIGIN_TL
3696                    ? "top-left" : "bottom-left", 0 );
3697     cvWriteString( fs, "layout", image->dataOrder == IPL_DATA_ORDER_PLANE
3698                    ? "planar" : "interleaved", 0 );
3699     if( image->roi )
3700     {
3701         cvStartWriteStruct( fs, "roi", CV_NODE_MAP + CV_NODE_FLOW );
3702         cvWriteInt( fs, "x", image->roi->xOffset );
3703         cvWriteInt( fs, "y", image->roi->yOffset );
3704         cvWriteInt( fs, "width", image->roi->width );
3705         cvWriteInt( fs, "height", image->roi->height );
3706         cvWriteInt( fs, "coi", image->roi->coi );
3707         cvEndWriteStruct( fs );
3708     }
3709
3710     depth = IplToCvDepth(image->depth);
3711     sprintf( dt_buf, "%d%c", image->nChannels, icvTypeSymbol[depth] );
3712     dt = dt_buf + (dt_buf[2] == '\0' && dt_buf[0] == '1');
3713     cvWriteString( fs, "dt", dt, 0 );
3714
3715     size = cvSize(image->width, image->height);
3716     if( size.width*image->nChannels*CV_ELEM_SIZE(depth) == image->widthStep )
3717     {
3718         size.width *= size.height;
3719         size.height = 1;
3720     }
3721
3722     cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3723     for( y = 0; y < size.height; y++ )
3724         cvWriteRawData( fs, image->imageData + y*image->widthStep, size.width, dt );
3725     cvEndWriteStruct( fs );
3726     cvEndWriteStruct( fs );
3727 }
3728
3729
3730 static void*
3731 icvReadImage( CvFileStorage* fs, CvFileNode* node )
3732 {
3733     void* ptr = 0;
3734     IplImage* image;
3735     const char* dt;
3736     CvFileNode* data;
3737     CvFileNode* roi_node;
3738     CvSeqReader reader;
3739     CvRect roi;
3740     int y, width, height, elem_type, coi, depth;
3741     const char* origin, *data_order;
3742
3743     width = cvReadIntByName( fs, node, "width", 0 );
3744     height = cvReadIntByName( fs, node, "height", 0 );
3745     dt = cvReadStringByName( fs, node, "dt", 0 );
3746     origin = cvReadStringByName( fs, node, "origin", 0 );
3747
3748     if( width == 0 || height == 0 || dt == 0 || origin == 0 )
3749         CV_Error( CV_StsError, "Some of essential image attributes are absent" );
3750
3751     elem_type = icvDecodeSimpleFormat( dt );
3752     data_order = cvReadStringByName( fs, node, "layout", "interleaved" );
3753     if( strcmp( data_order, "interleaved" ) != 0 )
3754         CV_Error( CV_StsError, "Only interleaved images can be read" );
3755
3756     data = cvGetFileNodeByName( fs, node, "data" );
3757     if( !data )
3758         CV_Error( CV_StsError, "The image data is not found in file storage" );
3759
3760     if( icvFileNodeSeqLen( data ) != width*height*CV_MAT_CN(elem_type) )
3761         CV_Error( CV_StsUnmatchedSizes,
3762         "The matrix size does not match to the number of stored elements" );
3763
3764     depth = cvIplDepth(elem_type);
3765     image = cvCreateImage( cvSize(width,height), depth, CV_MAT_CN(elem_type) );
3766
3767     roi_node = cvGetFileNodeByName( fs, node, "roi" );
3768     if( roi_node )
3769     {
3770         roi.x = cvReadIntByName( fs, roi_node, "x", 0 );
3771         roi.y = cvReadIntByName( fs, roi_node, "y", 0 );
3772         roi.width = cvReadIntByName( fs, roi_node, "width", 0 );
3773         roi.height = cvReadIntByName( fs, roi_node, "height", 0 );
3774         coi = cvReadIntByName( fs, roi_node, "coi", 0 );
3775
3776         cvSetImageROI( image, roi );
3777         cvSetImageCOI( image, coi );
3778     }
3779
3780     if( width*CV_ELEM_SIZE(elem_type) == image->widthStep )
3781     {
3782         width *= height;
3783         height = 1;
3784     }
3785
3786     width *= CV_MAT_CN(elem_type);
3787     cvStartReadRawData( fs, data, &reader );
3788     for( y = 0; y < height; y++ )
3789     {
3790         cvReadRawDataSlice( fs, &reader, width,
3791             image->imageData + y*image->widthStep, dt );
3792     }
3793
3794     ptr = image;
3795     return ptr;
3796 }
3797
3798
3799 /******************************* CvSeq ******************************/
3800
3801 static int
3802 icvIsSeq( const void* ptr )
3803 {
3804     return CV_IS_SEQ(ptr);
3805 }
3806
3807
3808 static void
3809 icvReleaseSeq( void** ptr )
3810 {
3811     if( !ptr )
3812         CV_Error( CV_StsNullPtr, "NULL double pointer" );
3813     *ptr = 0; // it's impossible now to release seq, so just clear the pointer
3814 }
3815
3816
3817 static void*
3818 icvCloneSeq( const void* ptr )
3819 {
3820     return cvSeqSlice( (CvSeq*)ptr, CV_WHOLE_SEQ,
3821                        0 /* use the same storage as for the original sequence */, 1 );
3822 }
3823
3824
3825 static void
3826 icvWriteHeaderData( CvFileStorage* fs, const CvSeq* seq,
3827                     CvAttrList* attr, int initial_header_size )
3828 {
3829     char header_dt_buf[128];
3830     const char* header_dt = cvAttrValue( attr, "header_dt" );
3831
3832     if( header_dt )
3833     {
3834         int dt_header_size;
3835         dt_header_size = icvCalcElemSize( header_dt, initial_header_size );
3836         if( dt_header_size > seq->header_size )
3837             CV_Error( CV_StsUnmatchedSizes,
3838             "The size of header calculated from \"header_dt\" is greater than header_size" );
3839     }
3840     else if( seq->header_size > initial_header_size )
3841     {
3842         if( CV_IS_SEQ(seq) && CV_IS_SEQ_POINT_SET(seq) &&
3843             seq->header_size == sizeof(CvPoint2DSeq) &&
3844             seq->elem_size == sizeof(int)*2 )
3845         {
3846             CvPoint2DSeq* point_seq = (CvPoint2DSeq*)seq;
3847
3848             cvStartWriteStruct( fs, "rect", CV_NODE_MAP + CV_NODE_FLOW );
3849             cvWriteInt( fs, "x", point_seq->rect.x );
3850             cvWriteInt( fs, "y", point_seq->rect.y );
3851             cvWriteInt( fs, "width", point_seq->rect.width );
3852             cvWriteInt( fs, "height", point_seq->rect.height );
3853             cvEndWriteStruct( fs );
3854             cvWriteInt( fs, "color", point_seq->color );
3855         }
3856         else if( CV_IS_SEQ(seq) && CV_IS_SEQ_CHAIN(seq) &&
3857                  CV_MAT_TYPE(seq->flags) == CV_8UC1 )
3858         {
3859             CvChain* chain = (CvChain*)seq;
3860
3861             cvStartWriteStruct( fs, "origin", CV_NODE_MAP + CV_NODE_FLOW );
3862             cvWriteInt( fs, "x", chain->origin.x );
3863             cvWriteInt( fs, "y", chain->origin.y );
3864             cvEndWriteStruct( fs );
3865         }
3866         else
3867         {
3868             unsigned extra_size = seq->header_size - initial_header_size;
3869             // a heuristic to provide nice defaults for sequences of int's & float's
3870             if( extra_size % sizeof(int) == 0 )
3871                 sprintf( header_dt_buf, "%ui", (unsigned)(extra_size/sizeof(int)) );
3872             else
3873                 sprintf( header_dt_buf, "%uu", extra_size );
3874             header_dt = header_dt_buf;
3875         }
3876     }
3877
3878     if( header_dt )
3879     {
3880         cvWriteString( fs, "header_dt", header_dt, 0 );
3881         cvStartWriteStruct( fs, "header_user_data", CV_NODE_SEQ + CV_NODE_FLOW );
3882         cvWriteRawData( fs, (uchar*)seq + sizeof(CvSeq), 1, header_dt );
3883         cvEndWriteStruct( fs );
3884     }
3885 }
3886
3887
3888 static char*
3889 icvGetFormat( const CvSeq* seq, const char* dt_key, CvAttrList* attr,
3890               int initial_elem_size, char* dt_buf )
3891 {
3892     char* dt = 0;
3893     dt = (char*)cvAttrValue( attr, dt_key );
3894
3895     if( dt )
3896     {
3897         int dt_elem_size;
3898         dt_elem_size = icvCalcElemSize( dt, initial_elem_size );
3899         if( dt_elem_size != seq->elem_size )
3900             CV_Error( CV_StsUnmatchedSizes,
3901             "The size of element calculated from \"dt\" and "
3902             "the elem_size do not match" );
3903     }
3904     else if( CV_MAT_TYPE(seq->flags) != 0 || seq->elem_size == 1 )
3905     {
3906         int align = CV_MAT_DEPTH(seq->flags) == CV_64F ? sizeof(double) : sizeof(size_t);
3907         int full_elem_size = cvAlign(CV_ELEM_SIZE(seq->flags) + initial_elem_size, align);
3908         if( seq->elem_size != full_elem_size )
3909             CV_Error( CV_StsUnmatchedSizes,
3910             "Size of sequence element (elem_size) is inconsistent with seq->flags" );
3911         dt = icvEncodeFormat( CV_MAT_TYPE(seq->flags), dt_buf );
3912     }
3913     else if( seq->elem_size > initial_elem_size )
3914     {
3915         unsigned extra_elem_size = seq->elem_size - initial_elem_size;
3916         // a heuristic to provide nice defaults for sequences of int's & float's
3917         if( extra_elem_size % sizeof(int) == 0 )
3918             sprintf( dt_buf, "%ui", (unsigned)(extra_elem_size/sizeof(int)) );
3919         else
3920             sprintf( dt_buf, "%uu", extra_elem_size );
3921         dt = dt_buf;
3922     }
3923
3924     return dt;
3925 }
3926
3927
3928 static void
3929 icvWriteSeq( CvFileStorage* fs, const char* name,
3930              const void* struct_ptr,
3931              CvAttrList attr, int level )
3932 {
3933     const CvSeq* seq = (CvSeq*)struct_ptr;
3934     CvSeqBlock* block;
3935     char buf[128];
3936     char dt_buf[128], *dt;
3937
3938     assert( CV_IS_SEQ( seq ));
3939     cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SEQ );
3940
3941     if( level >= 0 )
3942         cvWriteInt( fs, "level", level );
3943
3944     sprintf( buf, "%08x", seq->flags );
3945     cvWriteString( fs, "flags", buf, 1 );
3946     cvWriteInt( fs, "count", seq->total );
3947     dt = icvGetFormat( seq, "dt", &attr, 0, dt_buf );
3948     cvWriteString( fs, "dt", dt, 0 );
3949
3950     icvWriteHeaderData( fs, seq, &attr, sizeof(CvSeq) );
3951     cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3952
3953     for( block = seq->first; block; block = block->next )
3954     {
3955         cvWriteRawData( fs, block->data, block->count, dt );
3956         if( block == seq->first->prev )
3957             break;
3958     }
3959     cvEndWriteStruct( fs );
3960     cvEndWriteStruct( fs );
3961 }
3962
3963
3964 static void
3965 icvWriteSeqTree( CvFileStorage* fs, const char* name,
3966                  const void* struct_ptr, CvAttrList attr )
3967 {
3968     const CvSeq* seq = (CvSeq*)struct_ptr;
3969     const char* recursive_value = cvAttrValue( &attr, "recursive" );
3970     int is_recursive = recursive_value &&
3971                        strcmp(recursive_value,"0") != 0 &&
3972                        strcmp(recursive_value,"false") != 0 &&
3973                        strcmp(recursive_value,"False") != 0 &&
3974                        strcmp(recursive_value,"FALSE") != 0;
3975
3976     assert( CV_IS_SEQ( seq ));
3977
3978     if( !is_recursive )
3979     {
3980         icvWriteSeq( fs, name, seq, attr, -1 );
3981     }
3982     else
3983     {
3984         CvTreeNodeIterator tree_iterator;
3985
3986         cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SEQ_TREE );
3987         cvStartWriteStruct( fs, "sequences", CV_NODE_SEQ );
3988         cvInitTreeNodeIterator( &tree_iterator, seq, INT_MAX );
3989
3990         for(;;)
3991         {
3992             if( !tree_iterator.node )
3993                 break;
3994             icvWriteSeq( fs, 0, tree_iterator.node, attr, tree_iterator.level );
3995             cvNextTreeNode( &tree_iterator );
3996         }
3997
3998         cvEndWriteStruct( fs );
3999         cvEndWriteStruct( fs );
4000     }
4001 }
4002
4003
4004 static void*
4005 icvReadSeq( CvFileStorage* fs, CvFileNode* node )
4006 {
4007     void* ptr = 0;
4008     CvSeq* seq;
4009     CvSeqBlock* block;
4010     CvFileNode *data, *header_node, *rect_node, *origin_node;
4011     CvSeqReader reader;
4012     int total, flags;
4013     int elem_size, header_size = sizeof(CvSeq);
4014     int fmt_pairs[CV_FS_MAX_FMT_PAIRS], i, fmt_pair_count;
4015     int items_per_elem = 0;
4016     const char* flags_str;
4017     const char* header_dt;
4018     const char* dt;
4019     char* endptr = 0;
4020
4021     flags_str = cvReadStringByName( fs, node, "flags", 0 );
4022     total = cvReadIntByName( fs, node, "count", -1 );
4023     dt = cvReadStringByName( fs, node, "dt", 0 );
4024
4025     if( !flags_str || total == -1 || !dt )
4026         CV_Error( CV_StsError, "Some of essential sequence attributes are absent" );
4027
4028     flags = (int)strtol( flags_str, &endptr, 16 );
4029     if( endptr == flags_str || (flags & CV_MAGIC_MASK) != CV_SEQ_MAGIC_VAL )
4030         CV_Error( CV_StsError, "The sequence flags are invalid" );
4031
4032     header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
4033     header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
4034
4035     if( (header_dt != 0) ^ (header_node != 0) )
4036         CV_Error( CV_StsError,
4037         "One of \"header_dt\" and \"header_user_data\" is there, while the other is not" );
4038
4039     rect_node = cvGetFileNodeByName( fs, node, "rect" );
4040     origin_node = cvGetFileNodeByName( fs, node, "origin" );
4041
4042     if( (header_node != 0) + (rect_node != 0) + (origin_node != 0) > 1 )
4043         CV_Error( CV_StsError, "Only one of \"header_user_data\", \"rect\" and \"origin\" tags may occur" );
4044
4045     if( header_dt )
4046     {
4047         header_size = icvCalcElemSize( header_dt, header_size );
4048     }
4049     else if( rect_node )
4050         header_size = sizeof(CvPoint2DSeq);
4051     else if( origin_node )
4052         header_size = sizeof(CvChain);
4053
4054     elem_size = icvCalcElemSize( dt, 0 );
4055     seq = cvCreateSeq( flags, header_size, elem_size, fs->dststorage );
4056
4057     if( header_node )
4058     {
4059         cvReadRawData( fs, header_node, (char*)seq + sizeof(CvSeq), header_dt );
4060     }
4061     else if( rect_node )
4062     {
4063         CvPoint2DSeq* point_seq = (CvPoint2DSeq*)seq;
4064         point_seq->rect.x = cvReadIntByName( fs, rect_node, "x", 0 );
4065         point_seq->rect.y = cvReadIntByName( fs, rect_node, "y", 0 );
4066         point_seq->rect.width = cvReadIntByName( fs, rect_node, "width", 0 );
4067         point_seq->rect.height = cvReadIntByName( fs, rect_node, "height", 0 );
4068         point_seq->color = cvReadIntByName( fs, node, "color", 0 );
4069     }
4070     else if( origin_node )
4071     {
4072         CvChain* chain = (CvChain*)seq;
4073         chain->origin.x = cvReadIntByName( fs, origin_node, "x", 0 );
4074         chain->origin.y = cvReadIntByName( fs, origin_node, "y", 0 );
4075     }
4076
4077     cvSeqPushMulti( seq, 0, total, 0 );
4078     fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
4079     fmt_pair_count *= 2;
4080     for( i = 0; i < fmt_pair_count; i += 2 )
4081         items_per_elem += fmt_pairs[i];
4082
4083     data = cvGetFileNodeByName( fs, node, "data" );
4084     if( !data )
4085         CV_Error( CV_StsError, "The image data is not found in file storage" );
4086
4087     if( icvFileNodeSeqLen( data ) != total*items_per_elem )
4088         CV_Error( CV_StsError, "The number of stored elements does not match to \"count\"" );
4089
4090     cvStartReadRawData( fs, data, &reader );
4091     for( block = seq->first; block; block = block->next )
4092     {
4093         int delta = block->count*items_per_elem;
4094         cvReadRawDataSlice( fs, &reader, delta, block->data, dt );
4095         if( block == seq->first->prev )
4096             break;
4097     }
4098
4099     ptr = seq;
4100     return ptr;
4101 }
4102
4103
4104 static void*
4105 icvReadSeqTree( CvFileStorage* fs, CvFileNode* node )
4106 {
4107     void* ptr = 0;
4108     CvFileNode *sequences_node = cvGetFileNodeByName( fs, node, "sequences" );
4109     CvSeq* sequences;
4110     CvSeq* root = 0;
4111     CvSeq* parent = 0;
4112     CvSeq* prev_seq = 0;
4113     CvSeqReader reader;
4114     int i, total;
4115     int prev_level = 0;
4116
4117     if( !sequences_node || !CV_NODE_IS_SEQ(sequences_node->tag) )
4118         CV_Error( CV_StsParseError,
4119         "opencv-sequence-tree instance should contain a field \"sequences\" that should be a sequence" );
4120
4121     sequences = sequences_node->data.seq;
4122     total = sequences->total;
4123
4124     cvStartReadSeq( sequences, &reader, 0 );
4125     for( i = 0; i < total; i++ )
4126     {
4127         CvFileNode* elem = (CvFileNode*)reader.ptr;
4128         CvSeq* seq;
4129         int level;
4130         seq = (CvSeq*)cvRead( fs, elem );
4131         level = cvReadIntByName( fs, elem, "level", -1 );
4132         if( level < 0 )
4133             CV_Error( CV_StsParseError, "All the sequence tree nodes should contain \"level\" field" );
4134         if( !root )
4135             root = seq;
4136         if( level > prev_level )
4137         {
4138             assert( level == prev_level + 1 );
4139             parent = prev_seq;
4140             prev_seq = 0;
4141             if( parent )
4142                 parent->v_next = seq;
4143         }
4144         else if( level < prev_level )
4145         {
4146             for( ; prev_level > level; prev_level-- )
4147                 prev_seq = prev_seq->v_prev;
4148             parent = prev_seq->v_prev;
4149         }
4150         seq->h_prev = prev_seq;
4151         if( prev_seq )
4152             prev_seq->h_next = seq;
4153         seq->v_prev = parent;
4154         prev_seq = seq;
4155         prev_level = level;
4156         CV_NEXT_SEQ_ELEM( sequences->elem_size, reader );
4157     }
4158
4159     ptr = root;
4160     return ptr;
4161 }
4162
4163 /******************************* CvGraph ******************************/
4164
4165 static int
4166 icvIsGraph( const void* ptr )
4167 {
4168     return CV_IS_GRAPH(ptr);
4169 }
4170
4171
4172 static void
4173 icvReleaseGraph( void** ptr )
4174 {
4175     if( !ptr )
4176         CV_Error( CV_StsNullPtr, "NULL double pointer" );
4177
4178     *ptr = 0; // it's impossible now to release graph, so just clear the pointer
4179 }
4180
4181
4182 static void*
4183 icvCloneGraph( const void* ptr )
4184 {
4185     return cvCloneGraph( (const CvGraph*)ptr, 0 );
4186 }
4187
4188
4189 static void
4190 icvWriteGraph( CvFileStorage* fs, const char* name,
4191                const void* struct_ptr, CvAttrList attr )
4192 {
4193     int* flag_buf = 0;
4194     char* write_buf = 0;
4195     const CvGraph* graph = (const CvGraph*)struct_ptr;
4196     CvSeqReader reader;
4197     char buf[128];
4198     int i, k, vtx_count, edge_count;
4199     char vtx_dt_buf[128], *vtx_dt;
4200     char edge_dt_buf[128], *edge_dt;
4201     int write_buf_size;
4202
4203     assert( CV_IS_GRAPH(graph) );
4204     vtx_count = cvGraphGetVtxCount( graph );
4205     edge_count = cvGraphGetEdgeCount( graph );
4206     flag_buf = (int*)cvAlloc( vtx_count*sizeof(flag_buf[0]));
4207
4208     // count vertices
4209     cvStartReadSeq( (CvSeq*)graph, &reader );
4210     for( i = 0, k = 0; i < graph->total; i++ )
4211     {
4212         if( CV_IS_SET_ELEM( reader.ptr ))
4213         {
4214             CvGraphVtx* vtx = (CvGraphVtx*)reader.ptr;
4215             flag_buf[k] = vtx->flags;
4216             vtx->flags = k++;
4217         }
4218         CV_NEXT_SEQ_ELEM( graph->elem_size, reader );
4219     }
4220
4221     // write header
4222     cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_GRAPH );
4223
4224     sprintf( buf, "%08x", graph->flags );
4225     cvWriteString( fs, "flags", buf, 1 );
4226
4227     cvWriteInt( fs, "vertex_count", vtx_count );
4228     vtx_dt = icvGetFormat( (CvSeq*)graph, "vertex_dt",
4229                     &attr, sizeof(CvGraphVtx), vtx_dt_buf );
4230     if( vtx_dt )
4231         cvWriteString( fs, "vertex_dt", vtx_dt, 0 );
4232
4233     cvWriteInt( fs, "edge_count", edge_count );
4234     edge_dt = icvGetFormat( (CvSeq*)graph->edges, "edge_dt",
4235                                 &attr, sizeof(CvGraphEdge), buf );
4236     sprintf( edge_dt_buf, "2if%s", edge_dt ? edge_dt : "" );
4237     edge_dt = edge_dt_buf;
4238     cvWriteString( fs, "edge_dt", edge_dt, 0 );
4239
4240     icvWriteHeaderData( fs, (CvSeq*)graph, &attr, sizeof(CvGraph) );
4241
4242     write_buf_size = MAX( 3*graph->elem_size, 1 << 16 );
4243     write_buf_size = MAX( 3*graph->edges->elem_size, write_buf_size );
4244     write_buf = (char*)cvAlloc( write_buf_size );
4245
4246     // as vertices and edges are written in similar way,
4247     // do it as a parametrized 2-iteration loop
4248     for( k = 0; k < 2; k++ )
4249     {
4250         const char* dt = k == 0 ? vtx_dt : edge_dt;
4251         if( dt )
4252         {
4253             CvSet* data = k == 0 ? (CvSet*)graph : graph->edges;
4254             int elem_size = data->elem_size;
4255             int write_elem_size = icvCalcElemSize( dt, 0 );
4256             char* src_ptr = write_buf;
4257             int write_max = write_buf_size / write_elem_size, write_count = 0;
4258
4259             // alignment of user part of the edge data following 2if
4260             int edge_user_align = sizeof(float);
4261
4262             if( k == 1 )
4263             {
4264                 int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
4265                 fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
4266                 if( fmt_pair_count > 2 || CV_ELEM_SIZE(fmt_pairs[2*2+1]) >= (int)sizeof(double))
4267                     edge_user_align = sizeof(double);
4268             }
4269
4270             cvStartWriteStruct( fs, k == 0 ? "vertices" : "edges",
4271                                 CV_NODE_SEQ + CV_NODE_FLOW );
4272             cvStartReadSeq( (CvSeq*)data, &reader );
4273             for( i = 0; i < data->total; i++ )
4274             {
4275                 if( CV_IS_SET_ELEM( reader.ptr ))
4276                 {
4277                     if( k == 0 ) // vertices
4278                         memcpy( src_ptr, reader.ptr + sizeof(CvGraphVtx), write_elem_size );
4279                     else
4280                     {
4281                         CvGraphEdge* edge = (CvGraphEdge*)reader.ptr;
4282                         src_ptr = (char*)cvAlignPtr( src_ptr, sizeof(int) );
4283                         ((int*)src_ptr)[0] = edge->vtx[0]->flags;
4284                         ((int*)src_ptr)[1] = edge->vtx[1]->flags;
4285                         *(float*)(src_ptr + sizeof(int)*2) = edge->weight;
4286                         if( elem_size > (int)sizeof(CvGraphEdge) )
4287                         {
4288                             char* src_ptr2 = (char*)cvAlignPtr( src_ptr + 2*sizeof(int)
4289                                                 + sizeof(float), edge_user_align );
4290                             memcpy( src_ptr2, edge + 1, elem_size - sizeof(CvGraphEdge) );
4291                         }
4292                     }
4293                     src_ptr += write_elem_size;
4294                     if( ++write_count >= write_max )
4295                     {
4296                         cvWriteRawData( fs, write_buf, write_count, dt );
4297                         write_count = 0;
4298                         src_ptr = write_buf;
4299                     }
4300                 }
4301                 CV_NEXT_SEQ_ELEM( data->elem_size, reader );
4302             }
4303
4304             if( write_count > 0 )
4305                 cvWriteRawData( fs, write_buf, write_count, dt );
4306             cvEndWriteStruct( fs );
4307         }
4308     }
4309
4310     cvEndWriteStruct( fs );
4311
4312     // final stage. restore the graph flags
4313     cvStartReadSeq( (CvSeq*)graph, &reader );
4314     vtx_count = 0;
4315     for( i = 0; i < graph->total; i++ )
4316     {
4317         if( CV_IS_SET_ELEM( reader.ptr ))
4318             ((CvGraphVtx*)reader.ptr)->flags = flag_buf[vtx_count++];
4319         CV_NEXT_SEQ_ELEM( graph->elem_size, reader );
4320     }
4321
4322     cvFree( &write_buf );
4323     cvFree( &flag_buf );
4324 }
4325
4326
4327 static void*
4328 icvReadGraph( CvFileStorage* fs, CvFileNode* node )
4329 {
4330     void* ptr = 0;
4331     char* read_buf = 0;
4332     CvGraphVtx** vtx_buf = 0;
4333     CvGraph* graph;
4334     CvFileNode *header_node, *vtx_node, *edge_node;
4335     int flags, vtx_count, edge_count;
4336     int vtx_size = sizeof(CvGraphVtx), edge_size, header_size = sizeof(CvGraph);
4337     int src_vtx_size = 0, src_edge_size;
4338     int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
4339     int vtx_items_per_elem = 0, edge_items_per_elem = 0;
4340     int edge_user_align = sizeof(float);
4341     int read_buf_size;
4342     int i, k;
4343     const char* flags_str;
4344     const char* header_dt;
4345     const char* vtx_dt;
4346     const char* edge_dt;
4347     char* endptr = 0;
4348
4349     flags_str = cvReadStringByName( fs, node, "flags", 0 );
4350     vtx_dt = cvReadStringByName( fs, node, "vertex_dt", 0 );
4351     edge_dt = cvReadStringByName( fs, node, "edge_dt", 0 );
4352     vtx_count = cvReadIntByName( fs, node, "vertex_count", -1 );
4353     edge_count = cvReadIntByName( fs, node, "edge_count", -1 );
4354
4355     if( !flags_str || vtx_count == -1 || edge_count == -1 || !edge_dt )
4356         CV_Error( CV_StsError, "Some of essential sequence attributes are absent" );
4357
4358     flags = (int)strtol( flags_str, &endptr, 16 );
4359     if( endptr == flags_str ||
4360         (flags & (CV_SEQ_KIND_MASK|CV_MAGIC_MASK)) != (CV_GRAPH|CV_SET_MAGIC_VAL))
4361         CV_Error( CV_StsError, "Invalid graph signature" );
4362
4363     header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
4364     header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
4365
4366     if( (header_dt != 0) ^ (header_node != 0) )
4367         CV_Error( CV_StsError,
4368         "One of \"header_dt\" and \"header_user_data\" is there, while the other is not" );
4369
4370     if( header_dt )
4371         header_size = icvCalcElemSize( header_dt, header_size );
4372
4373     if( vtx_dt > 0 )
4374     {
4375         src_vtx_size = icvCalcElemSize( vtx_dt, 0 );
4376         vtx_size = icvCalcElemSize( vtx_dt, vtx_size );
4377         fmt_pair_count = icvDecodeFormat( edge_dt,
4378                             fmt_pairs, CV_FS_MAX_FMT_PAIRS );
4379         fmt_pair_count *= 2;
4380         for( i = 0; i < fmt_pair_count; i += 2 )
4381             vtx_items_per_elem += fmt_pairs[i];
4382     }
4383
4384     {
4385         char dst_edge_dt_buf[128];
4386         const char* dst_edge_dt = 0;
4387
4388         fmt_pair_count = icvDecodeFormat( edge_dt,
4389                             fmt_pairs, CV_FS_MAX_FMT_PAIRS );
4390         if( fmt_pair_count < 2 ||
4391             fmt_pairs[0] != 2 || fmt_pairs[1] != CV_32S ||
4392             fmt_pairs[2] < 1 || fmt_pairs[3] != CV_32F )
4393             CV_Error( CV_StsBadArg,
4394             "Graph edges should start with 2 integers and a float" );
4395
4396         // alignment of user part of the edge data following 2if
4397         if( fmt_pair_count > 2 && CV_ELEM_SIZE(fmt_pairs[5]) >= (int)sizeof(double))
4398             edge_user_align = sizeof(double);
4399
4400         fmt_pair_count *= 2;
4401         for( i = 0; i < fmt_pair_count; i += 2 )
4402             edge_items_per_elem += fmt_pairs[i];
4403
4404         if( edge_dt[2] == 'f' || (edge_dt[2] == '1' && edge_dt[3] == 'f') )
4405             dst_edge_dt = edge_dt + 3 + isdigit(edge_dt[2]);
4406         else
4407         {
4408             int val = (int)strtol( edge_dt + 2, &endptr, 10 );
4409             sprintf( dst_edge_dt_buf, "%df%s", val-1, endptr );
4410             dst_edge_dt = dst_edge_dt_buf;
4411         }
4412
4413         edge_size = icvCalcElemSize( dst_edge_dt, sizeof(CvGraphEdge) );
4414         src_edge_size = icvCalcElemSize( edge_dt, 0 );
4415     }
4416
4417     graph = cvCreateGraph( flags, header_size, vtx_size, edge_size, fs->dststorage );
4418
4419     if( header_node )
4420         cvReadRawData( fs, header_node, (char*)graph + sizeof(CvGraph), header_dt );
4421
4422     read_buf_size = MAX( src_vtx_size*3, 1 << 16 );
4423     read_buf_size = MAX( src_edge_size*3, read_buf_size );
4424     read_buf = (char*)cvAlloc( read_buf_size );
4425     vtx_buf = (CvGraphVtx**)cvAlloc( vtx_count * sizeof(vtx_buf[0]) );
4426
4427     vtx_node = cvGetFileNodeByName( fs, node, "vertices" );
4428     edge_node = cvGetFileNodeByName( fs, node, "edges" );
4429     if( !edge_node )
4430         CV_Error( CV_StsBadArg, "No edges data" );
4431     if( vtx_dt && !vtx_node )
4432         CV_Error( CV_StsBadArg, "No vertices data" );
4433
4434     // as vertices and edges are read in similar way,
4435     // do it as a parametrized 2-iteration loop
4436     for( k = 0; k < 2; k++ )
4437     {
4438         const char* dt = k == 0 ? vtx_dt : edge_dt;
4439         int elem_size = k == 0 ? vtx_size : edge_size;
4440         int src_elem_size = k == 0 ? src_vtx_size : src_edge_size;
4441         int items_per_elem = k == 0 ? vtx_items_per_elem : edge_items_per_elem;
4442         int elem_count = k == 0 ? vtx_count : edge_count;
4443         char* dst_ptr = read_buf;
4444         int read_max = read_buf_size /MAX(src_elem_size, 1), read_count = 0;
4445         CvSeqReader reader;
4446         cvStartReadRawData( fs, k == 0 ? vtx_node : edge_node, &reader );
4447
4448         for( i = 0; i < elem_count; i++ )
4449         {
4450             if( read_count == 0 && dt )
4451             {
4452                 int count = MIN( elem_count - i, read_max )*items_per_elem;
4453                 cvReadRawDataSlice( fs, &reader, count, read_buf, dt );
4454                 read_count = count;
4455                 dst_ptr = read_buf;
4456             }
4457
4458             if( k == 0 )
4459             {
4460                 CvGraphVtx* vtx;
4461                 cvGraphAddVtx( graph, 0, &vtx );
4462                 vtx_buf[i] = vtx;
4463                 if( dt )
4464                     memcpy( vtx + 1, dst_ptr, src_elem_size );
4465             }
4466             else
4467             {
4468                 CvGraphEdge* edge = 0;
4469                 int vtx1 = ((int*)dst_ptr)[0];
4470                 int vtx2 = ((int*)dst_ptr)[1];
4471                 int result;
4472
4473                 if( (unsigned)vtx1 >= (unsigned)vtx_count ||
4474                     (unsigned)vtx2 >= (unsigned)vtx_count )
4475                     CV_Error( CV_StsOutOfRange,
4476                     "Some of stored vertex indices are out of range" );
4477
4478                 result = cvGraphAddEdgeByPtr( graph,
4479                     vtx_buf[vtx1], vtx_buf[vtx2], 0, &edge );
4480
4481                 if( result == 0 )
4482                     CV_Error( CV_StsBadArg, "Duplicated edge has occured" );
4483
4484                 edge->weight = *(float*)(dst_ptr + sizeof(int)*2);
4485                 if( elem_size > (int)sizeof(CvGraphEdge) )
4486                 {
4487                     char* dst_ptr2 = (char*)cvAlignPtr( dst_ptr + sizeof(int)*2 +
4488                                                 sizeof(float), edge_user_align );
4489                     memcpy( edge + 1, dst_ptr2, elem_size - sizeof(CvGraphEdge) );
4490                 }
4491             }
4492
4493             dst_ptr += src_elem_size;
4494             read_count--;
4495         }
4496     }
4497
4498     ptr = graph;
4499     cvFree( &read_buf );
4500     cvFree( &vtx_buf );
4501
4502     return ptr;
4503 }
4504
4505 /****************************************************************************************\
4506 *                                    RTTI Functions                                      *
4507 \****************************************************************************************/
4508
4509 CvTypeInfo *CvType::first = 0, *CvType::last = 0;
4510
4511 CvType::CvType( const char* type_name,
4512                 CvIsInstanceFunc is_instance, CvReleaseFunc release,
4513                 CvReadFunc read, CvWriteFunc write, CvCloneFunc clone )
4514 {
4515     CvTypeInfo _info;
4516     _info.flags = 0;
4517     _info.header_size = sizeof(_info);
4518     _info.type_name = type_name;
4519     _info.prev = _info.next = 0;
4520     _info.is_instance = is_instance;
4521     _info.release = release;
4522     _info.clone = clone;
4523     _info.read = read;
4524     _info.write = write;
4525
4526     cvRegisterType( &_info );
4527     info = first;
4528 }
4529
4530
4531 CvType::~CvType()
4532 {
4533     cvUnregisterType( info->type_name );
4534 }
4535
4536
4537 CvType seq_type( CV_TYPE_NAME_SEQ, icvIsSeq, icvReleaseSeq, icvReadSeq,
4538                  icvWriteSeqTree /* this is the entry point for
4539                  writing a single sequence too */, icvCloneSeq );
4540
4541 CvType seq_tree_type( CV_TYPE_NAME_SEQ_TREE, icvIsSeq, icvReleaseSeq,
4542                       icvReadSeqTree, icvWriteSeqTree, icvCloneSeq );
4543
4544 CvType seq_graph_type( CV_TYPE_NAME_GRAPH, icvIsGraph, icvReleaseGraph,
4545                        icvReadGraph, icvWriteGraph, icvCloneGraph );
4546
4547 CvType sparse_mat_type( CV_TYPE_NAME_SPARSE_MAT, icvIsSparseMat,
4548                         (CvReleaseFunc)cvReleaseSparseMat, icvReadSparseMat,
4549                         icvWriteSparseMat, (CvCloneFunc)cvCloneSparseMat );
4550
4551 CvType image_type( CV_TYPE_NAME_IMAGE, icvIsImage, (CvReleaseFunc)cvReleaseImage,
4552                    icvReadImage, icvWriteImage, (CvCloneFunc)cvCloneImage );
4553
4554 CvType mat_type( CV_TYPE_NAME_MAT, icvIsMat, (CvReleaseFunc)cvReleaseMat,
4555                  icvReadMat, icvWriteMat, (CvCloneFunc)cvCloneMat );
4556
4557 CvType matnd_type( CV_TYPE_NAME_MATND, icvIsMatND, (CvReleaseFunc)cvReleaseMatND,
4558                    icvReadMatND, icvWriteMatND, (CvCloneFunc)cvCloneMatND );
4559
4560 CV_IMPL  void
4561 cvRegisterType( const CvTypeInfo* _info )
4562 {
4563     CvTypeInfo* info = 0;
4564     int i, len;
4565     char c;
4566
4567     //if( !CvType::first )
4568     //    icvCreateStandardTypes();
4569
4570     if( !_info || _info->header_size != sizeof(CvTypeInfo) )
4571         CV_Error( CV_StsBadSize, "Invalid type info" );
4572
4573     if( !_info->is_instance || !_info->release ||
4574         !_info->read || !_info->write )
4575         CV_Error( CV_StsNullPtr,
4576         "Some of required function pointers "
4577         "(is_instance, release, read or write) are NULL");
4578
4579     c = _info->type_name[0];
4580     if( !isalpha(c) && c != '_' )
4581         CV_Error( CV_StsBadArg, "Type name should start with a letter or _" );
4582
4583     len = (int)strlen(_info->type_name);
4584
4585     for( i = 0; i < len; i++ )
4586     {
4587         c = _info->type_name[i];
4588         if( !isalnum(c) && c != '-' && c != '_' )
4589             CV_Error( CV_StsBadArg,
4590             "Type name should contain only letters, digits, - and _" );
4591     }
4592
4593     info = (CvTypeInfo*)malloc( sizeof(*info) + len + 1 );
4594
4595     *info = *_info;
4596     info->type_name = (char*)(info + 1);
4597     memcpy( (char*)info->type_name, _info->type_name, len + 1 );
4598
4599     info->flags = 0;
4600     info->next = CvType::first;
4601     info->prev = 0;
4602     if( CvType::first )
4603         CvType::first->prev = info;
4604     else
4605         CvType::last = info;
4606     CvType::first = info;
4607 }
4608
4609
4610 CV_IMPL void
4611 cvUnregisterType( const char* type_name )
4612 {
4613     CvTypeInfo* info;
4614
4615     info = cvFindType( type_name );
4616     if( info )
4617     {
4618         if( info->prev )
4619             info->prev->next = info->next;
4620         else
4621             CvType::first = info->next;
4622
4623         if( info->next )
4624             info->next->prev = info->prev;
4625         else
4626             CvType::last = info->prev;
4627
4628         if( !CvType::first || !CvType::last )
4629             CvType::first = CvType::last = 0;
4630
4631         free( info );
4632     }
4633 }
4634
4635
4636 CV_IMPL CvTypeInfo*
4637 cvFirstType( void )
4638 {
4639     return CvType::first;
4640 }
4641
4642
4643 CV_IMPL CvTypeInfo*
4644 cvFindType( const char* type_name )
4645 {
4646     CvTypeInfo* info = 0;
4647
4648     for( info = CvType::first; info != 0; info = info->next )
4649         if( strcmp( info->type_name, type_name ) == 0 )
4650             break;
4651
4652     return info;
4653 }
4654
4655
4656 CV_IMPL CvTypeInfo*
4657 cvTypeOf( const void* struct_ptr )
4658 {
4659     CvTypeInfo* info = 0;
4660
4661     for( info = CvType::first; info != 0; info = info->next )
4662         if( info->is_instance( struct_ptr ))
4663             break;
4664
4665     return info;
4666 }
4667
4668
4669 /* universal functions */
4670 CV_IMPL void
4671 cvRelease( void** struct_ptr )
4672 {
4673     CvTypeInfo* info;
4674
4675     if( !struct_ptr )
4676         CV_Error( CV_StsNullPtr, "NULL double pointer" );
4677
4678     if( *struct_ptr )
4679     {
4680         info = cvTypeOf( *struct_ptr );
4681         if( !info )
4682             CV_Error( CV_StsError, "Unknown object type" );
4683         if( !info->release )
4684             CV_Error( CV_StsError, "release function pointer is NULL" );
4685
4686         info->release( struct_ptr );
4687         *struct_ptr = 0;
4688     }
4689 }
4690
4691
4692 void* cvClone( const void* struct_ptr )
4693 {
4694     void* struct_copy = 0;
4695     CvTypeInfo* info;
4696
4697     if( !struct_ptr )
4698         CV_Error( CV_StsNullPtr, "NULL structure pointer" );
4699
4700     info = cvTypeOf( struct_ptr );
4701     if( !info )
4702         CV_Error( CV_StsError, "Unknown object type" );
4703     if( !info->clone )
4704         CV_Error( CV_StsError, "clone function pointer is NULL" );
4705
4706     struct_copy = info->clone( struct_ptr );
4707     return struct_copy;
4708 }
4709
4710
4711 /* reads matrix, image, sequence, graph etc. */
4712 CV_IMPL void*
4713 cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* list )
4714 {
4715     void* obj = 0;
4716     CV_CHECK_FILE_STORAGE( fs );
4717
4718     if( !node )
4719         return 0;
4720
4721     if( !CV_NODE_IS_USER(node->tag) || !node->info )
4722         CV_Error( CV_StsError, "The node does not represent a user object (unknown type?)" );
4723
4724     obj = node->info->read( fs, node );
4725     if( list )
4726         *list = cvAttrList(0,0);
4727
4728     return obj;
4729 }
4730
4731
4732 /* writes matrix, image, sequence, graph etc. */
4733 CV_IMPL void
4734 cvWrite( CvFileStorage* fs, const char* name,
4735          const void* ptr, CvAttrList attributes )
4736 {
4737     CvTypeInfo* info;
4738
4739     CV_CHECK_OUTPUT_FILE_STORAGE( fs );
4740
4741     if( !ptr )
4742         CV_Error( CV_StsNullPtr, "Null pointer to the written object" );
4743
4744     info = cvTypeOf( ptr );
4745     if( !info )
4746         CV_Error( CV_StsBadArg, "Unknown object" );
4747
4748     if( !info->write )
4749         CV_Error( CV_StsBadArg, "The object does not have write function" );
4750
4751     info->write( fs, name, ptr, attributes );
4752 }
4753
4754
4755 /* simple API for reading/writing data */
4756 CV_IMPL void
4757 cvSave( const char* filename, const void* struct_ptr,
4758         const char* _name, const char* comment, CvAttrList attributes )
4759 {
4760     CvFileStorage* fs = 0;
4761
4762     if( !struct_ptr )
4763         CV_Error( CV_StsNullPtr, "NULL object pointer" );
4764
4765     fs = cvOpenFileStorage( filename, 0, CV_STORAGE_WRITE );
4766     if( !fs )
4767         CV_Error( CV_StsError, "Could not open the file storage. Check the path and permissions" );
4768
4769     cv::string name = _name ? cv::string(_name) : cv::FileStorage::getDefaultObjectName(filename);
4770
4771     if( comment )
4772         cvWriteComment( fs, comment, 0 );
4773     cvWrite( fs, name.c_str(), struct_ptr, attributes );
4774     cvReleaseFileStorage( &fs );
4775 }
4776
4777 CV_IMPL void*
4778 cvLoad( const char* filename, CvMemStorage* memstorage,
4779         const char* name, const char** _real_name )
4780 {
4781     void* ptr = 0;
4782     const char* real_name = 0;
4783     CvFileStorage* fs = 0;
4784
4785     CvFileNode* node = 0;
4786     fs = cvOpenFileStorage( filename, memstorage, CV_STORAGE_READ );
4787
4788     if( !fs )
4789         return 0;
4790
4791     if( name )
4792     {
4793         node = cvGetFileNodeByName( fs, 0, name );
4794     }
4795     else
4796     {
4797         int i, k;
4798         for( k = 0; k < fs->roots->total; k++ )
4799         {
4800             CvSeq* seq;
4801             CvSeqReader reader;
4802
4803             node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
4804             if( !CV_NODE_IS_MAP( node->tag ))
4805                 EXIT;
4806             seq = node->data.seq;
4807             node = 0;
4808
4809             cvStartReadSeq( seq, &reader, 0 );
4810
4811             // find the first element in the map
4812             for( i = 0; i < seq->total; i++ )
4813             {
4814                 if( CV_IS_SET_ELEM( reader.ptr ))
4815                 {
4816                     node = (CvFileNode*)reader.ptr;
4817                     goto stop_search;
4818                 }
4819                 CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
4820             }
4821         }
4822
4823 stop_search:
4824         ;
4825     }
4826
4827     if( !node )
4828         CV_Error( CV_StsObjectNotFound, "Could not find the/an object in file storage" );
4829
4830     real_name = cvGetFileNodeName( node );
4831     ptr = cvRead( fs, node, 0 );
4832
4833     // sanity check
4834     if( !memstorage && (CV_IS_SEQ( ptr ) || CV_IS_SET( ptr )) )
4835         CV_Error( CV_StsNullPtr,
4836         "NULL memory storage is passed - the loaded dynamic structure can not be stored" );
4837
4838     if( cvGetErrStatus() < 0 )
4839     {
4840         cvRelease( (void**)&ptr );
4841         real_name = 0;
4842     }
4843
4844     if( _real_name)
4845     {
4846         if (real_name)
4847         {
4848             *_real_name = (const char*)cvAlloc(strlen(real_name));
4849             memcpy((void*)*_real_name, real_name, strlen(real_name));
4850         } else {
4851             *_real_name = 0;
4852         }
4853     }
4854 exit:
4855     cvReleaseFileStorage( &fs );
4856
4857     return ptr;
4858 }
4859
4860
4861 ///////////////////////// new C++ interface for CvFileStorage ///////////////////////////
4862
4863 namespace cv
4864 {
4865
4866 static void getElemSize( const string& fmt, size_t& elemSize, size_t& cn )
4867 {
4868     const char* dt = fmt.c_str();
4869     cn = 1;
4870     if( isdigit(dt[0]) )
4871     {
4872         cn = dt[0] - '0';
4873         dt++;
4874     }
4875     char c = dt[0];
4876     elemSize = cn*(c == 'u' || c == 'c' ? sizeof(uchar) : c == 'w' || c == 's' ? sizeof(ushort) :
4877         c == 'i' ? sizeof(int) : c == 'f' ? sizeof(float) : c == 'd' ? sizeof(double) :
4878         c == 'r' ? sizeof(void*) : (size_t)0);
4879 }
4880
4881 FileStorage::FileStorage()
4882 {
4883     state = UNDEFINED;
4884 }
4885
4886 FileStorage::FileStorage(const string& filename, int flags)
4887 {
4888     state = UNDEFINED;
4889     open( filename, flags );
4890 }
4891
4892 FileStorage::FileStorage(CvFileStorage* _fs)
4893 {
4894     fs = Ptr<CvFileStorage>(_fs);
4895     state = _fs ? NAME_EXPECTED + INSIDE_MAP : UNDEFINED;
4896 }
4897
4898 FileStorage::~FileStorage()
4899 {
4900     while( structs.size() > 0 )
4901     {
4902         cvEndWriteStruct(fs);
4903         structs.pop_back();
4904     }
4905 }
4906
4907 bool FileStorage::open(const string& filename, int flags)
4908 {
4909     release();
4910     fs = Ptr<CvFileStorage>(cvOpenFileStorage( filename.c_str(), 0, flags ));
4911     bool ok = isOpened();
4912     state = ok ? NAME_EXPECTED + INSIDE_MAP : UNDEFINED;
4913     return ok;
4914 }
4915
4916 bool FileStorage::isOpened() const
4917 {
4918     return !fs.empty();
4919 }
4920
4921 void FileStorage::release()
4922 {
4923     fs.release();
4924     structs.clear();
4925     state = UNDEFINED;
4926 }
4927
4928 FileNode FileStorage::root(int streamidx) const
4929 {
4930     return isOpened() ? FileNode(fs, cvGetRootFileNode(fs, streamidx)) : FileNode();
4931 }
4932
4933 FileStorage& operator << (FileStorage& fs, const string& str)
4934 {
4935     enum { NAME_EXPECTED = FileStorage::NAME_EXPECTED,
4936         VALUE_EXPECTED = FileStorage::VALUE_EXPECTED,
4937         INSIDE_MAP = FileStorage::INSIDE_MAP };
4938     const char* _str = str.c_str();
4939     if( !fs.isOpened() || !_str )
4940         return fs;
4941     if( *_str == '}' || *_str == ']' )
4942     {
4943         if( fs.structs.empty() )
4944             CV_Error_( CV_StsError, ("Extra closing '%c'", *_str) );
4945         if( (*_str == ']' ? '[' : '{') != fs.structs.back() )
4946             CV_Error_( CV_StsError,
4947             ("The closing '%c' does not match the opening '%c'", *_str, fs.structs.back()));
4948         fs.structs.pop_back();
4949         fs.state = fs.structs.empty() || fs.structs.back() == '{' ?
4950             INSIDE_MAP + NAME_EXPECTED : VALUE_EXPECTED;
4951         cvEndWriteStruct( *fs );
4952         fs.elname = string();
4953     }
4954     else if( fs.state == NAME_EXPECTED + INSIDE_MAP )
4955     {
4956         if( !isalpha(*_str) )
4957             CV_Error_( CV_StsError, ("Incorrect element name %s", _str) );
4958         fs.elname = str;
4959         fs.state = VALUE_EXPECTED + INSIDE_MAP;
4960     }
4961     else if( (fs.state & 3) == VALUE_EXPECTED )
4962     {
4963         if( *_str == '{' || *_str == '[' )
4964         {
4965             fs.structs.push_back(*_str);
4966             int flags = *_str++ == '{' ? CV_NODE_MAP : CV_NODE_SEQ;
4967             fs.state = flags == CV_NODE_MAP ? INSIDE_MAP +
4968                 NAME_EXPECTED : VALUE_EXPECTED;
4969             if( *_str == ':' )
4970             {
4971                 flags |= CV_NODE_FLOW;
4972                 _str++;
4973             }
4974             cvStartWriteStruct( *fs, fs.elname.size() > 0 ? fs.elname.c_str() : 0,
4975                 flags, *_str ? _str : 0 );
4976             fs.elname = string();
4977         }
4978         else
4979         {
4980             write( fs, fs.elname, (_str[0] == '\\' && (_str[1] == '{' || _str[1] == '}' ||
4981                 _str[1] == '[' || _str[1] == ']')) ? string(_str+1) : str );
4982             if( fs.state == INSIDE_MAP + VALUE_EXPECTED )
4983                 fs.state = INSIDE_MAP + NAME_EXPECTED;
4984         }
4985     }
4986     else
4987         CV_Error( CV_StsError, "Invalid fs.state" );
4988     return fs;
4989 }
4990
4991
4992 void FileStorage::writeRaw( const string& fmt, const uchar* vec, size_t len )
4993 {
4994     if( !isOpened() )
4995         return;
4996     size_t elemSize, cn;
4997     getElemSize( fmt, elemSize, cn );
4998     CV_Assert( len % elemSize == 0 );
4999     cvWriteRawData( fs, vec, (int)(len/elemSize), fmt.c_str());
5000 }
5001
5002
5003 void FileStorage::writeObj( const string& name, const void* obj )
5004 {
5005     if( !isOpened() )
5006         return;
5007     cvWrite( fs, name.size() > 0 ? name.c_str() : 0, obj );
5008 }
5009
5010
5011 void* FileNode::readObj() const
5012 {
5013     if( !fs || !node )
5014         return 0;
5015     return cvRead( (CvFileStorage*)fs, (CvFileNode*)node );
5016 }
5017
5018
5019 FileNodeIterator::FileNodeIterator()
5020 {
5021     fs = 0;
5022     container = 0;
5023     reader.ptr = 0;
5024     remaining = 0;
5025 }
5026
5027 FileNodeIterator::FileNodeIterator(const CvFileStorage* _fs,
5028                                    const CvFileNode* _node, size_t _ofs)
5029 {
5030     if( _fs && _node )
5031     {
5032         int node_type = _node->tag & FileNode::TYPE_MASK;
5033         fs = _fs;
5034         container = _node;
5035         if( node_type == FileNode::SEQ || node_type == FileNode::MAP )
5036         {
5037             cvStartReadSeq( _node->data.seq, &reader );
5038             remaining = FileNode(_fs, _node).size();
5039         }
5040         else
5041         {
5042             reader.ptr = (schar*)_node;
5043             reader.seq = 0;
5044             remaining = 1;
5045         }
5046         (*this) += (int)_ofs;
5047     }
5048     else
5049     {
5050         fs = 0;
5051         container = 0;
5052         reader.ptr = 0;
5053         remaining = 0;
5054     }
5055 }
5056
5057 FileNodeIterator::FileNodeIterator(const FileNodeIterator& it)
5058 {
5059     fs = it.fs;
5060     container = it.container;
5061     reader = it.reader;
5062     remaining = it.remaining;
5063 }
5064
5065 FileNodeIterator& FileNodeIterator::operator ++()
5066 {
5067     if( remaining > 0 )
5068     {
5069         if( reader.seq )
5070             CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
5071         remaining--;
5072     }
5073     return *this;
5074 }
5075
5076 FileNodeIterator FileNodeIterator::operator ++(int)
5077 {
5078     FileNodeIterator it = *this;
5079     ++(*this);
5080     return it;
5081 }
5082
5083 FileNodeIterator& FileNodeIterator::operator --()
5084 {
5085     if( remaining < FileNode(fs, container).size() )
5086     {
5087         if( reader.seq )
5088             CV_PREV_SEQ_ELEM( reader.seq->elem_size, reader );
5089         remaining++;
5090     }
5091     return *this;
5092 }
5093
5094 FileNodeIterator FileNodeIterator::operator --(int)
5095 {
5096     FileNodeIterator it = *this;
5097     --(*this);
5098     return it;
5099 }
5100
5101 FileNodeIterator& FileNodeIterator::operator += (int ofs)
5102 {
5103     if( ofs == 0 )
5104         return *this;
5105     if( ofs > 0 )
5106         ofs = std::min(ofs, (int)remaining);
5107     else
5108     {
5109         size_t count = FileNode(fs, container).size();
5110         ofs = (int)(remaining - std::min(remaining - ofs, count));
5111     }
5112     remaining -= ofs;
5113     if( reader.seq )
5114         cvSetSeqReaderPos( &reader, ofs, 1 );
5115     return *this;
5116 }
5117
5118 FileNodeIterator& FileNodeIterator::operator -= (int ofs)
5119 {
5120     return operator += (-ofs);
5121 }
5122
5123
5124 FileNodeIterator& FileNodeIterator::readRaw( const string& fmt, uchar* vec, size_t maxCount )
5125 {
5126     if( fs && container && remaining > 0 )
5127     {
5128         size_t elem_size, cn;
5129         getElemSize( fmt, elem_size, cn );
5130         CV_Assert( elem_size > 0 );
5131         size_t count = std::min(remaining, maxCount);
5132
5133         if( reader.seq )
5134         {
5135             cvReadRawDataSlice( fs, &reader, (int)count, vec, fmt.c_str() );
5136             remaining -= count*cn;
5137         }
5138         else
5139         {
5140             cvReadRawData( fs, container, vec, fmt.c_str() );
5141             remaining = 0;
5142         }
5143     }
5144     return *this;
5145 }
5146
5147 void write( FileStorage& fs, const string& name, const Mat& value )
5148 {
5149     CvMat mat = value;
5150     cvWrite( *fs, name.size() ? name.c_str() : 0, &mat );
5151 }
5152
5153 void write( FileStorage& fs, const string& name, const MatND& value )
5154 {
5155     CvMatND mat = value;
5156     cvWrite( *fs, name.size() ? name.c_str() : 0, &mat );
5157 }
5158
5159 // TODO: the 4 functions below need to be implemented more efficiently
5160 void write( FileStorage& fs, const string& name, const SparseMat& value )
5161 {
5162     Ptr<CvSparseMat> mat = (CvSparseMat*)value;
5163     cvWrite( *fs, name.size() ? name.c_str() : 0, mat );
5164 }
5165
5166
5167 void read( const FileNode& node, Mat& mat, const Mat& default_mat )
5168 {
5169     if( node.empty() )
5170     {
5171         default_mat.copyTo(mat);
5172         return;
5173     }
5174     Ptr<CvMat> m = (CvMat*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node);
5175     CV_Assert(CV_IS_MAT(m));
5176     Mat(m).copyTo(mat);
5177 }
5178
5179 void read( const FileNode& node, MatND& mat, const MatND& default_mat )
5180 {
5181     if( node.empty() )
5182     {
5183         default_mat.copyTo(mat);
5184         return;
5185     }
5186     Ptr<CvMatND> m = (CvMatND*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node);
5187     CV_Assert(CV_IS_MATND(m));
5188     MatND(m).copyTo(mat);
5189 }
5190
5191 void read( const FileNode& node, SparseMat& mat, const SparseMat& default_mat )
5192 {
5193     if( node.empty() )
5194     {
5195         default_mat.copyTo(mat);
5196         return;
5197     }
5198     Ptr<CvSparseMat> m = (CvSparseMat*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node);
5199     CV_Assert(CV_IS_SPARSE_MAT(m));
5200     SparseMat(m).copyTo(mat);
5201 }
5202
5203 }
5204
5205 /* End of file. */