X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c1781804f5ce17958fcede075ab7dc1bd1e29f8b..e0d012a5fe6be526b6062eb17bbe23cc71771f84:/src/simdag/dax_dtd.c diff --git a/src/simdag/dax_dtd.c b/src/simdag/dax_dtd.c index 94df9368b5..83641a2099 100644 --- a/src/simdag/dax_dtd.c +++ b/src/simdag/dax_dtd.c @@ -27,7 +27,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 35 +#define YY_FLEX_SUBMINOR_VERSION 39 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -180,7 +180,12 @@ typedef unsigned int flex_uint32_t; typedef struct yy_buffer_state *YY_BUFFER_STATE; #endif -extern int dax_leng; +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern yy_size_t dax_leng; extern FILE *dax_in, *dax_out; @@ -202,6 +207,13 @@ extern FILE *dax_in, *dax_out; if ( dax_text[yyl] == '\n' )\ --dax_lineno;\ }while(0) + #define YY_LINENO_REWIND_TO(dst) \ + do {\ + const char *p;\ + for ( p = yy_cp-1; p >= (dst); --p)\ + if ( *p == '\n' )\ + --dax_lineno;\ + }while(0) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ @@ -219,11 +231,6 @@ extern FILE *dax_in, *dax_out; #define unput(c) yyunput( c, (yytext_ptr) ) -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state @@ -241,7 +248,7 @@ struct yy_buffer_state /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - int yy_n_chars; + yy_size_t yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -311,8 +318,8 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ /* yy_hold_char holds the character lost when dax_text is formed. */ static char yy_hold_char; -static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int dax_leng; +static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ +yy_size_t dax_leng; /* Points to current character in buffer. */ static char *yy_c_buf_p = (char *) 0; @@ -340,7 +347,7 @@ static void dax__init_buffer (YY_BUFFER_STATE b,FILE *file ); YY_BUFFER_STATE dax__scan_buffer (char *base,yy_size_t size ); YY_BUFFER_STATE dax__scan_string (yyconst char *yy_str ); -YY_BUFFER_STATE dax__scan_bytes (yyconst char *bytes,int len ); +YY_BUFFER_STATE dax__scan_bytes (yyconst char *bytes,yy_size_t len ); void *dax_alloc (yy_size_t ); void *dax_realloc (void *,yy_size_t ); @@ -372,7 +379,7 @@ void dax_free (void * ); /* Begin user sect3 */ -#define dax_wrap(n) 1 +#define dax_wrap() 1 #define YY_SKIP_YYWRAP typedef unsigned char YY_CHAR; @@ -1259,8 +1266,8 @@ char *dax_text; * * This program was generated with the FleXML XML processor generator. * FleXML is Copyright (C) 1999-2005 Kristoffer Rose. All rights reserved. - * FleXML is Copyright (C) 2003-2006 Martin Quinson. All rights reserved. - * (Id: flexml.pl,v 1.62 2007/10/11 10:00:14 mquinson Exp). + * FleXML is Copyright (C) 2003-2013 Martin Quinson. All rights reserved. + * (1.9.6). * * There are two, intertwined parts to this program, part A and part B. * @@ -1269,7 +1276,7 @@ char *dax_text; * * Some parts, here collectively called "Part A", are found in the * FleXML package. They are Copyright (C) 1999-2005 Kristoffer Rose - * and Copyright (C) 2003-2006 Martin Quinson. All rights reserved. + * and Copyright (C) 2003-2013 Martin Quinson. All rights reserved. * * You can redistribute, use, perform, display and/or modify "Part A" * provided the following two conditions hold: @@ -1302,10 +1309,7 @@ char *dax_text; */ /* Version strings. */ -const char rcs_dax__flexml_skeleton[] = - "$" "Id: skel,v 1.40 2007/10/11 09:57:24 mquinson Exp $"; -const char rcs_dax__flexml[] = - "$" "Id: flexml.pl,v 1.62 2007/10/11 10:00:14 mquinson Exp $"; +const char dax__flexml_version[] = "1.9.6"; /* ANSI headers. */ #include /* for realloc() -- needed here when using flex 2.5.4 */ @@ -1340,56 +1344,81 @@ const char rcs_dax__flexml[] = int dax__pcdata_ix; extern char *dax__bufferstack; #define dax__pcdata (dax__bufferstack + dax__pcdata_ix) -AT_dax__adag_version AX_dax__adag_version; -#define A_dax__adag_version (dax__bufferstack + AX_dax__adag_version) -AT_dax__uses_type AX_dax__uses_type; -#define A_dax__uses_type (dax__bufferstack + AX_dax__uses_type) AT_dax__uses_optional AX_dax__uses_optional; #define A_dax__uses_optional AX_dax__uses_optional -AT_dax__adag_name AX_dax__adag_name; -#define A_dax__adag_name (dax__bufferstack + AX_dax__adag_name) -AT_dax__child_ref AX_dax__child_ref; -#define A_dax__child_ref (dax__bufferstack + AX_dax__child_ref) -AT_dax__adag_xmlns AX_dax__adag_xmlns; -#define A_dax__adag_xmlns (dax__bufferstack + AX_dax__adag_xmlns) -AT_dax__uses_transfer AX_dax__uses_transfer; -#define A_dax__uses_transfer AX_dax__uses_transfer -AT_dax__job_id AX_dax__job_id; -#define A_dax__job_id (dax__bufferstack + AX_dax__job_id) -AT_dax__uses_file AX_dax__uses_file; -#define A_dax__uses_file (dax__bufferstack + AX_dax__uses_file) +short int dax__uses_optional_isset; +AT_dax__job_name AX_dax__job_name; +#define A_dax__job_name (dax__bufferstack + AX_dax__job_name) +short int dax__job_name_isset; +AT_dax__job_namespace AX_dax__job_namespace; +#define A_dax__job_namespace (dax__bufferstack + AX_dax__job_namespace) +short int dax__job_namespace_isset; +AT_dax__adag_fileCount AX_dax__adag_fileCount; +#define A_dax__adag_fileCount (dax__bufferstack + AX_dax__adag_fileCount) +short int dax__adag_fileCount_isset; AT_dax__parent_ref AX_dax__parent_ref; #define A_dax__parent_ref (dax__bufferstack + AX_dax__parent_ref) -AT_dax__adag_count AX_dax__adag_count; -#define A_dax__adag_count (dax__bufferstack + AX_dax__adag_count) -AT_dax__adag_xmlns_c_xsi AX_dax__adag_xmlns_c_xsi; -#define A_dax__adag_xmlns_c_xsi (dax__bufferstack + AX_dax__adag_xmlns_c_xsi) -AT_dax__adag_index AX_dax__adag_index; -#define A_dax__adag_index (dax__bufferstack + AX_dax__adag_index) -AT_dax__uses_size AX_dax__uses_size; -#define A_dax__uses_size (dax__bufferstack + AX_dax__uses_size) +short int dax__parent_ref_isset; +AT_dax__uses_transfer AX_dax__uses_transfer; +#define A_dax__uses_transfer AX_dax__uses_transfer +short int dax__uses_transfer_isset; AT_dax__adag_childCount AX_dax__adag_childCount; #define A_dax__adag_childCount (dax__bufferstack + AX_dax__adag_childCount) +short int dax__adag_childCount_isset; AT_dax__uses_link AX_dax__uses_link; #define A_dax__uses_link AX_dax__uses_link -AT_dax__job_runtime AX_dax__job_runtime; -#define A_dax__job_runtime (dax__bufferstack + AX_dax__job_runtime) +short int dax__uses_link_isset; +AT_dax__adag_xmlns_c_xsi AX_dax__adag_xmlns_c_xsi; +#define A_dax__adag_xmlns_c_xsi (dax__bufferstack + AX_dax__adag_xmlns_c_xsi) +short int dax__adag_xmlns_c_xsi_isset; +AT_dax__job_id AX_dax__job_id; +#define A_dax__job_id (dax__bufferstack + AX_dax__job_id) +short int dax__job_id_isset; AT_dax__job_level AX_dax__job_level; #define A_dax__job_level (dax__bufferstack + AX_dax__job_level) -AT_dax__job_namespace AX_dax__job_namespace; -#define A_dax__job_namespace (dax__bufferstack + AX_dax__job_namespace) -AT_dax__job_name AX_dax__job_name; -#define A_dax__job_name (dax__bufferstack + AX_dax__job_name) +short int dax__job_level_isset; +AT_dax__job_runtime AX_dax__job_runtime; +#define A_dax__job_runtime (dax__bufferstack + AX_dax__job_runtime) +short int dax__job_runtime_isset; +AT_dax__uses_size AX_dax__uses_size; +#define A_dax__uses_size (dax__bufferstack + AX_dax__uses_size) +short int dax__uses_size_isset; +AT_dax__child_ref AX_dax__child_ref; +#define A_dax__child_ref (dax__bufferstack + AX_dax__child_ref) +short int dax__child_ref_isset; +AT_dax__adag_index AX_dax__adag_index; +#define A_dax__adag_index (dax__bufferstack + AX_dax__adag_index) +short int dax__adag_index_isset; +AT_dax__adag_count AX_dax__adag_count; +#define A_dax__adag_count (dax__bufferstack + AX_dax__adag_count) +short int dax__adag_count_isset; +AT_dax__uses_register AX_dax__uses_register; +#define A_dax__uses_register AX_dax__uses_register +short int dax__uses_register_isset; AT_dax__adag_jobCount AX_dax__adag_jobCount; #define A_dax__adag_jobCount (dax__bufferstack + AX_dax__adag_jobCount) +short int dax__adag_jobCount_isset; +AT_dax__uses_file AX_dax__uses_file; +#define A_dax__uses_file (dax__bufferstack + AX_dax__uses_file) +short int dax__uses_file_isset; AT_dax__job_version AX_dax__job_version; #define A_dax__job_version (dax__bufferstack + AX_dax__job_version) +short int dax__job_version_isset; +AT_dax__adag_xmlns AX_dax__adag_xmlns; +#define A_dax__adag_xmlns (dax__bufferstack + AX_dax__adag_xmlns) +short int dax__adag_xmlns_isset; AT_dax__adag_xsi_c_schemaLocation AX_dax__adag_xsi_c_schemaLocation; #define A_dax__adag_xsi_c_schemaLocation (dax__bufferstack + AX_dax__adag_xsi_c_schemaLocation) -AT_dax__uses_register AX_dax__uses_register; -#define A_dax__uses_register AX_dax__uses_register -AT_dax__adag_fileCount AX_dax__adag_fileCount; -#define A_dax__adag_fileCount (dax__bufferstack + AX_dax__adag_fileCount) +short int dax__adag_xsi_c_schemaLocation_isset; +AT_dax__adag_name AX_dax__adag_name; +#define A_dax__adag_name (dax__bufferstack + AX_dax__adag_name) +short int dax__adag_name_isset; +AT_dax__uses_type AX_dax__uses_type; +#define A_dax__uses_type (dax__bufferstack + AX_dax__uses_type) +short int dax__uses_type_isset; +AT_dax__adag_version AX_dax__adag_version; +#define A_dax__adag_version (dax__bufferstack + AX_dax__adag_version) +short int dax__adag_version_isset; /* XML state. */ #ifdef FLEX_DEBUG @@ -1473,13 +1502,24 @@ static int ck_ilimit() #ifdef FLEXML_NEED_BUFFERLIT static void dax__bufferliteral(char c, int* pp, const char* text) { - const char *s = (c ? strchr(text,c) : text-1), *e = strrchr(text,c); - assert(s <= e); BUFFERSET(*pp); - while (++s");} dax__adag_xmlns_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns); YY_BREAK case 19: /* rule 19 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns); +if (dax__adag_xmlns_isset != 0) {FAIL("Multiple definition of attribute xmlns in ");} dax__adag_xmlns_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns); YY_BREAK case 20: /* rule 20 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns_c_xsi); +if (dax__adag_xmlns_c_xsi_isset != 0) {FAIL("Multiple definition of attribute xmlns:xsi in ");} dax__adag_xmlns_c_xsi_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns_c_xsi); YY_BREAK case 21: /* rule 21 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns_c_xsi); +if (dax__adag_xmlns_c_xsi_isset != 0) {FAIL("Multiple definition of attribute xmlns:xsi in ");} dax__adag_xmlns_c_xsi_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns_c_xsi); YY_BREAK case 22: /* rule 22 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation); +if (dax__adag_xsi_c_schemaLocation_isset != 0) {FAIL("Multiple definition of attribute xsi:schemaLocation in ");} dax__adag_xsi_c_schemaLocation_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation); YY_BREAK case 23: /* rule 23 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation); +if (dax__adag_xsi_c_schemaLocation_isset != 0) {FAIL("Multiple definition of attribute xsi:schemaLocation in ");} dax__adag_xsi_c_schemaLocation_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation); YY_BREAK case 24: /* rule 24 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_version); +if (dax__adag_version_isset != 0) {FAIL("Multiple definition of attribute version in ");} dax__adag_version_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_version); YY_BREAK case 25: /* rule 25 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_version); +if (dax__adag_version_isset != 0) {FAIL("Multiple definition of attribute version in ");} dax__adag_version_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_version); YY_BREAK case 26: /* rule 26 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_count); +if (dax__adag_count_isset != 0) {FAIL("Multiple definition of attribute count in ");} dax__adag_count_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_count); YY_BREAK case 27: /* rule 27 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_count); +if (dax__adag_count_isset != 0) {FAIL("Multiple definition of attribute count in ");} dax__adag_count_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_count); YY_BREAK case 28: /* rule 28 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_index); +if (dax__adag_index_isset != 0) {FAIL("Multiple definition of attribute index in ");} dax__adag_index_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_index); YY_BREAK case 29: /* rule 29 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_index); +if (dax__adag_index_isset != 0) {FAIL("Multiple definition of attribute index in ");} dax__adag_index_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_index); YY_BREAK case 30: /* rule 30 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_name); +if (dax__adag_name_isset != 0) {FAIL("Multiple definition of attribute name in ");} dax__adag_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_name); YY_BREAK case 31: /* rule 31 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_name); +if (dax__adag_name_isset != 0) {FAIL("Multiple definition of attribute name in ");} dax__adag_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_name); YY_BREAK case 32: /* rule 32 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_jobCount); +if (dax__adag_jobCount_isset != 0) {FAIL("Multiple definition of attribute jobCount in ");} dax__adag_jobCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_jobCount); YY_BREAK case 33: /* rule 33 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_jobCount); +if (dax__adag_jobCount_isset != 0) {FAIL("Multiple definition of attribute jobCount in ");} dax__adag_jobCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_jobCount); YY_BREAK case 34: /* rule 34 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_fileCount); +if (dax__adag_fileCount_isset != 0) {FAIL("Multiple definition of attribute fileCount in ");} dax__adag_fileCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_fileCount); YY_BREAK case 35: /* rule 35 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_fileCount); +if (dax__adag_fileCount_isset != 0) {FAIL("Multiple definition of attribute fileCount in ");} dax__adag_fileCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_fileCount); YY_BREAK case 36: /* rule 36 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__adag_childCount); +if (dax__adag_childCount_isset != 0) {FAIL("Multiple definition of attribute childCount in ");} dax__adag_childCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_childCount); YY_BREAK case 37: /* rule 37 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__adag_childCount); +if (dax__adag_childCount_isset != 0) {FAIL("Multiple definition of attribute childCount in ");} dax__adag_childCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_childCount); YY_BREAK case 38: YY_RULE_SETUP @@ -2160,11 +2212,11 @@ case 44: YY_RULE_SETUP FAIL("Unexpected character `%c': `' expected.",dax_text[0]); YY_BREAK -case YY_STATE_EOF(S_dax__adag_1): case YY_STATE_EOF(S_dax__adag_5): -case YY_STATE_EOF(E_dax__adag): -case YY_STATE_EOF(S_dax__adag_3): case YY_STATE_EOF(S_dax__adag): +case YY_STATE_EOF(S_dax__adag_3): +case YY_STATE_EOF(E_dax__adag): +case YY_STATE_EOF(S_dax__adag_1): FAIL("Premature EOF: `' expected."); YY_BREAK @@ -2178,11 +2230,17 @@ case 46: YY_RULE_SETUP { AX_dax__job_id = 0; + dax__job_id_isset = 0; AX_dax__job_namespace = 0; + dax__job_namespace_isset = 0; AX_dax__job_name = 0; + dax__job_name_isset = 0; AX_dax__job_version = 157; + dax__job_version_isset = 0; AX_dax__job_runtime = 0; + dax__job_runtime_isset = 0; AX_dax__job_level = 0; + dax__job_level_isset = 0; ENTER(AL_dax__job); pushbuffer(0); } YY_BREAK @@ -2190,62 +2248,62 @@ YY_RULE_SETUP case 47: /* rule 47 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__job_id); +if (dax__job_id_isset != 0) {FAIL("Multiple definition of attribute id in ");} dax__job_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_id); YY_BREAK case 48: /* rule 48 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__job_id); +if (dax__job_id_isset != 0) {FAIL("Multiple definition of attribute id in ");} dax__job_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_id); YY_BREAK case 49: /* rule 49 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__job_namespace); +if (dax__job_namespace_isset != 0) {FAIL("Multiple definition of attribute namespace in ");} dax__job_namespace_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_namespace); YY_BREAK case 50: /* rule 50 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__job_namespace); +if (dax__job_namespace_isset != 0) {FAIL("Multiple definition of attribute namespace in ");} dax__job_namespace_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_namespace); YY_BREAK case 51: /* rule 51 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__job_name); +if (dax__job_name_isset != 0) {FAIL("Multiple definition of attribute name in ");} dax__job_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_name); YY_BREAK case 52: /* rule 52 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__job_name); +if (dax__job_name_isset != 0) {FAIL("Multiple definition of attribute name in ");} dax__job_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_name); YY_BREAK case 53: /* rule 53 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__job_version); +if (dax__job_version_isset != 0) {FAIL("Multiple definition of attribute version in ");} dax__job_version_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_version); YY_BREAK case 54: /* rule 54 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__job_version); +if (dax__job_version_isset != 0) {FAIL("Multiple definition of attribute version in ");} dax__job_version_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_version); YY_BREAK case 55: /* rule 55 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__job_runtime); +if (dax__job_runtime_isset != 0) {FAIL("Multiple definition of attribute runtime in ");} dax__job_runtime_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_runtime); YY_BREAK case 56: /* rule 56 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__job_runtime); +if (dax__job_runtime_isset != 0) {FAIL("Multiple definition of attribute runtime in ");} dax__job_runtime_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_runtime); YY_BREAK case 57: /* rule 57 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__job_level); +if (dax__job_level_isset != 0) {FAIL("Multiple definition of attribute level in ");} dax__job_level_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_level); YY_BREAK case 58: /* rule 58 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__job_level); +if (dax__job_level_isset != 0) {FAIL("Multiple definition of attribute level in ");} dax__job_level_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_level); YY_BREAK case 59: YY_RULE_SETUP @@ -2301,9 +2359,9 @@ case 65: YY_RULE_SETUP FAIL("Unexpected character `%c': `' expected.",dax_text[0]); YY_BREAK -case YY_STATE_EOF(S_dax__job): -case YY_STATE_EOF(E_dax__job): case YY_STATE_EOF(S_dax__job_2): +case YY_STATE_EOF(E_dax__job): +case YY_STATE_EOF(S_dax__job): FAIL("Premature EOF: `' expected."); YY_BREAK @@ -2319,12 +2377,19 @@ case 67: YY_RULE_SETUP { AX_dax__uses_file = 0; + dax__uses_file_isset = 0; AX_dax__uses_link = AU_dax__uses_link; + dax__uses_link_isset = 0; AX_dax__uses_register = A_dax__uses_register_true; + dax__uses_register_isset = 0; AX_dax__uses_transfer = A_dax__uses_transfer_true; + dax__uses_transfer_isset = 0; AX_dax__uses_optional = A_dax__uses_optional_false; + dax__uses_optional_isset = 0; AX_dax__uses_type = 161; + dax__uses_type_isset = 0; AX_dax__uses_size = 0; + dax__uses_size_isset = 0; ENTER(AL_dax__uses); pushbuffer(0); } YY_BREAK @@ -2332,12 +2397,12 @@ YY_RULE_SETUP case 68: /* rule 68 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__uses_file); +if (dax__uses_file_isset != 0) {FAIL("Multiple definition of attribute file in ");} dax__uses_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_file); YY_BREAK case 69: /* rule 69 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__uses_file); +if (dax__uses_file_isset != 0) {FAIL("Multiple definition of attribute file in ");} dax__uses_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_file); YY_BREAK case 70: /* rule 70 can match eol */ @@ -2398,22 +2463,22 @@ A_dax__uses_optional = A_dax__uses_optional_true; case 86: /* rule 86 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__uses_type); +if (dax__uses_type_isset != 0) {FAIL("Multiple definition of attribute type in ");} dax__uses_type_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_type); YY_BREAK case 87: /* rule 87 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__uses_type); +if (dax__uses_type_isset != 0) {FAIL("Multiple definition of attribute type in ");} dax__uses_type_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_type); YY_BREAK case 88: /* rule 88 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__uses_size); +if (dax__uses_size_isset != 0) {FAIL("Multiple definition of attribute size in ");} dax__uses_size_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_size); YY_BREAK case 89: /* rule 89 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__uses_size); +if (dax__uses_size_isset != 0) {FAIL("Multiple definition of attribute size in ");} dax__uses_size_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_size); YY_BREAK case 90: YY_RULE_SETUP @@ -2430,7 +2495,7 @@ YY_RULE_SETUP if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element."); LEAVE; STag_dax__uses(); dax__pcdata_ix = 0; ETag_dax__uses(); popbuffer(); /* attribute */ switch (YY_START) { - case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break; + case S_dax__job_1: case S_dax__job: case S_dax__job_2: SET(S_dax__job_2); break; } } YY_BREAK @@ -2454,7 +2519,7 @@ YY_RULE_SETUP ETag_dax__uses(); popbuffer(); /* attribute */ switch (YY_START) { - case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break; + case S_dax__job_1: case S_dax__job: case S_dax__job_2: SET(S_dax__job_2); break; } } YY_BREAK @@ -2481,6 +2546,7 @@ case 98: YY_RULE_SETUP { AX_dax__child_ref = 0; + dax__child_ref_isset = 0; ENTER(AL_dax__child); pushbuffer(0); } YY_BREAK @@ -2488,12 +2554,12 @@ YY_RULE_SETUP case 99: /* rule 99 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__child_ref); +if (dax__child_ref_isset != 0) {FAIL("Multiple definition of attribute ref in ");} dax__child_ref_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__child_ref); YY_BREAK case 100: /* rule 100 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__child_ref); +if (dax__child_ref_isset != 0) {FAIL("Multiple definition of attribute ref in ");} dax__child_ref_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__child_ref); YY_BREAK case 101: YY_RULE_SETUP @@ -2508,7 +2574,7 @@ YY_RULE_SETUP if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element."); LEAVE; STag_dax__child(); dax__pcdata_ix = 0; ETag_dax__child(); popbuffer(); /* attribute */ switch (YY_START) { - 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; + case S_dax__adag: case S_dax__adag_5: case S_dax__adag_4: case S_dax__adag_1: case S_dax__adag_3: SET(S_dax__adag_5); break; } } YY_BREAK @@ -2532,7 +2598,7 @@ YY_RULE_SETUP ETag_dax__child(); popbuffer(); /* attribute */ switch (YY_START) { - 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; + case S_dax__adag: case S_dax__adag_5: case S_dax__adag_4: case S_dax__adag_1: case S_dax__adag_3: SET(S_dax__adag_5); break; } } YY_BREAK @@ -2545,8 +2611,8 @@ case 107: YY_RULE_SETUP FAIL("Unexpected character `%c': `' expected.",dax_text[0]); YY_BREAK -case YY_STATE_EOF(S_dax__child_2): case YY_STATE_EOF(E_dax__child): +case YY_STATE_EOF(S_dax__child_2): case YY_STATE_EOF(S_dax__child): FAIL("Premature EOF: `' expected."); YY_BREAK @@ -2561,6 +2627,7 @@ case 109: YY_RULE_SETUP { AX_dax__parent_ref = 0; + dax__parent_ref_isset = 0; ENTER(AL_dax__parent); pushbuffer(0); } YY_BREAK @@ -2568,12 +2635,12 @@ YY_RULE_SETUP case 110: /* rule 110 can match eol */ YY_RULE_SETUP -ENTER(VALUE1); BUFFERSET(AX_dax__parent_ref); +if (dax__parent_ref_isset != 0) {FAIL("Multiple definition of attribute ref in ");} dax__parent_ref_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__parent_ref); YY_BREAK case 111: /* rule 111 can match eol */ YY_RULE_SETUP -ENTER(VALUE2); BUFFERSET(AX_dax__parent_ref); +if (dax__parent_ref_isset != 0) {FAIL("Multiple definition of attribute ref in ");} dax__parent_ref_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__parent_ref); YY_BREAK case 112: YY_RULE_SETUP @@ -2588,7 +2655,7 @@ YY_RULE_SETUP if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element."); LEAVE; STag_dax__parent(); dax__pcdata_ix = 0; ETag_dax__parent(); popbuffer(); /* attribute */ switch (YY_START) { - case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break; + case S_dax__child: case S_dax__child_2: case S_dax__child_1: SET(S_dax__child_2); break; } } YY_BREAK @@ -2612,7 +2679,7 @@ YY_RULE_SETUP ETag_dax__parent(); popbuffer(); /* attribute */ switch (YY_START) { - case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break; + case S_dax__child: case S_dax__child_2: case S_dax__child_1: SET(S_dax__child_2); break; } } YY_BREAK @@ -2882,6 +2949,7 @@ case YY_STATE_EOF(IMPOSSIBLE): "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ + } /* end of user's declarations */ } /* end of dax_lex */ /* yy_get_next_buffer - try to read in a new buffer @@ -2937,21 +3005,21 @@ static int yy_get_next_buffer (void) else { - int num_to_read = + yy_size_t num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; int yy_c_buf_p_offset = (int) ((yy_c_buf_p) - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { - int new_size = b->yy_buf_size * 2; + yy_size_t new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -2982,7 +3050,7 @@ static int yy_get_next_buffer (void) /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - (yy_n_chars), (size_t) num_to_read ); + (yy_n_chars), num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } @@ -3077,7 +3145,7 @@ static int yy_get_next_buffer (void) yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; yy_is_jam = (yy_current_state == 774); - return yy_is_jam ? 0 : yy_current_state; + return yy_is_jam ? 0 : yy_current_state; } #ifndef YY_NO_INPUT @@ -3104,7 +3172,7 @@ static int yy_get_next_buffer (void) else { /* need more input */ - int offset = (yy_c_buf_p) - (yytext_ptr); + yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); ++(yy_c_buf_p); switch ( yy_get_next_buffer( ) ) @@ -3269,10 +3337,6 @@ static void dax__load_buffer_state (void) dax_free((void *) b ); } -#ifndef __cplusplus -extern int isatty (int ); -#endif /* __cplusplus */ - /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a dax_restart() or at EOF. @@ -3385,7 +3449,7 @@ void dax_pop_buffer_state (void) */ static void dax_ensure_buffer_stack (void) { - int num_to_alloc; + yy_size_t num_to_alloc; if (!(yy_buffer_stack)) { @@ -3482,12 +3546,12 @@ YY_BUFFER_STATE dax__scan_string (yyconst char * yystr ) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE dax__scan_bytes (yyconst char * yybytes, int _yybytes_len ) +YY_BUFFER_STATE dax__scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) { YY_BUFFER_STATE b; char *buf; yy_size_t n; - int i; + yy_size_t i; /* Get memory for full buffer, including space for trailing EOB's. */ n = _yybytes_len + 2; @@ -3601,7 +3665,7 @@ FILE *dax_get_out (void) /** Get the length of the current token. * */ -int dax_get_leng (void) +yy_size_t dax_get_leng (void) { return dax_leng; }