Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/lend/src/xDataTOM_importXML.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/hadronic/models/lend/src/xDataTOM_importXML.cc (Version 11.3.0) and /processes/hadronic/models/lend/src/xDataTOM_importXML.cc (Version 11.0.p4)


  1 /*                                                  1 /*
  2 # <<BEGIN-copyright>>                               2 # <<BEGIN-copyright>>
  3 # <<END-copyright>>                                 3 # <<END-copyright>>
  4 */                                                  4 */
  5                                                     5 
  6 #include <stdlib.h>                                 6 #include <stdlib.h>
  7 #include <string.h>                                 7 #include <string.h>
  8 #include <ctype.h>                                  8 #include <ctype.h>
  9 #include <sys/types.h>                              9 #include <sys/types.h>
 10 #include <sys/stat.h>                              10 #include <sys/stat.h>
 11 #include <fcntl.h>                                 11 #include <fcntl.h>
 12 #include <errno.h>                                 12 #include <errno.h>
 13                                                    13 
 14 #if defined(_WIN32)                            <<  14 #ifdef WIN32
 15 #include <basetsd.h>                           <<  15 #include <BaseTsd.h>
 16 #include <io.h>                                    16 #include <io.h>
 17 #include <windows.h>                               17 #include <windows.h>
 18 #define realpath( a, b ) GetFullPathName( a, P     18 #define realpath( a, b ) GetFullPathName( a, PATH_MAX, b, NULL )
 19 #define strtoll _strtoi64                          19 #define strtoll _strtoi64
 20 typedef SSIZE_T ssize_t;                           20 typedef SSIZE_T ssize_t;
 21 #else                                              21 #else
 22 #include <unistd.h>                                22 #include <unistd.h>
 23 #endif                                             23 #endif
 24                                                    24 
 25 #include "xDataTOM_importXML_private.h"            25 #include "xDataTOM_importXML_private.h"
 26                                                    26 
 27 #if defined __cplusplus                            27 #if defined __cplusplus
 28 namespace GIDI {                                   28 namespace GIDI {
 29 using namespace GIDI;                              29 using namespace GIDI;
 30 #endif                                             30 #endif
 31                                                    31 
 32 #ifndef PATH_MAX                                   32 #ifndef PATH_MAX
 33 #define PATH_MAX 4096                              33 #define PATH_MAX 4096
 34 #endif                                             34 #endif
 35                                                    35 
 36 static xDataXML_document *xDataXML_mallocDoc(      36 static xDataXML_document *xDataXML_mallocDoc( statusMessageReporting *smr );
 37 static int xDataXML_initializeDoc( statusMessa     37 static int xDataXML_initializeDoc( statusMessageReporting *smr, xDataXML_document *doc );
 38 static int xDataXML_endXMLParsing( statusMessa     38 static int xDataXML_endXMLParsing( statusMessageReporting *smr, xDataXML_document *doc );
 39 static void *xDataXML_freeElement( statusMessa     39 static void *xDataXML_freeElement( statusMessageReporting *smr, xDataXML_element *element );
 40 static void xDataXML_freeElementItems( statusM     40 static void xDataXML_freeElementItems( statusMessageReporting *smr, xDataXML_element *element );
 41 static int xDataXML_parse( xDataXML_document *     41 static int xDataXML_parse( xDataXML_document *doc, char const *s );
 42 static void XMLCALL xDataXML_parseStartElement     42 static void XMLCALL xDataXML_parseStartElement( void *userData, char const *name, char const **attris );
 43 static void XMLCALL xDataXML_parseEndElement(      43 static void XMLCALL xDataXML_parseEndElement( void *userData, char const *name );
 44 static void XMLCALL xDataXML_parseCharacterDat     44 static void XMLCALL xDataXML_parseCharacterData( void *userData, XML_Char const *s, int len );
 45 static void xDataXML_initializeRootElement( xD     45 static void xDataXML_initializeRootElement( xDataXML_document *doc, xDataXML_rootElement *re, xDataXML_element *parentElement, int depth );
 46 static int xDataXML_parseInitializeText( xData     46 static int xDataXML_parseInitializeText( xDataXML_document *doc, xDataXML_text *text );
 47 static int xDataXML_addElementToRoot( statusMe     47 static int xDataXML_addElementToRoot( statusMessageReporting *smr, xDataXML_rootElement *parentRoot, char const *name, char const **attris );
 48 static enum xDataXML_errorCodes xDataXML_parse     48 static enum xDataXML_errorCodes xDataXML_parseGetCurrentPosition( xDataXML_document *doc, xDataXML_docInfo *docInfo );
 49 static int xDataXML_init_xDataTypeNone( xDataX     49 static int xDataXML_init_xDataTypeNone( xDataXMLType *xDT, xDataXML_element *element );
 50 static char *xDataXML_getTraceback( statusMess     50 static char *xDataXML_getTraceback( statusMessageReporting *smr, xDataXML_element *element );
 51 static char *xDataXML_getTraceback2( statusMes     51 static char *xDataXML_getTraceback2( statusMessageReporting *smr, xDataXML_rootElement *parentRoot, int n );
 52 static int xDataXML_setFileName( statusMessage     52 static int xDataXML_setFileName( statusMessageReporting *smr, xDataXML_document *doc, char const *fileName );
 53                                                    53 
 54 static int xDataXML_smrUserInterfaceInitialize     54 static int xDataXML_smrUserInterfaceInitialize( xDataXML_document *doc );
 55 static int xDataXML_smrUserInterfaceFree( xDat     55 static int xDataXML_smrUserInterfaceFree( xDataXML_document *doc );
 56 static char *xDataXML_smrUserInterface( void *     56 static char *xDataXML_smrUserInterface( void *userData );
 57 static char const *xDataXML_shortStringForMess     57 static char const *xDataXML_shortStringForMessage( size_t size, char *Out, char const *In );
 58                                                    58 
 59 static int xDataXML_constructTOM( statusMessag     59 static int xDataXML_constructTOM( statusMessageReporting *smr, xDataTOM_element *TE, xDataXML_element *element );
 60 /*                                                 60 /*
 61 **********************************************     61 ************************************************************
 62 */                                                 62 */
 63 xDataTOM_TOM *xDataXML_importFile( statusMessa     63 xDataTOM_TOM *xDataXML_importFile( statusMessageReporting *smr, char const *fileName ) {
 64 /*                                                 64 /*
 65 *   Returns NULL is any error occurred. If an      65 *   Returns NULL is any error occurred. If an error occurs in an expat routine, xDataXML_endXMLParsing will set smr appropriately.
 66 */                                                 66 */
 67     xDataTOM_TOM *TOM = NULL;                      67     xDataTOM_TOM *TOM = NULL;
 68     xDataXML_document *XML = NULL;                 68     xDataXML_document *XML = NULL;
 69     xDataXML_element *element;                     69     xDataXML_element *element;
 70                                                    70 
 71     if( ( XML = xDataXML_importFile2( smr, fil     71     if( ( XML = xDataXML_importFile2( smr, fileName ) ) == NULL ) return( NULL );
 72                                                    72 
 73     if( ( TOM = xDataTOM_mallocTOM( smr ) ) ==     73     if( ( TOM = xDataTOM_mallocTOM( smr ) ) == NULL ) goto Err;
 74     if( xDataTOM_setFileNameTOM( smr, TOM, fil     74     if( xDataTOM_setFileNameTOM( smr, TOM, fileName ) != 0 ) goto Err;
 75                                                    75 
 76     element = xDataXML_getDocumentsElement( XM     76     element = xDataXML_getDocumentsElement( XML );
 77     if( xDataXML_constructTOM( smr, (&TOM->roo     77     if( xDataXML_constructTOM( smr, (&TOM->root), element ) != 0 ) goto Err;
 78                                                    78 
 79     xDataXML_freeDoc( smr, XML );                  79     xDataXML_freeDoc( smr, XML );
 80     return( TOM );                                 80     return( TOM );
 81                                                    81 
 82 Err:                                               82 Err:
 83     if( XML != NULL ) xDataXML_freeDoc( smr, X     83     if( XML != NULL ) xDataXML_freeDoc( smr, XML );
 84     if( TOM != NULL ) xDataTOM_freeTOM( smr, &     84     if( TOM != NULL ) xDataTOM_freeTOM( smr, &TOM );
 85     return( NULL );                                85     return( NULL );
 86 }                                                  86 }
 87 /*                                                 87 /*
 88 **********************************************     88 ************************************************************
 89 */                                                 89 */
 90 xDataXML_document *xDataXML_importFile2( statu     90 xDataXML_document *xDataXML_importFile2( statusMessageReporting *smr, char const *fileName ) {
 91 /*                                                 91 /*
 92 *   Returns NULL is any error occurred. If an      92 *   Returns NULL is any error occurred. If an error occurs in an expat routine, xDataXML_endXMLParsing will set smr appropriately.
 93 */                                                 93 */
 94     int f;                                         94     int f;
 95     char buffer[10 * 1000];                        95     char buffer[10 * 1000];
 96     ssize_t count, n = sizeof( buffer ) - 1;       96     ssize_t count, n = sizeof( buffer ) - 1;
 97     xDataXML_document *doc;                        97     xDataXML_document *doc;
 98                                                    98 
 99     if( ( doc = xDataXML_mallocDoc( smr ) ) ==     99     if( ( doc = xDataXML_mallocDoc( smr ) ) == NULL ) return( NULL );
100     if( xDataXML_setFileName( smr, doc, fileNa    100     if( xDataXML_setFileName( smr, doc, fileName ) == 0 ) {
101         f = open( fileName, O_RDONLY );           101         f = open( fileName, O_RDONLY );
102         if( f == -1 ) {                           102         if( f == -1 ) {
103                 xDataXML_endXMLParsing( smr, d    103                 xDataXML_endXMLParsing( smr, doc );
104                 smr_setReportError2( smr, xDat    104                 smr_setReportError2( smr, xDataTOM_smrLibraryID, xDataXML_errFileError, "could not open XML file %s", fileName ); }
105         else {                                    105         else {
106                 while( ( count = read( f, buff    106                 while( ( count = read( f, buffer, n ) ) > 0 ) {
107                     buffer[count] = 0;            107                     buffer[count] = 0;
108                     if( xDataXML_parse( doc, b    108                     if( xDataXML_parse( doc, buffer ) ) break;
109                     if( !smr_isOk( doc->smr )     109                     if( !smr_isOk( doc->smr ) ) break;
110                 }  // Loop checking, 11.06.201    110                 }  // Loop checking, 11.06.2015, T. Koi
111                 close( f );                       111                 close( f );
112                 xDataXML_endXMLParsing( smr, d    112                 xDataXML_endXMLParsing( smr, doc );
113                 if( count < 0 ) smr_setReportE    113                 if( count < 0 ) smr_setReportError2( smr, xDataTOM_smrLibraryID, xDataXML_errFileError, "read failed with errno = %d for XML %s", 
114                     errno, fileName );            114                     errno, fileName );
115         }                                         115         }
116     }                                             116     }
117     if( doc != NULL ) {                           117     if( doc != NULL ) {
118         if( !smr_isOk( smr ) ) {                  118         if( !smr_isOk( smr ) ) {
119             xDataXML_freeDoc( smr, doc );         119             xDataXML_freeDoc( smr, doc );
120             doc = NULL;                           120             doc = NULL;
121         }                                         121         }
122     }                                             122     }
123     return( doc );                                123     return( doc );
124 }                                                 124 }
125 /*                                                125 /*
126 **********************************************    126 ************************************************************
127 */                                                127 */
128 static xDataXML_document *xDataXML_mallocDoc(     128 static xDataXML_document *xDataXML_mallocDoc( statusMessageReporting *smr ) {
129                                                   129 
130     xDataXML_document *doc;                       130     xDataXML_document *doc;
131                                                   131 
132     if( ( doc = (xDataXML_document *) smr_mall    132     if( ( doc = (xDataXML_document *) smr_malloc2( smr, sizeof( xDataXML_document ), 1, "xDataXML_document" ) ) != NULL ) {
133         if( xDataXML_initializeDoc( smr, doc )    133         if( xDataXML_initializeDoc( smr, doc ) ) doc = (xDataXML_document *) xDataXML_freeDoc( smr, doc );
134     }                                             134     }
135     return( doc );                                135     return( doc );
136 }                                                 136 }
137 /*                                                137 /*
138 **********************************************    138 ************************************************************
139 */                                                139 */
140 static int xDataXML_initializeDoc( statusMessa    140 static int xDataXML_initializeDoc( statusMessageReporting *smr, xDataXML_document *doc ) {
141                                                   141 
142     doc->status = xDataXML_statusParsing;         142     doc->status = xDataXML_statusParsing;
143     doc->error = xDataXML_errNone;                143     doc->error = xDataXML_errNone;
144     doc->err = XML_ERROR_NONE;                    144     doc->err = XML_ERROR_NONE;
145     doc->err_line = 0;                            145     doc->err_line = 0;
146     doc->err_column = 0;                          146     doc->err_column = 0;
147     doc->fileName = NULL;                         147     doc->fileName = NULL;
148     doc->realFileName = NULL;                     148     doc->realFileName = NULL;
149     xDataXML_smrUserInterfaceInitialize( doc )    149     xDataXML_smrUserInterfaceInitialize( doc );
150     doc->smr= smr;                                150     doc->smr= smr;
151     if( ( doc->xmlParser = XML_ParserCreate( N    151     if( ( doc->xmlParser = XML_ParserCreate( NULL ) ) == NULL ) {
152         smr_setReportError2p( smr, xDataTOM_sm    152         smr_setReportError2p( smr, xDataTOM_smrLibraryID, xDataXML_errXML_ParserCreate, "XML_ParserCreate failed" ); }
153     else {                                        153     else {
154         XML_SetUserData( doc->xmlParser, doc      154         XML_SetUserData( doc->xmlParser, doc  );
155         xDataXML_initializeRootElement( doc, &    155         xDataXML_initializeRootElement( doc, &(doc->root), NULL, 0 );
156         doc->currentRoot = &(doc->root);          156         doc->currentRoot = &(doc->root);
157         XML_SetElementHandler( doc->xmlParser,    157         XML_SetElementHandler( doc->xmlParser, xDataXML_parseStartElement, xDataXML_parseEndElement );
158         XML_SetCharacterDataHandler( doc->xmlP    158         XML_SetCharacterDataHandler( doc->xmlParser, xDataXML_parseCharacterData );
159     }                                             159     }
160     return( !smr_isOk( smr ) );                   160     return( !smr_isOk( smr ) );
161 }                                                 161 }
162 /*                                                162 /*
163 **********************************************    163 ************************************************************
164 */                                                164 */
165 static int xDataXML_endXMLParsing( statusMessa    165 static int xDataXML_endXMLParsing( statusMessageReporting *smr, xDataXML_document *doc ) {
166                                                   166 
167     if( doc->xmlParser ) {                        167     if( doc->xmlParser ) {
168         doc->err = XML_GetErrorCode( doc->xmlP    168         doc->err = XML_GetErrorCode( doc->xmlParser );
169         doc->err_line = XML_GetCurrentLineNumb    169         doc->err_line = XML_GetCurrentLineNumber( doc->xmlParser );
170         doc->err_column = XML_GetCurrentColumn    170         doc->err_column = XML_GetCurrentColumnNumber( doc->xmlParser );
171         if( smr_isOk( smr ) && ( XML_Parse( do    171         if( smr_isOk( smr ) && ( XML_Parse( doc->xmlParser, NULL, 0, 1 ) == XML_STATUS_ERROR ) ) {
172             doc->status = xDataXML_statusError    172             doc->status = xDataXML_statusError;
173             smr_setReportError3( smr, xDataXML    173             smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromDocument( doc ), xDataTOM_smrLibraryID, xDataXML_errXMLParser, 
174                 "status = %d\nXML_Error code =    174                 "status = %d\nXML_Error code = %d\nXML_ErrorString = %s\nerror line, column = %d, %d", xDataXML_errXMLParser, 
175                 doc->err, XML_ErrorString( doc    175                 doc->err, XML_ErrorString( doc->err ), doc->err_line, doc->err_column );
176         }                                         176         }
177         XML_ParserFree( doc->xmlParser );         177         XML_ParserFree( doc->xmlParser );
178         doc->xmlParser = NULL;                    178         doc->xmlParser = NULL;
179         if( doc->status != xDataXML_statusErro    179         if( doc->status != xDataXML_statusError ) doc->status = xDataXML_statusCompleted;
180     }                                             180     }
181     return( 0 );                                  181     return( 0 );
182 }                                                 182 }
183 /*                                                183 /*
184 **********************************************    184 ************************************************************
185 */                                                185 */
186 void *xDataXML_freeDoc( statusMessageReporting    186 void *xDataXML_freeDoc( statusMessageReporting *smr, xDataXML_document *doc ) {
187                                                   187 
188     xDataXML_endXMLParsing( smr, doc );           188     xDataXML_endXMLParsing( smr, doc );
189     doc->root.children = (xDataXML_element *)     189     doc->root.children = (xDataXML_element *) xDataXML_freeElement( smr, doc->root.children );
190     smr_freeMemory( (void **) &(doc->fileName)    190     smr_freeMemory( (void **) &(doc->fileName) );
191     smr_freeMemory( (void **) &(doc->realFileN    191     smr_freeMemory( (void **) &(doc->realFileName) );
192     xDataXML_smrUserInterfaceFree( doc );         192     xDataXML_smrUserInterfaceFree( doc );
193     smr_freeMemory( (void **) &doc );             193     smr_freeMemory( (void **) &doc );
194     return( NULL );                               194     return( NULL );
195 }                                                 195 }
196 /*                                                196 /*
197 **********************************************    197 ************************************************************
198 */                                                198 */
199 static void *xDataXML_freeElement( statusMessa    199 static void *xDataXML_freeElement( statusMessageReporting *smr, xDataXML_element *element ) {
200                                                   200     
201     xDataXML_element *next;                       201     xDataXML_element *next;
202                                                   202 
203     for( ; element != NULL; element = next ) {    203     for( ; element != NULL; element = next ) {
204         next = element->next;                     204         next = element->next;
205         xDataXML_freeElementItems( smr, elemen    205         xDataXML_freeElementItems( smr, element );
206         smr_freeMemory( (void **) &element );     206         smr_freeMemory( (void **) &element );
207     }                                             207     }
208     return( NULL );                               208     return( NULL );
209 }                                                 209 }
210 /*                                                210 /*
211 **********************************************    211 ************************************************************
212 */                                                212 */
213 static void xDataXML_freeElementItems( statusM    213 static void xDataXML_freeElementItems( statusMessageReporting *smr, xDataXML_element *element ) {
214                                                   214 
215     element->childrenRoot.children = (xDataXML    215     element->childrenRoot.children = (xDataXML_element *) xDataXML_freeElement( smr, element->childrenRoot.children );
216 /* BRB, The next line needs work */               216 /* BRB, The next line needs work */
217     if( ( !strcmp( element->name, "xData" ) )     217     if( ( !strcmp( element->name, "xData" ) ) && ( element->xDataTypeInfo.release != NULL ) ) element->xDataTypeInfo.release( smr, &(element->xDataTypeInfo) );
218     smr_freeMemory( (void **) &(element->name)    218     smr_freeMemory( (void **) &(element->name) );
219     smr_freeMemory( (void **) &(element->fullN    219     smr_freeMemory( (void **) &(element->fullName) );
220     if( element->attributes.attributes ) smr_f    220     if( element->attributes.attributes ) smr_freeMemory( (void **) &(element->attributes.attributes) );
221     if( element->text.text ) smr_freeMemory( (    221     if( element->text.text ) smr_freeMemory( (void **) &(element->text.text) );
222 }                                                 222 }
223 /*                                                223 /*
224 **********************************************    224 ************************************************************
225 */                                                225 */
226 static int xDataXML_parse( xDataXML_document *    226 static int xDataXML_parse( xDataXML_document *doc, char const *s ) {
227                                                   227 
228     if( doc->status != xDataXML_statusParsing     228     if( doc->status != xDataXML_statusParsing ) return( doc->status );
229     if( XML_Parse( doc->xmlParser, s, (int) st    229     if( XML_Parse( doc->xmlParser, s, (int) strlen( s ), 0 ) == XML_STATUS_ERROR ) return( -1 );
230     return( 0 );                                  230     return( 0 );
231 }                                                 231 }
232 /*                                                232 /*
233 **********************************************    233 ************************************************************
234 */                                                234 */
235 static void XMLCALL xDataXML_parseStartElement    235 static void XMLCALL xDataXML_parseStartElement( void *userData, char const *name, char const **attris ) {
236                                                   236 
237     xDataXML_document *doc = (xDataXML_documen    237     xDataXML_document *doc = (xDataXML_document *) userData;
238                                                   238 
239     if( !smr_isOk( doc->smr ) ) return;           239     if( !smr_isOk( doc->smr ) ) return;
240     xDataXML_addElementToRoot( doc->smr, doc->    240     xDataXML_addElementToRoot( doc->smr, doc->currentRoot, name, attris );
241 }                                                 241 }
242 /*                                                242 /*
243 **********************************************    243 ************************************************************
244 */                                                244 */
245 static void XMLCALL xDataXML_parseEndElement(     245 static void XMLCALL xDataXML_parseEndElement( void *userData, char const * /*name*/ ) {
246                                                   246 
247     xDataXML_document *doc = (xDataXML_documen    247     xDataXML_document *doc = (xDataXML_document *) userData;
248                                                   248 
249     doc->currentRoot->currentChild = NULL;        249     doc->currentRoot->currentChild = NULL;
250     doc->currentRoot = doc->currentRoot->paren    250     doc->currentRoot = doc->currentRoot->parentRoot;
251 }                                                 251 }
252 /*                                                252 /*
253 **********************************************    253 ************************************************************
254 */                                                254 */
255 static void XMLCALL xDataXML_parseCharacterDat    255 static void XMLCALL xDataXML_parseCharacterData( void *userData, XML_Char const *s, int len ) {
256 /*                                                256 /*
257 *   Always terminates text with a 0.              257 *   Always terminates text with a 0.
258 */                                                258 */
259     xDataXML_document *doc = (xDataXML_documen    259     xDataXML_document *doc = (xDataXML_document *) userData;
260     xDataXML_text *text = &(doc->currentRoot->    260     xDataXML_text *text = &(doc->currentRoot->parentRoot->currentChild->text);
261     size_t needSize = text->length + len + 1,     261     size_t needSize = text->length + len + 1, l; 
262     char *p;                                      262     char *p;
263                                                   263 
264     if( !smr_isOk( doc->smr ) ) return;           264     if( !smr_isOk( doc->smr ) ) return;
265     if( needSize < 8  ) needSize = 8;             265     if( needSize < 8  ) needSize = 8;
266     if( needSize > text->allocated ) {            266     if( needSize > text->allocated ) {
267         if( text->allocated != 0 ) {              267         if( text->allocated != 0 ) {
268             l = ( 20 * text->allocated ) / 100    268             l = ( 20 * text->allocated ) / 100;
269             if( l < 100 ) l = 100;                269             if( l < 100 ) l = 100;
270             if( needSize < ( text->allocated +    270             if( needSize < ( text->allocated + l ) ) needSize = text->allocated + l;
271         }                                         271         }
272         text->allocated = needSize;               272         text->allocated = needSize;
273         text->text = (char *) smr_realloc2( do    273         text->text = (char *) smr_realloc2( doc->smr, text->text, text->allocated, "text" );
274         if( !smr_isOk( doc->smr ) ) return;       274         if( !smr_isOk( doc->smr ) ) return;
275     }                                             275     }
276     p = &(text->text[text->length]);              276     p = &(text->text[text->length]);
277     strncpy( p, s, len );                         277     strncpy( p, s, len );
278     text->length += len;                          278     text->length += len;
279     p[len] = 0;                                   279     p[len] = 0;
280 }                                                 280 }
281 /*                                                281 /*
282 **********************************************    282 ************************************************************
283 */                                                283 */
284 static void xDataXML_initializeRootElement( xD    284 static void xDataXML_initializeRootElement( xDataXML_document *doc, xDataXML_rootElement *re, xDataXML_element *parentElement, int depth ) {
285                                                   285 
286     re->xData_doc = doc;                          286     re->xData_doc = doc;
287     re->parentElement = parentElement;            287     re->parentElement = parentElement;
288     re->parentRoot = NULL;                        288     re->parentRoot = NULL;
289     if( parentElement != NULL ) re->parentRoot    289     if( parentElement != NULL ) re->parentRoot = parentElement->parentRoot;
290     re->depth = depth;                            290     re->depth = depth;
291     re->numberOfElements = 0;                     291     re->numberOfElements = 0;
292     re->children = NULL;                          292     re->children = NULL;
293     re->currentChild = NULL;                      293     re->currentChild = NULL;
294 }                                                 294 }
295 /*                                                295 /*
296 **********************************************    296 ************************************************************
297 */                                                297 */
298 static int xDataXML_parseInitializeText( xData    298 static int xDataXML_parseInitializeText( xDataXML_document *doc, xDataXML_text *text ) {
299                                                   299 
300     xDataXML_parseGetCurrentPosition( doc, &(t    300     xDataXML_parseGetCurrentPosition( doc, &(text->docInfo) );
301     text->allocated = 0;                          301     text->allocated = 0;
302     text->length = 0;                             302     text->length = 0;
303     text->text = NULL;                            303     text->text = NULL;
304     return( 0 );                                  304     return( 0 );
305 }                                                 305 }
306 /*                                                306 /*
307 **********************************************    307 ************************************************************
308 */                                                308 */
309 static int xDataXML_addElementToRoot( statusMe    309 static int xDataXML_addElementToRoot( statusMessageReporting *smr, xDataXML_rootElement *parentRoot, char const *name, char const **attris ) {
310                                                   310 
311     xDataXML_document *doc = parentRoot->xData    311     xDataXML_document *doc = parentRoot->xData_doc;
312     xDataXML_element *element;                    312     xDataXML_element *element;
313     int i, n, status = 1;                         313     int i, n, status = 1;
314     size_t lens;                                  314     size_t lens;
315     char *p, *e;                                  315     char *p, *e;
316     char const **pAttris;                         316     char const **pAttris;
317     xDataXML_attribute *a;                        317     xDataXML_attribute *a;
318     void *smrUser;                                318     void *smrUser;
319                                                   319 
320     element = (xDataXML_element *) smr_malloc2    320     element = (xDataXML_element *) smr_malloc2( doc->smr, sizeof( xDataXML_element ), 1, "xDataXML_element" );
321     if( element == NULL ) return( 1 );            321     if( element == NULL ) return( 1 );
322     xDataXML_parseGetCurrentPosition( doc, &(e    322     xDataXML_parseGetCurrentPosition( doc, &(element->docInfo) );
323     element->ordinal = parentRoot->numberOfEle    323     element->ordinal = parentRoot->numberOfElements;
324     element->index = -1;                          324     element->index = -1;
325     element->accessed = 0;                        325     element->accessed = 0;
326     element->parentRoot = parentRoot;             326     element->parentRoot = parentRoot;
327     xDataXML_initializeRootElement( doc, &(ele    327     xDataXML_initializeRootElement( doc, &(element->childrenRoot), element, parentRoot->depth + 1 );
328     element->next = NULL;                         328     element->next = NULL;
329     if( ( element->name = (char *) smr_malloc2    329     if( ( element->name = (char *) smr_malloc2( doc->smr, strlen( name ) + 1, 0, "name" ) ) == NULL ) {
330         smr_freeMemory( (void **) &element );     330         smr_freeMemory( (void **) &element );
331         return( 1 );                              331         return( 1 );
332     }                                             332     }
333     strcpy( element->name, name );                333     strcpy( element->name, name );
334     if( ( element->fullName = xDataXML_getTrac    334     if( ( element->fullName = xDataXML_getTraceback( smr, element ) ) == NULL ) {
335         smr_freeMemory( (void **) &(element->n    335         smr_freeMemory( (void **) &(element->name) );
336         smr_freeMemory( (void **) &element );     336         smr_freeMemory( (void **) &element );
337         return( 1 );                              337         return( 1 );
338     }                                             338     }
339     for( i = 0, lens = 0, pAttris = attris; *p    339     for( i = 0, lens = 0, pAttris = attris; *pAttris; i++, pAttris++ ) lens += strlen( *pAttris ) + 1;
340     n = i / 2;                                    340     n = i / 2;
341     element->attributes.size = n * sizeof( xDa    341     element->attributes.size = n * sizeof( xDataXML_attribute ) + lens;
342     element->attributes.number = n;               342     element->attributes.number = n;
343     element->attributes.attributes = NULL;        343     element->attributes.attributes = NULL;
344     smrUser = xDataXML_get_smrUserInterfaceFro    344     smrUser = xDataXML_get_smrUserInterfaceFromElement( element );
345     if( element->attributes.size  ) {             345     if( element->attributes.size  ) {
346         if( ( element->attributes.attributes =    346         if( ( element->attributes.attributes = (xDataXML_attribute *) smr_malloc2( doc->smr, element->attributes.size, 0, "attributes") ) == NULL ) {
347             status = 0; }                         347             status = 0; }
348         else {                                    348         else {
349             a = element->attributes.attributes    349             a = element->attributes.attributes;
350             p = (char *) &(element->attributes    350             p = (char *) &(element->attributes.attributes[n]);
351             for( i = 0, pAttris = attris; ( i     351             for( i = 0, pAttris = attris; ( i < n ) && status; i++, a++, pAttris++ ) {
352                 lens = strlen( *pAttris ) + 1;    352                 lens = strlen( *pAttris ) + 1;
353                 a->name = p;                      353                 a->name = p;
354                 strcpy( p, *pAttris );            354                 strcpy( p, *pAttris );
355                 p += lens;                        355                 p += lens;
356                 pAttris++;                        356                 pAttris++;
357                 lens = strlen( *pAttris ) + 1;    357                 lens = strlen( *pAttris ) + 1;
358                 a->value= p;                      358                 a->value= p;
359                 strcpy( p, *pAttris );            359                 strcpy( p, *pAttris );
360                 p += lens;                        360                 p += lens;
361                 if( !strcmp( "index", a->name     361                 if( !strcmp( "index", a->name ) ) {
362                     element->index = (int) str    362                     element->index = (int) strtoll( a->value, &e, 10 );
363                     if( *e != 0 ) {               363                     if( *e != 0 ) {
364                         status = 0;               364                         status = 0;
365                         smr_setReportError3( d    365                         smr_setReportError3( doc->smr, smrUser, xDataTOM_smrLibraryID, -1, "could not convert index attribute = %s to integer", a->value );
366                     }                             366                     }
367                 }                                 367                 }
368             }                                     368             }
369         }                                         369         }
370     }                                             370     }
371     if( !status ) {                               371     if( !status ) {
372         smr_freeMemory( (void **) &(element->a    372         smr_freeMemory( (void **) &(element->attributes.attributes) );
373         smr_freeMemory( (void **) &(element->n    373         smr_freeMemory( (void **) &(element->name) );
374         smr_freeMemory( (void **) &(element->f    374         smr_freeMemory( (void **) &(element->fullName) );
375         smr_freeMemory( (void **) &element );     375         smr_freeMemory( (void **) &element );
376         return( 1 );                              376         return( 1 );
377     }                                             377     }
378     xDataXML_init_xDataTypeNone( &(element->xD    378     xDataXML_init_xDataTypeNone( &(element->xDataTypeInfo), element );
379     element->textOffset = 0;                      379     element->textOffset = 0;
380     xDataXML_parseInitializeText( doc, &(eleme    380     xDataXML_parseInitializeText( doc, &(element->text) );
381     if( parentRoot->parentElement != NULL ) el    381     if( parentRoot->parentElement != NULL ) element->textOffset = parentRoot->parentElement->text.length;
382     if( parentRoot->currentChild == NULL ) {      382     if( parentRoot->currentChild == NULL ) {
383         parentRoot->children = element; }         383         parentRoot->children = element; }
384     else {                                        384     else {
385         parentRoot->currentChild->next = eleme    385         parentRoot->currentChild->next = element;
386     }                                             386     }
387     parentRoot->numberOfElements++;               387     parentRoot->numberOfElements++;
388     parentRoot->currentChild = element;           388     parentRoot->currentChild = element;
389     doc->currentRoot = &(element->childrenRoot    389     doc->currentRoot = &(element->childrenRoot);
390     return( 0 );                                  390     return( 0 );
391 }                                                 391 }
392 /*                                                392 /*
393 **********************************************    393 ************************************************************
394 */                                                394 */
395 static enum xDataXML_errorCodes xDataXML_parse    395 static enum xDataXML_errorCodes xDataXML_parseGetCurrentPosition( xDataXML_document *doc, xDataXML_docInfo *docInfo ) {
396                                                   396 
397     docInfo->column = XML_GetCurrentColumnNumb    397     docInfo->column = XML_GetCurrentColumnNumber( doc->xmlParser );
398     docInfo->line = XML_GetCurrentLineNumber(     398     docInfo->line = XML_GetCurrentLineNumber( doc->xmlParser );
399     return( xDataXML_errNone );                   399     return( xDataXML_errNone );
400 }                                                 400 }
401 /*                                                401 /*
402 **********************************************    402 ************************************************************
403 */                                                403 */
404 int xDataXML_parseIsError( xDataXML_document *    404 int xDataXML_parseIsError( xDataXML_document *doc ) {
405                                                   405 
406     return( doc->status == xDataXML_statusErro    406     return( doc->status == xDataXML_statusError );
407 }                                                 407 }
408 /*                                                408 /*
409 **********************************************    409 ************************************************************
410 */                                                410 */
411 xDataXML_element *xDataXML_getDocumentsElement    411 xDataXML_element *xDataXML_getDocumentsElement( xDataXML_document *doc ) { return( doc->root.children ); }
412 xDataXML_element *xDataXML_getFirstElement( xD    412 xDataXML_element *xDataXML_getFirstElement( xDataXML_element *element ) { return( element->childrenRoot.children ); }
413 xDataXML_element *xDataXML_getNextElement( xDa    413 xDataXML_element *xDataXML_getNextElement( xDataXML_element *element ) { return( element->next ); }
414 /*                                                414 /*
415 **********************************************    415 ************************************************************
416 */                                                416 */
417 enum xDataXML_itemMode xDataXML_getFirstItem(     417 enum xDataXML_itemMode xDataXML_getFirstItem( xDataXML_element *element, xDataXML_item *item ) {
418                                                   418 
419     item->parentElement = element;                419     item->parentElement = element;
420     item->element = xDataXML_getFirstElement(     420     item->element = xDataXML_getFirstElement( element );
421     if( item->element == NULL ) {                 421     if( item->element == NULL ) {
422         item->mode = xDataXML_itemModeText;       422         item->mode = xDataXML_itemModeText;
423         if( element->text.length == 0 ) item->    423         if( element->text.length == 0 ) item->mode = xDataXML_itemModeEnd; }
424     else {                                        424     else {
425         item->mode = xDataXML_itemModeElement;    425         item->mode = xDataXML_itemModeElement;
426         if( 0 < item->element->textOffset ) it    426         if( 0 < item->element->textOffset ) item->mode = xDataXML_itemModeText;
427     }                                             427     }
428     item->textOffset = 0;                         428     item->textOffset = 0;
429     item->textLength = element->text.length;      429     item->textLength = element->text.length;
430     if( item->element != NULL ) item->textLeng    430     if( item->element != NULL ) item->textLength = item->element->textOffset;
431     item->text = element->text.text;              431     item->text = element->text.text;
432     return( item->mode );                         432     return( item->mode );
433 }                                                 433 }
434 /*                                                434 /*
435 **********************************************    435 ************************************************************
436 */                                                436 */
437 enum xDataXML_itemMode xDataXML_getNextItem( x    437 enum xDataXML_itemMode xDataXML_getNextItem( xDataXML_item *item ) {
438                                                   438 
439     if( item->mode != xDataXML_itemModeEnd ) {    439     if( item->mode != xDataXML_itemModeEnd ) {
440         if( item->mode == xDataXML_itemModeTex    440         if( item->mode == xDataXML_itemModeText ) {
441             item->mode = xDataXML_itemModeElem    441             item->mode = xDataXML_itemModeElement;
442             if( item->element == NULL ) item->    442             if( item->element == NULL ) item->mode = xDataXML_itemModeEnd;
443             item->textOffset += item->textLeng    443             item->textOffset += item->textLength;
444             item->textLength = 0;                 444             item->textLength = 0;
445             item->text = &(item->parentElement    445             item->text = &(item->parentElement->text.text[item->textOffset]); }
446         else {                                    446         else {
447             item->element = item->element->nex    447             item->element = item->element->next;
448             item->mode = xDataXML_itemModeText    448             item->mode = xDataXML_itemModeText;
449             if( item->element == NULL ) {         449             if( item->element == NULL ) {
450                 if( item->textOffset < item->p    450                 if( item->textOffset < item->parentElement->text.length ) {
451                     item->textLength = item->p    451                     item->textLength = item->parentElement->text.length - item->textOffset; }
452                 else {                            452                 else {
453                     item->mode = xDataXML_item    453                     item->mode = xDataXML_itemModeEnd;
454                 } }                               454                 } }
455             else {                                455             else {
456                 item->textLength = item->eleme    456                 item->textLength = item->element->textOffset - item->textOffset;
457             }                                     457             }
458         }                                         458         }
459     }                                             459     }
460     return( item->mode );                         460     return( item->mode );
461 }                                                 461 }
462 /*                                                462 /*
463 **********************************************    463 ************************************************************
464 */                                                464 */
465 int xDataXML_isAttributeInList( xDataXML_attri    465 int xDataXML_isAttributeInList( xDataXML_attributionList *attributes, char const *name ) {
466                                                   466 
467     int i;                                        467     int i;
468                                                   468 
469     for( i = 0; i < attributes->number; i++ )     469     for( i = 0; i < attributes->number; i++ ) {
470         if( !strcmp( attributes->attributes[i]    470         if( !strcmp( attributes->attributes[i].name, name ) ) return( 1 );
471     }                                             471     }
472     return( 0 );                                  472     return( 0 );
473 }                                                 473 }
474 /*                                                474 /*
475 **********************************************    475 ************************************************************
476 */                                                476 */
477 int xDataXML_isAttributeInElement( xDataXML_el    477 int xDataXML_isAttributeInElement( xDataXML_element *element, char const *name ) {
478                                                   478 
479     return( xDataXML_isAttributeInList( &(elem    479     return( xDataXML_isAttributeInList( &(element->attributes), name ) );
480 }                                                 480 }
481 /*                                                481 /*
482 **********************************************    482 ************************************************************
483 */                                                483 */
484 char *xDataXML_getAttributesValue( xDataXML_at    484 char *xDataXML_getAttributesValue( xDataXML_attributionList *attributes, char const *name ) {
485                                                   485 
486     int i;                                        486     int i;
487                                                   487 
488     for( i = 0; i < attributes->number; i++ )     488     for( i = 0; i < attributes->number; i++ ) {
489         if( !strcmp( attributes->attributes[i]    489         if( !strcmp( attributes->attributes[i].name, name ) ) return( attributes->attributes[i].value );
490     }                                             490     }
491     return( NULL );                               491     return( NULL );
492 }                                                 492 }
493 /*                                                493 /*
494 **********************************************    494 ************************************************************
495 */                                                495 */
496 char const *xDataXML_getAttributesValueInEleme    496 char const *xDataXML_getAttributesValueInElement( xDataXML_element *element, char const *name ) {
497                                                   497 
498     return( (char const *) xDataXML_getAttribu    498     return( (char const *) xDataXML_getAttributesValue( &(element->attributes), name ) );
499 }                                                 499 }
500 /*                                                500 /*
501 **********************************************    501 ************************************************************
502 */                                                502 */
503 int xDataXML_attributeListLength( xDataXML_att    503 int xDataXML_attributeListLength( xDataXML_attributionList *attributes ) {
504                                                   504 
505     return( attributes->number );                 505     return( attributes->number );
506 }                                                 506 }
507 /*                                                507 /*
508 **********************************************    508 ************************************************************
509 */                                                509 */
510 xDataXML_attribute *xDataXML_attributeByIndex(    510 xDataXML_attribute *xDataXML_attributeByIndex( xDataXML_attributionList *attributes, int index ) {
511                                                   511 
512     if( index >= attributes->number ) return(     512     if( index >= attributes->number ) return( NULL );
513     return( &(attributes->attributes[index]) )    513     return( &(attributes->attributes[index]) );
514 }                                                 514 }
515 /*                                                515 /*
516 **********************************************    516 ************************************************************
517 */                                                517 */
518 static int xDataXML_init_xDataTypeNone( xDataX    518 static int xDataXML_init_xDataTypeNone( xDataXMLType *xDT, xDataXML_element *element ) {
519                                                   519 
520     xDT->status = xDataXML_xDataType_Ok;          520     xDT->status = xDataXML_xDataType_Ok;
521     xDT->ID = NULL;                               521     xDT->ID = NULL;
522     xDT->element = element;                       522     xDT->element = element;
523     xDT->toData = NULL;                           523     xDT->toData = NULL;
524     xDT->toString = NULL;                         524     xDT->toString = NULL;
525     xDT->release = NULL;                          525     xDT->release = NULL;
526     xDT->indexPresent = 1;                  /*    526     xDT->indexPresent = 1;                  /* The following describes the meaning of present variables. */
527     xDT->startPresent = 1;                  /*    527     xDT->startPresent = 1;                  /* If < 0, an error occured in converting value to an integer. */
528     xDT->endPresent = 1;                    /*    528     xDT->endPresent = 1;                    /* If > 0, not present as an attribute. */
529     xDT->lengthPresent = 1;                 /*    529     xDT->lengthPresent = 1;                 /* Else, if 0, present and converted without an error. */
530     xDT->index = -1;                              530     xDT->index = -1;
531     xDT->start = -1;                              531     xDT->start = -1;
532     xDT->end = -1;                                532     xDT->end = -1;
533     xDT->length = -1;                             533     xDT->length = -1;
534     xDT->data = NULL;                             534     xDT->data = NULL;
535     return( 0 );                                  535     return( 0 );
536 }                                                 536 }
537 /*                                                537 /*
538 **********************************************    538 ************************************************************
539 */                                                539 */
540 int xDataXML_getCommonData( statusMessageRepor    540 int xDataXML_getCommonData( statusMessageReporting *smr, xDataXML_element *element, xDataTOM_Int *index, xDataTOM_Int *start, xDataTOM_Int *end,
541         xDataTOM_Int *length ) {                  541         xDataTOM_Int *length ) {
542                                                   542 
543     if( element->xDataTypeInfo.ID == NULL ) {     543     if( element->xDataTypeInfo.ID == NULL ) {
544         smr_setReportError3( smr, xDataXML_get    544         smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( element ), xDataTOM_smrLibraryID, 1, 
545             "element %s is not xData", element    545             "element %s is not xData", element->fullName );
546         return( 1 );                              546         return( 1 );
547     }                                             547     }
548     *index = element->xDataTypeInfo.index;        548     *index = element->xDataTypeInfo.index;
549     *start = element->xDataTypeInfo.start;        549     *start = element->xDataTypeInfo.start;
550     *end = element->xDataTypeInfo.end;            550     *end = element->xDataTypeInfo.end;
551     *length = element->xDataTypeInfo.length;      551     *length = element->xDataTypeInfo.length;
552     return( 0 );                                  552     return( 0 );
553 }                                                 553 }
554 /*                                                554 /*
555 **********************************************    555 ************************************************************
556 */                                                556 */
557 int xDataXML_xDataTypeConvertAttributes( statu    557 int xDataXML_xDataTypeConvertAttributes( statusMessageReporting *smr, xDataXML_element *element ) {
558                                                   558 
559     xDataXMLType *xDT = &(element->xDataTypeIn    559     xDataXMLType *xDT = &(element->xDataTypeInfo);
560     void *smrUser = xDataXML_get_smrUserInterf    560     void *smrUser = xDataXML_get_smrUserInterfaceFromElement( element );
561                                                   561 
562     xDT->index = -1;                              562     xDT->index = -1;
563     xDT->start = -1;                              563     xDT->start = -1;
564     xDT->end = -1;                                564     xDT->end = -1;
565     xDT->length = -1;                             565     xDT->length = -1;
566     if( ( xDT->indexPresent = xDataXML_convert    566     if( ( xDT->indexPresent = xDataXML_convertAttributeTo_xDataTOM_Int( smr, element, "index", &(xDT->index), 0 ) ) < 0 ) return( 1 );
567     if( ( xDT->startPresent = xDataXML_convert    567     if( ( xDT->startPresent = xDataXML_convertAttributeTo_xDataTOM_Int( smr, element, "start", &(xDT->start), 0 ) ) < 0 ) return( 1 );
568     if( ( xDT->endPresent = xDataXML_convertAt    568     if( ( xDT->endPresent = xDataXML_convertAttributeTo_xDataTOM_Int( smr, element, "end", &(xDT->end), 0 ) ) < 0 ) return( 1 );
569     if( ( xDT->lengthPresent = xDataXML_conver    569     if( ( xDT->lengthPresent = xDataXML_convertAttributeTo_xDataTOM_Int( smr, element, "length", &(xDT->length), 0 ) ) < 0 ) return( 1 );
570     if( ( xDT->endPresent > 0 ) ) {               570     if( ( xDT->endPresent > 0 ) ) {
571         if( xDT->lengthPresent > 0 ) {            571         if( xDT->lengthPresent > 0 ) {
572             smr_setReportError3p( smr, smrUser    572             smr_setReportError3p( smr, smrUser, xDataTOM_smrLibraryID, 1, "missing length (or end) in xData" );
573             return( 1 );                          573             return( 1 );
574         }                                         574         }
575         xDT->end = xDT->length; }                 575         xDT->end = xDT->length; }
576     else {                                        576     else {
577         if( xDT->lengthPresent > 0 ) xDT->leng    577         if( xDT->lengthPresent > 0 ) xDT->length = xDT->end;
578     }                                             578     }
579                                                   579 
580     if( xDT->startPresent > 0 ) xDT->start = 0    580     if( xDT->startPresent > 0 ) xDT->start = 0;
581     if( xDT->start < 0 ) {                        581     if( xDT->start < 0 ) {
582         smr_setReportError3( smr, smrUser, xDa    582         smr_setReportError3( smr, smrUser, xDataTOM_smrLibraryID, 1, "start = %d < 0", xDT->start );
583         return( 1 );                              583         return( 1 );
584     }                                             584     }
585     if( xDT->end < xDT->start ) {                 585     if( xDT->end < xDT->start ) {
586         smr_setReportError3( smr, smrUser, xDa    586         smr_setReportError3( smr, smrUser, xDataTOM_smrLibraryID, 1, "start = %d >= end = %d", xDT->start, xDT->end );
587         return( 1 );                              587         return( 1 );
588     }                                             588     }
589     if( xDT->length < 0 ) {                       589     if( xDT->length < 0 ) {
590         smr_setReportError3( smr, smrUser, xDa    590         smr_setReportError3( smr, smrUser, xDataTOM_smrLibraryID, 1, "length = %d < 0", xDT->length );
591         return( 1 );                              591         return( 1 );
592     }                                             592     }
593                                                   593 
594     return( 0 );                                  594     return( 0 );
595 }                                                 595 }
596 /*                                                596 /*
597 **********************************************    597 ************************************************************
598 */                                                598 */
599 xDataTOM_Int xDataXML_convertAttributeTo_xData    599 xDataTOM_Int xDataXML_convertAttributeTo_xDataTOM_Int( statusMessageReporting *smr, xDataXML_element *element, char const *name, xDataTOM_Int *n, int required ) {
600 /*                                                600 /*
601 *   Returns 1 if no such attribute, -1 if erro    601 *   Returns 1 if no such attribute, -1 if error converting to xDataTOM_Int and 0 if successful.
602 */                                                602 */
603     char const *value;                            603     char const *value;
604     char *e;                                      604     char *e;
605                                                   605 
606     if( ( value = xDataXML_getAttributesValueI    606     if( ( value = xDataXML_getAttributesValueInElement( element, name ) ) == NULL ) {
607         if( required ) smr_setReportError3( sm    607         if( required ) smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( element ), xDataTOM_smrLibraryID, 1,
608             "missing required attribute '%s'",    608             "missing required attribute '%s'", name );
609         return( 1 );                              609         return( 1 );
610     }                                             610     }
611     *n = (xDataTOM_Int) strtoll( value, &e, 10    611     *n = (xDataTOM_Int) strtoll( value, &e, 10 );
612     if( *e != 0 ) {                               612     if( *e != 0 ) {
613         smr_setReportError3( smr, xDataXML_get    613         smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( element ), xDataTOM_smrLibraryID, 1, 
614             "could not convert attribute %s's     614             "could not convert attribute %s's value = %s to an integer", name, value );
615         return( -1 );                             615         return( -1 );
616     }                                             616     }
617     return( 0 );                                  617     return( 0 );
618 }                                                 618 }
619 /*                                                619 /*
620 **********************************************    620 ************************************************************
621 */                                                621 */
622 int xDataXML_convertAttributeToDouble( statusM    622 int xDataXML_convertAttributeToDouble( statusMessageReporting *smr, xDataXML_element *element, char const *name, double *d, int required ) {
623 /*                                                623 /*
624 *   Returns 1 if no such attribute, -1 if erro    624 *   Returns 1 if no such attribute, -1 if error converting to double and 0 if successful.
625 */                                                625 */
626     char const *value;                            626     char const *value;
627     char *e;                                      627     char *e;
628                                                   628 
629     if( ( value = xDataXML_getAttributesValueI    629     if( ( value = xDataXML_getAttributesValueInElement( element, name ) ) == NULL ) {
630         if( required ) smr_setReportError3( sm    630         if( required ) smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( element ), xDataTOM_smrLibraryID, 1,
631             "missing required attribute '%s'",    631             "missing required attribute '%s'", name );
632         return( 1 );                              632         return( 1 );
633     }                                             633     }
634     *d = strtod( value, &e );                     634     *d = strtod( value, &e );
635     if( *e != 0 ) {                               635     if( *e != 0 ) {
636         smr_setReportError3( smr, xDataXML_get    636         smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( element) , xDataTOM_smrLibraryID, 1, 
637             "could not convert attribute %s's     637             "could not convert attribute %s's values = %s to a double", name, value );
638         return( -1 );                             638         return( -1 );
639     }                                             639     }
640     return( 0 );                                  640     return( 0 );
641 }                                                 641 }
642 /*                                                642 /*
643 **********************************************    643 ************************************************************
644 */                                                644 */
645 int xDataXML_numberOfElementsByTagName( status    645 int xDataXML_numberOfElementsByTagName( statusMessageReporting * /*smr*/, xDataXML_element *element, char const *tagName ) {
646                                                   646 
647     int n = 0;                                    647     int n = 0;
648     xDataXML_element *child;                      648     xDataXML_element *child;
649                                                   649 
650     for( child = xDataXML_getFirstElement( ele    650     for( child = xDataXML_getFirstElement( element ); child != NULL; child = xDataXML_getNextElement( child ) ) if( !strcmp( child->name, tagName ) ) n++;
651     return( n );                                  651     return( n );
652 }                                                 652 }
653 /*                                                653 /*
654 **********************************************    654 ************************************************************
655 */                                                655 */
656 xDataXML_elementList *xDataXML_getElementsByTa    656 xDataXML_elementList *xDataXML_getElementsByTagName( statusMessageReporting *smr, xDataXML_element *element, char const *tagName ) {
657                                                   657 
658     int n = xDataXML_numberOfElementsByTagName    658     int n = xDataXML_numberOfElementsByTagName( smr, element, tagName );
659     size_t size;                                  659     size_t size;
660     xDataXML_element *child;                      660     xDataXML_element *child;
661     xDataXML_elementListItem *p;                  661     xDataXML_elementListItem *p;
662     xDataXML_elementList *list = NULL;            662     xDataXML_elementList *list = NULL;
663                                                   663 
664                                                   664 
665     size = sizeof( xDataXML_elementList ) + n     665     size = sizeof( xDataXML_elementList ) + n * sizeof( xDataXML_elementListItem );
666     if( ( list = (xDataXML_elementList *) smr_    666     if( ( list = (xDataXML_elementList *) smr_malloc2( smr, size, 0, "list" ) ) != NULL ) {
667         list->n = n;                              667         list->n = n;
668         p = list->items = (xDataXML_elementLis    668         p = list->items = (xDataXML_elementListItem *) &(list[1]);
669         for( child = xDataXML_getFirstElement(    669         for( child = xDataXML_getFirstElement( element ); child != NULL; child = xDataXML_getNextElement( child ) ) {
670             if( !strcmp( child->name, tagName     670             if( !strcmp( child->name, tagName ) ) {
671                 p->element = child;               671                 p->element = child;
672                 p->sortString = NULL;             672                 p->sortString = NULL;
673                 p++;                              673                 p++;
674             }                                     674             }
675         }                                         675         }
676     }                                             676     }
677     return( list );                               677     return( list );
678 }                                                 678 }
679 /*                                                679 /*
680 **********************************************    680 ************************************************************
681 */                                                681 */
682 xDataXML_element *xDataXML_getOneElementByTagN    682 xDataXML_element *xDataXML_getOneElementByTagName( statusMessageReporting *smr, xDataXML_element *element, char *name, int required ) {
683                                                   683 
684     xDataXML_elementList *list;                   684     xDataXML_elementList *list;
685     xDataXML_element *xData = NULL;               685     xDataXML_element *xData = NULL;
686                                                   686 
687     if( ( list = xDataXML_getElementsByTagName    687     if( ( list = xDataXML_getElementsByTagName( smr, element, name ) ) != NULL ) {
688         if( list->n == 0 ) {                      688         if( list->n == 0 ) {
689             if( required ) smr_setReportError3    689             if( required ) smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( element ), xDataTOM_smrLibraryID, 
690                 1, "element %s does not have s    690                 1, "element %s does not have sub-element named %s", element->fullName, name ); }
691         else if( list->n > 1 ) {                  691         else if( list->n > 1 ) {
692             smr_setReportError3( smr, xDataXML    692             smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( element ), xDataTOM_smrLibraryID, 1, 
693                 "element %s contains more than    693                 "element %s contains more than one sub-element named %s", element->fullName, name ); }
694         else {                                    694         else {
695             xData = list->items[0].element;       695             xData = list->items[0].element;
696         }                                         696         }
697         xDataXML_freeElementList( smr, list );    697         xDataXML_freeElementList( smr, list );
698     }                                             698     }
699     return( xData );                              699     return( xData );
700 }                                                 700 }
701 /*                                                701 /*
702 **********************************************    702 ************************************************************
703 */                                                703 */
704 void xDataXML_freeElementList( statusMessageRe    704 void xDataXML_freeElementList( statusMessageReporting * /*smr*/, xDataXML_elementList *list ) {
705                                                   705 
706     smr_freeMemory( (void **) &list );            706     smr_freeMemory( (void **) &list );
707 }                                                 707 }
708 /*                                                708 /*
709 **********************************************    709 ************************************************************
710 */                                                710 */
711 static char *xDataXML_getTraceback( statusMess    711 static char *xDataXML_getTraceback( statusMessageReporting *smr, xDataXML_element *element ) {
712 /*                                                712 /*
713 *   Returned string must be freed by calling r    713 *   Returned string must be freed by calling routine.
714 */                                                714 */
715     int size;                                     715     int size;
716     char *s, *name;                               716     char *s, *name;
717                                                   717 
718     name = element->name;                         718     name = element->name;
719     size = (int) strlen( name ) + 1;              719     size = (int) strlen( name ) + 1;
720     if( ( s = xDataXML_getTraceback2( smr, ele    720     if( ( s = xDataXML_getTraceback2( smr, element->parentRoot, size ) ) != NULL ) {
721         strcat( s, "/" );                         721         strcat( s, "/" );
722         strcat( s, name );                        722         strcat( s, name );
723     }                                             723     }
724     return( s );                                  724     return( s );
725 }                                                 725 }
726 /*                                                726 /*
727 **********************************************    727 ************************************************************
728 */                                                728 */
729 static char *xDataXML_getTraceback2( statusMes    729 static char *xDataXML_getTraceback2( statusMessageReporting *smr, xDataXML_rootElement *parentRoot, int n ) {
730                                                   730 
731     int size;                                     731     int size;
732     char *s, *name;                               732     char *s, *name;
733                                                   733 
734     if( parentRoot->parentRoot == NULL ) {        734     if( parentRoot->parentRoot == NULL ) {
735         s = (char *) smr_malloc2( smr, n + 1,     735         s = (char *) smr_malloc2( smr, n + 1, 0, "traceback string" );
736         *s = 0; }                                 736         *s = 0; }
737     else {                                        737     else {
738         name = parentRoot->parentElement->name    738         name = parentRoot->parentElement->name;
739         size = (int) strlen( name ) + 1;          739         size = (int) strlen( name ) + 1;
740         n += size;                                740         n += size;
741         if( ( s = xDataXML_getTraceback2( smr,    741         if( ( s = xDataXML_getTraceback2( smr, parentRoot->parentRoot, n ) ) != NULL ) {
742             strcat( s, "/" );                     742             strcat( s, "/" );
743             strcat( s, name );                    743             strcat( s, name );
744         }                                         744         }
745     }                                             745     }
746     return( s );                                  746     return( s );
747 }                                                 747 }
748 /*                                                748 /*
749 **********************************************    749 ************************************************************
750 */                                                750 */
751 int xDataXML_is_xDataType( statusMessageReport    751 int xDataXML_is_xDataType( statusMessageReporting *smr, xDataXMLType *xDT, char const * const ID, int setMsg ) {
752                                                   752 
753     if( xDT->ID == NULL ) {                       753     if( xDT->ID == NULL ) {
754         if( setMsg ) smr_setReportError3( smr,    754         if( setMsg ) smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( xDT->element ), xDataTOM_smrLibraryID, 1, 
755             "element %s not xData object", xDT    755             "element %s not xData object", xDT->element->fullName ); }
756     else if( xDT->ID != ID ) {                    756     else if( xDT->ID != ID ) {
757         if( setMsg ) smr_setReportError3( smr,    757         if( setMsg ) smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( xDT->element ), xDataTOM_smrLibraryID, 1, 
758             "Element %s is not xData object of    758             "Element %s is not xData object of ID %s but %s", xDT->element->fullName, ID, xDT->ID );
759     }                                             759     }
760     return( xDT->ID == ID );                      760     return( xDT->ID == ID );
761 }                                                 761 }
762 /*                                                762 /*
763 **********************************************    763 ************************************************************
764 */                                                764 */
765 char const *xDataXML_getFileName( xDataXML_doc    765 char const *xDataXML_getFileName( xDataXML_document *doc ) {
766                                                   766 
767     return( doc->fileName );                      767     return( doc->fileName );
768 }                                                 768 }
769 /*                                                769 /*
770 **********************************************    770 ************************************************************
771 */                                                771 */
772 char const *xDataXML_getRealFileName( xDataXML    772 char const *xDataXML_getRealFileName( xDataXML_document *doc ) {
773                                                   773 
774     return( doc->realFileName );                  774     return( doc->realFileName );
775 }                                                 775 }
776 /*                                                776 /*
777 **********************************************    777 ************************************************************
778 */                                                778 */
779 static int xDataXML_setFileName( statusMessage    779 static int xDataXML_setFileName( statusMessageReporting *smr, xDataXML_document *doc, char const *fileName ) {
780                                                   780 
781     char realPath[PATH_MAX+1];                    781     char realPath[PATH_MAX+1];
782                                                   782 
783     smr_freeMemory( (void **) &(doc->fileName)    783     smr_freeMemory( (void **) &(doc->fileName) );
784     smr_freeMemory( (void **) &(doc->realFileN    784     smr_freeMemory( (void **) &(doc->realFileName) );
785     if( fileName != NULL ) {                      785     if( fileName != NULL ) {
786         if( ( doc->fileName = smr_allocateCopy    786         if( ( doc->fileName = smr_allocateCopyString2( smr, fileName, "fileName" ) ) == NULL ) return( 1 );
787         if( realpath( fileName, realPath ) !=     787         if( realpath( fileName, realPath ) != NULL ) {
788             if( ( doc->realFileName = smr_allo    788             if( ( doc->realFileName = smr_allocateCopyString2( smr, realPath, "realFileName" ) ) == NULL ) return( 1 );
789         }                                         789         }
790     }                                             790     }
791     return( 0 );                                  791     return( 0 );
792 }                                                 792 }
793 /*                                                793 /*
794 **********************************************    794 ************************************************************
795 */                                                795 */
796 xDataXML_document *xDataXML_getElementsDocumen    796 xDataXML_document *xDataXML_getElementsDocument( xDataXML_element *element ) {
797                                                   797 
798     xDataXML_rootElement* root = element->pare    798     xDataXML_rootElement* root = element->parentRoot;
799                                                   799 
800     while( root->parentRoot != NULL ) root = r    800     while( root->parentRoot != NULL ) root = root->parentRoot; // Loop checking, 11.06.2015, T. Koi
801     return( root->xData_doc );                    801     return( root->xData_doc );
802 }                                                 802 }
803 /*                                                803 /*
804 **********************************************    804 ************************************************************
805 */                                                805 */
806 void *xDataXML_get_smrUserInterfaceFromDocumen    806 void *xDataXML_get_smrUserInterfaceFromDocument( xDataXML_document *doc ) {
807                                                   807 
808     if( doc == NULL ) return( NULL );             808     if( doc == NULL ) return( NULL );
809     return( &(doc->smrUserInterface ) );          809     return( &(doc->smrUserInterface ) );
810 }                                                 810 }
811 /*                                                811 /*
812 **********************************************    812 ************************************************************
813 */                                                813 */
814 void *xDataXML_get_smrUserInterfaceFromElement    814 void *xDataXML_get_smrUserInterfaceFromElement( xDataXML_element *element ) {
815                                                   815 
816     return( xDataXML_get_smrUserInterfaceFromD    816     return( xDataXML_get_smrUserInterfaceFromDocument( xDataXML_getElementsDocument( element ) ) );
817 }                                                 817 }
818 /*                                                818 /*
819 **********************************************    819 ************************************************************
820 */                                                820 */
821 static int xDataXML_smrUserInterfaceInitialize    821 static int xDataXML_smrUserInterfaceInitialize( xDataXML_document *doc ) {
822                                                   822 
823     doc->smrUserInterface.smrUserInterface = x    823     doc->smrUserInterface.smrUserInterface = xDataXML_smrUserInterface;
824     doc->smrUserInterface.doc = doc;              824     doc->smrUserInterface.doc = doc;
825     return( 0 );                                  825     return( 0 );
826 }                                                 826 }
827 /*                                                827 /*
828 **********************************************    828 ************************************************************
829 */                                                829 */
830 static int xDataXML_smrUserInterfaceFree( xDat    830 static int xDataXML_smrUserInterfaceFree( xDataXML_document *doc ) {
831                                                   831 
832     doc->smrUserInterface.smrUserInterface = N    832     doc->smrUserInterface.smrUserInterface = NULL;
833     doc->smrUserInterface.doc = NULL;             833     doc->smrUserInterface.doc = NULL;
834     return( 0 );                                  834     return( 0 );
835 }                                                 835 }
836 /*                                                836 /*
837 **********************************************    837 ************************************************************
838 */                                                838 */
839 static char *xDataXML_smrUserInterface( void *    839 static char *xDataXML_smrUserInterface( void *userData ) {
840                                                   840 
841     xDataXML_smr *smrUserInterface = (xDataXML    841     xDataXML_smr *smrUserInterface = (xDataXML_smr *) userData;
842     xDataXML_rootElement *currentRoot = smrUse    842     xDataXML_rootElement *currentRoot = smrUserInterface->doc->currentRoot;
843                                                   843 
844     if( currentRoot->parentElement != NULL ) {    844     if( currentRoot->parentElement != NULL ) {
845         return( smr_allocateFormatMessage( "\n    845         return( smr_allocateFormatMessage( "\nat line %d and column %d of file %s\nin element %s", currentRoot->parentElement->docInfo.line, 
846             currentRoot->parentElement->docInf    846             currentRoot->parentElement->docInfo.column, smrUserInterface->doc->fileName, currentRoot->parentElement->fullName ) ); }
847     else if( smrUserInterface->doc->fileName !    847     else if( smrUserInterface->doc->fileName != NULL ) {
848         return( smr_allocateFormatMessage( "\n    848         return( smr_allocateFormatMessage( "\nof file %s", smrUserInterface->doc->fileName ) );
849     }                                             849     }
850     return( smr_allocateFormatMessage( "\nat l    850     return( smr_allocateFormatMessage( "\nat line %d and column %d\nin element %s", currentRoot->parentElement->docInfo.line,
851         currentRoot->parentElement->docInfo.co    851         currentRoot->parentElement->docInfo.column, currentRoot->parentElement->fullName ) );
852 }                                                 852 }
853 /*                                                853 /*
854 **********************************************    854 ************************************************************
855 */                                                855 */
856 int xDataXML_stringTo_xDataTOM_Int( statusMess    856 int xDataXML_stringTo_xDataTOM_Int( statusMessageReporting *smr, void *smrUserInterface, char const *c, xDataTOM_Int *value, char const *endings, char **e ) {
857                                                   857 
858     char const *s;                                858     char const *s;
859     char tmp[64];                                 859     char tmp[64];
860     int status = 1, n = sizeof( tmp );            860     int status = 1, n = sizeof( tmp );
861                                                   861 
862     for( s = c; *s != 0; s++ ) if( !isspace( *    862     for( s = c; *s != 0; s++ ) if( !isspace( *s ) ) break;
863     *value = (xDataTOM_Int) strtoll( s, e, 10     863     *value = (xDataTOM_Int) strtoll( s, e, 10 );
864     if( *e == s ) {                               864     if( *e == s ) {
865         smr_setReportError3(smr, smrUserInterf    865         smr_setReportError3(smr, smrUserInterface, xDataTOM_smrLibraryID, 1, "could not convert \"%s\" to an integer", xDataXML_shortStringForMessage( n, tmp, c ));}
866     else {                                        866     else {
867         if( *endings == 0 ) while( isspace( **    867         if( *endings == 0 ) while( isspace( **e ) ) (*e)++; // Loop checking, 11.06.2015, T. Koi
868         if( **e == 0 ) {                          868         if( **e == 0 ) {
869             status = 0; }                         869             status = 0; }
870         else {                                    870         else {
871             if( *endings == 0 ) {                 871             if( *endings == 0 ) {
872                 smr_setReportError3( smr, smrU    872                 smr_setReportError3( smr, smrUserInterface, xDataTOM_smrLibraryID, 1, "integer string \"%s\" does not end with a '\\0'", 
873                     xDataXML_shortStringForMes    873                     xDataXML_shortStringForMessage( n, tmp, c ) ); }
874             else {                                874             else {
875                 if( strchr( endings, **e ) ==     875                 if( strchr( endings, **e ) == NULL ) {
876                     smr_setReportError3( smr,     876                     smr_setReportError3( smr, smrUserInterface, xDataTOM_smrLibraryID, 1, "integer string \"%s\" does not end with a white space or a '\\0\'", 
877                         xDataXML_shortStringFo    877                         xDataXML_shortStringForMessage( n, tmp, c ) ); }
878                 else {                            878                 else {
879                     status = 0;                   879                     status = 0;
880                 }                                 880                 }
881             }                                     881             }
882         }                                         882         }
883     }                                             883     }
884     return( status );                             884     return( status );
885 }                                                 885 }
886 /*                                                886 /*
887 **********************************************    887 ************************************************************
888 */                                                888 */
889 int xDataXML_stringTo_double( statusMessageRep    889 int xDataXML_stringTo_double( statusMessageReporting *smr, void *smrUserInterface, char const *c, double *value, char const *endings, char **e ) {
890                                                   890 
891     char const *s;                                891     char const *s;
892     char tmp[64];                                 892     char tmp[64];
893     int status = 1, n = sizeof( tmp );            893     int status = 1, n = sizeof( tmp );
894                                                   894 
895     for( s = c; *s != 0; s++ ) if( !isspace( *    895     for( s = c; *s != 0; s++ ) if( !isspace( *s ) ) break;
896     *value = strtod( s, e );                      896     *value = strtod( s, e );
897     if( *e == s ) {                               897     if( *e == s ) {
898         smr_setReportError3( smr, smrUserInter    898         smr_setReportError3( smr, smrUserInterface, xDataTOM_smrLibraryID, 1, "could not convert \"%s\" to an double", 
899             xDataXML_shortStringForMessage( n,    899             xDataXML_shortStringForMessage( n, tmp, c ));}
900     else {                                        900     else {
901         if( *endings == 0 ) while( isspace( **    901         if( *endings == 0 ) while( isspace( **e ) ) (*e)++; // Loop checking, 11.06.2015, T. Koi
902         if( **e == 0 ) {                          902         if( **e == 0 ) {
903             status = 0; }                         903             status = 0; }
904         else {                                    904         else {
905             if( *endings == 0 ) {                 905             if( *endings == 0 ) {
906                 smr_setReportError3( smr, smrU    906                 smr_setReportError3( smr, smrUserInterface, xDataTOM_smrLibraryID, 1, "double string \"%s\" does not end with a '\\0'", 
907                     xDataXML_shortStringForMes    907                     xDataXML_shortStringForMessage( n, tmp, c ) ); }
908             else {                                908             else {
909                 if( strchr( endings, **e ) ==     909                 if( strchr( endings, **e ) == NULL ) {
910                     smr_setReportError3( smr,     910                     smr_setReportError3( smr, smrUserInterface, xDataTOM_smrLibraryID, 1, "double string \"%s\" does not end with a white space or a '\\0\'", 
911                         xDataXML_shortStringFo    911                         xDataXML_shortStringForMessage( n, tmp, c ) ); }
912                 else {                            912                 else {
913                     status = 0;                   913                     status = 0;
914                 }                                 914                 }
915             }                                     915             }
916         }                                         916         }
917     }                                             917     }
918     return( status );                             918     return( status );
919 }                                                 919 }
920 /*                                                920 /*
921 **********************************************    921 ************************************************************
922 */                                                922 */
923 int xDataXML_addToAccessed( statusMessageRepor    923 int xDataXML_addToAccessed( statusMessageReporting * /*smr*/, xDataXML_element *element, int increment ) {
924                                                   924 
925     element->accessed += increment;               925     element->accessed += increment;
926     return( element->accessed );                  926     return( element->accessed );
927 }                                                 927 }
928 /*                                                928 /*
929 **********************************************    929 ************************************************************
930 */                                                930 */
931 int xDataXML_getAccessed( statusMessageReporti    931 int xDataXML_getAccessed( statusMessageReporting * /*smr*/, xDataXML_element *element ) {
932                                                   932 
933     return( element->accessed );                  933     return( element->accessed );
934 }                                                 934 }
935 /*                                                935 /*
936 **********************************************    936 ************************************************************
937 */                                                937 */
938 static char const *xDataXML_shortStringForMess    938 static char const *xDataXML_shortStringForMessage( size_t size, char *Out, char const *In ) {
939                                                   939 
940     if( strlen( In ) > size ) {                   940     if( strlen( In ) > size ) {
941         strncpy( Out, In, size - 5 );             941         strncpy( Out, In, size - 5 );
942         Out[size-5] = 0;                          942         Out[size-5] = 0;
943         strcat( Out, " ..." );                    943         strcat( Out, " ..." );
944         return( Out );                            944         return( Out );
945     }                                             945     }
946     return( In );                                 946     return( In );
947 }                                                 947 }
948 /*                                                948 /*
949 **********************************************    949 ************************************************************
950 */                                                950 */
951 static int xDataXML_constructTOM( statusMessag    951 static int xDataXML_constructTOM( statusMessageReporting *smr, xDataTOM_element *TE, xDataXML_element *XE ) {
952                                                   952 
953     int i, status = 0;                            953     int i, status = 0;
954     xDataTOM_element *TOMChild;                   954     xDataTOM_element *TOMChild;
955     xDataXML_element *XMLChild;                   955     xDataXML_element *XMLChild;
956     xDataXML_attribute *attribute;                956     xDataXML_attribute *attribute;
957     char const *xDataValue = xDataXML_getAttri    957     char const *xDataValue = xDataXML_getAttributesValueInElement( XE, "xData" );
958                                                   958 
959     if( !smr_isOk( smr ) ) return( 1 );           959     if( !smr_isOk( smr ) ) return( 1 );
960     if( ( TOMChild = xDataTOM_addElementInElem    960     if( ( TOMChild = xDataTOM_addElementInElement( smr, TE, XE->index, XE->name ) ) == NULL ) return( 1 );
961     for( i = 0; 1; i++ ) {                        961     for( i = 0; 1; i++ ) {
962         if( ( attribute = xDataXML_attributeBy    962         if( ( attribute = xDataXML_attributeByIndex( &(XE->attributes), i ) ) == NULL ) break;
963         if( xDataTOME_addAttribute( smr, TOMCh    963         if( xDataTOME_addAttribute( smr, TOMChild, attribute->name, attribute->value ) != 0 ) return( 1 );
964     }                                             964     }
965                                                   965 
966     if( !strcmp( XE->name, xDataTOM_KalbachMan    966     if( !strcmp( XE->name, xDataTOM_KalbachMann_ID ) ) {
967         xDataValue = xDataTOM_KalbachMann_ID;     967         xDataValue = xDataTOM_KalbachMann_ID;
968     }                                             968     }
969                                                   969 
970     if( xDataValue == NULL ) {                    970     if( xDataValue == NULL ) {
971         for( XMLChild = xDataXML_getFirstEleme    971         for( XMLChild = xDataXML_getFirstElement( XE ); ( status == 0 ) && ( XMLChild != NULL ); XMLChild = xDataXML_getNextElement( XMLChild ) ) {
972             status = xDataXML_constructTOM( sm    972             status = xDataXML_constructTOM( smr, TOMChild, XMLChild );
973         } }                                       973         } }
974     else {                                        974     else {
975         if( strcmp( xDataValue, xDataTOM_XYs_I    975         if( strcmp( xDataValue, xDataTOM_XYs_ID ) == 0 ) {
976             status = xDataXML_XYsToTOM( smr, X    976             status = xDataXML_XYsToTOM( smr, XE, TOMChild ); }
977         else if( strcmp( xDataValue, xDataTOM_    977         else if( strcmp( xDataValue, xDataTOM_regionsXYs_ID ) == 0 ) {
978             status = xDataXML_regionsXYsToTOM(    978             status = xDataXML_regionsXYsToTOM( smr, XE, TOMChild ); }
979         else if( strcmp( xDataValue, xDataTOM_    979         else if( strcmp( xDataValue, xDataTOM_W_XYs_ID ) == 0 ) {
980             status = xDataXML_W_XYsToTOM( smr,    980             status = xDataXML_W_XYsToTOM( smr, XE, TOMChild ); }
981         else if( strcmp( xDataValue, xDataTOM_    981         else if( strcmp( xDataValue, xDataTOM_V_W_XYs_ID ) == 0 ) {
982             status = xDataXML_V_W_XYsToTOM( sm    982             status = xDataXML_V_W_XYsToTOM( smr, XE, TOMChild ); }
983         else if( strcmp( xDataValue, xDataTOM_    983         else if( strcmp( xDataValue, xDataTOM_W_XYs_LegendreSeries_ID ) == 0 ) {
984             status = xDataXML_W_XYs_LegendreSe    984             status = xDataXML_W_XYs_LegendreSeriesToTOM( smr, XE, TOMChild ); }
985         else if( strcmp( xDataValue, xDataTOM_    985         else if( strcmp( xDataValue, xDataTOM_regionsW_XYs_LegendreSeries_ID ) == 0 ) {
986             status = xDataXML_regionsW_XYs_Leg    986             status = xDataXML_regionsW_XYs_LegendreSeriesToTOM( smr, XE, TOMChild ); }
987         else if( strcmp( xDataValue, xDataTOM_    987         else if( strcmp( xDataValue, xDataTOM_V_W_XYs_LegendreSeries_ID ) == 0 ) {
988             status = xDataXML_V_W_XYs_Legendre    988             status = xDataXML_V_W_XYs_LegendreSeriesToTOM( smr, XE, TOMChild ); }
989         else if( strcmp( xDataValue, xDataTOM_    989         else if( strcmp( xDataValue, xDataTOM_KalbachMann_ID ) == 0 ) {
990             status = xDataXML_KalbachMannToTOM    990             status = xDataXML_KalbachMannToTOM( smr, XE, TOMChild ); }
991         else if( strcmp( xDataValue, xDataTOM_    991         else if( strcmp( xDataValue, xDataTOM_polynomial_ID ) == 0 ) {
992             status = xDataXML_polynomialToTOM(    992             status = xDataXML_polynomialToTOM( smr, XE, TOMChild ); }
993         else {                                    993         else {
994             printf( "Unsupported xData type '%    994             printf( "Unsupported xData type '%s' in element '%s'\n", xDataValue, XE->name );
995 #if 0                                             995 #if 0
996             smr_setReportError3( smr, xDataXML    996             smr_setReportError3( smr, xDataXML_get_smrUserInterfaceFromElement( XE ), xDataTOM_smrLibraryID, -1, 
997                 "Unsupported xData type = \"%s    997                 "Unsupported xData type = \"%s\"", xDataValue );
998             status = 1;                           998             status = 1;
999 #endif                                            999 #endif
1000         }                                        1000         }
1001     }                                            1001     }
1002     return( status );                            1002     return( status );
1003 }                                                1003 }
1004 /*                                               1004 /*
1005 *********************************************    1005 ************************************************************
1006 */                                               1006 */
1007 void *xDataXML_initializeData( statusMessageR    1007 void *xDataXML_initializeData( statusMessageReporting *smr, xDataXML_element *XE, xDataTOM_element *TE, char const *ID, size_t size ) {
1008                                                  1008 
1009     xDataTOM_xDataInfo *xDI = &(TE->xDataInfo    1009     xDataTOM_xDataInfo *xDI = &(TE->xDataInfo);
1010                                                  1010 
1011     if( xData_initializeData( smr, TE, ID, si    1011     if( xData_initializeData( smr, TE, ID, size ) == NULL ) return( NULL );
1012     if( xDataXML_axesElememtToTOM( smr, XE, &    1012     if( xDataXML_axesElememtToTOM( smr, XE, &(xDI->axes) ) != 0 ) smr_freeMemory( (void **) &(xDI->data) );
1013     return( xDI->data );                         1013     return( xDI->data );
1014 }                                                1014 }
1015                                                  1015 
1016 #if defined __cplusplus                          1016 #if defined __cplusplus
1017 }                                                1017 }
1018 #endif                                           1018 #endif
1019                                                  1019