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