src/simdag/dax_dtd.l

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