LP1779158 Angular7 and ng-lint updates
[Evergreen.git] / Open-ILS / src / c-apps / idlval.c
1 /**
2         @file idlval.c
3         @brief Validator for IDL files.
4 */
5
6 /*
7 Copyright (C) 2009  Georgia Public Library Service
8 Scott McKellar <scott@esilibrary.com>
9
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License
12 as published by the Free Software Foundation; either version 2
13 of the License, or (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 GNU General Public License for more details.
19 */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <ctype.h>
25 #include <libxml/globals.h>
26 #include <libxml/xmlerror.h>
27 #include <libxml/parser.h>
28 #include <libxml/tree.h>
29 #include <libxml/debugXML.h>
30 #include <libxml/xmlmemory.h>
31
32 #include <opensrf/utils.h>
33 #include <opensrf/osrf_hash.h>
34
35 /* Represents the command line */
36 struct Opts {
37         int new_argc;
38         char ** new_argv;
39
40         char * idl_file_name;
41         int idl_file_name_found;
42         int warning;
43 };
44 typedef struct Opts Opts;
45
46 /* datatype attribute of <field> element */
47 typedef enum {
48         DT_NONE,
49         DT_BOOL,
50         DT_FLOAT,
51         DT_ID,
52         DT_INT,
53         DT_INTERVAL,
54         DT_LINK,
55         DT_MONEY,
56         DT_NUMBER,
57         DT_ORG_UNIT,
58         DT_TEXT,
59         DT_TIMESTAMP,
60         DT_INVALID
61 } Datatype;
62
63 /* Represents a <Field> aggregate */
64 struct Field_struct {
65         struct Field_struct* next;
66         xmlChar* name;
67         int is_virtual;     // boolean
68         xmlChar* label;
69         Datatype datatype;
70 };
71 typedef struct Field_struct Field;
72
73 /* reltype attribute of <link> element */
74 typedef enum {
75         RT_NONE,
76         RT_HAS_A,
77         RT_MIGHT_HAVE,
78         RT_HAS_MANY,
79         RT_INVALID
80 } Reltype;
81
82 /* Represents a <link> element */
83 struct Link_struct {
84         struct Link_struct* next;
85         xmlChar* field;
86         Reltype reltype;
87         xmlChar* key;
88         xmlChar* classref;
89 };
90 typedef struct Link_struct Link;
91
92 /* Represents a <class> aggregate */
93 typedef struct {
94         xmlNodePtr node;
95         int loaded;        // boolean
96         int is_virtual;    // boolean
97         xmlChar* primary;  // name of primary key column
98         Field* fields;     // linked list
99         Link* links;       // linked list
100 } Class;
101
102 static int get_Opts( int argc, char * argv[], Opts * pOpts );;
103 static int val_idl( void );
104 static int cross_validate_classes( Class* class, const char* id );
105 static int cross_validate_linkage( Class* class, const char*id, Link* link );
106 static int val_class( Class* class, const char* id );
107 static int val_class_attributes( Class* class, const char* id );
108 static int check_labels( const Class* class, const char* id );
109 static int val_fields_attributes( Class* class, const char* id, xmlNodePtr fields );
110 static int val_links_to_fields( const Class* class, const char* id );
111 static int compareFieldAndLink( const Class* class, const char* id,
112                 const Field* field, const Link* link );
113 static int val_fields_to_links( const Class* class, const char* id );
114 static const Field* searchFieldByName( const Class* class, const xmlChar* field_name );
115 static int val_fields( Class* class, const char* id, xmlNodePtr fields );
116 static int val_one_field( Class* class, const char* id, xmlNodePtr field );
117 static Datatype translate_datatype( const xmlChar* value );
118 static int val_links( Class* class, const char* id, xmlNodePtr links );
119 static int val_one_link( Class* class, const char* id, xmlNodePtr link );
120 static Reltype translate_reltype( const xmlChar* value );
121 static int scan_idl( xmlDocPtr doc );
122 static int register_class( xmlNodePtr child );
123 static int addField( Class* class, const char* id, Field* new_field );
124 static int addLink( Class* class, const char* id, Link* new_link );
125 static Class* newClass( xmlNodePtr node );
126 static void freeClass( char* key, void* p );
127 static Field* newField( xmlChar* name );
128 static void freeField( Field* field );
129 static Link* newLink( xmlChar* field );
130 static void freeLink( Link* link );
131
132 /* Stores an in-memory representation of the IDL */
133 static osrfHash* classes = NULL;
134
135 static int warn = 0;       // boolean; true if -w present on command line
136
137 int main( int argc, char* argv[] ) {
138
139         // Examine command line
140         Opts opts;
141         if( get_Opts( argc, argv, &opts ) )
142                 return 1;
143
144         const char* IDL_filename = NULL;
145         if( opts.idl_file_name_found )
146                 IDL_filename = opts.idl_file_name;
147         else {
148                 IDL_filename = getenv( "OILS_IDL_FILENAME" );
149                 if( ! IDL_filename )
150                         IDL_filename = "/openils/conf/fm_IDL.xml";
151         }
152
153         if( opts.warning )
154                 warn = 1;
155
156         int rc = 0;
157
158         xmlLineNumbersDefault(1);
159         xmlDocPtr doc = xmlReadFile( IDL_filename, NULL, XML_PARSE_XINCLUDE );
160         if ( ! doc ) {
161                 fprintf( stderr, "Could not load or parse the IDL XML file %s\n", IDL_filename );
162                 rc = 1;
163         } else {
164                 printf( "Validating: %s\n", IDL_filename );
165                 classes = osrfNewHash();
166                 osrfHashSetCallback( classes, freeClass );
167
168                 // Load the IDL
169                 if( scan_idl( doc ) )
170                         rc = 1;
171
172                 if( opts.new_argc < 2 ) {
173
174                         // No classes specified: validate all classes
175                         if( val_idl() )
176                                 rc = 1;
177                 } else {
178
179                         // Validate one or more specified classes
180                         int i = 1;
181                         while( i < opts.new_argc ) {
182                                 const char* classname = opts.new_argv[ i ];
183                                 Class* class = osrfHashGet( classes, classname );
184                                 if( ! class ) {
185                                         printf( "Class \"%s\" does not exist\n", classname );
186                                         rc = 1;
187                                 } else {
188                                         // Validate the class in isolation
189                                         if( val_class( class, classname ) )
190                                                 rc = 1;
191                                         // Cross-validate with linked classes
192                                         if( cross_validate_classes( class, classname ) )
193                                                 rc = 1;
194                                 }
195                                 ++i;
196                         }
197                 }
198                 osrfHashFree( classes );
199                 xmlFreeDoc( doc );
200         }
201
202         return rc;
203 }
204
205 /**
206         @brief Examine the command line
207         @param argc Number of entries in argv[]
208         @param argv Array of pointers to command line strings
209         @param pOpts Pointer to structure to be populated
210         @return 0 upon success, or 1 if the command line is invalid
211 */
212 static int get_Opts( int argc, char * argv[], Opts * pOpts ) {
213         int rc = 0; /* return code */
214         int opt;
215
216         /* Define valid option characters */
217
218         const char optstring[] = ":f:w";
219
220         /* Initialize members of struct */
221
222         pOpts->new_argc = 0;
223         pOpts->new_argv = NULL;
224
225         pOpts->idl_file_name_found = 0;
226         pOpts->idl_file_name = NULL;
227         pOpts->warning = 0;
228
229         /* Suppress error messages from getopt() */
230
231         opterr = 0;
232
233         /* Examine command line options */
234
235         while( ( opt = getopt( argc, argv, optstring ) ) != -1 ) {
236                 switch( opt ) {
237                         case 'f' :   /* Get idl_file_name */
238                                 if( pOpts->idl_file_name_found ) {
239                                         fprintf( stderr, "Only one occurrence of -f option allowed\n" );
240                                         rc = 1;
241                                         break;
242                                 }
243                                 pOpts->idl_file_name_found = 1;
244
245                                 pOpts->idl_file_name = optarg;
246                                 break;
247                                 case 'w' :   /* Get warning */
248                                         pOpts->warning = 1;
249                                         break;
250                                         case ':' : /* Missing argument */
251                                                 fprintf( stderr, "Required argument missing on -%c option\n",
252                                                                  (char) optopt );
253                                                 rc = 1;
254                                                 break;
255                                                 case '?' : /* Invalid option */
256                                                         fprintf( stderr, "Invalid option '-%c' on command line\n",
257                                                                          (char) optopt );
258                                                         rc = 1;
259                                                         break;
260                                                         default :  /* Programmer error */
261                                                                 fprintf( stderr, "Internal error: unexpected value '-%c'"
262                                                                                 "for optopt", (char) optopt );
263                                                                 rc = 1;
264                                                                 break;
265                 } /* end switch */
266         } /* end while */
267
268         if( optind > argc ) {
269                 /* This should never happen! */
270
271                 fprintf( stderr, "Program error: found more arguments than expected\n" );
272                 rc = 1;
273         } else {
274                 /* Calculate new_argcv and new_argc to reflect */
275                 /* the number of arguments consumed */
276
277                 pOpts->new_argc = argc - optind + 1;
278                 pOpts->new_argv = argv + optind - 1;
279         }
280
281         return rc;
282 }
283
284 /**
285         @brief Validate all classes.
286         @return 1 if errors found, or 0 if not.
287
288         Traverse the class list and validate each class in turn.
289 */
290 static int val_idl( void ) {
291         int rc = 0;
292         osrfHashIterator* itr = osrfNewHashIterator( classes );
293         Class* class = NULL;
294
295         // For each class
296         while( (class = osrfHashIteratorNext( itr )) ) {
297                 const char* id = osrfHashIteratorKey( itr );
298                 if( val_class( class, id ) )               // validate class separately
299                         rc = 1;
300                 if( cross_validate_classes( class, id ) )  // cross-validate with linked classes
301                         rc = 1;
302         }
303
304         osrfHashIteratorFree( itr );
305         return rc;
306 }
307
308 /**
309         @brief Make sure that every linkage appropriately matches the linked class.
310         @param class Pointer to the current Class.
311         @param id Class id.
312         @return 1 if errors found, or 0 if not.
313 */
314 static int cross_validate_classes( Class* class, const char* id ) {
315         int rc = 0;
316         Link* link = class->links;
317         while( link ) {
318                 if( cross_validate_linkage( class, id, link ) )
319                         rc = 1;
320                 link = link->next;
321         }
322
323         return rc;
324 }
325
326 /**
327         @brief Make sure that a linkage appropriately matches the linked class.
328         @param class Pointer to the current class.
329         @param id Class id.
330         @param link Pointer to the link being validated.
331         @return 1 if errors found, or 0 if not.
332
333         Rules:
334         - The linked class must exist.
335         - The field to which the linkage points must exist.
336         - If the linked class has a corresponding link back to the current class, then exactly
337         one end of the linkage must have a reltype of "has_many".
338
339         It is not an error if the linkage is not reciprocated.
340 */
341 static int cross_validate_linkage( Class* class, const char*id, Link* link ) {
342         int rc = 0;
343         Class* other_class = osrfHashGet( classes, (char*) link->classref );
344         if( ! other_class ) {
345                 printf( "In class \"%s\": class \"%s\", referenced by \"%s\" field, does not exist\n",
346                                 id, (char*) link->classref, (char*) link->field );
347                 rc = 1;
348         } else {
349                 // Make sure the other class is loaded before we look at it further
350                 if( val_class( other_class, (char*) link->classref ) )
351                         rc = 1;
352
353                 // Now see if the other class links back to this one
354                 Link* other_link = other_class->links;
355                 while( other_link ) {
356                         if( !strcmp( id, (char*) other_link->classref )                    // class to class
357                                 && !strcmp( (char*) link->key,   (char*) other_link->field )   // key to field
358                                 && !strcmp( (char*) link->field, (char*) other_link->key ) ) { // field to key
359                                 break;
360                         }
361                         other_link = other_link->next;
362                 }
363
364                 if( ! other_link ) {
365                         // Link is not reciprocated?  That's okay, as long as
366                         // the referenced field exists in the referenced class.
367                         if( !searchFieldByName( other_class, link->key ) ) {
368                                 printf( "In class \"%s\": field \"%s\" links to field \"%s\" of class \"%s\", "
369                                         "but that field doesn't exist\n", id, (char*) link->field,
370                                         (char*) link->key, (char*) link->classref );
371                                 rc = 1;
372                         }
373                 } else {
374                         // The link is reciprocated.  Make sure that exactly one of the links
375                         // has a reltype of "has_many"
376                         int many_count = 0;
377                         if( RT_HAS_MANY == link->reltype )
378                                 ++many_count;
379                         if( RT_HAS_MANY == other_link->reltype )
380                                 ++many_count;
381
382                         if( 0 == many_count ) {
383                                 printf( "Classes \"%s\" and \"%s\" link to each other, but neither has a reltype "
384                                                 "of \"has_many\"\n", id, (char*) link->classref );
385                                 rc = 1;
386                         } else if( 2 == many_count ) {
387                                 printf( "Classes \"%s\" and \"%s\" link to each other, but both have a reltype "
388                                                 "of \"has_many\"\n", id, (char*) link->classref );
389                                 rc = 1;
390                         }
391                 }
392         }
393
394         return rc;
395 }
396
397 /**
398         @brief Validate a single class.
399         @param id Class id.
400         @param class Pointer to the XML node for the class element.
401         @return 1 if errors found, or 0 if not.
402
403         We have already validated the id.
404
405         Rules:
406         - Allowed elements are "fields", "links", "permacrud", and "source_definition".
407         - None of these elements may occur more than once in the same class.
408         - The "fields" element is required.
409         - No text allowed, other than white space.
410         - Comments are allowed (and ignored).
411 */
412 static int val_class( Class* class, const char* id ) {
413         if( !class )
414                 return 1;
415         else if( class->loaded )
416                 return 0;         // We've already validated this one locally
417
418         int rc = 0;
419
420         if( val_class_attributes( class, id ) )
421                 rc = 1;
422
423         xmlNodePtr fields = NULL;
424         xmlNodePtr links = NULL;
425         xmlNodePtr permacrud = NULL;
426         xmlNodePtr src_def = NULL;
427
428         // Examine every child element of the <class> element.
429         xmlNodePtr child = class->node->children;
430         while( child ) {
431                 const char* child_name = (char*) child->name;
432                 if( xmlNodeIsText( child ) ) {
433                         if( ! xmlIsBlankNode( child ) ) {
434                                 // Found unexpected text.  After removing leading and
435                                 // trailing white space, complain about it.
436                                 xmlChar* content = xmlNodeGetContent( child );
437
438                                 xmlChar* begin = content;
439                                 while( *begin && isspace( *begin ) )
440                                         ++begin;
441                                 if( *begin ) {
442                                         xmlChar* end = begin + strlen( (char*) begin ) - 1;
443                                         while( (isspace( *end ) ) )
444                                                 --end;
445                                         end[ 1 ] = '\0';
446                                 }
447
448                                 printf( "Unexpected text in class \"%s\": \"%s\"\n", id,
449                                         (char*) begin );
450                                 xmlFree( content );
451                         }
452                 } else if( !strcmp( child_name, "fields" ) ) {
453                         if( fields ) {
454                                 printf( "Multiple <fields> elements in class \"%s\"\n", id );
455                                 rc = 1;
456                         } else {
457                                 fields = child;
458                                 // Identify the primary key, if any
459                                 class->primary = xmlGetProp( fields, (xmlChar*) "primary" );
460                                 if( val_fields( class, id, fields ) )
461                                         rc = 1;
462                         }
463                 } else if( !strcmp( child_name, "links" ) ) {
464                         if( links ) {
465                                 printf( "Multiple <links> elements in class \"%s\"\n", id );
466                                 rc = 1;
467                         } else {
468                                 links = child;
469                                 if( val_links( class, id, links ) )
470                                         rc = 1;
471                         }
472                 } else if( !strcmp( child_name, "permacrud" ) ) {
473                         if( permacrud ) {
474                                 printf( "Multiple <permacrud> elements in class \"%s\"\n", id );
475                                 rc = 1;
476                         } else {
477                                 permacrud = child;
478                         }
479                 } else if( !strcmp( child_name, "source_definition" ) ) {
480                         if( src_def ) {
481                                 printf( "Multiple <source_definition> elements in class \"%s\"\n", id );
482                                 rc = 1;
483                         } else {
484                                 // To do: verify that there is nothing in <source_definition> except text and
485                                 // comments, and that the text is non-empty.
486                                 src_def = child;
487                         }
488                 } else if( !strcmp( child_name, "comment" ) )
489                         ;  // ignore comment
490                 else {
491                         printf( "Line %ld: Unexpected <%s> element in class \"%s\"\n",
492                                 xmlGetLineNo( child ), child_name, id );
493                         rc = 1;
494                 }
495                 child = child->next;
496         }
497
498         if( fields ) {
499                 if( check_labels( class, id ) )
500                         rc = 1;
501                 if( val_fields_attributes( class, id, fields ) )
502                         rc = 1;
503         } else {
504                 printf( "No <fields> element in class \"%s\"\n", id );
505                 rc = 1;
506         }
507
508         if( val_links_to_fields( class, id ) )
509                 rc = 1;
510
511         if( val_fields_to_links( class, id ) )
512                 rc = 1;
513
514         class->loaded = 1;
515         return rc;
516 }
517
518 /**
519         @brief Validate the class attributes.
520         @param class Pointer to the current Class.
521         @param id Class id.
522         @return if errors found, or 0 if not.
523
524         Rules:
525         - Only the following attributes are valid: controller, core, field_safe, field_mapper,
526         id, label, readonly, restrict_primary, tablename, and virtual.
527         - The controller and fieldmapper attributes are required (as is the id attribute, but
528         that's checked elsewhere).
529         - Every attribute value must be non-empty.
530         - The values of attributes core, field_safe, reaadonly, and virtual must be either
531         "true" or "false".
532         - A virtual class must not have a tablename attribute.
533 */
534 static int val_class_attributes( Class* class, const char* id ) {
535         int rc = 0;
536
537         int controller_found = 0;     // boolean
538         int fieldmapper_found = 0;    // boolean
539         int tablename_found = 0;      // boolean
540
541         xmlAttrPtr attr = class->node->properties;
542         while( attr ) {
543                 const char* attr_name = (char*) attr->name;
544                 if( !strcmp( (char*) attr_name, "id" ) ) {
545                         ;  // ignore; we already grabbed this one
546                 } else if( !strcmp( (char*) attr_name, "controller" ) ) {
547                         controller_found = 1;
548                         xmlChar* value = xmlGetProp( class->node, (xmlChar*) "controller" );
549                         if( '\0' == *value ) {
550                                 printf( "Line %ld: Value of controller attribute is empty in class \"%s\"\n",
551                                         xmlGetLineNo( class->node ), id );
552                                 rc = 1;
553                         }
554                         xmlFree( value );
555                 } else if( !strcmp( (char*) attr_name, "fieldmapper" ) ) {
556                         fieldmapper_found = 1;
557                         xmlChar* value = xmlGetProp( class->node, (xmlChar*) "fieldmapper" );
558                         if( '\0' == *value ) {
559                                 printf( "Line %ld: Value of fieldmapper attribute is empty in class \"%s\"\n",
560                                                 xmlGetLineNo( class->node ), id );
561                                 rc = 1;
562                         }
563                         xmlFree( value );
564                 } else if( !strcmp( (char*) attr_name, "label" ) ) {
565                         xmlChar* value = xmlGetProp( class->node, (xmlChar*) "label" );
566                         if( '\0' == *value ) {
567                                 printf( "Line %ld: Value of label attribute is empty in class \"%s\"\n",
568                                                 xmlGetLineNo( class->node ), id );
569                                 rc = 1;
570                         }
571                         xmlFree( value );
572                 } else if( !strcmp( (char*) attr_name, "tablename" ) ) {
573                         tablename_found = 1;
574                         xmlChar* value = xmlGetProp( class->node, (xmlChar*) "tablename" );
575                         if( '\0' == *value ) {
576                                 printf( "Line %ld: Value of tablename attribute is empty in class \"%s\"\n",
577                                                 xmlGetLineNo( class->node ), id );
578                                 rc = 1;
579                         }
580                         xmlFree( value );
581                 } else if( !strcmp( (char*) attr_name, "virtual" ) ) {
582                         xmlChar* virtual_str = xmlGetProp( class->node, (xmlChar*) "virtual" );
583                         if( virtual_str ) {
584                                 if( !strcmp( (char*) virtual_str, "true" ) ) {
585                                         class->is_virtual = 1;
586                                 } else if( strcmp( (char*) virtual_str, "false" ) ) {
587                                         printf(
588                                                 "Line %ld: Invalid value \"%s\" for virtual attribute of class\"%s\"\n",
589                                                 xmlGetLineNo( class->node ), (char*) virtual_str, id );
590                                         rc = 1;
591                                 }
592                                 xmlFree( virtual_str );
593                         }
594                 } else if( !strcmp( (char*) attr_name, "readonly" ) ) {
595                         xmlChar* readonly = xmlGetProp( class->node, (xmlChar*) "readonly" );
596                         if( readonly ) {
597                                 if(    strcmp( (char*) readonly, "true" )
598                                         && strcmp( (char*) readonly, "false" ) ) {
599                                         printf(
600                                                 "Line %ld: Invalid value \"%s\" for readonly attribute of class\"%s\"\n",
601                                                 xmlGetLineNo( class->node ), (char*) readonly, id );
602                                         rc = 1;
603                                 }
604                                 xmlFree( readonly );
605                         }
606                 } else if( !strcmp( (char*) attr_name, "restrict_primary" ) ) {
607                         xmlChar* value = xmlGetProp( class->node, (xmlChar*) "restrict_primary" );
608                         if( '\0' == *value ) {
609                                 printf( "Line %ld: Value of restrict_primary attribute is empty in class \"%s\"\n",
610                                                 xmlGetLineNo( class->node ), id );
611                                 rc = 1;
612                         }
613                         xmlFree( value );
614                 } else if( !strcmp( (char*) attr_name, "core" ) ) {
615                         xmlChar* core = xmlGetProp( class->node, (xmlChar*) "core" );
616                         if( core ) {
617                                 if(    strcmp( (char*) core, "true" )
618                                         && strcmp( (char*) core, "false" ) ) {
619                                         printf(
620                                            "Line %ld: Invalid value \"%s\" for core attribute of class\"%s\"\n",
621                                                 xmlGetLineNo( class->node ), (char*) core, id );
622                                         rc = 1;
623                                 }
624                                 xmlFree( core );
625                         }
626                 } else if( !strcmp( (char*) attr_name, "field_safe" ) ) {
627                         xmlChar* field_safe = xmlGetProp( class->node, (xmlChar*) "field_safe" );
628                         if( field_safe ) {
629                                 if(    strcmp( (char*) field_safe, "true" )
630                                         && strcmp( (char*) field_safe, "false" ) ) {
631                                         printf(
632                                                 "Line %ld: Invalid value \"%s\" for field_safe attribute of class\"%s\"\n",
633                                                 xmlGetLineNo( class->node ), (char*) field_safe, id );
634                                         rc = 1;
635                                 }
636                                 xmlFree( field_safe );
637                         }
638                 } else {
639                         printf( "Line %ld: Unrecognized class attribute \"%s\" in class \"%s\"\n",
640                                 xmlGetLineNo( class->node ), attr_name, id );
641                         rc = 1;
642                 }
643                 attr = attr->next;
644         } // end while
645
646         if( ! controller_found ) {
647                 printf( "Line %ld: No controller attribute for class \"%s\"\n",
648                         xmlGetLineNo( class->node ), id );
649                 rc = 1;
650         }
651
652         if( ! fieldmapper_found ) {
653                 printf( "Line %ld: No fieldmapper attribute for class \"\%s\"\n",
654                         xmlGetLineNo( class->node ), id );
655                 rc = 1;
656         }
657
658         if( class->is_virtual && tablename_found ) {
659                 printf( "Line %ld: Virtual class \"%s\" shouldn't have a tablename",
660                         xmlGetLineNo( class->node ), id );
661                 rc = 1;
662         }
663
664         return rc;
665 }
666
667 /**
668         @brief Determine whether fields are either all labeled or all unlabeled.
669         @param class Pointer to the current Class.
670         @param id Class id.
671         @return 1 if errors found, or 0 if not.
672
673         Rule:
674         - The fields for a given class must either all be labeled or all unlabeled.
675
676         For purposes of this validation, a field is considered labeled even if the label is an
677         empty string.  Empty labels are reported elsewhere.
678 */
679 static int check_labels( const Class* class, const char* id ) {
680         int rc = 0;
681
682         int label_found = 0;    // boolean
683         int unlabel_found = 0;  // boolean
684
685         Field* field = class->fields;
686         while( field ) {
687                 if( field->label )
688                         label_found = 1;
689                 else
690                         unlabel_found = 1;
691                 field = field->next;
692         }
693
694         if( label_found && unlabel_found ) {
695                 printf( "Class \"%s\" has a mixture of labeled and unlabeled fields\n", id );
696                 rc = 1;
697         }
698
699         return rc;
700 }
701
702 /**
703         @brief Validate the fields attributes.
704         @param class Pointer to the current Class.
705         @param id Class id.
706         @param fields Pointer to the XML node for the fields element.
707         @return if errors found, or 0 if not.
708
709         Rules:
710         - The only valid attributes for the fields element are "primary" and "sequence".
711         - Neither attribute may have an empty string for a value.
712         - If there is a sequence attribute, there must also be a primary attribute.
713         - If there is a primary attribute, the field identified must exist.
714         - If the primary key field has the datatype "id", there must be a sequence attribute.
715         - If the datatype of the primary key is not "id" or "int", there must @em not be a
716         sequence attribute.
717 */
718 static int val_fields_attributes( Class* class, const char* id, xmlNodePtr fields ) {
719         int rc = 0;
720
721         xmlChar* sequence = NULL;
722         xmlChar* primary  = NULL;
723
724         // Traverse the attributes
725         xmlAttrPtr attr = fields->properties;
726         while( attr ) {
727                 const char* attr_name = (char*) attr->name;
728                 if( !strcmp( attr_name, "primary" ) ) {
729                         primary = xmlGetProp( fields, (xmlChar*) "primary" );
730                         if( '\0' == primary[0] ) {
731                                 printf(
732                                         "Line %ld: value of primary attribute is an empty string for class \"%s\"\n",
733                                         xmlGetLineNo( fields ), id );
734                                 rc = 1;
735                         }
736                 } else if( !strcmp( attr_name, "sequence" )) {
737                         sequence = xmlGetProp( fields, (xmlChar*) "sequence" );
738                         if( '\0' == sequence[0] ) {
739                                 printf(
740                                         "Line %ld: value of sequence attribute is an empty string for class \"%s\"\n",
741                                         xmlGetLineNo( fields ), id );
742                                 rc = 1;
743                         } else if( !strchr( (const char*) sequence, '.' )) {
744                                 printf(
745                                         "Line %ld: name of sequence for class \"%s\" is not qualified by schema\n",
746                                         xmlGetLineNo( fields ), id );
747                                 rc = 1;
748                         }
749                 } else {
750                         printf( "Line %ld: Unexpected fields attribute \"%s\" in class \"%s\"\n",
751                                 xmlGetLineNo( fields ), attr_name, id );
752                         rc = 1;
753                 }
754
755                 attr = attr->next;
756         }
757
758         if( sequence && ! primary ) {
759                 printf( "Line %ld: class \"%s\" has a sequence identified but no primary key\n",
760                         xmlGetLineNo( fields ), id );
761                 rc = 1;
762         }
763
764         if( primary ) {
765                 // look for the primary key
766                 Field* field = class->fields;
767                 while( field ) {
768                         if( !strcmp( (char*) field->name, (char*) primary ) )
769                                 break;
770                         field = field->next;
771                 }
772                 if( !field ) {
773                         printf( "Primary key field \"%s\" does not exist for class \"%s\"\n",
774                                 (char*) primary, id );
775                         rc = 1;
776                 } else if( DT_ID == field->datatype && ! sequence && ! class->is_virtual ) {
777                         printf(
778                                 "Line %ld: Primary key is an id; class \"%s\" may need a sequence attribute\n",
779                                 xmlGetLineNo( fields ), id );
780                         rc = 1;
781                 } else if(    DT_ID != field->datatype
782                                    && DT_INT != field->datatype
783                                    && DT_ORG_UNIT != field->datatype
784                                    && sequence ) {
785                         printf(
786                                 "Line %ld: Datatype of key for class \"%s\" does not allow a sequence attribute\n",
787                                 xmlGetLineNo( fields ), id );
788                         rc = 1;
789                 }
790         }
791
792         xmlFree( primary );
793         xmlFree( sequence );
794         return rc;
795 }
796
797 /**
798         @brief Verify that every Link has a matching Field for a given Class.
799         @param class Pointer to the current class.
800         @param id Class id.
801         @return 1 if errors found, or 0 if not.
802
803         Rules:
804         - For every link element, there must be a matching field element in the same class.
805         - If the link's reltype is "has_many", the field must be a virtual field of type link
806         or org_unit.
807         - If the link's reltype is "has_a" or "might_have", the field must be a non-virtual link
808         of type link or org_unit.
809 */
810 static int val_links_to_fields( const Class* class, const char* id ) {
811         if( !class )
812                 return 1;
813
814         int rc = 0;
815
816         const Link* link = class->links;
817         while( link ) {
818                 if( link->field && *link->field ) {
819                         const Field* field = searchFieldByName( class, link->field );
820                         if( field ) {
821                                 if( compareFieldAndLink( class, id, field, link ) )
822                                         rc = 1;
823                         } else {
824                                 printf( "\"%s\" class has no <field> corresponding to <link> for \"%s\"\n",
825                                         id, (char*) link->field );
826                                 rc = 1;
827                         }
828                 }
829                 link = link->next;
830         }
831
832         return rc;
833 }
834
835 /**
836         @brief Compare matching field and link elements to see if they are compatible
837         @param class Pointer to the current Class.
838         @param id Class id.
839         @param field Pointer to the Field to be compared to the Link.
840         @param link Pointer to the Link to be compared to the Field.
841         @return 0 if they are compatible, or 1 if not.
842
843         Rules:
844         - If the reltype is "has_many", the field must be virtual.
845         - If a field corresponds to a link, and is not the primary key, then it must have a
846         datatype "link" or "org_unit".
847         - If the datatype is "org_unit", the linkage must be to the class "aou".
848
849         Warnings:
850         - If the reltype is "has_a" or "might_have", the the field should probably @em not
851         be virtual, but there are legitimate exceptions.
852         - If the linkage is to the class "aou", then the datatype should probably be "org_unit".
853 */
854 static int compareFieldAndLink( const Class* class, const char* id,
855                 const Field* field, const Link* link ) {
856         int rc = 0;
857
858         Datatype datatype = field->datatype;
859         const char* classref = (const char*) link->classref;
860
861         // Validate the virtuality of the field
862         if( RT_HAS_A == link->reltype || RT_MIGHT_HAVE == link->reltype ) {
863                 if( warn && field->is_virtual ) {
864                         // This is the child class; field should usually be non-virtual,
865                         // but there are legitimate exceptions.
866                         printf( "WARNING: In class \"%s\": field \"%s\" is tied to a \"has_a\" or "
867                                 "\"might_have\" link; perhaps should not be virtual\n",
868                                 id, (char*) field->name );
869                 }
870         } else if ( RT_HAS_MANY == link->reltype ) {
871                 if( ! field->is_virtual ) {
872                         printf( "In class \"%s\": field \"%s\" is tied to a \"has_many\" link "
873                                         "and therefore should be virtual\n", id, (char*) field->name );
874                         rc = 1;
875                 }
876         }
877
878         // Validate the datatype of the field
879         if( class->primary && !strcmp( (char*) class->primary, (char*) field->name ) ) {
880                 ; // For the primary key field, the datatype can be anything
881         } else if( DT_NONE == datatype || DT_INVALID == datatype ) {
882                 printf( "In class \"%s\": \"%s\" field should have a datatype for linkage\n",
883                                 id, (char*) field->name );
884                 rc = 1;
885         } else if( DT_ORG_UNIT == datatype ) {
886                 if( strcmp( classref, "aou" ) ) {
887                         printf( "In class \"%s\": \"%s\" field should have a datatype "
888                                         "\"link\", not \"org_unit\"\n", id, field->name );
889                         rc = 1;
890                 }
891         } else if( DT_LINK == datatype ) {
892                 if( warn && !strcmp( classref, "aou" ) ) {
893                         printf( "WARNING: In class \"%s\", field \"%s\": Consider changing datatype "
894                                         "to \"org_unit\"\n", id, (char*) field->name );
895                 }
896         } else {
897                 // Datatype should be "link", or maybe "org_unit"
898                 if( !strcmp( classref, "aou" ) ) {
899                         printf( "In class \"%s\": \"%s\" field should have a datatype "
900                                         "\"org_unit\" or \"link\"\n",
901                                         id, (char*) field->name );
902                         rc = 1;
903                 } else {
904                         printf( "In class \"%s\": \"%s\" field should have a datatype \"link\"\n",
905                                         id, (char*) field->name );
906                         rc = 1;
907                 }
908         }
909
910         return rc;
911 }
912
913 /**
914         @brief See if every linked field has a counterpart in the links aggregate.
915         @param class Pointer to the current class.
916         @param id Class id.
917         @return 1 if errors found, or 0 if not.
918
919         Rules:
920         - If a field has a datatype of "link" or "org_unit, there must be a corresponding
921         entry in the links aggregate.
922 */
923 static int val_fields_to_links( const Class* class, const char* id ) {
924         int rc = 0;
925         const Field* field = class->fields;
926         while( field ) {
927                 if( DT_LINK != field->datatype && DT_ORG_UNIT != field->datatype ) {
928                         field = field->next;
929                         continue;  // not a link?  skip it
930                 }
931                 // See if there's a matching entry in the <links> aggregate
932                 const Link* link = class->links;
933                 while( link ) {
934                         if( !strcmp( (char*) field->name, (char*) link->field ) )
935                                 break;
936                         link = link->next;
937                 }
938
939                 if( !link ) {
940                         if( !strcmp( (char*) field->name, "id" ) && !strcmp( id, "aou" ) ) {
941                                 // Special exception: primary key of "aou" is of
942                                 // datatype "org_unit", but it's not a foreign key.
943                                 ;
944                         } else {
945                                 printf( "In class \"%s\": Linked field \"%s\" has no matching <link>\n",
946                                                 id, (char*) field->name );
947                                 rc = 1;
948                         }
949                 }
950                 field = field->next;
951         }
952         return rc;
953 }
954
955 /**
956         @brief Search a given Class for a Field with a given name.
957         @param class Pointer to the class in which to search.
958         @param field_name The field name for which to search.
959         @return Pointer to the Field if found, or NULL if not.
960 */
961 static const Field* searchFieldByName( const Class* class, const xmlChar* field_name ) {
962         if( ! class || ! field_name || ! *field_name )
963                 return NULL;
964
965         const char* name = (const char*) field_name;
966         const Field* field = class->fields;
967         while( field ) {
968                 if( field->name && !strcmp( (char*) field->name, name ) )
969                         return field;
970                 field = field->next;
971         }
972
973         return NULL;
974 }
975
976 /**
977         @brief Validate a fields element.
978         @param class Pointer to the current Class.
979         @param id Id of the current Class.
980         @param fields Pointer to the XML node for the fields element.
981         @return 1 if errors found, or 0 if not.
982
983         Rules:
984         - There must be at least one field element.
985         - No other elements are allowed.
986         - Text is not allowed, other than white space.
987         - Comments are allowed (and ignored).
988 */
989 static int val_fields( Class* class, const char* id, xmlNodePtr fields ) {
990         int rc = 0;
991         int field_found = 0;    // boolean
992
993         xmlNodePtr child = fields->children;
994         while( child ) {
995                 const char* child_name = (char*) child->name;
996                 if( xmlNodeIsText( child ) ) {
997                         if( ! xmlIsBlankNode( child ) ) {
998                                 // Found unexpected text.  After removing leading and
999                                 // trailing white space, complain about it.
1000                                 xmlChar* content = xmlNodeGetContent( child );
1001
1002                                 xmlChar* begin = content;
1003                                 while( *begin && isspace( *begin ) )
1004                                         ++begin;
1005                                 if( *begin ) {
1006                                         xmlChar* end = begin + strlen( (char*) begin ) - 1;
1007                                         while( (isspace( *end ) ) )
1008                                                 --end;
1009                                         end[ 1 ] = '\0';
1010                                 }
1011
1012                                 printf( "Unexpected text in <fields> element of class \"%s\": \"%s\"\n", id,
1013                                         (char*) begin );
1014                                 xmlFree( content );
1015                         }
1016                 } else if( ! strcmp( child_name, "field" ) ) {
1017                         field_found = 1;
1018                         if( val_one_field( class, id, child ) )
1019                                 rc = 1;
1020                 } else if( !strcmp( child_name, "comment" ) )
1021                         ;  // ignore comment
1022                 else {
1023                         printf( "Line %ld: Unexpected <%s> element in <fields> of class \"%s\"\n",
1024                                 xmlGetLineNo( child ), child_name, id );
1025                         rc = 1;
1026                 }
1027                 child = child->next;
1028         }
1029
1030         if( !field_found ) {
1031                 printf( "No <field> element in class \"%s\"\n", id );
1032                 rc = 1;
1033         }
1034
1035         return rc;
1036 }
1037
1038 /**
1039         @brief Validate a field element within a fields element.
1040         @param class Pointer to the current Class.
1041         @param id Class id.
1042         @param field Pointer to the XML node for the field element.
1043         @return 1 if errors found, or 0 if not.
1044
1045         Rules:
1046         - attribute names are limited to: "name", "virtual", "label", "datatype", "array_position",
1047         "selector", "i18n", "primitive".
1048         - "name" attribute is required.
1049         - label attribute, if present, must have a non-empty value.
1050         - virtual and i18n attributes, if present, must have a value of "true" or "false".
1051         - if the datatype attribute is present, its value must be one of: "bool", "float", "id",
1052         "int", "interval", "link", "money", "number", "org_unit", "text", "timestamp".
1053
1054         Warnings:
1055         - A non-virtual field should have a datatype attribute.
1056         - Attribute "array_position" is deprecated.
1057 */
1058 static int val_one_field( Class* class, const char* id, xmlNodePtr field ) {
1059         int rc = 0;
1060         xmlChar* label = NULL;
1061         xmlChar* field_name = NULL;
1062         int is_virtual = 0;
1063         Datatype datatype = DT_NONE;
1064
1065         // Traverse the attributes
1066         xmlAttrPtr attr = field->properties;
1067         while( attr ) {
1068                 const char* attr_name = (char*) attr->name;
1069                 if( !strcmp( attr_name, "name" ) ) {
1070                         field_name = xmlGetProp( field, (xmlChar*) "name" );
1071                 } else if( !strcmp( attr_name, "virtual" ) ) {
1072                         xmlChar* virt = xmlGetProp( field, (xmlChar*) "virtual" );
1073                         if( !strcmp( (char*) virt, "true" ) )
1074                                 is_virtual = 1;
1075                         else if( strcmp( (char*) virt, "false" ) ) {
1076                                 printf( "Line %ld: Invalid value for virtual attribute: \"%s\"\n",
1077                                         xmlGetLineNo( field ), (char*) virt );
1078                                 rc = 1;
1079                         }
1080                         xmlFree( virt );
1081                         // To do: verify that the namespace is oils_persist
1082                 } else if( !strcmp( attr_name, "label" ) ) {
1083                         label = xmlGetProp( field, (xmlChar*) "label" );
1084                         if( '\0' == *label ) {
1085                                 printf( "Line %ld: Empty value for label attribute for class \"%s\"\n",
1086                                         xmlGetLineNo( field ), id );
1087                                 xmlFree( label );
1088                                 label = NULL;
1089                                 rc = 1;
1090                         }
1091                         // To do: verify that the namespace is reporter
1092                 } else if( !strcmp( attr_name, "datatype" ) ) {
1093                         xmlChar* dt_str = xmlGetProp( field, (xmlChar*) "datatype" );
1094                         datatype = translate_datatype( dt_str );
1095                         if( DT_INVALID == datatype ) {
1096                                 printf( "Line %ld: Invalid datatype \"%s\" in class \"%s\"\n",
1097                                         xmlGetLineNo( field ), (char*) dt_str, id );
1098                                 rc = 1;
1099                         }
1100                         xmlFree( dt_str );
1101                         // To do: make sure that the namespace is reporter
1102                 } else if( !strcmp( attr_name, "array_position" ) ) {
1103                         printf( "Line %ld: WARNING: Deprecated array_position attribute "
1104                                         "for field \"%s\" in class \"%s\"\n",
1105                                         xmlGetLineNo( field ), ((char*) field_name ? : ""), id );
1106                 } else if( !strcmp( attr_name, "selector" ) ) {
1107                         ;  // Ignore for now
1108                 } else if( !strcmp( attr_name, "i18n" ) ) {
1109                         xmlChar* i18n = xmlGetProp( field, (xmlChar*) "i18n" );
1110                         if( strcmp( (char*) i18n, "true" ) && strcmp( (char*) i18n, "false" ) ) {
1111                                 printf( "Line %ld: Invalid value for i18n attribute: \"%s\"\n",
1112                                         xmlGetLineNo( field ), (char*) i18n );
1113                                 rc = 1;
1114                         }
1115                         xmlFree( i18n );
1116                         // To do: verify that the namespace is oils_persist
1117                 } else if( !strcmp( attr_name, "primitive" ) ) {
1118                         xmlChar* primitive = xmlGetProp( field, (xmlChar*) "primitive" );
1119                         if( strcmp( (char*) primitive, "string" ) && strcmp( (char*) primitive, "number" ) ) {
1120                                 printf( "Line %ld: Invalid value for primitive attribute: \"%s\"\n",
1121                                         xmlGetLineNo( field ), (char*) primitive );
1122                                 rc = 1;
1123                         }
1124                         xmlFree( primitive );
1125                 } else if( !strcmp( attr_name, "validate" )) {
1126                         xmlChar* validate = xmlGetProp( field, (xmlChar*) "validate" );
1127                         if( !*validate ) {
1128                                 // Value should be a regular expression to define a validation rule
1129                                 printf( "Line %ld: Empty value for \"validate\" attribute "
1130                                         "for field \"%s\" in class \"%s\"\n",
1131                                         xmlGetLineNo( field ), (char*) field_name ? : "", id );
1132                                 rc = 1;
1133                         }
1134                         xmlFree( validate );
1135                         // To do: verify that the namespace is oils_obj
1136                 } else if( !strcmp( attr_name, "required" )) {
1137                         xmlChar* required = xmlGetProp( field, (xmlChar*) "required" );
1138                         if( strcmp( (char*) required, "true" ) && strcmp( (char*) required, "false" )) {
1139                                 printf( 
1140                                         "Line %ld: Invalid value \"%s\" for \"required\" attribute "
1141                                         "for field \"%s\" in class \"%s\"\n",
1142                                         xmlGetLineNo( field ), (char*) required,
1143                                         (char*) field_name ? : "", id );
1144                                 rc = 1;
1145                         }
1146                         xmlFree( required );
1147                         // To do: verify that the namespace is oils_obj
1148                 } else {
1149                         printf( "Line %ld: Unexpected field attribute \"%s\" in class \"%s\"\n",
1150                                 xmlGetLineNo( field ), attr_name, id );
1151                         rc = 1;
1152                 }
1153
1154                 attr = attr->next;
1155         }
1156
1157         if( warn && (!is_virtual) && DT_NONE == datatype ) {
1158                 printf( "Line %ld: WARNING: No datatype attribute for field \"%s\" in class \"%s\"\n",
1159                         xmlGetLineNo( field ), ((char*) field_name ? : ""), id );
1160         }
1161
1162         if( ! field_name ) {
1163                 printf( "Line %ld: No name attribute for <field> element in class \"%s\"\n",
1164                         xmlGetLineNo( field ), id );
1165                 rc = 1;
1166         } else if( '\0' == *field_name ) {
1167                 printf( "Line %ld: Field name is empty for <field> element in class \"%s\"\n",
1168                         xmlGetLineNo( field ), id );
1169                 rc = 1;
1170         } else {
1171                 // Add to the class's field list
1172                 Field* new_field = newField( field_name );
1173                 new_field->is_virtual = is_virtual;
1174                 new_field->label = label;
1175                 new_field->datatype = datatype;
1176                 if( addField( class, id, new_field ) )
1177                         rc = 1;
1178         }
1179
1180         return rc;
1181 }
1182
1183 /**
1184         @brief Translate a datatype string into a Dataype (an enum).
1185         @param value The value of a datatype attribute.
1186         @return The datatype in the form of an enum.
1187 */
1188 static Datatype translate_datatype( const xmlChar* value ) {
1189         const char* val = (const char*) value;
1190         Datatype type;
1191
1192         if( !value || !*value )
1193                 type = DT_NONE;
1194         else if( !strcmp( val, "bool" ) )
1195                 type = DT_BOOL;
1196         else if( !strcmp( val, "float" ) )
1197                 type = DT_FLOAT;
1198         else if( !strcmp( val, "id" ) )
1199                 type = DT_ID;
1200         else if( !strcmp( val, "int" ) )
1201                 type = DT_INT;
1202         else if( !strcmp( val, "interval" ) )
1203                 type = DT_INTERVAL;
1204         else if( !strcmp( val, "link" ) )
1205                 type = DT_LINK;
1206         else if( !strcmp( val, "money" ) )
1207                 type = DT_MONEY;
1208         else if( !strcmp( val, "number" ) )
1209                 type = DT_NUMBER;
1210         else if( !strcmp( val, "org_unit" ) )
1211                 type = DT_ORG_UNIT;
1212         else if( !strcmp( val, "text" ) )
1213                 type = DT_TEXT;
1214         else if( !strcmp( val, "timestamp" ) )
1215                 type = DT_TIMESTAMP;
1216         else
1217                 type = DT_INVALID;
1218
1219         return type;
1220 }
1221
1222 /**
1223         @brief Validate a links element.
1224         @param class Pointer to the current Class.
1225         @param id Id of the current Class.
1226         @param links Pointer to the XML node for the links element.
1227         @return 1 if errors found, or 0 if not.
1228
1229         Rules:
1230         - No elements other than "link" are allowed.
1231         - Text is not allowed, other than white space.
1232         - Comments are allowed (and ignored).
1233
1234         Warnings:
1235         - There is usually at least one link element.
1236 */
1237 static int val_links( Class* class, const char* id, xmlNodePtr links ) {
1238         int rc = 0;
1239         int link_found = 0;    // boolean
1240
1241         xmlNodePtr child = links->children;
1242         while( child ) {
1243                 const char* child_name = (char*) child->name;
1244                 if( xmlNodeIsText( child ) ) {
1245                         if( ! xmlIsBlankNode( child ) ) {
1246                                 // Found unexpected text.  After removing leading and
1247                                 // trailing white space, complain about it.
1248                                 xmlChar* content = xmlNodeGetContent( child );
1249
1250                                 xmlChar* begin = content;
1251                                 while( *begin && isspace( *begin ) )
1252                                         ++begin;
1253                                 if( *begin ) {
1254                                         xmlChar* end = begin + strlen( (char*) begin ) - 1;
1255                                         while( (isspace( *end ) ) )
1256                                                 --end;
1257                                         end[ 1 ] = '\0';
1258                                 }
1259
1260                                 printf( "Unexpected text in <links> element of class \"%s\": \"%s\"\n", id,
1261                                         (char*) begin );
1262                                 xmlFree( content );
1263                         }
1264                 } else if( ! strcmp( child_name, "link" ) ) {
1265                         link_found = 1;
1266                         if( val_one_link( class, id, child ) )
1267                                 rc = 1;
1268                 } else if( !strcmp( child_name, "comment" ) )
1269                         ;  // ignore comment
1270                 else {
1271                         printf( "Line %ld: Unexpected <%s> element in <link> of class \"%s\"\n",
1272                                 xmlGetLineNo( child ), child_name, id );
1273                                 rc = 1;
1274                 }
1275                 child = child->next;
1276         }
1277
1278         if( warn && !link_found ) {
1279                 printf( "WARNING: No <link> element in class \"%s\"\n", id );
1280         }
1281
1282         return rc;
1283 }
1284
1285 /**
1286                 @brief Validate one link element.
1287                 @param class Pointer to the current Class.
1288                 @param id Id of the current Class.
1289                 @param link Pointer to the XML node for the link element.
1290                 @return 1 if errors found, or 0 if not.
1291
1292         Rules:
1293         - The only allowed attributes are "field", "reltype", "key", "map", and "class".
1294         - Except for map, every attribute is required.
1295         - Except for map, every attribute must have a non-empty value.
1296         - The value of the reltype attribute must be one of "has_a", "might_have", or "has_many".
1297 */
1298 static int val_one_link( Class* class, const char* id, xmlNodePtr link ) {
1299         int rc = 0;
1300         xmlChar* field_name = NULL;
1301         Reltype reltype = RT_NONE;
1302         xmlChar* key = NULL;
1303         xmlChar* classref = NULL;
1304
1305         // Traverse the attributes
1306         xmlAttrPtr attr = link->properties;
1307         while( attr ) {
1308                 const char* attr_name = (const char*) attr->name;
1309                 if( !strcmp( attr_name, "field" ) ) {
1310                         field_name = xmlGetProp( link, (xmlChar*) "field" );
1311                 } else if (!strcmp( attr_name, "reltype" ) ) {
1312                         ;
1313                         xmlChar* rt = xmlGetProp( link, (xmlChar*) "reltype" );
1314                         if( *rt ) {
1315                                 reltype = translate_reltype( rt );
1316                                 if( RT_INVALID == reltype ) {
1317                                         printf(
1318                                                 "Line %ld: Invalid value \"%s\" for reltype attribute in class \"%s\"\n",
1319                                                 xmlGetLineNo( link ), (char*) rt, id );
1320                                         rc = 1;
1321                                 }
1322                         } else {
1323                                 printf( "Line %ld: Empty value for reltype attribute in class \"%s\"\n",
1324                                         xmlGetLineNo( link ), id );
1325                                 rc = 1;
1326                         }
1327                         xmlFree( rt );
1328                 } else if (!strcmp( attr_name, "key" ) ) {
1329                         key = xmlGetProp( link, (xmlChar*) "key" );
1330                 } else if (!strcmp( attr_name, "map" ) ) {
1331                         ;   // ignore for now
1332                 } else if (!strcmp( attr_name, "class" ) ) {
1333                         classref = xmlGetProp( link, (xmlChar*) "class" );
1334                 } else {
1335                         printf( "Line %ld: Unexpected attribute %s in links element of class \"%s\"\n",
1336                                 xmlGetLineNo( link ), attr_name, id );
1337                         rc = 1;
1338                 }
1339                 attr = attr->next;
1340         }
1341
1342         if( !field_name ) {
1343                 printf( "Line %ld: No field attribute found in <link> in class \"%s\"\n",
1344                         xmlGetLineNo( link ), id );
1345                 rc = 1;
1346         } else if( '\0' == *field_name ) {
1347                 printf( "Line %ld: Field name is empty for <link> element in class \"%s\"\n",
1348                         xmlGetLineNo( link ), id );
1349                 rc = 1;
1350         } else if( !reltype ) {
1351                 printf( "Line %ld: No reltype attribute found in <link> in class \"%s\"\n",
1352                         xmlGetLineNo( link ), id );
1353                 rc = 1;
1354         } else if( !key ) {
1355                 printf( "Line %ld: No key attribute found in <link> in class \"%s\"\n",
1356                                 xmlGetLineNo( link ), id );
1357                 rc = 1;
1358         } else if( '\0' == *key ) {
1359                 printf( "Line %ld: key attribute is empty for <link> element in class \"%s\"\n",
1360                         xmlGetLineNo( link ), id );
1361                 rc = 1;
1362         } else if( !classref ) {
1363                 printf( "Line %ld: No class attribute found in <link> in class \"%s\"\n",
1364                          xmlGetLineNo( link ), id );
1365                 rc = 1;
1366         } else if( '\0' == *classref ) {
1367                 printf( "Line %ld: class attribute is empty for <link> element in class \"%s\"\n",
1368                         xmlGetLineNo( link ), id );
1369                 rc = 1;
1370         } else {
1371                 // Add to Link list
1372                 Link* new_link = newLink( field_name );
1373                 new_link->reltype = reltype;
1374                 new_link->key = key;
1375                 new_link->classref = classref;
1376                 if( addLink( class, id, new_link ) )
1377                         rc = 1;
1378         }
1379
1380         return rc;
1381 }
1382
1383 /**
1384         @brief Translate an attribute value into a Reltype (an enum).
1385         @param value The value of a reltype attribute.
1386         @return The value of the attribute translated into the enum Reltype.
1387 */
1388 static Reltype translate_reltype( const xmlChar* value ) {
1389         const char* val = (char*) value;
1390         Reltype reltype;
1391
1392         if( !val || !*val )
1393                 reltype = RT_NONE;
1394         else if( !strcmp( val, "has_a" ) )
1395                 reltype = RT_HAS_A;
1396         else if( !strcmp( val, "might_have" ) )
1397                 reltype = RT_MIGHT_HAVE;
1398         else if( !strcmp( val, "has_many" ) )
1399                 reltype = RT_HAS_MANY;
1400         else
1401                 reltype = RT_INVALID;
1402
1403         return reltype;
1404 }
1405
1406 /**
1407         @brief Build a list of classes, while checking for several errors.
1408         @param doc Pointer to the xmlDoc loaded from the IDL.
1409         @return 1 if errors found, or 0 if not.
1410
1411         Rules:
1412         - Every child element of the root must be of the element "class".
1413         - No text is allowed, other than white space, between classes.
1414         - Comments are allowed (and ignored) between classes.
1415 */
1416 static int scan_idl( xmlDocPtr doc ) {
1417         int rc = 0;
1418
1419         xmlNodePtr child = xmlDocGetRootElement( doc )->children;
1420         while( child ) {
1421                 char* child_name = (char*) child->name;
1422                 if( xmlNodeIsText( child ) ) {
1423                         if( ! xmlIsBlankNode( child ) ) {
1424                                 // Found unexpected text.  After removing leading and
1425                                 // trailing white space, complain about it.
1426                                 xmlChar* content = xmlNodeGetContent( child );
1427
1428                                 xmlChar* begin = content;
1429                                 while( *begin && isspace( *begin ) )
1430                                         ++begin;
1431                                 if( *begin ) {
1432                                         xmlChar* end = begin + strlen( (char*) begin ) - 1;
1433                                         while( (isspace( *end ) ) )
1434                                                 --end;
1435                                         end[ 1 ] = '\0';
1436                                 }
1437
1438                                 printf( "Unexpected text between class elements: \"%s\"\n",
1439                                         (char*) begin );
1440                                 xmlFree( content );
1441                         }
1442                 } else if( !strcmp( child_name, "class" ) ) {
1443                         if( register_class( child ) )
1444                                 rc = 1;
1445                 } else if( !strcmp( child_name, "comment" ) )
1446                         ;  // ignore comment
1447                 else {
1448                         printf( "Line %ld: Unexpected <%s> element under root\n",
1449                                 xmlGetLineNo( child ), child_name );
1450                         rc = 1;
1451                 }
1452
1453                 child = child->next;
1454         }
1455         return rc;
1456 }
1457
1458 /**
1459         @brief Register a class.
1460         @param class Pointer to the class node.
1461         @return 1 if errors found, or 0 if not.
1462
1463         Rules:
1464         - Every class element must have an "id" attribute.
1465         - A class id must not be an empty string.
1466         - Every class id must be unique.
1467
1468         Warnings:
1469         - A class id normally consists entirely of lower case letters, digits and underscores.
1470         - A class id longer than 12 characters is suspiciously long.
1471 */
1472 static int register_class( xmlNodePtr class ) {
1473         int rc = 0;
1474         xmlChar* id = xmlGetProp( class, (xmlChar*) "id" );
1475
1476         if( ! id ) {
1477                 printf( "Line %ld: Class has no \"id\" attribute\n", xmlGetLineNo( class ) );
1478                 rc = 1;
1479         } else if( ! *id ) {
1480                 printf( "Line %ld: Class id is an empty string\n", xmlGetLineNo( class ) );
1481                 rc = 1;
1482         } else {
1483
1484                 // In principle a class id could contain any arbitrary characters, but in practice
1485                 // anything but lower case, digits, and underscores is probably a mistake.
1486                 const xmlChar* p = id;
1487                 while( *p ) {
1488                         if( islower( *p ) || isdigit( *p ) || '_' == *p )
1489                                 ++p;
1490                         else if( warn ) {
1491                                 printf( "Line %ld: WARNING: Dubious class id \"%s\"; not all lower case, "
1492                                                 "digits, and underscores\n", xmlGetLineNo( class ), (char*) id );
1493                                 break;
1494                         }
1495                 }
1496
1497                 // Warn about a suspiciously long id
1498                 if( warn && strlen( (char*) id ) > 12 ) {
1499                         printf( "Line %ld: WARNING: Class id is unusually long: \"%s\"\n",
1500                                 xmlGetLineNo( class ), (char*) id );
1501                 }
1502
1503                 // Add the classname to the list of classes.  If the size of
1504                 // the list doesn't change, then we must have a duplicate.
1505                 Class* entry = newClass( class );
1506                 unsigned long class_count = osrfHashGetCount( classes );
1507                 osrfHashSet( classes, entry, (char*) id );
1508                 if( osrfHashGetCount( classes ) == class_count ) {
1509                         printf( "Line %ld: Duplicate class name \"%s\"\n",
1510                                 xmlGetLineNo( class ), (char*) id );
1511                         rc = 1;
1512                 }
1513                 xmlFree( id );
1514         }
1515         return rc;
1516 }
1517
1518 /**
1519         @brief Add a field to a class's field list (unless the id collides with an earlier entry).
1520         @param class Pointer to the current class.
1521         @param id The class id.
1522         @param new_field Pointer to the Field to be added.
1523         @return 0 if successful, or 1 if not (probably due to a duplicate key).
1524
1525         If the id collides with a previous entry, we free the new Field instead of adding it
1526         to the list.  If the label collides with a previous entry, we complain, but we go
1527         ahead and add the Field to the list.
1528
1529         RULES:
1530         - Each field name should be unique within the fields element.
1531         - Each label should be unique within the fields element.
1532 */
1533 static int addField( Class* class, const char* id, Field* new_field ) {
1534         if( ! class || ! new_field )
1535                 return 1;
1536
1537         int rc = 0;
1538         int dup_name = 0;
1539
1540         // See if the class has any other fields with the same name or label.
1541         const Field* old_field = class->fields;
1542         while( old_field ) {
1543
1544                 // Compare the ids
1545                 if( !strcmp( (char*) old_field->name, (char*) new_field->name ) ) {
1546                         printf( "Duplicate field name \"%s\" in class \"%s\"\n",
1547                                 (char*) new_field->name, id );
1548                         dup_name = 1;
1549                         rc = 1;
1550                         break;
1551                 }
1552
1553                 // Compare the labels. if they're both non-empty
1554                 if( old_field->label && *old_field->label
1555                  && new_field->label && *new_field->label
1556                  && !strcmp( (char*) old_field->label, (char*) new_field->label )) {
1557                         printf( "Duplicate labels \"%s\" in class \"%s\"\n",
1558                                 (char*) old_field->label, id );
1559                         rc = 1;
1560                 }
1561
1562                 old_field = old_field->next;
1563         }
1564
1565         if( dup_name ) {
1566                 free( new_field );
1567         } else {
1568                 new_field->next = class->fields;
1569                 class->fields = new_field;
1570         }
1571
1572         return rc;
1573 }
1574
1575 /**
1576         @brief Add a Link to the Link list of a specified Class (unless it's a duplicate).
1577         @param class Pointer to the Class to whose list to add the Link.
1578         @param id Class id.
1579         @param new_link Pointer to the Link to be added.
1580         @return 0 if successful, or 1 if not (probably due to a duplicate).
1581
1582         If there's already a Link in the list with the same field name, free the new Link
1583         instead of adding it.
1584 */
1585 static int addLink( Class* class, const char* id, Link* new_link ) {
1586         if( ! class || ! new_link )
1587                 return 1;
1588
1589         int rc = 0;
1590         int dup_name = 0;
1591
1592         // See if the class has any other links with the same field
1593         const Link* old_link = class->links;
1594         while( old_link ) {
1595
1596                 if( !strcmp( (char*) old_link->field, (char*) new_link->field ) ) {
1597                         printf( "Duplicate field name \"%s\" in links of class \"%s\"\n",
1598                                 (char*) old_link->field, id );
1599                         rc = 1;
1600                         dup_name = 1;
1601                         break;
1602                 }
1603
1604                 old_link = old_link->next;
1605         }
1606
1607         if( dup_name ) {
1608                 freeLink( new_link );
1609         } else {
1610                 // Add to the linked list
1611                 new_link->next = class->links;
1612                 class->links = new_link;
1613         }
1614
1615         return rc;
1616 }
1617
1618 /**
1619         @brief Create and initialize a new Class.
1620         @param node Pointer to the XML node for a class element.
1621         @return Pointer to the newly created Class.
1622
1623         The calling code is responsible for freeing the Class by calling freeClass().  In practice
1624         this happens automagically when we free the osrfHash classes.
1625 */
1626 static Class* newClass( xmlNodePtr node ) {
1627         Class* class = safe_malloc( sizeof( Class ) );
1628         class->node = node;
1629         class->loaded = 0;
1630         class->is_virtual = 0;
1631         xmlFree( class->primary );
1632         class->fields = NULL;
1633         class->links = NULL;
1634         return class;
1635 }
1636
1637 /**
1638         @brief Free a Class and everything it owns.
1639         @param key The class id (not used).
1640         @param p A pointer to the Class to be freed, cast to a void pointer.
1641
1642         This function is designed to be a freeItem callback for an osrfHash.
1643 */
1644 static void freeClass( char* key, void* p ) {
1645         Class* class = p;
1646
1647         // Free the linked list of Fields
1648         Field* next_field = NULL;
1649         Field* field = class->fields;
1650         while( field ) {
1651                 next_field = field->next;
1652                 freeField( field );
1653                 field = next_field;
1654         }
1655
1656         // Free the linked list of Links
1657         Link* next_link = NULL;
1658         Link* link = class->links;
1659         while( link ) {
1660                 next_link = link->next;
1661                 freeLink( link );
1662                 link = next_link;
1663         }
1664
1665         free( class );
1666 }
1667
1668 /**
1669         @brief Allocate and initialize a Field.
1670         @param name Field name.
1671         @return Pointer to a new Field.
1672
1673         It is the responsibility of the caller to free the Field by calling freeField().
1674 */
1675 static Field* newField( xmlChar* name ) {
1676         Field* field = safe_malloc( sizeof( Field ) );
1677         field->next         = NULL;
1678         field->name         = name;
1679         field->is_virtual   = 0;
1680         field->label        = NULL;
1681         field->datatype     = DT_NONE;
1682         return field;
1683 }
1684
1685 /**
1686         @brief Free a Field and everything in it.
1687         @param field Pointer to the Field to be freed.
1688 */
1689 static void freeField( Field* field ) {
1690         if( field ) {
1691                 xmlFree( field->name );
1692                 if( field->label )
1693                         xmlFree( field->label );
1694                 free( field );
1695         }
1696 }
1697
1698 /**
1699         @brief Allocate and initialize a Link.
1700         @param field Field name.
1701         @return Pointer to a new Link.
1702
1703         It is the responsibility of the caller to free the Link by calling freeLink().
1704 */
1705 static Link* newLink( xmlChar* field ) {
1706         Link* link = safe_malloc( sizeof( Link ) );
1707         link->next         = NULL;
1708         link->field        = field;
1709         link->reltype      = RT_NONE;
1710         link->key          = NULL;
1711         link->classref     = NULL;
1712         return link;
1713 }
1714
1715 /**
1716         @brief Free a Link and everything it owns.
1717         @param link Pointer to the Link to be freed.
1718 */
1719 static void freeLink( Link* link ) {
1720         if( link ) {
1721                 xmlFree( link->field );
1722                 xmlFree( link->key );
1723                 xmlFree( link->classref );
1724                 free( link );
1725         }
1726 }