[1] | 1 | %{ |
---|
| 2 | //====================================================== |
---|
| 3 | /** |
---|
| 4 | * Thx to Jean-Marie CODOL and Naitan GROLLEMUND |
---|
| 5 | * copyright 2009 GeoLabs SARL |
---|
| 6 | * Author : Gérald FENOY |
---|
| 7 | * |
---|
| 8 | */ |
---|
| 9 | //====================================================== |
---|
| 10 | |
---|
| 11 | #include <string> |
---|
| 12 | #include <stdio.h> |
---|
| 13 | #include <ctype.h> |
---|
| 14 | #include <service.h> |
---|
| 15 | |
---|
| 16 | static int tmp_count=1; |
---|
| 17 | static int defaultsc=0; |
---|
| 18 | static bool wait_maincontent=true; |
---|
| 19 | static bool wait_mainmetadata=false; |
---|
| 20 | static bool wait_metadata=false; |
---|
| 21 | static bool wait_inputs=false; |
---|
| 22 | static bool wait_defaults=false; |
---|
| 23 | static bool wait_supporteds=false; |
---|
| 24 | static bool wait_outputs=false; |
---|
| 25 | static bool wait_data=false; |
---|
| 26 | static int services_c=0; |
---|
| 27 | static service* my_service=NULL; |
---|
| 28 | static map* previous_content=NULL; |
---|
| 29 | static map* current_content=NULL; |
---|
| 30 | static elements* current_element=NULL; |
---|
| 31 | static map* scontent=NULL; |
---|
| 32 | static char* curr_key; |
---|
| 33 | static int debug=0; |
---|
| 34 | static int data=-1; |
---|
| 35 | static int previous_data=0; |
---|
| 36 | static int current_data=0; |
---|
| 37 | // namespace |
---|
| 38 | using namespace std; |
---|
| 39 | //====================================================== |
---|
| 40 | |
---|
| 41 | // srerror |
---|
[114] | 42 | void srerror(const char *s); |
---|
[1] | 43 | //====================================================== |
---|
| 44 | |
---|
| 45 | // usage () |
---|
| 46 | void usage(void) ; |
---|
| 47 | //====================================================== |
---|
| 48 | |
---|
| 49 | // srdebug |
---|
| 50 | extern int srdebug; |
---|
| 51 | //====================================================== |
---|
| 52 | |
---|
| 53 | extern char srtext[]; |
---|
| 54 | |
---|
| 55 | // srlineno |
---|
| 56 | extern int srlineno; |
---|
| 57 | //====================================================== |
---|
| 58 | |
---|
| 59 | // srin |
---|
| 60 | extern FILE* srin; |
---|
| 61 | //====================================================== |
---|
| 62 | |
---|
| 63 | // srlex |
---|
| 64 | extern int srlex(void); |
---|
[9] | 65 | extern int srlex_destroy(void); |
---|
[1] | 66 | |
---|
[9] | 67 | //vector<char*> lattribute; |
---|
[1] | 68 | |
---|
| 69 | %} |
---|
| 70 | |
---|
| 71 | |
---|
| 72 | |
---|
| 73 | %union |
---|
| 74 | {char * s;char* chaine;char* key;char* val;} |
---|
| 75 | |
---|
| 76 | // jetons // |
---|
| 77 | %token <s> ID |
---|
| 78 | %token <s> CHAINE |
---|
| 79 | /* STARTXMLDECL et ENDXMLDECL qui sont <?xml et ?>*/ |
---|
| 80 | %token STARTXMLDECL ENDXMLDECL |
---|
| 81 | //====================================================== |
---|
| 82 | /* version="xxx" et encoding="xxx" */ |
---|
| 83 | %token VERSIONDECL ENCODINGDECL SDDECL |
---|
| 84 | //====================================================== |
---|
| 85 | /* < et > */ |
---|
| 86 | %token INFCAR SUPCAR |
---|
| 87 | //====================================================== |
---|
| 88 | /* / = a1 texte "texte" */ |
---|
| 89 | %token SLASH Eq CHARDATA ATTVALUE PAIR SPAIR EPAIR ANID |
---|
| 90 | %type <chaine> PAIR |
---|
| 91 | %type <chaine> EPAIR |
---|
| 92 | %type <chaine> SPAIR |
---|
| 93 | //====================================================== |
---|
| 94 | /* <!-- xxx -> <? xxx yyy ?> */ |
---|
| 95 | %token PI PIERROR /** COMMENT **/ |
---|
| 96 | //====================================================== |
---|
| 97 | /* <!-- xxx -> <? xxx yyy ?> */ |
---|
| 98 | %token ERREURGENERALE CDATA WHITESPACE NEWLINE |
---|
| 99 | %type <s> STag |
---|
| 100 | %type <s> ETag |
---|
| 101 | %type <s> ANID |
---|
| 102 | //====================================================== |
---|
| 103 | // %start |
---|
| 104 | //====================================================== |
---|
| 105 | |
---|
| 106 | %% |
---|
| 107 | // document <//=== |
---|
| 108 | //====================================================== |
---|
| 109 | // regle 1 |
---|
| 110 | // on est a la racine du fichier xml |
---|
| 111 | //====================================================== |
---|
| 112 | document |
---|
| 113 | : miscetoile element miscetoile {} |
---|
| 114 | | contentetoile processid contentetoile document {} |
---|
| 115 | ; |
---|
| 116 | |
---|
| 117 | miscetoile |
---|
| 118 | : miscetoile PIERROR { srerror("processing instruction begining with <?xml ?> impossible\n");} |
---|
| 119 | | miscetoile PI {} |
---|
| 120 | | {} |
---|
| 121 | ; |
---|
| 122 | // element |
---|
| 123 | //====================================================== |
---|
| 124 | // regle 39 |
---|
| 125 | // OUVRANTE CONTENU FERMANTE obligatoirement |
---|
| 126 | // ou neutre |
---|
| 127 | // on ne peut pas avoir Epsilon |
---|
| 128 | // un fichier xml ne peut pas etre vide ou seulement avec un prolog |
---|
| 129 | //====================================================== |
---|
| 130 | element |
---|
| 131 | : STag contentetoile ETag |
---|
| 132 | { |
---|
| 133 | } |
---|
[20] | 134 | |
---|
[1] | 135 | // pour neutre |
---|
| 136 | // on a rien a faire, meme pas renvoyer l identificateur de balise |
---|
| 137 | // vu qu'il n y a pas de comparaison d'identificateurs avec un balise jumelle . |
---|
| 138 | | EmptyElemTag {} |
---|
| 139 | ; |
---|
[20] | 140 | |
---|
[1] | 141 | //====================================================== |
---|
| 142 | // STag |
---|
| 143 | //====================================================== |
---|
| 144 | // regle 40 |
---|
| 145 | // BALISE OUVRANTE |
---|
| 146 | // on est obligé de faire appel a infcar et supcar |
---|
| 147 | // pour acceder aux start conditions DANSBALISE et INITIAL |
---|
| 148 | //====================================================== |
---|
| 149 | STag |
---|
| 150 | : INFCAR ID Attributeetoile SUPCAR |
---|
| 151 | { |
---|
[379] | 152 | #ifdef DEBUG_SERVICE_CONF |
---|
| 153 | fprintf(stderr,"(%s %d) %s\n",__FILE__,__LINE__,$2); |
---|
| 154 | fflush(stderr); |
---|
| 155 | #endif |
---|
[1] | 156 | if(my_service->content==NULL){ |
---|
| 157 | #ifdef DEBUG_SERVICE_CONF |
---|
| 158 | fprintf(stderr,"NO CONTENT\n"); |
---|
| 159 | #endif |
---|
[9] | 160 | addMapToMap(&my_service->content,current_content); |
---|
| 161 | freeMap(¤t_content); |
---|
| 162 | free(current_content); |
---|
[1] | 163 | current_content=NULL; |
---|
| 164 | my_service->metadata=NULL; |
---|
| 165 | wait_maincontent=false; |
---|
| 166 | } |
---|
[9] | 167 | if(strncasecmp($2,"DataInputs",10)==0){ |
---|
[1] | 168 | if(wait_mainmetadata==true){ |
---|
[9] | 169 | addMapToMap(&my_service->metadata,current_content); |
---|
| 170 | freeMap(¤t_content); |
---|
| 171 | free(current_content); |
---|
[1] | 172 | current_content=NULL; |
---|
[104] | 173 | wait_mainmetadata=false; |
---|
[1] | 174 | } |
---|
| 175 | if(current_element==NULL){ |
---|
| 176 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 177 | fprintf(stderr,"(DATAINPUTS - %d) FREE current_element\n",__LINE__); |
---|
[1] | 178 | #endif |
---|
| 179 | freeElements(¤t_element); |
---|
| 180 | free(current_element); |
---|
| 181 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 182 | fprintf(stderr,"(DATAINPUTS - %d) ALLOCATE current_element\n",__LINE__); |
---|
[1] | 183 | #endif |
---|
| 184 | current_element=NULL; |
---|
| 185 | current_element=(elements*)malloc(ELEMENTS_SIZE); |
---|
| 186 | current_element->name=NULL; |
---|
| 187 | current_element->content=NULL; |
---|
| 188 | current_element->metadata=NULL; |
---|
| 189 | current_element->format=NULL; |
---|
| 190 | current_element->defaults=NULL; |
---|
| 191 | current_element->supported=NULL; |
---|
| 192 | current_element->next=NULL; |
---|
| 193 | } |
---|
| 194 | wait_inputs=true; |
---|
| 195 | current_data=1; |
---|
| 196 | previous_data=1; |
---|
| 197 | } |
---|
| 198 | else |
---|
[9] | 199 | if(strncasecmp($2,"DataOutputs",11)==0){ |
---|
[1] | 200 | if(wait_inputs==true){ |
---|
| 201 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 202 | fprintf(stderr,"(DATAOUTPUTS %d) DUP INPUTS current_element\n",__LINE__); |
---|
[9] | 203 | fprintf(stderr,"CURRENT_ELEMENT\n"); |
---|
| 204 | dumpElements(current_element); |
---|
| 205 | fprintf(stderr,"SERVICE INPUTS\n"); |
---|
| 206 | dumpElements(my_service->inputs); |
---|
| 207 | dumpService(my_service); |
---|
[65] | 208 | #endif |
---|
[9] | 209 | if(my_service->inputs==NULL){ |
---|
[1] | 210 | my_service->inputs=dupElements(current_element); |
---|
[9] | 211 | my_service->inputs->next=NULL; |
---|
| 212 | } |
---|
[57] | 213 | else if(current_element!=NULL && current_element->name!=NULL){ |
---|
[9] | 214 | addToElements(&my_service->inputs,current_element); |
---|
[57] | 215 | } |
---|
[1] | 216 | #ifdef DEBUG_SERVICE_CONF |
---|
[9] | 217 | fprintf(stderr,"CURRENT_ELEMENT\n"); |
---|
[1] | 218 | dumpElements(current_element); |
---|
[9] | 219 | fprintf(stderr,"SERVICE INPUTS\n"); |
---|
[1] | 220 | dumpElements(my_service->inputs); |
---|
| 221 | fprintf(stderr,"(DATAOUTPUTS) FREE current_element\n"); |
---|
| 222 | #endif |
---|
| 223 | freeElements(¤t_element); |
---|
| 224 | free(current_element); |
---|
| 225 | current_element=NULL; |
---|
| 226 | wait_inputs=false; |
---|
| 227 | } |
---|
| 228 | if(current_element==NULL){ |
---|
| 229 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 230 | fprintf(stderr,"(DATAOUTPUTS - %d) ALLOCATE current_element (%s)\n",__LINE__,$2); |
---|
[379] | 231 | fflush(stderr); |
---|
[1] | 232 | #endif |
---|
| 233 | current_element=(elements*)malloc(ELEMENTS_SIZE); |
---|
| 234 | current_element->name=NULL; |
---|
| 235 | current_element->content=NULL; |
---|
| 236 | current_element->metadata=NULL; |
---|
| 237 | current_element->format=NULL; |
---|
| 238 | current_element->defaults=NULL; |
---|
| 239 | current_element->supported=NULL; |
---|
| 240 | current_element->next=NULL; |
---|
| 241 | } |
---|
| 242 | wait_outputs=true; |
---|
| 243 | current_data=2; |
---|
[65] | 244 | previous_data=2; |
---|
[1] | 245 | } |
---|
| 246 | else |
---|
[9] | 247 | if(strncasecmp($2,"MetaData",8)==0){ |
---|
[73] | 248 | previous_data=current_data; |
---|
[1] | 249 | current_data=3; |
---|
| 250 | if(current_element!=NULL){ |
---|
| 251 | #ifdef DEBUG_SERVICE_CONF |
---|
| 252 | fprintf(stderr,"add current_content to current_element->content\n"); |
---|
[104] | 253 | fprintf(stderr,"LINE %d",__LINE__); |
---|
[1] | 254 | #endif |
---|
| 255 | addMapToMap(¤t_element->content,current_content); |
---|
| 256 | freeMap(¤t_content); |
---|
| 257 | free(current_content); |
---|
[104] | 258 | if(previous_data==1 || previous_data==2) |
---|
| 259 | wait_metadata=true; |
---|
| 260 | else |
---|
| 261 | wait_mainmetadata=true; |
---|
[1] | 262 | } |
---|
| 263 | else{ |
---|
[104] | 264 | if(previous_data==1 || previous_data==2) |
---|
| 265 | wait_metadata=true; |
---|
| 266 | else |
---|
| 267 | wait_mainmetadata=true; |
---|
[1] | 268 | } |
---|
| 269 | current_content=NULL; |
---|
| 270 | } |
---|
| 271 | else |
---|
[9] | 272 | if(strncasecmp($2,"ComplexData",11)==0 || strncasecmp($2,"LiteralData",10)==0 |
---|
[76] | 273 | || strncasecmp($2,"ComplexOutput",13)==0 || strncasecmp($2,"LiteralOutput",12)==0 |
---|
| 274 | || strncasecmp($2,"BoundingBoxOutput",13)==0 || strncasecmp($2,"BoundingBoxData",12)==0){ |
---|
[1] | 275 | current_data=4; |
---|
| 276 | if(wait_metadata==true){ |
---|
| 277 | if(current_content!=NULL){ |
---|
[379] | 278 | #ifdef DEBUG_SERVICE_CONF |
---|
| 279 | fprintf(stderr,"add current_content to current_element->content\n"); |
---|
| 280 | fprintf(stderr,"LINE %d",__LINE__); |
---|
| 281 | #endif |
---|
[9] | 282 | addMapToMap(¤t_element->metadata,current_content); |
---|
[1] | 283 | current_element->next=NULL; |
---|
[104] | 284 | if($2!=NULL) |
---|
| 285 | current_element->format=strdup($2); |
---|
| 286 | |
---|
[1] | 287 | current_element->defaults=NULL; |
---|
[9] | 288 | current_element->supported=NULL; |
---|
| 289 | freeMap(¤t_content); |
---|
| 290 | free(current_content); |
---|
[1] | 291 | } |
---|
[9] | 292 | }else{ |
---|
| 293 | // No MainMetaData |
---|
| 294 | addMapToMap(¤t_element->content,current_content); |
---|
| 295 | freeMap(¤t_content); |
---|
| 296 | free(current_content); |
---|
[1] | 297 | current_element->metadata=NULL; |
---|
| 298 | current_element->next=NULL; |
---|
[104] | 299 | if($2!=NULL) |
---|
[379] | 300 | current_element->format=strdup($2); |
---|
[1] | 301 | current_element->defaults=NULL; |
---|
[9] | 302 | current_element->supported=NULL; |
---|
[1] | 303 | } |
---|
| 304 | current_content=NULL; |
---|
| 305 | wait_metadata=false; |
---|
| 306 | } |
---|
| 307 | else |
---|
[9] | 308 | if(strncasecmp($2,"Default",7)==0){ |
---|
[1] | 309 | wait_defaults=true; |
---|
| 310 | current_data=5; |
---|
| 311 | } |
---|
| 312 | else |
---|
[9] | 313 | if(strncasecmp($2,"Supported",9)==0){ |
---|
[1] | 314 | wait_supporteds=true; |
---|
| 315 | if(wait_defaults==true){ |
---|
| 316 | defaultsc++; |
---|
| 317 | } |
---|
| 318 | current_data=5; |
---|
| 319 | } |
---|
| 320 | #ifdef DEBUG_SERVICE_CONF |
---|
| 321 | printf("* Identifiant : %s\n",$2); |
---|
[379] | 322 | fflush(stdout); |
---|
[1] | 323 | #endif |
---|
| 324 | } |
---|
| 325 | ; |
---|
[20] | 326 | |
---|
[1] | 327 | //====================================================== |
---|
| 328 | // Attributeetoile |
---|
| 329 | //====================================================== |
---|
| 330 | // regle 41 |
---|
| 331 | // une liste qui peut etre vide d'attributs |
---|
| 332 | // utiliser la récursivité a gauche |
---|
| 333 | //====================================================== |
---|
| 334 | Attributeetoile |
---|
| 335 | : Attributeetoile attribute {} |
---|
| 336 | | {/* Epsilon */} |
---|
| 337 | ; |
---|
[20] | 338 | |
---|
[1] | 339 | //====================================================== |
---|
| 340 | // attribute |
---|
| 341 | //====================================================== |
---|
| 342 | // regle 41 |
---|
| 343 | // un attribut est compose d'un identifiant |
---|
| 344 | // d'un "=" |
---|
| 345 | // et d'une définition de chaine de caractere |
---|
| 346 | // ( "xxx" ou 'xxx' ) |
---|
| 347 | //====================================================== |
---|
| 348 | attribute |
---|
| 349 | : ID Eq ATTVALUE |
---|
| 350 | { |
---|
| 351 | #ifdef DEBUG_SERVICE_CONF |
---|
| 352 | printf ("attribute : %s\n",$1) ; |
---|
| 353 | #endif |
---|
| 354 | } |
---|
| 355 | ; |
---|
[20] | 356 | |
---|
[1] | 357 | //====================================================== |
---|
| 358 | // EmptyElemTag |
---|
| 359 | //====================================================== |
---|
| 360 | // regle 44 |
---|
| 361 | // ICI ON DEFINIT NEUTRE |
---|
| 362 | // on ne renvoie pas de char* |
---|
| 363 | // parce qu'il n'y a pas de comparaisons a faire |
---|
| 364 | // avec un identifiant d'une balise jumelle |
---|
| 365 | //====================================================== |
---|
| 366 | EmptyElemTag |
---|
[226] | 367 | : INFCAR ID Attributeetoile SLASH SUPCAR { |
---|
[379] | 368 | #ifdef DEBUG_SERVICE_CONF |
---|
| 369 | fprintf(stderr,"(%s %d)\n",__FILE__,__LINE__); |
---|
| 370 | #endif |
---|
[226] | 371 | if(strncasecmp($2,"Default",7)==0){ |
---|
| 372 | wait_defaults=false; |
---|
| 373 | current_data=previous_data; |
---|
| 374 | if(current_element->defaults==NULL){ |
---|
| 375 | current_element->defaults=(iotype*)malloc(IOTYPE_SIZE); |
---|
| 376 | current_element->defaults->content=NULL; |
---|
| 377 | } |
---|
| 378 | addMapToMap(¤t_element->defaults->content,current_content); |
---|
| 379 | freeMap(¤t_content); |
---|
| 380 | free(current_content); |
---|
| 381 | current_element->defaults->next=NULL; |
---|
| 382 | wait_defaults=false; |
---|
| 383 | current_content=NULL; |
---|
| 384 | current_element->supported=NULL; |
---|
| 385 | current_element->next=NULL; |
---|
| 386 | } |
---|
| 387 | } |
---|
[1] | 388 | ; |
---|
[20] | 389 | |
---|
[1] | 390 | //====================================================== |
---|
| 391 | // ETag |
---|
| 392 | //====================================================== |
---|
| 393 | // regle 42 |
---|
| 394 | // BALISE FERMANTE |
---|
| 395 | // les separateurs après ID sont filtrés |
---|
| 396 | //====================================================== |
---|
| 397 | ETag |
---|
| 398 | : INFCAR SLASH ID SUPCAR |
---|
| 399 | { |
---|
[379] | 400 | #ifdef DEBUG_SERVICE_CONF |
---|
| 401 | fprintf(stderr,"(%s %d)\n",__FILE__,__LINE__); |
---|
| 402 | #endif |
---|
[1] | 403 | if(strcmp($3,"DataInputs")==0){ |
---|
| 404 | current_data=1; |
---|
| 405 | } |
---|
| 406 | if(strcmp($3,"DataOutputs")==0){ |
---|
| 407 | current_data=2; |
---|
| 408 | } |
---|
| 409 | if(strcmp($3,"MetaData")==0){ |
---|
| 410 | current_data=previous_data; |
---|
| 411 | } |
---|
| 412 | if(strcmp($3,"ComplexData")==0 || strcmp($3,"LiteralData")==0 |
---|
| 413 | || strcmp($3,"ComplexOutput")==0 || strcmp($3,"LiteralOutput")==0){ |
---|
| 414 | current_content=NULL; |
---|
| 415 | } |
---|
| 416 | if(strcmp($3,"Default")==0){ |
---|
| 417 | current_data=previous_data; |
---|
| 418 | if(current_element->defaults==NULL){ |
---|
[9] | 419 | current_element->defaults=(iotype*)malloc(IOTYPE_SIZE); |
---|
| 420 | current_element->defaults->content=NULL; |
---|
[1] | 421 | } |
---|
[9] | 422 | addMapToMap(¤t_element->defaults->content,current_content); |
---|
| 423 | freeMap(¤t_content); |
---|
| 424 | free(current_content); |
---|
[1] | 425 | current_element->defaults->next=NULL; |
---|
| 426 | wait_defaults=false; |
---|
| 427 | current_content=NULL; |
---|
| 428 | current_element->supported=NULL; |
---|
[57] | 429 | current_element->next=NULL; |
---|
[1] | 430 | } |
---|
| 431 | if(strcmp($3,"Supported")==0){ |
---|
| 432 | current_data=previous_data; |
---|
| 433 | if(current_element->supported==NULL){ |
---|
[57] | 434 | if(current_content!=NULL){ |
---|
| 435 | current_element->supported=(iotype*)malloc(IOTYPE_SIZE); |
---|
| 436 | current_element->supported->content=NULL; |
---|
| 437 | addMapToMap(¤t_element->supported->content,current_content); |
---|
| 438 | freeMap(¤t_content); |
---|
| 439 | free(current_content); |
---|
| 440 | current_element->supported->next=NULL; |
---|
| 441 | current_content=NULL; |
---|
| 442 | }else{ |
---|
| 443 | current_element->supported=NULL; |
---|
| 444 | current_element->next=NULL; |
---|
| 445 | } |
---|
[1] | 446 | } |
---|
[9] | 447 | else{ |
---|
[57] | 448 | #ifdef DEBUG_SERVICE_CONF |
---|
[9] | 449 | fprintf(stderr,"SECOND SUPPORTED FORMAT !!!!\n"); |
---|
[1] | 450 | #endif |
---|
[57] | 451 | addMapToIoType(¤t_element->supported,current_content); |
---|
[9] | 452 | freeMap(¤t_content); |
---|
| 453 | free(current_content); |
---|
| 454 | current_content=NULL; |
---|
[57] | 455 | #ifdef DEBUG_SERVICE_CONF |
---|
| 456 | dumpElements(current_element); |
---|
[9] | 457 | fprintf(stderr,"SECOND SUPPORTED FORMAT !!!!\n"); |
---|
| 458 | #endif |
---|
[1] | 459 | } |
---|
| 460 | current_content=NULL; |
---|
| 461 | } |
---|
| 462 | } |
---|
| 463 | ; |
---|
[20] | 464 | |
---|
[1] | 465 | //====================================================== |
---|
| 466 | // contentetoile |
---|
| 467 | //====================================================== |
---|
| 468 | // regle 43 |
---|
| 469 | // ENTRE 2 BALISES |
---|
| 470 | // entre 2 balises, on peut avoir : |
---|
| 471 | // --- OUVRANTE CONTENU FERMANTE (recursivement !) |
---|
| 472 | // --- DU TEXTE quelconque |
---|
| 473 | // --- COMMENTS |
---|
| 474 | // --- DES PROCESSES INSTRUCTIONS |
---|
| 475 | // --- /!\ il peut y avoir une processing instruction invalide ! <?xml |
---|
| 476 | // --- EPSILON |
---|
| 477 | // ### et/ou tout ca a la suite en nombre indeterminé |
---|
| 478 | // ### donc c'est un operateur etoile (*) |
---|
| 479 | //====================================================== |
---|
| 480 | contentetoile |
---|
| 481 | : contentetoile element {} |
---|
| 482 | | contentetoile PIERROR {srerror("processing instruction <?xml ?> impossible\n");} |
---|
| 483 | | contentetoile PI {} |
---|
| 484 | ///// on filtre les commentaires | contentetoile comment {} |
---|
| 485 | | contentetoile NEWLINE {/*printf("NEWLINE FOUND !!");*/} |
---|
| 486 | | contentetoile pair {} |
---|
| 487 | | contentetoile processid {} |
---|
| 488 | | contentetoile texteinterbalise {} |
---|
| 489 | | contentetoile CDATA {} |
---|
| 490 | | {/* Epsilon */} |
---|
| 491 | ; |
---|
[20] | 492 | |
---|
[1] | 493 | //====================================================== |
---|
| 494 | // texteinterbalise |
---|
| 495 | //====================================================== |
---|
| 496 | // regle 14 |
---|
| 497 | // DU TEXTE quelconque |
---|
| 498 | // c'est du CHARDATA |
---|
| 499 | // il y a eut un probleme avec ID, |
---|
| 500 | // on a mis des starts conditions, |
---|
| 501 | // maintenant on croise les ID dans les dbalises |
---|
| 502 | // et des CHARDATA hors des balises |
---|
| 503 | //====================================================== |
---|
| 504 | texteinterbalise |
---|
| 505 | : CHARDATA {} |
---|
| 506 | ; |
---|
| 507 | //====================================================== |
---|
| 508 | |
---|
[104] | 509 | pair: PAIR { if(debug) fprintf(stderr,"PAIR FOUND !!\n");if(curr_key!=NULL){free(curr_key);curr_key=NULL;} } |
---|
[1] | 510 | | EPAIR { |
---|
| 511 | #ifdef DEBUG_SERVICE_CONF |
---|
[379] | 512 | fprintf(stderr,"(%s %d)\n",__FILE__,__LINE__); |
---|
[104] | 513 | fprintf(stderr,"EPAIR FOUND !! \n"); |
---|
| 514 | fprintf(stderr,"[%s=>%s]\n",curr_key,$1); |
---|
| 515 | fprintf(stderr,"[ZOO: service_conf.y line %d free(%s)]\n",__LINE__,curr_key); |
---|
| 516 | dumpMap(current_content); |
---|
| 517 | fflush(stderr); |
---|
[1] | 518 | #endif |
---|
[104] | 519 | if($1!=NULL){ |
---|
| 520 | if(current_content==NULL){ |
---|
[1] | 521 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 522 | fprintf(stderr,"[ZOO: service_conf.y line %d free(%s)]\n",__LINE__,curr_key); |
---|
[1] | 523 | #endif |
---|
[104] | 524 | current_content=createMap(curr_key,$1); |
---|
[1] | 525 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 526 | fprintf(stderr,"[ZOO: service_conf.y line %d free(%s)]\n",__LINE__,curr_key); |
---|
[1] | 527 | #endif |
---|
[104] | 528 | } |
---|
| 529 | else{ |
---|
[1] | 530 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 531 | dumpMap(current_content); |
---|
| 532 | fprintf(stderr,"addToMap(current_content,%s,%s) !! \n",curr_key,$1); |
---|
[1] | 533 | #endif |
---|
[104] | 534 | addToMap(current_content,curr_key,$1); |
---|
[1] | 535 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 536 | fprintf(stderr,"addToMap(current_content,%s,%s) end !! \n",curr_key,$1); |
---|
[1] | 537 | #endif |
---|
[104] | 538 | } |
---|
[1] | 539 | } |
---|
| 540 | #ifdef DEBUG_SERVICE_CONF |
---|
| 541 | fprintf(stderr,"[%s=>%s]\n",curr_key,$1); |
---|
[93] | 542 | fprintf(stderr,"[ZOO: service_conf.y line %d free(%s)]\n",__LINE__,curr_key); |
---|
[379] | 543 | dumpMap(current_content); |
---|
[1] | 544 | fflush(stderr); |
---|
| 545 | #endif |
---|
[9] | 546 | if(curr_key!=NULL){ |
---|
| 547 | free(curr_key); |
---|
| 548 | curr_key=NULL; |
---|
[1] | 549 | } |
---|
[9] | 550 | } |
---|
[104] | 551 | | SPAIR { if(curr_key!=NULL) {free(curr_key);curr_key=NULL;} if($1!=NULL) curr_key=strdup($1);if(debug) fprintf(stderr,"SPAIR FOUND !!\n"); } |
---|
[1] | 552 | ; |
---|
| 553 | |
---|
| 554 | |
---|
| 555 | processid |
---|
| 556 | : ANID { |
---|
[379] | 557 | #ifdef DEBUG_SERVICE_CONF |
---|
| 558 | fprintf(stderr,"(%s %d)\n",__FILE__,__LINE__); |
---|
| 559 | #endif |
---|
[1] | 560 | if(data==-1){ |
---|
| 561 | data=1; |
---|
[104] | 562 | if($1!=NULL){ |
---|
| 563 | char *cen=strdup($1); |
---|
| 564 | my_service->name=(char*)malloc((strlen(cen)-1)*sizeof(char*)); |
---|
| 565 | cen[strlen(cen)-1]=0; |
---|
| 566 | cen+=1; |
---|
| 567 | sprintf(my_service->name,"%s",cen); |
---|
| 568 | cen-=1; |
---|
| 569 | free(cen); |
---|
| 570 | my_service->content=NULL; |
---|
| 571 | my_service->metadata=NULL; |
---|
| 572 | my_service->inputs=NULL; |
---|
| 573 | my_service->outputs=NULL; |
---|
| 574 | } |
---|
[1] | 575 | } else { |
---|
| 576 | if(current_data==1){ |
---|
| 577 | if(my_service->content!=NULL && current_element->name!=NULL){ |
---|
| 578 | if(my_service->inputs==NULL){ |
---|
| 579 | my_service->inputs=dupElements(current_element); |
---|
[9] | 580 | my_service->inputs->next=NULL; |
---|
[1] | 581 | tmp_count++; |
---|
| 582 | } |
---|
| 583 | else{ |
---|
[9] | 584 | addToElements(&my_service->inputs,current_element); |
---|
[1] | 585 | } |
---|
| 586 | #ifdef DEBUG_SERVICE_CONF |
---|
[9] | 587 | fprintf(stderr,"(%s %d)FREE current_element (after adding to allread existing inputs)",__FILE__,__LINE__); |
---|
| 588 | dumpElements(current_element); |
---|
| 589 | fprintf(stderr,"(%s %d)FREE current_element (after adding to allread existing inputs)",__FILE__,__LINE__); |
---|
[1] | 590 | dumpElements(my_service->inputs); |
---|
| 591 | #endif |
---|
[9] | 592 | freeElements(¤t_element); |
---|
[1] | 593 | free(current_element); |
---|
| 594 | current_element=NULL; |
---|
| 595 | #ifdef DEBUG_SERVICE_CONF |
---|
| 596 | fprintf(stderr,"(DATAINPUTS - 489) ALLOCATE current_element\n"); |
---|
| 597 | #endif |
---|
| 598 | current_element=(elements*)malloc(ELEMENTS_SIZE); |
---|
| 599 | current_element->name=NULL; |
---|
| 600 | current_element->content=NULL; |
---|
| 601 | current_element->metadata=NULL; |
---|
| 602 | current_element->format=NULL; |
---|
| 603 | current_element->defaults=NULL; |
---|
| 604 | current_element->supported=NULL; |
---|
| 605 | current_element->next=NULL; |
---|
| 606 | } |
---|
| 607 | if(current_element->name==NULL){ |
---|
| 608 | #ifdef DEBUG_SERVICE_CONF |
---|
| 609 | fprintf(stderr,"NAME IN %s (current - %s)\n", |
---|
| 610 | $1,current_element->name); |
---|
| 611 | #endif |
---|
| 612 | wait_inputs=true; |
---|
| 613 | #ifdef DEBUG_SERVICE_CONF |
---|
| 614 | fprintf(stderr,"(DATAINPUTS - 501) SET NAME OF current_element\n"); |
---|
| 615 | #endif |
---|
[104] | 616 | if($1!=NULL){ |
---|
| 617 | char *cen=strdup($1); |
---|
| 618 | current_element->name=(char*)malloc((strlen(cen)-1)*sizeof(char*)); |
---|
| 619 | cen[strlen(cen)-1]=0; |
---|
| 620 | cen+=1; |
---|
| 621 | sprintf(current_element->name,"%s",cen); |
---|
| 622 | cen-=1; |
---|
| 623 | free(cen); |
---|
[1] | 624 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 625 | fprintf(stderr,"NAME IN %s (current - %s)\n",$1,current_element->name); |
---|
[1] | 626 | #endif |
---|
[104] | 627 | current_element->content=NULL; |
---|
| 628 | current_element->metadata=NULL; |
---|
| 629 | current_element->format=NULL; |
---|
| 630 | current_element->defaults=NULL; |
---|
| 631 | current_element->supported=NULL; |
---|
| 632 | current_element->next=NULL; |
---|
[1] | 633 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 634 | fprintf(stderr,"NAME IN %s (current - %s)\n",$1,current_element->name); |
---|
[1] | 635 | #endif |
---|
[104] | 636 | } |
---|
[1] | 637 | } |
---|
| 638 | } |
---|
| 639 | else |
---|
| 640 | if(current_data==2){ |
---|
[65] | 641 | wait_outputs=true; |
---|
| 642 | if(wait_inputs){ |
---|
[57] | 643 | if(current_element!=NULL && current_element->name!=NULL){ |
---|
[65] | 644 | if(my_service->outputs==NULL){ |
---|
| 645 | my_service->outputs=dupElements(current_element); |
---|
| 646 | my_service->outputs->next=NULL; |
---|
[1] | 647 | } |
---|
| 648 | else{ |
---|
| 649 | #ifdef DEBUG_SERVICE_CONF |
---|
| 650 | fprintf(stderr,"LAST NAME IN %s (current - %s)\n",$1,current_element->name); |
---|
| 651 | #endif |
---|
[65] | 652 | addToElements(&my_service->outputs,current_element); |
---|
[1] | 653 | } |
---|
| 654 | #ifdef DEBUG_SERVICE_CONF |
---|
| 655 | dumpElements(current_element); |
---|
[9] | 656 | fprintf(stderr,"(DATAOUTPUTS) FREE current_element %s %i\n",__FILE__,__LINE__); |
---|
[1] | 657 | #endif |
---|
| 658 | freeElements(¤t_element); |
---|
[9] | 659 | free(current_element); |
---|
[1] | 660 | current_element=NULL; |
---|
| 661 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 662 | fprintf(stderr,"(DATAOUTPUTS -%d) ALLOCATE current_element %s \n",__LINE__,__FILE__); |
---|
[1] | 663 | #endif |
---|
| 664 | current_element=(elements*)malloc(ELEMENTS_SIZE); |
---|
| 665 | current_element->name=NULL; |
---|
| 666 | current_element->content=NULL; |
---|
| 667 | current_element->metadata=NULL; |
---|
| 668 | current_element->format=NULL; |
---|
| 669 | current_element->defaults=NULL; |
---|
| 670 | current_element->supported=NULL; |
---|
| 671 | current_element->next=NULL; |
---|
| 672 | } |
---|
| 673 | if(current_element->name==NULL){ |
---|
| 674 | #ifdef DEBUG_SERVICE_CONF |
---|
| 675 | fprintf(stderr,"NAME OUT %s\n",$1); |
---|
[104] | 676 | fprintf(stderr,"(DATAOUTPUTS - %d) SET NAME OF current_element\n",__LINE__); |
---|
[1] | 677 | #endif |
---|
[104] | 678 | if($1!=NULL){ |
---|
| 679 | char *cen=strdup($1); |
---|
| 680 | current_element->name=(char*)malloc((strlen(cen)-1)*sizeof(char)); |
---|
| 681 | cen[strlen(cen)-1]=0; |
---|
| 682 | cen+=1; |
---|
| 683 | sprintf(current_element->name,"%s",cen); |
---|
| 684 | cen-=1; |
---|
| 685 | free(cen); |
---|
| 686 | current_element->content=NULL; |
---|
| 687 | current_element->metadata=NULL; |
---|
| 688 | current_element->format=NULL; |
---|
| 689 | current_element->defaults=NULL; |
---|
| 690 | current_element->supported=NULL; |
---|
| 691 | current_element->next=NULL; |
---|
| 692 | } |
---|
[1] | 693 | } |
---|
[65] | 694 | |
---|
[1] | 695 | current_content=NULL; |
---|
| 696 | } |
---|
| 697 | else |
---|
[65] | 698 | if(current_element!=NULL && current_element->name!=NULL){ |
---|
| 699 | if(my_service->outputs==NULL) |
---|
| 700 | my_service->outputs=dupElements(current_element); |
---|
| 701 | else |
---|
| 702 | addToElements(&my_service->outputs,current_element); |
---|
[92] | 703 | #ifdef DEBUG_SERVICE_CONF |
---|
[65] | 704 | fprintf(stderr,"ADD TO OUTPUTS Elements\n"); |
---|
| 705 | dupElements(current_element); |
---|
[92] | 706 | #endif |
---|
[65] | 707 | freeElements(¤t_element); |
---|
| 708 | free(current_element); |
---|
| 709 | current_element=NULL; |
---|
[379] | 710 | current_element=(elements*)malloc(ELEMENTS_SIZE); |
---|
| 711 | char *cen=strdup($1); |
---|
| 712 | current_element->name=(char*)malloc((strlen(cen)-1)*sizeof(char)); |
---|
| 713 | cen[strlen(cen)-1]=0; |
---|
| 714 | cen+=1; |
---|
| 715 | sprintf(current_element->name,"%s",cen); |
---|
| 716 | cen-=1; |
---|
| 717 | free(cen); |
---|
| 718 | current_element->content=NULL; |
---|
| 719 | current_element->metadata=NULL; |
---|
| 720 | current_element->format=NULL; |
---|
| 721 | current_element->defaults=NULL; |
---|
| 722 | current_element->supported=NULL; |
---|
| 723 | current_element->next=NULL; |
---|
[65] | 724 | } |
---|
| 725 | else{ |
---|
[1] | 726 | #ifdef DEBUG_SERVICE_CONF |
---|
| 727 | fprintf(stderr,"NAME OUT %s\n",$1); |
---|
[379] | 728 | fprintf(stderr,"(DATAOUTPUTS - %d) SET NAME OF current_element %s\n",__LINE__,$1); |
---|
[1] | 729 | #endif |
---|
[104] | 730 | if($1!=NULL){ |
---|
| 731 | char *cen=strdup($1); |
---|
[379] | 732 | current_element->name=(char*)malloc((strlen(cen))*sizeof(char*)); |
---|
[104] | 733 | cen[strlen(cen)-1]=0; |
---|
[9] | 734 | #ifdef DEBUG |
---|
[104] | 735 | fprintf(stderr,"tmp %s\n",cen); |
---|
[9] | 736 | #endif |
---|
[104] | 737 | cen+=1; |
---|
| 738 | sprintf(current_element->name,"%s",cen); |
---|
| 739 | cen-=1; |
---|
| 740 | free(cen); |
---|
| 741 | current_element->content=NULL; |
---|
| 742 | current_element->metadata=NULL; |
---|
| 743 | current_element->format=NULL; |
---|
| 744 | current_element->defaults=NULL; |
---|
| 745 | current_element->supported=NULL; |
---|
| 746 | current_element->next=NULL; |
---|
| 747 | } |
---|
[1] | 748 | } |
---|
[65] | 749 | wait_inputs=false; |
---|
[1] | 750 | wait_outputs=true; |
---|
[65] | 751 | //wait_outputs=true; |
---|
[1] | 752 | } |
---|
| 753 | } |
---|
| 754 | } |
---|
| 755 | ; |
---|
| 756 | |
---|
| 757 | %% |
---|
| 758 | |
---|
| 759 | // srerror |
---|
| 760 | //====================================================== |
---|
| 761 | /* fonction qui affiche l erreur si il y en a une */ |
---|
| 762 | //====================================================== |
---|
[114] | 763 | void srerror(const char *s) |
---|
[1] | 764 | { |
---|
| 765 | if(debug) |
---|
| 766 | fprintf(stderr,"\nligne %d : %s\n",srlineno,s); |
---|
| 767 | } |
---|
| 768 | |
---|
| 769 | /** |
---|
| 770 | * getServiceFromFile : |
---|
| 771 | * set service given as second parameter with informations extracted from the |
---|
| 772 | * definition file. |
---|
| 773 | */ |
---|
[114] | 774 | int getServiceFromFile(const char* file,service** service){ |
---|
[1] | 775 | |
---|
| 776 | freeMap(&previous_content); |
---|
| 777 | previous_content=NULL; |
---|
| 778 | freeMap(¤t_content); |
---|
| 779 | current_content=NULL; |
---|
| 780 | freeMap(&scontent); |
---|
| 781 | #ifdef DEBUG_SERVICE_CONF |
---|
| 782 | fprintf(stderr,"(STARTING)FREE current_element\n"); |
---|
| 783 | #endif |
---|
| 784 | freeElements(¤t_element); |
---|
[60] | 785 | free(current_element); |
---|
[1] | 786 | current_element=NULL; |
---|
| 787 | my_service=NULL; |
---|
| 788 | scontent=NULL; |
---|
| 789 | |
---|
| 790 | wait_maincontent=true; |
---|
| 791 | wait_mainmetadata=false; |
---|
| 792 | wait_metadata=false; |
---|
| 793 | wait_inputs=false; |
---|
| 794 | wait_defaults=false; |
---|
| 795 | wait_supporteds=false; |
---|
| 796 | wait_outputs=false; |
---|
| 797 | wait_data=false; |
---|
| 798 | data=-1; |
---|
| 799 | previous_data=1; |
---|
| 800 | current_data=0; |
---|
| 801 | |
---|
| 802 | my_service=*service; |
---|
| 803 | |
---|
| 804 | srin = fopen(file,"r"); |
---|
| 805 | if (srin==NULL){ |
---|
[60] | 806 | fprintf(stderr,"error : file not found\n") ; |
---|
[9] | 807 | return -1; |
---|
[1] | 808 | } |
---|
| 809 | |
---|
| 810 | int resultatYYParse = srparse() ; |
---|
| 811 | |
---|
[65] | 812 | if(wait_outputs && current_element!=NULL && current_element->name!=NULL){ |
---|
[1] | 813 | if(my_service->outputs==NULL){ |
---|
| 814 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 815 | fprintf(stderr,"(DATAOUTPUTS - %d) DUP current_element\n",__LINE__); |
---|
[1] | 816 | #endif |
---|
| 817 | my_service->outputs=dupElements(current_element); |
---|
[9] | 818 | my_service->outputs->next=NULL; |
---|
[1] | 819 | } |
---|
| 820 | else{ |
---|
| 821 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 822 | fprintf(stderr,"(DATAOUTPUTS - %d) COPY current_element\n",__LINE__); |
---|
[1] | 823 | #endif |
---|
[9] | 824 | addToElements(&my_service->outputs,current_element); |
---|
[1] | 825 | } |
---|
| 826 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 827 | fprintf(stderr,"(DATAOUTPUTS - %d) FREE current_element\n",__LINE__); |
---|
[1] | 828 | #endif |
---|
| 829 | freeElements(¤t_element); |
---|
[9] | 830 | free(current_element); |
---|
| 831 | current_element=NULL; |
---|
[57] | 832 | #ifdef DEBUG_SERVICE_CONF |
---|
[104] | 833 | fprintf(stderr,"(DATAOUTPUTS - %d) FREE current_element\n",__LINE__); |
---|
[57] | 834 | #endif |
---|
[1] | 835 | } |
---|
| 836 | if(current_element!=NULL){ |
---|
| 837 | freeElements(¤t_element); |
---|
[9] | 838 | free(current_element); |
---|
[1] | 839 | current_element=NULL; |
---|
| 840 | } |
---|
| 841 | if(current_content!=NULL){ |
---|
| 842 | freeMap(¤t_content); |
---|
[9] | 843 | free(current_content); |
---|
[1] | 844 | current_content=NULL; |
---|
| 845 | } |
---|
| 846 | fclose(srin); |
---|
| 847 | #ifdef DEBUG_SERVICE_CONF |
---|
| 848 | dumpService(my_service); |
---|
| 849 | #endif |
---|
| 850 | *service=my_service; |
---|
| 851 | |
---|
[216] | 852 | #ifndef WIN32 |
---|
[9] | 853 | srlex_destroy(); |
---|
[216] | 854 | #endif |
---|
[1] | 855 | return resultatYYParse; |
---|
| 856 | } |
---|