service_conf.y @ 839

Last change on this file since 839 was 839, checked in by djay, 7 years ago

Update the source code for HPC support. Automatically adding nested outputs for the HPC support (should this be available for every support?). Add capability to store the metadata in the Collection DataBase?. Addition of the zcfg2sql to import any existing ZCFG file into the Collection DB. Add the support to invoke a callback (for history purpose) in case a [callback] section contains at least one parameter defined (url). Add support to convert maps and map to JSON (for callback use only by now). Fix some memory leaks (some are still there).

File size: 27.5 KB

Line
1	/*
2	* Author : Gérald FENOY
3	*
4	* Copyright (c) 209-2015 GeoLabs SARL
5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a copy
7	* of this software and associated documentation files (the "Software"), to deal
8	* in the Software without restriction, including without limitation the rights
9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10	* copies of the Software, and to permit persons to whom the Software is
11	* furnished to do so, subject to the following conditions:
12	*
13	* The above copyright notice and this permission notice shall be included in
14	* all copies or substantial portions of the Software.
15	*
16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22	* THE SOFTWARE.
23	*/
24	%{
25
26	#include <string>
27	#include <stdio.h>
28	#include <ctype.h>
29	#include <service.h>
30
31	static int tmp_count=1;
32	static int defaultsc=0;
33	static bool wait_maincontent=true;
34	static bool wait_mainmetadata=false;
35	static bool wait_mainap=false;
36	static bool wait_metadata=false;
37	static bool wait_ap=false;
38	static bool wait_nested=false;
39	static bool wait_inputs=false;
40	static bool wait_defaults=false;
41	static bool wait_supporteds=false;
42	static bool wait_outputs=false;
43	static bool wait_data=false;
44	static service* my_service=NULL;
45	static map* current_content=NULL;
46	static elements* current_element=NULL;
47	static char* curr_key;
48	static int debug=0;
49	static int data=-1;
50	static int previous_data=0;
51	static int current_data=0;
52	static int nested_level=0;
53	// namespace
54	using namespace std;
55
56	// srerror
57	void srerror(const char *s);
58
59	// usage ()
60	void usage(void) ;
61
62	// srdebug
63	extern int srdebug;
64
65	extern char srtext[];
66
67	// srlineno
68	extern int srlineno;
69
70	// srin
71	extern FILE* srin;
72
73	// srlex
74	extern int srlex(void);
75	extern int srlex_destroy(void);
76
77	%}
78
79
80
81	%union
82	{char * s;char* chaine;char* key;char* val;}
83
84	// jetons //
85	%token <s> ID
86	%token <s> CHAINE
87
88	%token INFCAR SUPCAR
89
90	/* / = a1 texte "texte" */
91	%token SLASH Eq CHARDATA ATTVALUE PAIR SPAIR EPAIR ANID
92	%type <chaine> PAIR
93	%type <chaine> EPAIR
94	%type <chaine> SPAIR
95
96	/* <!-- xxx -> <? xxx yyy ?> */
97	%token PI PIERROR / COMMENT /
98
99	/* <!-- xxx -> <? xxx yyy ?> */
100	%token ERREURGENERALE CDATA WHITESPACE NEWLINE
101	%type <s> STag
102	%type <s> ETag
103	%type <s> ANID
104
105	// % start
106
107	%%
108	// document
109	// regle 1
110	// on est a la racine du fichier xml
111	document
112	: miscetoile element miscetoile {}
113	\| contentetoile processid contentetoile document {}
114	;
115
116	miscetoile
117	: miscetoile PIERROR { srerror("processing instruction beginning with <?xml ?> impossible\n");}
118	\| miscetoile PI {}
119	\| {}
120	;
121	// element
122	// regle 39
123	// OUVRANTE CONTENU FERMANTE obligatoirement
124	// ou neutre
125	// on ne peut pas avoir Epsilon
126	// un fichier xml ne peut pas etre vide ou seulement avec un prolog
127	element
128	: STag contentetoile ETag
129	{
130	}
131
132	// pour neutre
133	// on a rien a faire, meme pas renvoyer l identificateur de balise
134	// vu qu'il n y a pas de comparaison d'identificateurs avec un balise jumelle .
135	\| EmptyElemTag {}
136	;
137
138	// STag
139	// regle 40
140	// BALISE OUVRANTE
141	// on est obligé de faire appel a infcar et supcar
142	// pour acceder aux start conditions DANSBALISE et INITIAL
143	STag
144	: INFCAR ID Attributeetoile SUPCAR
145	{
146	#ifdef DEBUG_SERVICE_CONF
147	fprintf(stderr,"STag (%s %d) %s %d %d \n",__FILE__,__LINE__,$2,current_data,previous_data);
148	fflush(stderr);
149	dumpMap(current_content);
150	#endif
151	if(my_service->content==NULL && current_content!=NULL){
152	#ifdef DEBUG_SERVICE_CONF
153	fprintf(stderr,"NO CONTENT\n");
154	#endif
155	addMapToMap(&my_service->content,current_content);
156	freeMap(&current_content);
157	free(current_content);
158	current_content=NULL;
159	my_service->metadata=NULL;
160	my_service->additional_parameters=NULL;
161	wait_maincontent=false;
162	}
163	if(strncasecmp($2,"EndNested",9)==0){
164	#ifdef DEBUG_SERVICE_CONF
165	fprintf(stderr,"(ENDNESTED - %d) \n",__LINE__);
166	fflush(stderr);
167	#endif
168	nested_level-=1;
169	if(nested_level==0){
170	wait_nested=false;
171	}
172	}
173
174	if(strncasecmp($2,"DataInputs",10)==0){
175	if(current_element==NULL){
176	#ifdef DEBUG_SERVICE_CONF
177	fprintf(stderr,"(DATAINPUTS - %d) FREE current_element\n",__LINE__);
178	#endif
179	freeElements(&current_element);
180	free(current_element);
181	#ifdef DEBUG_SERVICE_CONF
182	fprintf(stderr,"(DATAINPUTS - %d) ALLOCATE current_element\n",__LINE__);
183	#endif
184	current_element=NULL;
185	current_element=createEmptyElements();
186	}
187	wait_inputs=true;
188	current_data=1;
189	previous_data=1;
190	}
191	else
192	if(strncasecmp($2,"DataOutputs",11)==0){
193	if(wait_inputs==true){
194	#ifdef DEBUG_SERVICE_CONF
195	fprintf(stderr,"(DATAOUTPUTS %d) DUP INPUTS current_element\n",__LINE__);
196	fprintf(stderr,"CURRENT_ELEMENT\n");
197	dumpElements(current_element);
198	fprintf(stderr,"SERVICE INPUTS\n");
199	dumpElements(my_service->inputs);
200	dumpService(my_service);
201	#endif
202	if(my_service->inputs==NULL && current_element!=NULL && current_element->name!=NULL){
203	my_service->inputs=dupElements(current_element);
204	my_service->inputs->next=NULL;
205	freeElements(&current_element);
206	}
207	else if(current_element!=NULL && current_element->name!=NULL){
208	addToElements(&my_service->inputs,current_element);
209	freeElements(&current_element);
210	}
211	#ifdef DEBUG_SERVICE_CONF
212	fprintf(stderr,"CURRENT_ELEMENT\n");
213	dumpElements(current_element);
214	fprintf(stderr,"SERVICE INPUTS\n");
215	dumpElements(my_service->inputs);
216	fprintf(stderr,"(DATAOUTPUTS) FREE current_element\n");
217	#endif
218	free(current_element);
219	current_element=NULL;
220	wait_inputs=false;
221	}
222	if(current_element==NULL){
223	#ifdef DEBUG_SERVICE_CONF
224	fprintf(stderr,"(DATAOUTPUTS - %d) ALLOCATE current_element (%s)\n",__LINE__,$2);
225	fflush(stderr);
226	#endif
227	current_element=createEmptyElements();
228	}
229	wait_outputs=1;
230	current_data=2;
231	previous_data=2;
232	}
233	else
234	if(strncasecmp($2,"MetaData",8)==0 \|\|
235	strncasecmp($2,"AdditionalParameters",8)==0){
236	if(strncasecmp($2,"AdditionalParameters",8)==0){
237	previous_data=current_data;
238	current_data=4;
239	if(current_element!=NULL){
240	#ifdef DEBUG_SERVICE_CONF
241	fprintf(stderr,"add current_content to current_element->content\n");
242	fprintf(stderr,"LINE %d",__LINE__);
243	#endif
244	if(wait_mainmetadata)
245	addMapToMap(&my_service->metadata,current_content);
246	else
247	if(wait_metadata)
248	addMapToMap(&current_element->metadata,current_content);
249	else
250	addMapToMap(&current_element->content,current_content);
251	freeMap(&current_content);
252	free(current_content);
253	if(previous_data==1 \|\| previous_data==2)
254	wait_ap=true;
255	else
256	wait_mainap=true;
257	}
258	else{
259	if(previous_data==1 \|\| previous_data==2)
260	wait_ap=true;
261	else
262	wait_mainap=true;
263	}
264	}else{
265	previous_data=current_data;
266	current_data=3;
267	if(current_element!=NULL){
268	#ifdef DEBUG_SERVICE_CONF
269	fprintf(stderr,"add current_content to current_element->content\n");
270	fprintf(stderr,"LINE %d",__LINE__);
271	#endif
272	addMapToMap(&current_element->content,current_content);
273	freeMap(&current_content);
274	free(current_content);
275	if(previous_data==1 \|\| previous_data==2)
276	wait_metadata=true;
277	else
278	wait_mainmetadata=true;
279	}
280	else{
281	if(previous_data==1 \|\| previous_data==2)
282	wait_metadata=true;
283	else
284	wait_mainmetadata=true;
285	}
286	}
287	current_content=NULL;
288	}
289	else
290	if(strncasecmp($2,"ComplexData",11)==0 \|\| strncasecmp($2,"LiteralData",10)==0
291	\|\| strncasecmp($2,"ComplexOutput",13)==0 \|\| strncasecmp($2,"LiteralOutput",12)==0
292	\|\| strncasecmp($2,"BoundingBoxOutput",13)==0 \|\| strncasecmp($2,"BoundingBoxData",12)==0){
293	current_data=4;
294	addMapToMap(&current_element->content,current_content);
295	freeMap(&current_content);
296	free(current_content);
297	current_element->next=NULL;
298	if($2!=NULL)
299	current_element->format=zStrdup($2);
300	current_element->defaults=NULL;
301	current_element->supported=NULL;
302	current_element->child=NULL;
303	current_content=NULL;
304	}
305	else
306	if(strncasecmp($2,"Default",7)==0){
307	wait_defaults=true;
308	current_data=5;
309	}
310	else
311	if(strncasecmp($2,"Supported",9)==0){
312	wait_supporteds=true;
313	if(wait_defaults==true){
314	defaultsc++;
315	}
316	current_data=5;
317	}
318	#ifdef DEBUG_SERVICE_CONF
319	fprintf(stderr,"* Identifiant : %s\n",$2);
320	fflush(stderr);
321	#endif
322	}
323	;
324
325	// Attributeetoile
326	// regle 41
327	// une liste qui peut etre vide d'attributs
328	// utiliser la récursivité a gauche
329	Attributeetoile
330	: Attributeetoile attribute {}
331	\| {/* Epsilon */}
332	;
333
334	// attribute
335	// regle 41
336	// un attribut est compose d'un identifiant
337	// d'un "="
338	// et d'une définition de chaine de caractere
339	// ( "xxx" ou 'xxx' )
340	attribute
341	: ID Eq ATTVALUE
342	{
343	#ifdef DEBUG_SERVICE_CONF
344	printf ("attribute : %s\n",$1) ;
345	#endif
346	}
347	;
348
349	// EmptyElemTag
350	// regle 44
351	// ICI ON DEFINIT NEUTRE
352	// on ne renvoie pas de char*
353	// parce qu'il n'y a pas de comparaisons a faire
354	// avec un identifiant d'une balise jumelle
355	EmptyElemTag
356	: INFCAR ID Attributeetoile SLASH SUPCAR {
357	#ifdef DEBUG_SERVICE_CONF
358	fprintf(stderr,"(%s %d)\n",__FILE__,__LINE__);
359	#endif
360	if(strncasecmp($2,"Default",7)==0){
361	wait_defaults=false;
362	current_data=previous_data;
363	if(current_element->defaults==NULL){
364	current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
365	current_element->defaults->content=NULL;
366	}
367	addMapToMap(&current_element->defaults->content,current_content);
368	freeMap(&current_content);
369	free(current_content);
370	current_element->defaults->next=NULL;
371	wait_defaults=false;
372	current_content=NULL;
373	current_element->supported=NULL;
374	current_element->child=NULL;
375	current_element->next=NULL;
376	}
377	if(strncasecmp($2,"EndNested",9)==0){
378	if(current_data==1){
379	elements* cursor=my_service->inputs;
380	while(cursor->next!=NULL)
381	cursor=cursor->next;
382	if(nested_level>1){
383	for(int j=0;j<nested_level-1;j++){
384	cursor=cursor->child;
385	while(cursor->next!=NULL)
386	cursor=cursor->next;
387	}
388	}
389	if(cursor->child==NULL){
390	cursor->child=dupElements(current_element);
391	}else{
392	addToElements(&cursor->child,current_element);
393	}
394	}else{
395	if(current_element->name!=NULL){
396	elements* cursor=my_service->outputs;
397	while(cursor->next!=NULL)
398	cursor=cursor->next;
399	if(nested_level>1){
400	for(int j=0;j<nested_level-1;j++){
401	cursor=cursor->child;
402	while(cursor->next!=NULL)
403	cursor=cursor->next;
404	}
405	}
406	if(cursor->child==NULL){
407	cursor->child=dupElements(current_element);
408	}else
409	addToElements(&cursor->child,current_element);
410	}
411	}
412	freeElements(&current_element);
413	free(current_element);
414	current_element=NULL;
415	current_element=createEmptyElements();
416	nested_level-=1;
417	if(nested_level==0){
418	wait_nested=false;
419	}
420	}
421	}
422	;
423
424	// ETag
425	// BALISE FERMANTE
426	// les separateurs après ID sont filtrés
427	ETag
428	: INFCAR SLASH ID SUPCAR
429	{
430	#ifdef DEBUG_SERVICE_CONF
431	fprintf(stderr,"ETag %s (%s %d) %d %d \n",$3,__FILE__,__LINE__,current_data,previous_data);
432	#endif
433	if(strcmp($3,"DataInputs")==0){
434	current_data=1;
435	if(current_content!=NULL){
436	if(current_element->content==NULL){
437	addMapToMap(&current_element->content,current_content);
438	}
439	freeMap(&current_content);
440	free(current_content);
441	current_content=NULL;
442	}
443	if(current_element!=NULL){
444	if(my_service->content!=NULL && current_element->name!=NULL){
445	if(my_service->inputs==NULL){
446	my_service->inputs=dupElements(current_element);
447	my_service->inputs->next=NULL;
448	tmp_count++;
449	}
450	else{
451	addToElements(&my_service->inputs,current_element);
452	}
453	freeElements(&current_element);
454	free(current_element);
455	current_element=NULL;
456	}
457	}
458	}
459	if(strcmp($3,"DataOutputs")==0){
460	current_data=2;
461	}
462	if(strcmp($3,"AdditionalParameters")==0){
463	if(current_content!=NULL){
464	#ifdef DEBUG_SERVICE_CONF
465	fprintf(stderr,"add current_content to current_element->content\n");
466	fprintf(stderr,"LINE %d",__LINE__);
467	#endif
468	if(wait_ap){
469	current_element->additional_parameters=NULL;
470	addMapToMap(&current_element->additional_parameters,current_content);
471	current_element->next=NULL;
472	current_element->defaults=NULL;
473	current_element->supported=NULL;
474	current_element->child=NULL;
475	}else{
476	if(wait_mainap){
477	addMapToMap(&my_service->additional_parameters,current_content);
478	}
479	}
480
481	freeMap(&current_content);
482	free(current_content);
483	current_content=NULL;
484	}
485	current_data=previous_data;
486	wait_mainap=false;
487	wait_ap=false;
488	}
489	if(strcmp($3,"MetaData")==0){
490	if(current_content!=NULL){
491	#ifdef DEBUG_SERVICE_CONF
492	fprintf(stderr,"add current_content to current_element->content\n");
493	fprintf(stderr,"LINE %d",__LINE__);
494	#endif
495	if(wait_metadata){
496	current_element->metadata=NULL;
497	addMapToMap(&current_element->metadata,current_content);
498	current_element->next=NULL;
499	current_element->defaults=NULL;
500	current_element->supported=NULL;
501	current_element->child=NULL;
502	}else{
503	if(wait_mainmetadata){
504	addMapToMap(&my_service->metadata,current_content);
505	}
506	}
507
508	freeMap(&current_content);
509	free(current_content);
510	current_content=NULL;
511	}
512	current_data=previous_data;
513	wait_mainmetadata=false;
514	wait_metadata=false;
515	}
516	if(strcmp($3,"ComplexData")==0 \|\| strcmp($3,"LiteralData")==0
517	\|\| strcmp($3,"ComplexOutput")==0 \|\| strcmp($3,"LiteralOutput")==0){
518	if(current_element->format==NULL)
519	current_element->format=zStrdup($3);
520	current_content=NULL;
521	}
522	if(strcmp($3,"Default")==0){
523	current_data=previous_data;
524	if(current_element->defaults==NULL){
525	current_element->defaults=(iotype*)malloc(IOTYPE_SIZE);
526	current_element->defaults->content=NULL;
527	}
528	addMapToMap(&current_element->defaults->content,current_content);
529	freeMap(&current_content);
530	free(current_content);
531	current_element->defaults->next=NULL;
532	wait_defaults=false;
533	current_content=NULL;
534	current_element->supported=NULL;
535	current_element->child=NULL;
536	current_element->next=NULL;
537	}
538	if(strcmp($3,"Supported")==0){
539	current_data=previous_data;
540	if(current_element->supported==NULL){
541	if(current_content!=NULL){
542	current_element->supported=(iotype*)malloc(IOTYPE_SIZE);
543	current_element->supported->content=NULL;
544	addMapToMap(&current_element->supported->content,current_content);
545	freeMap(&current_content);
546	free(current_content);
547	current_element->supported->next=NULL;
548	current_content=NULL;
549	}else{
550	current_element->supported=NULL;
551	current_element->child=NULL;
552	current_element->next=NULL;
553	}
554	}
555	else{
556	#ifdef DEBUG_SERVICE_CONF
557	fprintf(stderr,"SECOND SUPPORTED FORMAT !!!!\n");
558	#endif
559	addMapToIoType(&current_element->supported,current_content);
560	freeMap(&current_content);
561	free(current_content);
562	current_content=NULL;
563	#ifdef DEBUG_SERVICE_CONF
564	dumpElements(current_element);
565	fprintf(stderr,"SECOND SUPPORTED FORMAT !!!!\n");
566	#endif
567	}
568	current_content=NULL;
569	}
570	}
571	;
572
573	//======================================================
574	// contentetoile
575	//======================================================
576	// regle 43
577	// ENTRE 2 BALISES
578	// entre 2 balises, on peut avoir :
579	// --- OUVRANTE CONTENU FERMANTE (recursivement !)
580	// --- DU TEXTE quelconque
581	// --- COMMENTS
582	// --- DES PROCESSES INSTRUCTIONS
583	// --- /!\ il peut y avoir une processing instruction invalide ! <?xml
584	// --- EPSILON
585	// ### et/ou tout ca a la suite en nombre indeterminé
586	// ### donc c'est un operateur etoile (*)
587	//======================================================
588	contentetoile
589	: contentetoile element {}
590	\| contentetoile PIERROR {srerror("processing instruction <?xml ?> impossible\n");}
591	\| contentetoile PI {}
592	///// on filtre les commentaires \| contentetoile comment {}
593	\| contentetoile NEWLINE {/printf("NEWLINE FOUND !!");/}
594	\| contentetoile pair {}
595	\| contentetoile processid {}
596	\| contentetoile texteinterbalise {}
597	\| contentetoile CDATA {}
598	\| {/* Epsilon */}
599	;
600
601	// texteinterbalise
602	// regle 14
603	// DU TEXTE quelconque
604	// c'est du CHARDATA
605	// il y a eut un probleme avec ID,
606	// on a mis des starts conditions,
607	// maintenant on croise les ID dans les dbalises
608	// et des CHARDATA hors des balises
609	texteinterbalise
610	: CHARDATA {}
611	;
612
613	pair: PAIR { if(debug) fprintf(stderr,"PAIR FOUND !!\n");if(curr_key!=NULL){free(curr_key);curr_key=NULL;} }
614	\| EPAIR {
615	#ifdef DEBUG_SERVICE_CONF
616	fprintf(stderr,"EPAIR (%s %d)\n",__FILE__,__LINE__);
617	fprintf(stderr,"[%s=>%s]\n",curr_key,$1);
618	dumpMap(current_content);
619	fflush(stderr);
620	#endif
621	if($1!=NULL && curr_key!=NULL){
622	if(current_content==NULL){
623	#ifdef DEBUG_SERVICE_CONF
624	fprintf(stderr,"[ZOO: service_conf.y line %d free(%s)]\n",__LINE__,curr_key);
625	#endif
626	current_content=createMap(curr_key,$1);
627	#ifdef DEBUG_SERVICE_CONF
628	fprintf(stderr,"[ZOO: service_conf.y line %d free(%s)]\n",__LINE__,curr_key);
629	#endif
630	}
631	else{
632	#ifdef DEBUG_SERVICE_CONF
633	dumpMap(current_content);
634	fprintf(stderr,"addToMap(current_content,%s,%s) !! \n",curr_key,$1);
635	#endif
636	addToMap(current_content,curr_key,$1);
637	#ifdef DEBUG_SERVICE_CONF
638	fprintf(stderr,"addToMap(current_content,%s,%s) end !! \n",curr_key,$1);
639	#endif
640	}
641	}
642	#ifdef DEBUG_SERVICE_CONF
643	fprintf(stderr,"[%s=>%s]\n",curr_key,$1);
644	fprintf(stderr,"[ZOO: service_conf.y line %d free(%s)]\n",__LINE__,curr_key);
645	dumpMap(current_content);
646	fflush(stderr);
647	#endif
648	if(curr_key!=NULL){
649	free(curr_key);
650	curr_key=NULL;
651	}
652	}
653	\| SPAIR { if(curr_key!=NULL) {free(curr_key);curr_key=NULL;} if($1!=NULL) curr_key=zStrdup($1);if(debug) fprintf(stderr,"SPAIR FOUND !!\n"); }
654	;
655
656
657	processid
658	: ANID {
659	#ifdef DEBUG_SERVICE_CONF
660	fprintf(stderr,"processid (%s %d) %s\n",__FILE__,__LINE__,$1);
661	#endif
662	if(::data==-1){ // knut: add namespace to avoid ambiguous symbol
663	::data=1;
664	if($1!=NULL){
665	char *cen=zStrdup($1);
666	cen[strlen(cen)-1]=0;
667	cen+=1;
668	setServiceName(&my_service,cen);
669	cen-=1;
670	free(cen);
671	}
672	} else {
673	if(current_data==1){
674	if(my_service->content!=NULL && current_element->name!=NULL){
675	if(my_service->inputs==NULL){
676	my_service->inputs=dupElements(current_element);
677	my_service->inputs->next=NULL;
678	tmp_count++;
679	}
680	else{
681	if(wait_nested){
682	elements* cursor=my_service->inputs;
683	while(cursor->next!=NULL)
684	cursor=cursor->next;
685	if(nested_level>1){
686	for(int j=0;j<nested_level-1;j++){
687	cursor=cursor->child;
688	while(cursor->next!=NULL)
689	cursor=cursor->next;
690	}
691	}
692	if(cursor->child==NULL){
693	cursor->child=dupElements(current_element);
694	}else{
695	addToElements(&cursor->child,current_element);
696	}
697	}else
698	addToElements(&my_service->inputs,current_element);
699	}
700	if(current_element->format==NULL){
701	wait_nested=true;
702	nested_level+=1;
703	if(current_content!=NULL){
704	elements* cursor=my_service->inputs;
705	while(cursor->next!=NULL)
706	cursor=cursor->next;
707	if(nested_level>1){
708	for(int j=0;j<nested_level-1;j++){
709	cursor=cursor->child;
710	while(cursor->next!=NULL)
711	cursor=cursor->next;
712	}
713	}
714	addMapToMap(&cursor->content,current_content);
715	freeMap(&current_content);
716	free(current_content);
717	current_content=NULL;
718	}
719	}
720	#ifdef DEBUG_SERVICE_CONF
721	fprintf(stderr,"(%s %d)FREE current_element (after adding to allread existing inputs)",__FILE__,__LINE__);
722	dumpElements(current_element);
723	fprintf(stderr,"(%s %d)FREE current_element (after adding to allread existing inputs)",__FILE__,__LINE__);
724	dumpElements(my_service->inputs);
725	#endif
726	freeElements(&current_element);
727	free(current_element);
728	current_element=NULL;
729	#ifdef DEBUG_SERVICE_CONF
730	fprintf(stderr,"(DATAINPUTS - 489) ALLOCATE current_element\n");
731	#endif
732	current_element=createEmptyElements();
733	}
734	if(current_element->name==NULL){
735	#ifdef DEBUG_SERVICE_CONF
736	fprintf(stderr,"NAME IN %s (current - %s)\n",
737	$1,current_element->name);
738	#endif
739	wait_inputs=true;
740	#ifdef DEBUG_SERVICE_CONF
741	fprintf(stderr,"(DATAINPUTS - 501) SET NAME OF current_element\n");
742	#endif
743	if($1!=NULL){
744	char *cen=zStrdup($1);
745	cen[strlen(cen)-1]=0;
746	cen+=1;
747	setElementsName(&current_element,cen);
748	cen-=1;
749	free(cen);
750	#ifdef DEBUG_SERVICE_CONF
751	fprintf(stderr,"NAME IN %s (current - %s)\n",$1,current_element->name);
752	#endif
753	#ifdef DEBUG_SERVICE_CONF
754	fprintf(stderr,"NAME IN %s (current - %s)\n",$1,current_element->name);
755	#endif
756	}
757	}
758	}
759	else
760	if(current_data==2){
761	wait_outputs=1;
762	if(wait_inputs){
763	if(current_element!=NULL && current_element->name!=NULL){
764	if(my_service->outputs==NULL){
765	my_service->outputs=dupElements(current_element);
766	my_service->outputs->next=NULL;
767	}
768	else{
769	#ifdef DEBUG_SERVICE_CONF
770	fprintf(stderr,"LAST NAME IN %s (current - %s)\n",$1,current_element->name);
771	#endif
772	addToElements(&my_service->outputs,current_element);
773	}
774	#ifdef DEBUG_SERVICE_CONF
775	dumpElements(current_element);
776	fprintf(stderr,"(DATAOUTPUTS) FREE current_element %s %i\n",__FILE__,__LINE__);
777	#endif
778	freeElements(&current_element);
779	free(current_element);
780	current_element=NULL;
781	#ifdef DEBUG_SERVICE_CONF
782	fprintf(stderr,"(DATAOUTPUTS -%d) ALLOCATE current_element %s \n",__LINE__,__FILE__);
783	#endif
784	current_element=createEmptyElements();
785	}
786	if(current_element->name==NULL){
787	#ifdef DEBUG_SERVICE_CONF
788	fprintf(stderr,"NAME OUT %s\n",$1);
789	fprintf(stderr,"(DATAOUTPUTS - %d) SET NAME OF current_element\n",__LINE__);
790	#endif
791	if($1!=NULL){
792	char *cen=zStrdup($1);
793	cen[strlen(cen)-1]=0;
794	cen+=1;
795	setElementsName(&current_element,cen);
796	cen-=1;
797	free(cen);
798	}
799	}
800
801	current_content=NULL;
802	}
803	else
804	if(current_element!=NULL && current_element->name!=NULL){
805	if(my_service->outputs==NULL)
806	my_service->outputs=dupElements(current_element);
807	else{
808	if(wait_nested){
809	elements* cursor=my_service->outputs;
810	while(cursor->next!=NULL)
811	cursor=cursor->next;
812	if(nested_level>1){
813	for(int j=0;j<nested_level-1;j++){
814	cursor=cursor->child;
815	while(cursor->next!=NULL)
816	cursor=cursor->next;
817	}
818	}
819	if(cursor->child==NULL){
820	cursor->child=dupElements(current_element);
821	}else
822	addToElements(&cursor->child,current_element);
823	}else
824	addToElements(&my_service->outputs,current_element);
825	}
826	if(current_element->format==NULL){
827	wait_nested=true;
828	nested_level+=1;
829	if(current_content!=NULL){
830	elements* cursor=my_service->outputs;
831	while(cursor->next!=NULL)
832	cursor=cursor->next;
833	if(nested_level>1){
834	for(int j=0;j<nested_level-1;j++){
835	cursor=cursor->child;
836	while(cursor->next!=NULL)
837	cursor=cursor->next;
838	}
839	}
840	addMapToMap(&cursor->content,current_content);
841	freeMap(&current_content);
842	free(current_content);
843	current_content=NULL;
844	}
845	}
846
847	#ifdef DEBUG_SERVICE_CONF
848	fprintf(stderr,"ADD TO OUTPUTS Elements\n");
849	dupElements(current_element);
850	#endif
851	freeElements(&current_element);
852	free(current_element);
853	current_element=NULL;
854
855	char *cen=zStrdup($1);
856	cen[strlen(cen)-1]=0;
857	cen+=1;
858	current_element=createElements(cen);
859	cen-=1;
860	free(cen);
861	}
862	else{
863	#ifdef DEBUG_SERVICE_CONF
864	fprintf(stderr,"NAME OUT %s\n",$1);
865	fprintf(stderr,"(DATAOUTPUTS - %d) SET NAME OF current_element %s\n",__LINE__,$1);
866	#endif
867	if($1!=NULL){
868	char *cen=zStrdup($1);
869	cen[strlen(cen)-1]=0;
870	#ifdef DEBUG
871	fprintf(stderr,"tmp %s\n",cen);
872	#endif
873	cen+=1;
874	setElementsName(&current_element,cen);
875	cen-=1;
876	free(cen);
877	}
878	}
879	wait_inputs=false;
880	wait_outputs=1;
881	//wait_outputs=true;
882	}
883	}
884	}
885	;
886
887	%%
888
889	/**
890	* Print on stderr the message and the line number of the error which occurred.
891	*
892	* @param s the error message
893	*/
894	void srerror(const char *s)
895	{
896	if(debug)
897	fprintf(stderr,"\nligne %d : %s\n",srlineno,s);
898	}
899
900	/**
901	* Parse a ZCFG file and fill the service structure.
902	*
903	* @param conf the conf maps containing the main.cfg settings
904	* @param file the fullpath to the ZCFG file
905	* @param service the service structure to fill
906	* @return 0 on success, -1 on failure
907	*/
908	int getServiceFromFile(maps* conf,const char* file,service** service){
909	if(current_content!=NULL){
910	freeMap(&current_content);
911	free(current_content);
912	current_content=NULL;
913	}
914	#ifdef DEBUG_SERVICE_CONF
915	fprintf(stderr,"(STARTING)FREE current_element %s\n",file);
916	#endif
917	fflush(stderr);
918	fflush(stdout);
919	if(current_element!=NULL){
920	freeElements(&current_element);
921	free(current_element);
922	current_element=NULL;
923	}
924	my_service=NULL;
925
926	wait_maincontent=true;
927	wait_mainmetadata=false;
928	wait_metadata=false;
929	wait_mainap=false;
930	wait_ap=false;
931	wait_inputs=false;
932	wait_defaults=false;
933	wait_supporteds=false;
934	wait_outputs=-1;
935	wait_data=false;
936	wait_nested=false;
937	//data=-1;
938	::data=-1; // knut: add namespace to avoid ambiguous symbol
939	previous_data=1;
940	current_data=0;
941
942	my_service=*service;
943
944	srin = fopen(file,"r");
945	if (srin==NULL){
946	setMapInMaps(conf,"lenv","message","file not found");
947	return -1;
948	}
949
950	int resultatYYParse = srparse() ;
951
952	#ifdef DEBUG_SERVICE_CONF
953	fprintf(stderr,"RESULT: %d %d\n",resultatYYParse,wait_outputs);
954	dumpElements(current_element);
955	#endif
956	if(wait_outputs && current_element!=NULL && current_element->name!=NULL){
957	if(current_content!=NULL){
958	addMapToMap(&current_element->content,current_content);
959	}
960	if(my_service->outputs==NULL){
961	#ifdef DEBUG_SERVICE_CONF
962	fprintf(stderr,"(DATAOUTPUTS - %d) DUP current_element\n",__LINE__);
963	#endif
964	my_service->outputs=dupElements(current_element);
965	my_service->outputs->next=NULL;
966	}
967	else{
968	#ifdef DEBUG_SERVICE_CONF
969	fprintf(stderr,"(DATAOUTPUTS - %d) COPY current_element\n",__LINE__);
970	#endif
971	if(wait_nested){
972	elements* cursor=my_service->outputs;
973	while(cursor->next!=NULL)
974	cursor=cursor->next;
975	if(nested_level>1){
976	for(int j=0;j<nested_level-1;j++){
977	cursor=cursor->child;
978	while(cursor->next!=NULL)
979	cursor=cursor->next;
980	}
981	}
982	if(cursor->child==NULL){
983	cursor->child=dupElements(current_element);
984	}else
985	addToElements(&cursor->child,current_element);
986	}else
987	addToElements(&my_service->outputs,current_element);
988	}
989	#ifdef DEBUG_SERVICE_CONF
990	fprintf(stderr,"(DATAOUTPUTS - %d) FREE current_element\n",__LINE__);
991	#endif
992	freeElements(&current_element);
993	free(current_element);
994	current_element=NULL;
995	#ifdef DEBUG_SERVICE_CONF
996	fprintf(stderr,"(DATAOUTPUTS - %d) FREE current_element\n",__LINE__);
997	#endif
998	}
999	if(current_element!=NULL){
1000	freeElements(&current_element);
1001	free(current_element);
1002	current_element=NULL;
1003	}
1004	int contentOnly=false;
1005	if(current_content!=NULL){
1006	if(my_service->content==NULL){
1007	addMapToMap(&my_service->content,current_content);
1008	contentOnly=true;
1009	wait_maincontent=false;
1010	}
1011	freeMap(&current_content);
1012	free(current_content);
1013	current_content=NULL;
1014	}
1015	fclose(srin);
1016	#ifdef DEBUG_SERVICE_CONF
1017	dumpService(my_service);
1018	#endif
1019	if(wait_maincontent==true \|\| (contentOnly==false && ((!wait_outputs && current_data==2 && my_service->outputs==NULL) \|\| my_service==NULL \|\| my_service->name==NULL \|\| my_service->content==NULL))){
1020	setMapInMaps(conf,"lenv","message",srlval.chaine);
1021	#ifndef WIN32
1022	srlex_destroy();
1023	#endif
1024	return -1;
1025	}
1026	else
1027	*service=my_service;
1028
1029	#ifndef WIN32
1030	srlex_destroy();
1031	#endif
1032	return resultatYYParse;
1033	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format

Open WPS platform

source: branches/prototype-v0/zoo-project/zoo-kernel/service_conf.y @ 839

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links