source: XMLIO_SERVER/trunk/src/XMLIO/mod_parse_xml.f90 @ 26

Last change on this file since 26 was 26, checked in by ymipsl, 13 years ago

Mise à jour importante :

  • ajout de la grille type LMDZ
  • ajout des context
  • ajout de namelist pour parametrer l'utilisation du server : avec/sans MPI, en utlisant ou pas OASIS
File size: 19.4 KB
Line 
1MODULE parsing_xml
2  USE flib_dom
3  USE error_msg
4  USE string_function
5 
6CONTAINS
7
8  SUBROUTINE parsing_xml_file(name)
9  IMPLICIT NONE
10    CHARACTER(len=*), INTENT(IN) :: name
11    TYPE(fnode), POINTER :: myDoc
12
13    myDoc => parsefile(name)
14    CALL parsing_root(myDoc)
15
16    PRINT *, 'Le parsing est termine !!! '
17 
18  END SUBROUTINE parsing_xml_file
19 
20 
21  SUBROUTINE parsing_root(root)
22  IMPLICIT NONE
23    TYPE(fnode), POINTER :: root
24    TYPE(fnode), POINTER :: child_node
25    TYPE(fnodeList), POINTER :: child_list
26
27    INTEGER :: il
28    CHARACTER(len=100) :: node_name
29     
30    IF (hasChildNodes(root)) THEN
31      child_list => getChildnodes(root)
32
33      DO il=0,getLength(child_list)-1
34        child_node => item(child_list,il)
35        node_name=getNodename(child_node)
36         
37        SELECT CASE (TRIM(node_name)) 
38         
39           CASE ('simulation') 
40             CALL parsing_simulation(child_node)
41
42           CASE DEFAULT
43             IF (is_bad_node(node_name)) THEN
44               WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing root'
45               CALL Warning("mod_parse_xml:parsing_root")
46             ENDIF
47        END SELECT
48      ENDDO
49    ENDIF
50             
51  END SUBROUTINE parsing_root
52
53  SUBROUTINE parsing_simulation(root)
54  IMPLICIT NONE
55    TYPE(fnode), POINTER :: root
56    TYPE(fnode), POINTER :: child_node
57    TYPE(fnodeList), POINTER :: child_list
58
59    INTEGER :: il
60    CHARACTER(len=100) :: node_name
61     
62     IF (hasChildNodes(root)) THEN
63      child_list => getChildnodes(root)
64
65      DO il=0,getLength(child_list)-1
66        child_node => item(child_list,il)
67        node_name=getNodename(child_node)
68         
69        SELECT CASE (TRIM(node_name)) 
70         
71           CASE ('context') 
72             CALL parsing_context(child_node)
73
74           CASE DEFAULT
75             IF (is_bad_node(node_name)) THEN
76               WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing simulation'
77               CALL Warning("mod_parse_xml:parsing_simulationt")
78             ENDIF
79         END SELECT
80       
81       ENDDO
82    ENDIF
83             
84  END SUBROUTINE parsing_simulation
85
86  SUBROUTINE parsing_context(node)
87  USE mod_context
88  USE mod_axis_definition
89  USE mod_grid_definition
90  USE mod_field_definition
91  USE mod_file_definition
92  IMPLICIT NONE 
93    TYPE(fnode), POINTER         :: node
94   
95    TYPE(fnode), POINTER     :: child_node
96    TYPE(fnodeList), POINTER :: child_list
97    TYPE(axis),POINTER       :: attribute
98    LOGICAL                  :: is_root
99    INTEGER :: il
100    CHARACTER(len=100) :: node_name
101    CHARACTER(len=100) :: value
102   
103    IF (is_attribute_exist(node,"id")) THEN
104      value=getAttribute(node,"id")
105      CALL context__create(TRIM(value)) 
106      CALL context__swap(TRIM(value))
107    ENDIF
108   
109    IF (hasChildNodes(node)) THEN
110      child_list => getChildnodes(node)
111
112      DO il=0,getLength(child_list)-1
113        child_node => item(child_list,il)
114        node_name=getNodename(child_node)
115       
116        SELECT CASE (TRIM(node_name)) 
117         
118           CASE ('axis_definition') 
119             CALL parsing_axis_group(child_node,axis_definition,root=.TRUE.)
120               
121           CASE ('grid_definition')
122             CALL parsing_grid_group(child_node,grid_definition,root=.TRUE.)
123               
124           CASE ('field_definition')
125             CALL parsing_field_group(child_node,field_definition,root=.TRUE.)
126               
127           CASE ('file_definition')
128             CALL parsing_file_group(child_node,file_definition,root=.TRUE.)
129               
130           CASE DEFAULT
131             IF (is_bad_node(node_name)) THEN
132               WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing context'
133               CALL Warning("mod_parse_xml:parsing_context")
134             ENDIF   
135        END SELECT
136      ENDDO
137
138    ENDIF
139
140  END SUBROUTINE parsing_context
141
142
143  RECURSIVE SUBROUTINE parsing_axis_group(node,parent,root)
144  USE mod_axis_definition
145  USE mod_axis_group
146  USE mod_axis
147  IMPLICIT NONE 
148    TYPE(fnode), POINTER         :: node
149    TYPE(axis_group),POINTER     :: parent
150    LOGICAL,INTENT(IN),OPTIONAL :: root
151   
152    TYPE(axis_group),POINTER :: pt_axis_group
153    TYPE(fnode), POINTER     :: child_node
154    TYPE(fnodeList), POINTER :: child_list
155    TYPE(axis),POINTER       :: attribute
156    LOGICAL                  :: is_root
157    INTEGER :: il
158    CHARACTER(len=100) :: node_name
159    CHARACTER(len=100) :: value
160   
161    is_root=.FALSE.
162    IF (PRESENT(root)) is_root=root
163 
164    IF (is_root) THEN
165      pt_axis_group=>parent
166    ELSE 
167      IF (is_attribute_exist(node,"id")) THEN
168        value=getAttribute(node,"id")
169        CALL axis_group__get_new_group(parent,pt_axis_group,TRIM(value))
170      ELSE
171        CALL axis_group__get_new_group(parent,pt_axis_group)
172      ENDIF
173    ENDIF
174     
175    CALL axis_group__get_default_attrib(pt_axis_group,attribute)
176    CALL parsing_axis_attribute(node,attribute)
177   
178    IF (hasChildNodes(node)) THEN
179      child_list => getChildnodes(node)
180
181      DO il=0,getLength(child_list)-1
182        child_node => item(child_list,il)
183        node_name=getNodename(child_node)
184       
185        SELECT CASE (TRIM(node_name)) 
186       
187          CASE ('group') 
188            CALL parsing_axis_group(child_node,pt_axis_group)
189             
190          CASE ('axis')
191            CALL parsing_axis(child_node,pt_axis_group)
192
193          CASE DEFAULT
194            IF (is_bad_node(node_name)) THEN
195              WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing group_axis'
196              CALL Warning("mod_parse_xml:parsing_group_axis")
197            ENDIF
198        END SELECT
199      ENDDO
200    ENDIF
201
202  END SUBROUTINE parsing_axis_group
203
204  SUBROUTINE parsing_axis(node,parent)
205  USE mod_axis_group
206  USE mod_axis
207  IMPLICIT NONE 
208    TYPE(fnode), POINTER     :: node
209    TYPE(axis_group),POINTER :: parent
210   
211    TYPE(axis),POINTER :: pt_axis
212    TYPE(axis),POINTER       :: attribute
213    INTEGER :: il
214    CHARACTER(len=100) :: node_name
215    CHARACTER(len=100) :: value
216 
217     
218    IF (is_attribute_exist(node,"id")) THEN
219      value=getAttribute(node,"id")
220      CALL axis_group__get_new_axis(parent,pt_axis,TRIM(value))
221    ELSE
222      CALL axis_group__get_new_axis(parent,pt_axis)
223    ENDIF
224     
225    CALL parsing_axis_attribute(node,pt_axis)
226 
227  END SUBROUTINE parsing_axis
228
229 
230  SUBROUTINE parsing_axis_attribute(node,pt_axis)
231  USE mod_axis
232  IMPLICIT NONE
233    TYPE(fnode), POINTER     :: node
234    TYPE(axis),POINTER :: pt_axis
235
236    CHARACTER(len=100) :: value
237   
238    IF (is_attribute_exist(node,"name")) THEN
239      value =  getAttribute(node,"name")
240      CALL axis__set(pt_axis,name=TRIM(value))
241    ENDIF
242
243    IF (is_attribute_exist(node,"description")) THEN
244      value =  getAttribute(node,"description")
245      CALL axis__set(pt_axis,description=TRIM(value))
246    ENDIF
247       
248    IF (is_attribute_exist(node,"unit")) THEN
249      value =  getAttribute(node,"unit")
250      CALL axis__set(pt_axis,unit=TRIM(value))
251    ENDIF
252
253    IF (is_attribute_exist(node,"size")) THEN
254      value =  getAttribute(node,"size")
255      CALL axis__set(pt_axis,a_size=string_to_integer(value))
256    ENDIF
257   
258  END SUBROUTINE parsing_axis_attribute 
259
260
261
262
263
264
265
266
267  RECURSIVE SUBROUTINE parsing_grid_group(node,parent,root)
268  USE mod_grid_definition
269  USE mod_grid_group
270  USE mod_grid
271  IMPLICIT NONE 
272    TYPE(fnode), POINTER     :: node
273    TYPE(grid_group),POINTER :: parent
274    LOGICAL,INTENT(IN),OPTIONAL :: root
275
276    TYPE(grid_group),POINTER :: pt_grid_group
277    TYPE(fnode), POINTER     :: child_node
278    TYPE(fnodeList), POINTER :: child_list
279    TYPE(grid),POINTER       :: attribute
280    LOGICAL                  :: is_root
281    INTEGER :: il
282    CHARACTER(len=100) :: node_name
283    CHARACTER(len=100) :: value
284 
285    is_root=.FALSE.
286    IF (PRESENT(root)) is_root=root
287 
288    IF (is_root) THEN
289      pt_grid_group=>parent
290    ELSE 
291      IF (is_attribute_exist(node,"id")) THEN
292        value=getAttribute(node,"id")
293        CALL grid_group__get_new_group(parent,pt_grid_group,TRIM(value))
294      ELSE
295        CALL grid_group__get_new_group(parent,pt_grid_group)
296      ENDIF
297    ENDIF
298     
299    CALL grid_group__get_default_attrib(pt_grid_group,attribute)
300    CALL parsing_grid_attribute(node,attribute)
301   
302    IF (hasChildNodes(node)) THEN
303      child_list => getChildnodes(node)
304
305      DO il=0,getLength(child_list)-1
306        child_node => item(child_list,il)
307        node_name=getNodename(child_node)
308       
309        SELECT CASE (TRIM(node_name)) 
310       
311          CASE ('group') 
312            CALL parsing_grid_group(child_node,pt_grid_group)
313             
314          CASE ('grid')
315            CALL parsing_grid(child_node,pt_grid_group)
316
317          CASE DEFAULT
318            IF (is_bad_node(node_name)) THEN
319              WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing group_grid'
320              CALL Warning("mod_parse_xml:parsing_group_grid")
321            ENDIF
322        END SELECT
323      ENDDO
324    ENDIF
325
326  END SUBROUTINE parsing_grid_group
327
328  SUBROUTINE parsing_grid(node,parent)
329  USE mod_grid_group
330  USE mod_grid
331  IMPLICIT NONE 
332    TYPE(fnode), POINTER     :: node
333    TYPE(grid_group),POINTER :: parent
334   
335    TYPE(grid),POINTER :: pt_grid
336    TYPE(grid),POINTER       :: attribute
337    INTEGER :: il
338    CHARACTER(len=100) :: node_name
339    CHARACTER(len=100) :: value
340 
341     
342    IF (is_attribute_exist(node,"id")) THEN
343      value=getAttribute(node,"id")
344      CALL grid_group__get_new_grid(parent,pt_grid,TRIM(value))
345    ELSE
346      CALL grid_group__get_new_grid(parent,pt_grid)
347    ENDIF
348     
349    CALL parsing_grid_attribute(node,pt_grid)
350 
351  END SUBROUTINE parsing_grid
352
353 
354  SUBROUTINE parsing_grid_attribute(node,pt_grid)
355  USE mod_grid
356  IMPLICIT NONE
357    TYPE(fnode), POINTER     :: node
358    TYPE(grid),POINTER :: pt_grid
359
360    CHARACTER(len=100) :: value
361   
362    IF (is_attribute_exist(node,"name")) THEN
363      value =  getAttribute(node,"name")
364      CALL grid__set(pt_grid,name=TRIM(value))
365    ENDIF
366
367    IF (is_attribute_exist(node,"description")) THEN
368      value =  getAttribute(node,"description")
369      CALL grid__set(pt_grid,description=TRIM(value))
370    ENDIF
371       
372  END SUBROUTINE parsing_grid_attribute 
373
374
375
376
377
378
379
380  RECURSIVE SUBROUTINE parsing_field_group(node,parent,root)
381  USE mod_field_definition
382  USE mod_field_group
383  USE mod_field
384  IMPLICIT NONE 
385    TYPE(fnode), POINTER          :: node
386    TYPE(field_group),POINTER     :: parent
387    LOGICAL,INTENT(IN),OPTIONAL   :: root
388   
389    TYPE(field_group),POINTER :: pt_field_group
390    TYPE(fnode), POINTER     :: child_node
391    TYPE(fnodeList), POINTER :: child_list
392    TYPE(field),POINTER       :: attribute
393    INTEGER :: il
394    CHARACTER(len=100) :: node_name
395    CHARACTER(len=100) :: value
396    LOGICAL            :: is_root
397   
398    is_root=.FALSE.
399    IF (PRESENT(root)) is_root=root
400   
401    IF (is_root) THEN
402      pt_field_group=>parent
403    ELSE 
404      IF (is_attribute_exist(node,"id")) THEN
405        value=getAttribute(node,"id")
406        CALL field_group__get_new_group(parent,pt_field_group,TRIM(value))
407      ELSE
408        CALL field_group__get_new_group(parent,pt_field_group)
409      ENDIF
410    ENDIF
411     
412    CALL field_group__get_default_attrib(pt_field_group,attribute)
413    CALL parsing_field_attribute(node,attribute)
414   
415    IF (hasChildNodes(node)) THEN
416      child_list => getChildnodes(node)
417
418      DO il=0,getLength(child_list)-1
419        child_node => item(child_list,il)
420        node_name=getNodename(child_node)
421       
422        SELECT CASE (TRIM(node_name)) 
423       
424          CASE ('group') 
425            CALL parsing_field_group(child_node,pt_field_group)
426             
427          CASE ('field')
428            CALL parsing_field(child_node,pt_field_group)
429
430          CASE DEFAULT
431            IF (is_bad_node(node_name)) THEN
432              WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing group_field'
433              CALL Warning("mod_parse_xml:parsing_group_field")
434            ENDIF
435        END SELECT
436      ENDDO
437    ENDIF
438
439  END SUBROUTINE parsing_field_group
440
441  SUBROUTINE parsing_field(node,parent)
442  USE mod_field_group
443  USE mod_field
444  IMPLICIT NONE 
445    TYPE(fnode), POINTER     :: node
446    TYPE(field_group),POINTER :: parent
447   
448    TYPE(field),POINTER :: pt_field
449    TYPE(field),POINTER       :: attribute
450    INTEGER :: il
451    CHARACTER(len=100) :: node_name
452    CHARACTER(len=100) :: value
453 
454     
455    IF (is_attribute_exist(node,"id")) THEN
456      value=getAttribute(node,"id")
457      CALL field_group__get_new_field(parent,pt_field,TRIM(value))
458    ELSE
459      CALL field_group__get_new_field(parent,pt_field)
460    ENDIF
461     
462    CALL parsing_field_attribute(node,pt_field)
463 
464  END SUBROUTINE parsing_field
465
466 
467  SUBROUTINE parsing_field_attribute(node,pt_field)
468  USE mod_field
469  IMPLICIT NONE
470    TYPE(fnode), POINTER     :: node
471    TYPE(field),POINTER :: pt_field
472
473    CHARACTER(len=100) :: value
474   
475    IF (is_attribute_exist(node,"name")) THEN
476      value =  getAttribute(node,"name")
477      CALL field__set(pt_field,name=TRIM(value))
478    ENDIF
479
480    IF (is_attribute_exist(node,"description")) THEN
481      value =  getAttribute(node,"description")
482      CALL field__set(pt_field,description=TRIM(value))
483    ENDIF
484       
485    IF (is_attribute_exist(node,"unit")) THEN
486      value =  getAttribute(node,"unit")
487      CALL field__set(pt_field,unit=TRIM(value))
488    ENDIF
489
490    IF (is_attribute_exist(node,"operation")) THEN
491      value =  getAttribute(node,"operation")
492      CALL field__set(pt_field,operation=TRIM(value))
493    ENDIF
494
495    IF (is_attribute_exist(node,"freq_op")) THEN
496      value =  getAttribute(node,"freq_op")
497      CALL field__set(pt_field,freq_op=string_to_integer(value))
498    ENDIF
499   
500    IF (is_attribute_exist(node,"axis_ref")) THEN
501      value =  getAttribute(node,"axis_ref")
502      CALL field__set(pt_field,axis_ref=TRIM(value))
503    ENDIF
504
505    IF (is_attribute_exist(node,"grid_ref")) THEN
506      value =  getAttribute(node,"grid_ref")
507      CALL field__set(pt_field,grid_ref=TRIM(value))
508    ENDIF
509
510    IF (is_attribute_exist(node,"level")) THEN
511      value =  getAttribute(node,"level")
512      CALL field__set(pt_field,level=string_to_integer(value))
513    ENDIF
514   
515    IF (is_attribute_exist(node,"prec")) THEN
516      value =  getAttribute(node,"prec")
517      CALL field__set(pt_field,prec=string_to_integer(value))
518    ENDIF
519
520    IF (is_attribute_exist(node,"ref")) THEN
521      value =  getAttribute(node,"ref")
522      CALL field__set(pt_field,ref=TRIM(value))
523    ENDIF
524
525    IF (is_attribute_exist(node,"enabled")) THEN
526      value =  getAttribute(node,"enabled")
527      CALL field__set(pt_field,enabled=string_to_logical(value))
528    ENDIF
529 
530
531  END SUBROUTINE parsing_field_attribute 
532
533
534  RECURSIVE SUBROUTINE parsing_file_group(node,parent,root)
535  USE mod_file_definition
536  USE mod_file_group
537  USE mod_file
538  IMPLICIT NONE 
539    TYPE(fnode), POINTER          :: node
540    TYPE(file_group),POINTER      :: parent
541    LOGICAL,INTENT(IN),OPTIONAL   :: root
542
543    TYPE(file_group),POINTER :: pt_file_group
544    TYPE(fnode), POINTER     :: child_node
545    TYPE(fnodeList), POINTER :: child_list
546    TYPE(file),POINTER       :: attribute
547    LOGICAL                  :: is_root
548    INTEGER :: il
549    CHARACTER(len=100) :: node_name
550    CHARACTER(len=100) :: value
551   
552    is_root=.FALSE.
553    IF (PRESENT(root)) is_root=root
554 
555    IF (is_root) THEN
556      pt_file_group=>parent
557    ELSE 
558      IF (is_attribute_exist(node,"id")) THEN
559        value=getAttribute(node,"id")
560        CALL file_group__get_new_group(parent,pt_file_group,TRIM(value))
561      ELSE
562        CALL file_group__get_new_group(parent,pt_file_group)
563      ENDIF
564    ENDIF
565     
566    CALL file_group__get_default_attrib(pt_file_group,attribute)
567    CALL parsing_file_attribute(node,attribute)
568   
569    IF (hasChildNodes(node)) THEN
570      child_list => getChildnodes(node)
571
572      DO il=0,getLength(child_list)-1
573        child_node => item(child_list,il)
574        node_name=getNodename(child_node)
575       
576        SELECT CASE (TRIM(node_name)) 
577       
578          CASE ('group') 
579            CALL parsing_file_group(child_node,pt_file_group)
580             
581          CASE ('file')
582            CALL parsing_file(child_node,pt_file_group)
583
584          CASE DEFAULT
585            IF (is_bad_node(node_name)) THEN
586              WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing group_file'
587              CALL Warning("mod_parse_xml:parsing_group_file")
588            ENDIF
589        END SELECT
590      ENDDO
591    ENDIF
592
593  END SUBROUTINE parsing_file_group
594
595  SUBROUTINE parsing_file(node,parent)
596  USE mod_file_group
597  USE mod_file
598  IMPLICIT NONE 
599    TYPE(fnode), POINTER     :: node
600    TYPE(file_group),POINTER :: parent
601   
602    TYPE(file),POINTER :: pt_file
603    TYPE(file),POINTER       :: attribute
604    TYPE(fnode), POINTER     :: child_node
605    TYPE(fnodeList), POINTER :: child_list
606    INTEGER :: il
607    CHARACTER(len=100) :: node_name
608    CHARACTER(len=100) :: value
609 
610     
611    IF (is_attribute_exist(node,"id")) THEN
612      value=getAttribute(node,"id")
613      CALL file_group__get_new_file(parent,pt_file,TRIM(value))
614    ELSE
615      CALL file_group__get_new_file(parent,pt_file)
616    ENDIF
617     
618    CALL parsing_file_attribute(node,pt_file)
619 
620    IF (hasChildNodes(node)) THEN
621      child_list => getChildnodes(node)
622
623      DO il=0,getLength(child_list)-1
624        child_node => item(child_list,il)
625        node_name=getNodename(child_node)
626       
627        SELECT CASE (TRIM(node_name)) 
628       
629          CASE ('group') 
630            CALL parsing_field_group(child_node,pt_file%field_list)
631             
632          CASE ('field')
633            CALL parsing_field(child_node,pt_file%field_list)
634
635          CASE DEFAULT
636            IF (is_bad_node(node_name)) THEN
637              WRITE(message,*) 'Unknown node <<',TRIM(node_name),'>> while parsing group_file'
638              CALL Warning("mod_parse_xml:parsing_group_file")
639            ENDIF
640        END SELECT
641      ENDDO
642    ENDIF
643  END SUBROUTINE parsing_file
644
645 
646  SUBROUTINE parsing_file_attribute(node,pt_file)
647  USE mod_file
648  IMPLICIT NONE
649    TYPE(fnode), POINTER     :: node
650    TYPE(file),POINTER :: pt_file
651
652    CHARACTER(len=100) :: value
653   
654    IF (is_attribute_exist(node,"name")) THEN
655      value =  getAttribute(node,"name")
656      CALL file__set(pt_file,name=TRIM(value))
657    ENDIF
658
659    IF (is_attribute_exist(node,"description")) THEN
660      value =  getAttribute(node,"description")
661      CALL file__set(pt_file,description=TRIM(value))
662    ENDIF
663       
664    IF (is_attribute_exist(node,"output_freq")) THEN
665      value =  getAttribute(node,"output_freq")
666      CALL file__set(pt_file,output_freq=string_to_integer(value))
667    ENDIF
668   
669    IF (is_attribute_exist(node,"output_level")) THEN
670      value =  getAttribute(node,"output_level")
671      CALL file__set(pt_file,output_level=string_to_integer(value))
672    ENDIF
673
674    IF (is_attribute_exist(node,"enabled")) THEN
675      value =  getAttribute(node,"enabled")
676      CALL file__set(pt_file,enabled=string_to_logical(value))
677    ENDIF
678
679  END SUBROUTINE parsing_file_attribute
680 
681
682   
683 
684  FUNCTION is_attribute_exist(node, name)
685
686    LOGICAL :: is_attribute_exist
687    TYPE(fnode), POINTER :: node
688    CHARACTER(len=*) :: name
689    CHARACTER(len=100) :: value
690
691    value=""
692   
693    is_attribute_exist= .false.
694    value=getAttribute(node, TRIM(name))
695    IF (value .NE. "") is_attribute_exist= .true.
696
697  END FUNCTION is_attribute_exist
698
699  FUNCTION is_bad_node(node_name)
700  IMPLICIT NONE
701    CHARACTER(len=*),INTENT(IN) :: node_name
702    LOGICAL                     :: is_bad_node
703   
704    IF (TRIM(node_name)=='#text' .OR. TRIM(node_name)=='#comment') THEN
705      is_bad_node=.FALSE.
706    ELSE
707      is_bad_node=.TRUE.
708    ENDIF
709     
710  END FUNCTION is_bad_node
711 
712END MODULE parsing_xml
Note: See TracBrowser for help on using the repository browser.