Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
New dax loader infrastructure (empty box so far)
[simgrid.git] / src / simdag / dax_dtd.l
1 /* Validating XML processor for simdag/dax.dtd.
2  * Generated 2009/10/05 17:12:40.
3  *
4  * This program was generated with the FleXML XML processor generator.
5  * FleXML is Copyright (C) 1999-2005 Kristoffer Rose.  All rights reserved.
6  * FleXML is Copyright (C) 2003-2006 Martin Quinson.  All rights reserved.
7  * (Id: flexml.pl,v 1.62 2007/10/11 10:00:14 mquinson Exp).
8  * 
9  * There are two, intertwined parts to this program, part A and part B.
10  *
11  * Part A
12  * ------
13  * 
14  * Some parts, here collectively called "Part A", are found in the 
15  * FleXML package.  They are Copyright (C) 1999-2005 Kristoffer Rose
16  * and Copyright (C) 2003-2006 Martin Quinson. All rights reserved.
17  *
18  * You can redistribute, use, perform, display and/or modify "Part A"
19  * provided the following two conditions hold:
20  *
21  * 1. The program is distributed WITHOUT ANY WARRANTY from the author of
22  *    FleXML; without even the implied warranty of MERCHANTABILITY or
23  *    FITNESS FOR A PARTICULAR PURPOSE.
24  *
25  * 2. The program distribution conditions do not in any way affect the
26  *    distribution conditions of the FleXML system used to generate this
27  *    file or any version of FleXML derived from that system.
28  *
29  * Notice that these are explicit rights granted to you for files
30  * generated by the FleXML system.  For your rights in connection with
31  * the FleXML system itself please consult the GNU General Public License.
32  * 
33  * Part B
34  * ------
35  * 
36  * The other parts, here collectively called "Part B", and which came 
37  * from the DTD used by FleXML to generate this program, can be 
38  * distributed (or not, as the case may be) under the terms of whoever
39  * wrote them, provided these terms respect and obey the two conditions 
40  * above under the heading "Part A".
41  *
42  * The author of and contributors to FleXML specifically disclaim
43  * any copyright interest in "Part B", unless "Part B" was written 
44  * by the author of or contributors to FleXML.
45  * 
46  */
47
48 %{
49
50 /* Version strings. */
51 const char rcs_dax__flexml_skeleton[] =
52  "$" "Id: skel,v 1.40 2007/10/11 09:57:24 mquinson Exp $";
53 const char rcs_dax__flexml[] =
54  "$" "Id: flexml.pl,v 1.62 2007/10/11 10:00:14 mquinson Exp $";
55
56 /* ANSI headers. */
57 #include <stdlib.h> /* for realloc() -- needed here when using flex 2.5.4 */
58 #include <stdio.h>
59 #include <string.h>
60 #include <assert.h>
61 #include <stdarg.h>
62 #include <ctype.h>
63      
64 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__)
65 # ifndef __STRICT_ANSI__
66 #  include <io.h>
67 #  include <process.h>
68 # endif
69 #else
70 # include <unistd.h>
71 #endif
72      
73 #ifndef FLEXML_INDEXSTACKSIZE
74 #define FLEXML_INDEXSTACKSIZE 1000
75 #endif
76
77 /* Generated definitions. */
78 #define FLEXML_yylineno
79 #ifndef FLEXML_BUFFERSTACKSIZE
80 #define FLEXML_BUFFERSTACKSIZE 1000000
81 #endif
82 #define FLEXML_NEED_BUFFERLIT
83
84 /* XML processor api. */
85 /* FleXML-provided data. */
86 int dax__pcdata_ix;
87 extern char *dax__bufferstack;
88 #define dax__pcdata (dax__bufferstack + dax__pcdata_ix)
89 AT_dax__adag_version AX_dax__adag_version;
90 #define A_dax__adag_version (dax__bufferstack + AX_dax__adag_version)
91 AT_dax__uses_type AX_dax__uses_type;
92 #define A_dax__uses_type (dax__bufferstack + AX_dax__uses_type)
93 AT_dax__uses_optional AX_dax__uses_optional;
94 #define A_dax__uses_optional AX_dax__uses_optional
95 AT_dax__adag_name AX_dax__adag_name;
96 #define A_dax__adag_name (dax__bufferstack + AX_dax__adag_name)
97 AT_dax__child_ref AX_dax__child_ref;
98 #define A_dax__child_ref (dax__bufferstack + AX_dax__child_ref)
99 AT_dax__adag_xmlns AX_dax__adag_xmlns;
100 #define A_dax__adag_xmlns (dax__bufferstack + AX_dax__adag_xmlns)
101 AT_dax__uses_transfer AX_dax__uses_transfer;
102 #define A_dax__uses_transfer AX_dax__uses_transfer
103 AT_dax__job_id AX_dax__job_id;
104 #define A_dax__job_id (dax__bufferstack + AX_dax__job_id)
105 AT_dax__uses_file AX_dax__uses_file;
106 #define A_dax__uses_file (dax__bufferstack + AX_dax__uses_file)
107 AT_dax__parent_ref AX_dax__parent_ref;
108 #define A_dax__parent_ref (dax__bufferstack + AX_dax__parent_ref)
109 AT_dax__adag_count AX_dax__adag_count;
110 #define A_dax__adag_count (dax__bufferstack + AX_dax__adag_count)
111 AT_dax__adag_xmlns_c_xsi AX_dax__adag_xmlns_c_xsi;
112 #define A_dax__adag_xmlns_c_xsi (dax__bufferstack + AX_dax__adag_xmlns_c_xsi)
113 AT_dax__adag_index AX_dax__adag_index;
114 #define A_dax__adag_index (dax__bufferstack + AX_dax__adag_index)
115 AT_dax__uses_size AX_dax__uses_size;
116 #define A_dax__uses_size (dax__bufferstack + AX_dax__uses_size)
117 AT_dax__adag_childCount AX_dax__adag_childCount;
118 #define A_dax__adag_childCount (dax__bufferstack + AX_dax__adag_childCount)
119 AT_dax__uses_link AX_dax__uses_link;
120 #define A_dax__uses_link AX_dax__uses_link
121 AT_dax__job_runtime AX_dax__job_runtime;
122 #define A_dax__job_runtime (dax__bufferstack + AX_dax__job_runtime)
123 AT_dax__job_namespace AX_dax__job_namespace;
124 #define A_dax__job_namespace (dax__bufferstack + AX_dax__job_namespace)
125 AT_dax__job_name AX_dax__job_name;
126 #define A_dax__job_name (dax__bufferstack + AX_dax__job_name)
127 AT_dax__adag_jobCount AX_dax__adag_jobCount;
128 #define A_dax__adag_jobCount (dax__bufferstack + AX_dax__adag_jobCount)
129 AT_dax__adag_xmlns_c_schemaLocation AX_dax__adag_xmlns_c_schemaLocation;
130 #define A_dax__adag_xmlns_c_schemaLocation (dax__bufferstack + AX_dax__adag_xmlns_c_schemaLocation)
131 AT_dax__job_version AX_dax__job_version;
132 #define A_dax__job_version (dax__bufferstack + AX_dax__job_version)
133 AT_dax__uses_register AX_dax__uses_register;
134 #define A_dax__uses_register AX_dax__uses_register
135 AT_dax__adag_fileCount AX_dax__adag_fileCount;
136 #define A_dax__adag_fileCount (dax__bufferstack + AX_dax__adag_fileCount)
137
138 /* XML state. */
139 #ifdef FLEX_DEBUG
140 # define ENTER(state)   debug_enter(state,#state)
141 # define LEAVE          debug_leave()
142 # define SET(state)     debug_set(state,#state)
143   static void debug_enter(int, const char*);
144   static void debug_leave(void);
145   static void debug_set(int, const char*);
146 #else
147 # define ENTER(state)   (yy_push_state(state))
148 # define LEAVE          (yy_pop_state())
149 # define SET(state)     BEGIN(state)
150 #endif
151
152 /* Generic actions. */
153 #define SKIP    /*skip*/
154 #define SUCCEED        CLEANUP; return 0
155
156 #define FAIL    return fail
157 static int fail(const char*, ...);
158
159 enum {flexml_max_err_msg_size = 512};
160 static char flexml_err_msg[flexml_max_err_msg_size];
161 const char * dax__parse_err_msg()
162 {
163     return flexml_err_msg;
164 }
165 static void reset_dax__parse_err_msg()
166 {
167     flexml_err_msg[0] = '\0';
168 }
169
170 /* Cleanup */
171 static void cleanup(void);
172 #define CLEANUP  cleanup()
173
174 /* Text buffer stack handling. */
175 char *dax__bufferstack = NULL;
176 static int blimit = FLEXML_BUFFERSTACKSIZE;
177 static int bnext = 1;
178
179 static int *indexstack = NULL;
180 static int ilimit = FLEXML_INDEXSTACKSIZE;
181 static int inext = 1;
182
183 #define BUFFERSET(P)  (P = bnext)
184 #define BUFFERPUTC(C) (ck_blimit(), dax__bufferstack[bnext++] = (C))
185 #define BUFFERDONE    (BUFFERPUTC('\0'))
186
187 #define BUFFERLITERAL(C, P) dax__bufferliteral(C, &(P), yytext)
188
189 /* after this is called, there are at least 2 slots left in the stack */
190 static int ck_blimit()
191 {
192      if (bnext >= blimit) {
193          blimit += FLEXML_BUFFERSTACKSIZE + 2;
194          {
195              char *temp = (char *) realloc(dax__bufferstack, blimit);
196              assert(temp);
197              dax__bufferstack = temp;
198          }
199      }
200      return 0;
201 }
202
203 /* after this is called, there are at least 2 slots left in the stack */
204 static int ck_ilimit()
205 {
206      if (inext >= ilimit) {
207          ilimit += FLEXML_INDEXSTACKSIZE + 2;
208          {
209              int *temp = (int *) realloc(indexstack, ilimit);
210              assert(temp);
211              indexstack = temp;
212          }
213      }
214      return 0;
215 }
216
217 #ifdef FLEXML_NEED_BUFFERLIT
218 static void dax__bufferliteral(char c, int* pp, const char* text)
219 {
220   const char *s = (c ? strchr(text,c) : text-1), *e = strrchr(text,c);
221   assert(s <= e); BUFFERSET(*pp);
222   while (++s<e) {
223     if (isspace(*s) && c) { BUFFERPUTC(' '); while (isspace(*s)) ++s; }
224     else BUFFERPUTC(*s);
225   }
226   BUFFERDONE;
227 }
228 #endif
229
230 static void pushbuffer(int p)
231 {
232     ck_ilimit();
233     indexstack[inext++] = p;
234     indexstack[inext++] = bnext;    
235 }
236
237 static int popbuffer(void)
238 {
239     assert(inext >= 2);
240     bnext = indexstack[--inext];
241     return indexstack[--inext];
242 }
243
244 /* General internal entities are `unput' back onto the input stream... */
245 #define ENTITYTEXT(T) \
246   { char *s = (T), *e = s+strlen(s);\
247     while (--e >= s) { unput(*e); }}
248
249
250 %}
251
252 /* Flex standard options. */
253 %option stack
254 %option noyy_top_state
255 %option noinput
256 %option noreject
257 %option noyymore
258 %option noyywrap
259
260 /* Flex user-requested options. */
261 %option yylineno
262 %option nounput
263
264 /* XML character classes (currently restricted to ASCII). */
265
266 /* "Common syntactic structures." */
267 S               [ \t\n\r\f]+
268 s               [ \t\n\r\f]*
269
270 /* "Names and Tokens." */
271 NameChar        [A-Za-z0-9.:_-]
272 Name            [A-Za-z_:]{NameChar}*
273 Names           {Name}({S}{Name})*
274 Nmtoken         ({NameChar})+
275 Nmtokens        {Nmtoken}({S}{Nmtoken})*
276
277 /* Miscellaneous. */
278 VersionNum      [a-zA-Z0-9_.:-]+
279 Eq              {s}"="{s}
280 Literal         \'[^'']*\'|\"[^""]*\"
281
282 /* Parser states (flex `exclusive start conditions'):
283  *
284  * PROLOG       the XML prolog of the document before <?xml...>
285  * DOCTYPE      the XML prolog of the document after <?xml...>
286  * EPILOG       after the root element
287  * INCOMMENT    inside an XML comment <!--....-->
288  * INPI         inside an XML PI <?...?>
289  * VALUE1       inside a '...'-delimited literal
290  * VALUE2       inside a "..."-delimited literal
291  * CDATA        inside a <![CDATA[...] ]> section.
292  * ROOT_<tag>   expect root element <tag>
293  * AL_<tag>     inside the attribute list for <tag>
294  * IN_<tag>     inside a <tag> with element contents (ready for end tag)
295  * IMPOSSIBLE   dummy to permit disabling rules; must be last
296  */
297 %x PROLOG DOCTYPE EPILOG INCOMMENT INPI VALUE1 VALUE2 CDATA
298 %x ROOT_dax__adag AL_dax__adag S_dax__adag S_dax__adag_1 S_dax__adag_2 S_dax__adag_3 S_dax__adag_4 S_dax__adag_5 E_dax__adag
299 %x ROOT_dax__job AL_dax__job S_dax__job S_dax__job_1 S_dax__job_2 E_dax__job
300 %x ROOT_dax__uses AL_dax__uses E_dax__uses
301 %x ROOT_dax__child AL_dax__child S_dax__child S_dax__child_1 S_dax__child_2 E_dax__child
302 %x ROOT_dax__parent AL_dax__parent E_dax__parent
303 %x IMPOSSIBLE
304
305 %{
306 /* State names. */
307 const char* *dax__statenames=NULL;
308 %}
309
310 %%
311
312  /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
313  SET(PROLOG);
314  reset_dax__parse_err_msg();
315  dax__bufferstack = (char *) malloc(FLEXML_BUFFERSTACKSIZE);
316  assert(dax__bufferstack);
317  #ifdef FLEX_DEBUG
318  {
319      int i;
320      for (i = 0; i < blimit; i++) {
321          dax__bufferstack[i] = '\377';
322      }
323  }
324  #endif
325  dax__bufferstack[0] = '\0';
326  indexstack = (int *) malloc(FLEXML_INDEXSTACKSIZE * sizeof(int));
327  assert(indexstack);
328  indexstack[0] = 0;
329
330   /* FleXML_init */
331   bnext = inext = 1;
332   dax__bufferliteral('\0', &bnext, "http://pegasus.isi.edu/schema/DAX");
333   dax__bufferliteral('\0', &bnext, "http://www.w3.org/2001/XMLSchema-instance");
334   dax__bufferliteral('\0', &bnext, "http://pegasus.isi.edu/schema/DAX http://pegasus.isi.edu/schema/dax-2.1.xsd");
335   dax__bufferliteral('\0', &bnext, "0.0");
336   dax__bufferliteral('\0', &bnext, "0.0");
337   dax__bufferliteral('\0', &bnext, "data");
338   if(!dax__statenames) {dax__statenames= (const char **)calloc(IMPOSSIBLE,sizeof(char*));
339   dax__statenames[PROLOG] = NULL;
340   dax__statenames[DOCTYPE] = NULL;
341   dax__statenames[EPILOG] = NULL;
342   dax__statenames[INCOMMENT] = NULL;
343   dax__statenames[INPI] = NULL;
344   dax__statenames[VALUE1] = NULL;
345   dax__statenames[VALUE2] = NULL;
346   dax__statenames[CDATA] = NULL;
347   dax__statenames[ROOT_dax__adag] = NULL;
348   dax__statenames[AL_dax__adag] = NULL;
349   dax__statenames[S_dax__adag] = "adag";
350   dax__statenames[S_dax__adag_1] = "adag";
351   dax__statenames[S_dax__adag_2] = "adag";
352   dax__statenames[S_dax__adag_3] = "adag";
353   dax__statenames[S_dax__adag_4] = "adag";
354   dax__statenames[S_dax__adag_5] = "adag";
355   dax__statenames[E_dax__adag] = "adag";
356   dax__statenames[ROOT_dax__job] = NULL;
357   dax__statenames[AL_dax__job] = NULL;
358   dax__statenames[S_dax__job] = "job";
359   dax__statenames[S_dax__job_1] = "job";
360   dax__statenames[S_dax__job_2] = "job";
361   dax__statenames[E_dax__job] = "job";
362   dax__statenames[ROOT_dax__uses] = NULL;
363   dax__statenames[AL_dax__uses] = NULL;
364   dax__statenames[E_dax__uses] = "uses";
365   dax__statenames[ROOT_dax__child] = NULL;
366   dax__statenames[AL_dax__child] = NULL;
367   dax__statenames[S_dax__child] = "child";
368   dax__statenames[S_dax__child_1] = "child";
369   dax__statenames[S_dax__child_2] = "child";
370   dax__statenames[E_dax__child] = "child";
371   dax__statenames[ROOT_dax__parent] = NULL;
372   dax__statenames[AL_dax__parent] = NULL;
373   dax__statenames[E_dax__parent] = "parent";
374   }
375
376  /* COMMENTS and PIs: handled uniformly for efficiency. */
377
378 <ROOT_dax__adag,AL_dax__adag,S_dax__adag,S_dax__adag_1,S_dax__adag_2,S_dax__adag_3,S_dax__adag_4,S_dax__adag_5,E_dax__adag,ROOT_dax__job,AL_dax__job,S_dax__job,S_dax__job_1,S_dax__job_2,E_dax__job,ROOT_dax__uses,AL_dax__uses,E_dax__uses,ROOT_dax__child,AL_dax__child,S_dax__child,S_dax__child_1,S_dax__child_2,E_dax__child,ROOT_dax__parent,AL_dax__parent,E_dax__parent,PROLOG,DOCTYPE,EPILOG>{
379  "<!--" ENTER(INCOMMENT);
380  "<?" ENTER(INPI);
381 }
382 <INCOMMENT>{
383  "-->"          LEAVE;
384  "--"           |
385  .              |
386  \n             SKIP;
387  <<EOF>>        FAIL("EOF in comment.");
388 }
389 <INPI>{
390  "?>"           LEAVE;
391  .              |
392  \n             SKIP;
393  <<EOF>>        FAIL("EOF in PI (processing instruction).");
394 }
395
396  /* SPACES: skipped uniformly */
397
398 <ROOT_dax__adag,AL_dax__adag,S_dax__adag,S_dax__adag_1,S_dax__adag_2,S_dax__adag_3,S_dax__adag_4,S_dax__adag_5,E_dax__adag,ROOT_dax__job,AL_dax__job,S_dax__job,S_dax__job_1,S_dax__job_2,E_dax__job,ROOT_dax__uses,AL_dax__uses,E_dax__uses,ROOT_dax__child,AL_dax__child,S_dax__child,S_dax__child_1,S_dax__child_2,E_dax__child,ROOT_dax__parent,AL_dax__parent,E_dax__parent,PROLOG,DOCTYPE,EPILOG>{S} SKIP;
399
400  /* PROLOG: determine root element and process it. */
401
402 <PROLOG>{
403  "<?xml"({S}version{Eq}(\'{VersionNum}\'|\"{VersionNum}\"))?({S}encoding{Eq}(\'[^']*\'|\"[^"]*\"))?"?>" SET(DOCTYPE); 
404  "<?xml"[^>]*">" FAIL("Bad declaration %s.",yytext);
405 }
406
407 <PROLOG,DOCTYPE>{
408  "<!DOCTYPE"{S}"parent"{S}SYSTEM{S}("'dax.dtd'"|"\"dax.dtd\""){s}">" SET(ROOT_dax__parent);
409  "<!DOCTYPE"{S}"uses"{S}SYSTEM{S}("'dax.dtd'"|"\"dax.dtd\""){s}">" SET(ROOT_dax__uses);
410  "<!DOCTYPE"{S}"child"{S}SYSTEM{S}("'dax.dtd'"|"\"dax.dtd\""){s}">" SET(ROOT_dax__child);
411  "<!DOCTYPE"{S}"adag"{S}SYSTEM{S}("'dax.dtd'"|"\"dax.dtd\""){s}">" SET(ROOT_dax__adag);
412  "<!DOCTYPE"{S}"job"{S}SYSTEM{S}("'dax.dtd'"|"\"dax.dtd\""){s}">" SET(ROOT_dax__job);
413  "<!"[^>-][^>]*">" FAIL("Bad declaration %s.",yytext);
414  .              FAIL("Unexpected character `%c' in prolog.", yytext[0]);
415  <<EOF>>        FAIL("EOF in prolog.");
416 }
417
418  /* RULES DERIVED FROM DTD. */
419
420  /* <!-- Small DTD for DAX files. -->  */
421
422 <S_dax__child_1,S_dax__job,S_dax__adag_3,S_dax__child_2,S_dax__adag_5,S_dax__job_1,E_dax__job,E_dax__adag,S_dax__child,S_dax__adag_4,S_dax__job_2,S_dax__adag,S_dax__adag_2,S_dax__adag_1,E_dax__child>"<adag"{s} FAIL("Starting tag <adag> is not allowed here.");
423
424 <ROOT_dax__adag>"<adag"{s} {
425   AX_dax__adag_xmlns = 1;
426   AX_dax__adag_xmlns_c_xsi = 35;
427   AX_dax__adag_xmlns_c_schemaLocation = 77;
428   AX_dax__adag_version = 153;
429   AX_dax__adag_count = 0;
430   AX_dax__adag_index = 0;
431   AX_dax__adag_name = 0;
432   AX_dax__adag_jobCount = 0;
433   AX_dax__adag_fileCount = 0;
434   AX_dax__adag_childCount = 0;
435   ENTER(AL_dax__adag); pushbuffer(0);
436   }
437
438 <AL_dax__adag>{
439  "xmlns"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns);
440  "xmlns"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns);
441
442  "xmlns:xsi"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns_c_xsi);
443  "xmlns:xsi"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns_c_xsi);
444
445  "xmlns:schemaLocation"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns_c_schemaLocation);
446  "xmlns:schemaLocation"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns_c_schemaLocation);
447
448  "version"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_version);
449  "version"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_version);
450
451  "count"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_count);
452  "count"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_count);
453
454  "index"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_index);
455  "index"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_index);
456
457  "name"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_name);
458  "name"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_name);
459
460  "jobCount"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_jobCount);
461  "jobCount"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_jobCount);
462
463  "fileCount"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_fileCount);
464  "fileCount"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_fileCount);
465
466  "childCount"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__adag_childCount);
467  "childCount"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__adag_childCount);
468
469  ">" {
470   LEAVE; STag_dax__adag();dax__pcdata_ix = 0; ENTER(S_dax__adag);
471  }
472  "/>" {
473   LEAVE; STag_dax__adag(); dax__pcdata_ix = 0; ETag_dax__adag(); popbuffer(); /* attribute */
474   switch (YY_START) {
475    case ROOT_dax__adag: SET(EPILOG); break;
476   }
477  }
478  .       FAIL("Unexpected character `%c' in attribute list of adag element.", yytext[0]);
479  {Name} FAIL("Bad attribute `%s' in `adag' element start tag.",yytext);
480  <<EOF>> FAIL("EOF in attribute list of `adag' element.");
481 }
482
483 <S_dax__adag_1,S_dax__adag_5,E_dax__adag,S_dax__adag_3,S_dax__adag>{
484  "</adag"{s}">" {
485   LEAVE;
486   ETag_dax__adag();
487   popbuffer(); /* attribute */
488   switch (YY_START) {
489    case ROOT_dax__adag: SET(EPILOG); break;
490   }
491  }
492  "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</adag>' expected.",yytext);
493  .       FAIL("Unexpected character `%c': `</adag>' expected.",yytext[0]);
494  <<EOF>> FAIL("Premature EOF: `</adag>' expected.");
495 }
496
497 <S_dax__child_1,S_dax__job,S_dax__child_2,S_dax__adag_5,S_dax__job_1,E_dax__job,E_dax__adag,S_dax__child,S_dax__adag_4,S_dax__job_2,E_dax__child,S_dax__adag_1>"<job"{s} FAIL("Starting tag <job> is not allowed here.");
498
499 <ROOT_dax__job,S_dax__adag_2,S_dax__adag_3,S_dax__adag>"<job"{s} {
500   AX_dax__job_id = 0;
501   AX_dax__job_namespace = 0;
502   AX_dax__job_name = 0;
503   AX_dax__job_version = 157;
504   AX_dax__job_runtime = 0;
505   ENTER(AL_dax__job); pushbuffer(0);
506   }
507
508 <AL_dax__job>{
509  "id"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__job_id);
510  "id"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__job_id);
511
512  "namespace"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__job_namespace);
513  "namespace"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__job_namespace);
514
515  "name"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__job_name);
516  "name"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__job_name);
517
518  "version"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__job_version);
519  "version"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__job_version);
520
521  "runtime"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__job_runtime);
522  "runtime"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__job_runtime);
523
524  ">" {
525   if (!AX_dax__job_id) FAIL("Required attribute `id' not set for `job' element.");
526   if (!AX_dax__job_name) FAIL("Required attribute `name' not set for `job' element.");
527   if (!AX_dax__job_runtime) FAIL("Required attribute `runtime' not set for `job' element.");
528   LEAVE; STag_dax__job();dax__pcdata_ix = 0; ENTER(S_dax__job);
529  }
530  "/>" {
531   if (!AX_dax__job_id) FAIL("Required attribute `id' not set for `job' element.");
532   if (!AX_dax__job_name) FAIL("Required attribute `name' not set for `job' element.");
533   if (!AX_dax__job_runtime) FAIL("Required attribute `runtime' not set for `job' element.");
534   LEAVE; STag_dax__job(); dax__pcdata_ix = 0; ETag_dax__job(); popbuffer(); /* attribute */
535   switch (YY_START) {
536    case S_dax__adag_2: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_3); break;
537    case ROOT_dax__job: SET(EPILOG); break;
538   }
539  }
540  .       FAIL("Unexpected character `%c' in attribute list of job element.", yytext[0]);
541  {Name} FAIL("Bad attribute `%s' in `job' element start tag.",yytext);
542  <<EOF>> FAIL("EOF in attribute list of `job' element.");
543 }
544
545 <S_dax__job,E_dax__job,S_dax__job_2>{
546  "</job"{s}">" {
547   LEAVE;
548   ETag_dax__job();
549   popbuffer(); /* attribute */
550   switch (YY_START) {
551    case S_dax__adag_2: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_3); break;
552    case ROOT_dax__job: SET(EPILOG); break;
553   }
554  }
555  "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</job>' expected.",yytext);
556  .       FAIL("Unexpected character `%c': `</job>' expected.",yytext[0]);
557  <<EOF>> FAIL("Premature EOF: `</job>' expected.");
558 }
559
560 <S_dax__child_1,S_dax__adag_3,S_dax__child_2,S_dax__adag_5,E_dax__job,E_dax__adag,S_dax__child,S_dax__adag_4,S_dax__adag,S_dax__adag_2,E_dax__child,S_dax__adag_1>"<uses"{s} FAIL("Starting tag <uses> is not allowed here.");
561
562 <ROOT_dax__uses,S_dax__job,S_dax__job_2,S_dax__job_1>"<uses"{s} {
563   AX_dax__uses_file = 0;
564   AX_dax__uses_link = AU_dax__uses_link;
565   AX_dax__uses_register = A_dax__uses_register_true;
566   AX_dax__uses_transfer = A_dax__uses_transfer_true;
567   AX_dax__uses_optional = A_dax__uses_optional_false;
568   AX_dax__uses_type = 161;
569   AX_dax__uses_size = 0;
570   ENTER(AL_dax__uses); pushbuffer(0);
571   }
572
573 <AL_dax__uses>{
574  "file"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__uses_file);
575  "file"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__uses_file);
576
577  "link"{Eq}"'input'" |
578  "link"{Eq}"\"input\"" A_dax__uses_link = A_dax__uses_link_input;
579  "link"{Eq}"'output'" |
580  "link"{Eq}"\"output\"" A_dax__uses_link = A_dax__uses_link_output;
581
582  "register"{Eq}"'false'" |
583  "register"{Eq}"\"false\"" A_dax__uses_register = A_dax__uses_register_false;
584  "register"{Eq}"'true'" |
585  "register"{Eq}"\"true\"" A_dax__uses_register = A_dax__uses_register_true;
586
587  "transfer"{Eq}"'false'" |
588  "transfer"{Eq}"\"false\"" A_dax__uses_transfer = A_dax__uses_transfer_false;
589  "transfer"{Eq}"'true'" |
590  "transfer"{Eq}"\"true\"" A_dax__uses_transfer = A_dax__uses_transfer_true;
591
592  "optional"{Eq}"'false'" |
593  "optional"{Eq}"\"false\"" A_dax__uses_optional = A_dax__uses_optional_false;
594  "optional"{Eq}"'true'" |
595  "optional"{Eq}"\"true\"" A_dax__uses_optional = A_dax__uses_optional_true;
596
597  "type"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__uses_type);
598  "type"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__uses_type);
599
600  "size"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__uses_size);
601  "size"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__uses_size);
602
603  ">" {
604   if (!AX_dax__uses_file) FAIL("Required attribute `file' not set for `uses' element.");
605   if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element.");
606   LEAVE; STag_dax__uses();dax__pcdata_ix = 0; ENTER(E_dax__uses);
607  }
608  "/>" {
609   if (!AX_dax__uses_file) FAIL("Required attribute `file' not set for `uses' element.");
610   if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element.");
611   LEAVE; STag_dax__uses(); dax__pcdata_ix = 0; ETag_dax__uses(); popbuffer(); /* attribute */
612   switch (YY_START) {
613    case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break;
614    case ROOT_dax__uses: SET(EPILOG); break;
615   }
616  }
617  .       FAIL("Unexpected character `%c' in attribute list of uses element.", yytext[0]);
618  {Name} FAIL("Bad attribute `%s' in `uses' element start tag.",yytext);
619  <<EOF>> FAIL("EOF in attribute list of `uses' element.");
620 }
621
622 <E_dax__uses>{
623  "</uses"{s}">" {
624   LEAVE;
625   ETag_dax__uses();
626   popbuffer(); /* attribute */
627   switch (YY_START) {
628    case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break;
629    case ROOT_dax__uses: SET(EPILOG); break;
630   }
631  }
632  "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</uses>' expected.",yytext);
633  .       FAIL("Unexpected character `%c': `</uses>' expected.",yytext[0]);
634  <<EOF>> FAIL("Premature EOF: `</uses>' expected.");
635 }
636
637 <S_dax__child_1,S_dax__job,S_dax__child_2,S_dax__job_1,E_dax__job,E_dax__adag,S_dax__child,S_dax__job_2,S_dax__adag_2,E_dax__child>"<child"{s} FAIL("Starting tag <child> is not allowed here.");
638
639 <ROOT_dax__child,S_dax__adag_1,S_dax__adag_4,S_dax__adag_5,S_dax__adag_3,S_dax__adag>"<child"{s} {
640   AX_dax__child_ref = 0;
641   ENTER(AL_dax__child); pushbuffer(0);
642   }
643
644 <AL_dax__child>{
645  "ref"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__child_ref);
646  "ref"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__child_ref);
647
648  ">" {
649   if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element.");
650   LEAVE; STag_dax__child();dax__pcdata_ix = 0; ENTER(S_dax__child);
651  }
652  "/>" {
653   if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element.");
654   LEAVE; STag_dax__child(); dax__pcdata_ix = 0; ETag_dax__child(); popbuffer(); /* attribute */
655   switch (YY_START) {
656    case S_dax__adag_1: case S_dax__adag_4: case S_dax__adag_5: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_5); break;
657    case ROOT_dax__child: SET(EPILOG); break;
658   }
659  }
660  .       FAIL("Unexpected character `%c' in attribute list of child element.", yytext[0]);
661  {Name} FAIL("Bad attribute `%s' in `child' element start tag.",yytext);
662  <<EOF>> FAIL("EOF in attribute list of `child' element.");
663 }
664
665 <S_dax__child_2,E_dax__child,S_dax__child>{
666  "</child"{s}">" {
667   LEAVE;
668   ETag_dax__child();
669   popbuffer(); /* attribute */
670   switch (YY_START) {
671    case S_dax__adag_1: case S_dax__adag_4: case S_dax__adag_5: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_5); break;
672    case ROOT_dax__child: SET(EPILOG); break;
673   }
674  }
675  "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</child>' expected.",yytext);
676  .       FAIL("Unexpected character `%c': `</child>' expected.",yytext[0]);
677  <<EOF>> FAIL("Premature EOF: `</child>' expected.");
678 }
679
680 <S_dax__job,S_dax__adag_3,S_dax__adag_5,S_dax__job_1,E_dax__job,E_dax__adag,S_dax__adag_4,S_dax__job_2,S_dax__adag,S_dax__adag_2,E_dax__child,S_dax__adag_1>"<parent"{s} FAIL("Starting tag <parent> is not allowed here.");
681
682 <ROOT_dax__parent,S_dax__child_2,S_dax__child,S_dax__child_1>"<parent"{s} {
683   AX_dax__parent_ref = 0;
684   ENTER(AL_dax__parent); pushbuffer(0);
685   }
686
687 <AL_dax__parent>{
688  "ref"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_dax__parent_ref);
689  "ref"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_dax__parent_ref);
690
691  ">" {
692   if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element.");
693   LEAVE; STag_dax__parent();dax__pcdata_ix = 0; ENTER(E_dax__parent);
694  }
695  "/>" {
696   if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element.");
697   LEAVE; STag_dax__parent(); dax__pcdata_ix = 0; ETag_dax__parent(); popbuffer(); /* attribute */
698   switch (YY_START) {
699    case ROOT_dax__parent: SET(EPILOG); break;
700    case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break;
701   }
702  }
703  .       FAIL("Unexpected character `%c' in attribute list of parent element.", yytext[0]);
704  {Name} FAIL("Bad attribute `%s' in `parent' element start tag.",yytext);
705  <<EOF>> FAIL("EOF in attribute list of `parent' element.");
706 }
707
708 <E_dax__parent>{
709  "</parent"{s}">" {
710   LEAVE;
711   ETag_dax__parent();
712   popbuffer(); /* attribute */
713   switch (YY_START) {
714    case ROOT_dax__parent: SET(EPILOG); break;
715    case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break;
716   }
717  }
718  "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</parent>' expected.",yytext);
719  .       FAIL("Unexpected character `%c': `</parent>' expected.",yytext[0]);
720  <<EOF>> FAIL("Premature EOF: `</parent>' expected.");
721 }
722
723  /* EPILOG: after the root element. */
724
725 <EPILOG>{
726  . {SET(PROLOG); yyless(0); CLEANUP; return -1;}
727  <<EOF>>        SUCCEED;
728 }
729
730  /* CHARACTER DATA. */
731
732 <IMPOSSIBLE,VALUE1,VALUE2>{
733  /* Non-defined standard entities... */
734 "&amp;"  BUFFERPUTC('&');
735 "&lt;"   BUFFERPUTC('<');
736 "&gt;"   BUFFERPUTC('>');
737 "&apos;" BUFFERPUTC('\'');
738 "&quot;" BUFFERPUTC('"');
739
740  /* Character entities. */
741  "&#"[[:digit:]]+";"    BUFFERPUTC((unsigned char)atoi(yytext+2));
742  "&#x"[[:xdigit:]]+";"  BUFFERPUTC((unsigned char)strtol(yytext+3,NULL,16));
743 }
744
745 <IMPOSSIBLE,VALUE1,VALUE2,CDATA>{
746  "\n"           |
747  "\r"           |
748  "\r\n"         |
749  "\n\r"         BUFFERPUTC('\n');
750 }
751
752 <IMPOSSIBLE>{
753  "<![CDATA["    ENTER(CDATA);
754  "]""]>"                FAIL("Unexpected `]""]>' in character data.");
755 }
756
757 <VALUE1>{
758  \'             BUFFERDONE; LEAVE;
759  <<EOF>>        FAIL("EOF in literal (\"'\" expected).");
760 }
761
762 <VALUE2>{
763  \"             BUFFERDONE; LEAVE;
764  <<EOF>>        FAIL("EOF in literal (`\"' expected).");
765 }
766
767 <IMPOSSIBLE,VALUE1,VALUE2>{
768  [^<&]          BUFFERPUTC(yytext[0]);
769  [<&]           FAIL("Spurious `%c' in character data.",yytext[0]);
770 }
771
772 <CDATA>{
773  "]""]>"                LEAVE;
774  /* "]""]"              BUFFERPUTC(yytext[0]); BUFFERPUTC(yytext[1]); */
775  .              BUFFERPUTC(yytext[0]);
776  <<EOF>>        FAIL("EOF in CDATA section.");
777 }
778
779  /* Impossible rules to avoid warnings from flex(1). */
780  /* Ideally, this should be replaced by code in flexml.pl that
781     generates just the states not covered by other rules. */
782 <*>{
783  .|[\n] FAIL("Syntax error on character `%c'.", yytext[0]);
784 }
785
786 %%
787
788 /* Element context stack lookup. */
789 int dax__element_context(int i)
790 {
791   return (0<i && i<yy_start_stack_depth
792           ? yy_start_stack[yy_start_stack_ptr - i]
793           : 0);
794 }
795
796 #ifdef FLEX_DEBUG
797 void print_yy_stack(char* fmt, ...)
798 {
799   int i = 0; va_list ap; va_start(ap, fmt);
800   vfprintf(stderr, fmt, ap);
801   if (dax__statenames) {
802       for (i=1; i<yy_start_stack_ptr; i++) {
803           fprintf(stderr, "%s/", dax__statenames[yy_start_stack[i] ]);
804       }
805       fprintf(stderr,"%s\n", dax__statenames[YY_START]);
806   }
807   va_end(ap);
808 }
809
810 void print_dax__bufferstack()
811 {
812     int i;
813     fputs("Buffer: ", stderr);
814     for (i = 0; i < blimit; i++) {
815        if ( dax__bufferstack[i] == '\377' ) break;
816          putc(dax__bufferstack[i], stderr);
817     }
818     putc('\n', stderr);
819 }
820
821 static void debug_enter(int state, const char* statename) {
822   yy_push_state(state);
823   if (yy_flex_debug) {
824        print_yy_stack("--ENTER(%s) : ",statename);
825        print_dax__bufferstack();
826   }
827 }
828
829 static void debug_leave(void) {
830     if (yy_flex_debug) {
831         print_yy_stack("--LEAVE : ");
832         print_dax__bufferstack();
833     }
834   yy_pop_state();
835 }
836
837 static void debug_set(int state, const char* statename) {
838   BEGIN(state);
839   if (yy_flex_debug) print_yy_stack("--SET(%s) : ",statename);
840 }
841 #endif
842
843
844 static void cleanup(void)
845 {
846     if (dax__statenames) {
847         free(dax__statenames);
848         dax__statenames = NULL;
849     }
850     free(dax__bufferstack);
851     dax__bufferstack = NULL;
852
853     free(indexstack);
854     indexstack = NULL;
855 }
856
857
858 static int fail(const char* fmt, ...)
859 {
860     int chars_left, used;
861     va_list ap; va_start(ap, fmt);
862 #ifdef FLEXML_yylineno
863     used = sprintf(flexml_err_msg,
864                    "Invalid XML (XML input line %d, state %d): ",
865                    yylineno, YY_START);
866 #else
867     used = sprintf(flexml_err_msg,
868                    "Invalid XML (state %d): ",
869                    YY_START);
870 #endif
871     chars_left = flexml_max_err_msg_size - used - 1;
872     vsnprintf(flexml_err_msg + used, chars_left, fmt, ap);
873     va_end(ap);
874
875 #ifndef FLEXML_quiet_parser
876     /* print directly to sdterr */
877     fprintf(stderr, "%s\n", flexml_err_msg);
878     flexml_err_msg[0] = '\0';
879 #endif
880
881     cleanup();
882
883     return 1;
884 }