X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fdc3365141999b8b24885ae7473162e4563e2dcd..f0886ea4ab50491bd7cf056d8ed576cd939acd3e:/src/xbt/graphxml.c diff --git a/src/xbt/graphxml.c b/src/xbt/graphxml.c index f757c80d19..2b1a8efbb6 100644 --- a/src/xbt/graphxml.c +++ b/src/xbt/graphxml.c @@ -1,9 +1,5 @@ -#include "graphxml.h" - -#line 2 "xbt/graphxml.c" - -#line 4 "xbt/graphxml.c" +#line 3 "xbt/graphxml.c" #define YY_INT_ALIGNED short int @@ -12,7 +8,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 31 +#define YY_FLEX_SUBMINOR_VERSION 33 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -34,7 +30,15 @@ /* C99 systems have . Non-C99 systems may or may not. */ -#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L +#if __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + #include typedef int8_t flex_int8_t; typedef uint8_t flex_uint8_t; @@ -138,6 +142,10 @@ typedef unsigned int flex_uint32_t; #define YY_BUF_SIZE 16384 #endif +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + #ifndef YY_TYPEDEF_YY_BUFFER_STATE #define YY_TYPEDEF_YY_BUFFER_STATE typedef struct yy_buffer_state *YY_BUFFER_STATE; @@ -284,7 +292,7 @@ int xbt_graph_parse_leng; /* Points to current character in buffer. */ static char *yy_c_buf_p = (char *) 0; -static int yy_init = 1; /* whether we need to initialize */ +static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ /* Flag which is used to allow xbt_graph_parse_wrap()'s to do buffer switches @@ -1003,14 +1011,13 @@ int xbt_graph_parse__flex_debug = 0; #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET char *xbt_graph_parse_text; -#line 1 "xbt/graphxml.l" /* Validating XML processor for xbt/graphxml.dtd. - * Generated 2006/07/18 21:02:16. + * Generated 2007/08/09 10:57:49. * * 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.53 2006/07/18 12:12:06 mquinson Exp). + * (Id: flexml.pl,v 1.61 2006/09/13 16:34:33 wdowling Exp). * * There are two, intertwined parts to this program, part A and part B. * @@ -1050,16 +1057,15 @@ char *xbt_graph_parse_text; * by the author of or contributors to FleXML. * */ -#line 49 "xbt/graphxml.l" /* Version strings. */ const char rcs_graphxml_flexml_skeleton[] = - "$" "Id: skel,v 1.31 2006/07/18 18:21:13 mquinson Exp $"; + "$" "Id: skel,v 1.38 2006/09/12 18:05:45 wdowling Exp $"; const char rcs_graphxml_flexml[] = - "$" "Id: flexml.pl,v 1.53 2006/07/18 12:12:06 mquinson Exp $"; + "$" "Id: flexml.pl,v 1.61 2006/09/13 16:34:33 wdowling Exp $"; /* ANSI headers. */ - +/* ANSI headers. */ #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__) # ifndef __STRICT_ANSI__ # include @@ -1068,32 +1074,52 @@ const char rcs_graphxml_flexml[] = #else # include #endif - #include #include #include #include #include +#ifndef FLEXML_INDEXSTACKSIZE +#define FLEXML_INDEXSTACKSIZE 1000 +#endif + /* Generated definitions. */ #define FLEXML_yylineno +#ifndef FLEXML_BUFFERSTACKSIZE #define FLEXML_BUFFERSTACKSIZE 1000000 +#endif +#define FLEXML_NEED_BUFFERLIT /* XML processor api. */ /* FleXML-provided data. */ -const char* graphxml_pcdata; -AT_graphxml_node_name A_graphxml_node_name; -AT_graphxml_edge_source A_graphxml_edge_source; -AT_graphxml_node_position_y A_graphxml_node_position_y; -AT_graphxml_node_position_x A_graphxml_node_position_x; -AT_graphxml_edge_data A_graphxml_edge_data; -AT_graphxml_edge_target A_graphxml_edge_target; -AT_graphxml_graph_isDirected A_graphxml_graph_isDirected; -AT_graphxml_node_label A_graphxml_node_label; -AT_graphxml_node_data A_graphxml_node_data; -AT_graphxml_edge_label A_graphxml_edge_label; -AT_graphxml_edge_length A_graphxml_edge_length; -AT_graphxml_edge_name A_graphxml_edge_name; +int graphxml_pcdata_ix; +extern char *graphxml_bufferstack; +#define graphxml_pcdata (graphxml_bufferstack + graphxml_pcdata_ix) +AT_graphxml_node_name AX_graphxml_node_name; +#define A_graphxml_node_name (graphxml_bufferstack + AX_graphxml_node_name) +AT_graphxml_edge_source AX_graphxml_edge_source; +#define A_graphxml_edge_source (graphxml_bufferstack + AX_graphxml_edge_source) +AT_graphxml_node_position_y AX_graphxml_node_position_y; +#define A_graphxml_node_position_y (graphxml_bufferstack + AX_graphxml_node_position_y) +AT_graphxml_node_position_x AX_graphxml_node_position_x; +#define A_graphxml_node_position_x (graphxml_bufferstack + AX_graphxml_node_position_x) +AT_graphxml_edge_data AX_graphxml_edge_data; +#define A_graphxml_edge_data (graphxml_bufferstack + AX_graphxml_edge_data) +AT_graphxml_edge_target AX_graphxml_edge_target; +#define A_graphxml_edge_target (graphxml_bufferstack + AX_graphxml_edge_target) +AT_graphxml_graph_isDirected AX_graphxml_graph_isDirected; +#define A_graphxml_graph_isDirected AX_graphxml_graph_isDirected +AT_graphxml_node_label AX_graphxml_node_label; +#define A_graphxml_node_label (graphxml_bufferstack + AX_graphxml_node_label) +AT_graphxml_node_data AX_graphxml_node_data; +#define A_graphxml_node_data (graphxml_bufferstack + AX_graphxml_node_data) +AT_graphxml_edge_label AX_graphxml_edge_label; +#define A_graphxml_edge_label (graphxml_bufferstack + AX_graphxml_edge_label) +AT_graphxml_edge_length AX_graphxml_edge_length; +#define A_graphxml_edge_length (graphxml_bufferstack + AX_graphxml_edge_length) +AT_graphxml_edge_name AX_graphxml_edge_name; +#define A_graphxml_edge_name (graphxml_bufferstack + AX_graphxml_edge_name) /* XML state. */ #ifdef FLEX_DEBUG @@ -1115,64 +1141,97 @@ AT_graphxml_edge_name A_graphxml_edge_name; #define FAIL return fail static int fail(const char*, ...); -const char * graphxml_parse_err_msg(void); + +enum {flexml_max_err_msg_size = 512}; +static char flexml_err_msg[flexml_max_err_msg_size]; +const char * graphxml_parse_err_msg() +{ + return flexml_err_msg; +} +static void reset_graphxml_parse_err_msg() +{ + flexml_err_msg[0] = '\0'; +} /* Cleanup */ static void cleanup(void); #define CLEANUP cleanup() /* Text buffer stack handling. */ -static char bufferstack[FLEXML_BUFFERSTACKSIZE]; -static char* limit = bufferstack + FLEXML_BUFFERSTACKSIZE; -typedef struct BufferLast_s { - struct BufferLast_s *old; const char* saved; char new1[1]; -} BufferLast; -#ifdef FLEXML_HasMixed -static BufferLast* last = (BufferLast*)0; -#endif -static char* next = bufferstack; +char *graphxml_bufferstack = NULL; +static int blimit = FLEXML_BUFFERSTACKSIZE; +static int bnext = 1; + +static int *indexstack = NULL; +static int ilimit = FLEXML_INDEXSTACKSIZE; +static int inext = 1; -#define BUFFERSET(P) (P = next) -#define BUFFERPUTC(C) (assert(next= blimit) { + blimit += FLEXML_BUFFERSTACKSIZE + 2; + { + char *temp = (char *) realloc(graphxml_bufferstack, blimit); + assert(temp); + graphxml_bufferstack = temp; + } + } + return 0; +} + +/* after this is called, there are at least 2 slots left in the stack */ +static int ck_ilimit() +{ + if (inext >= ilimit) { + ilimit += FLEXML_INDEXSTACKSIZE + 2; + { + int *temp = (int *) realloc(indexstack, ilimit); + assert(temp); + indexstack = temp; + } + } + return 0; +} + +#ifdef FLEXML_NEED_BUFFERLIT +static void graphxml_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 (++sold = last; - l->saved = p; - next = l->new1; - last = l; + ck_ilimit(); + indexstack[inext++] = p; + indexstack[inext++] = bnext; } -static const char* popbuffer(void) +static int popbuffer(void) { - BufferLast* l = last; - assert(last != (BufferLast*)0); - last = l->old; - next = (char*)l; - return l->saved; + assert(inext >= 2); + bnext = indexstack[--inext]; + return indexstack[--inext]; } -#endif /* General internal entities are `unput' back onto the input stream... */ #define ENTITYTEXT(T) \ { char *s = (T), *e = s+strlen(s);\ while (--e >= s) { unput(*e); }} + /* Flex standard options. */ #define YY_NO_INPUT 1 /* Flex user-requested options. */ @@ -1196,14 +1255,8 @@ static const char* popbuffer(void) * IMPOSSIBLE dummy to permit disabling rules; must be last */ - - - - -#line 216 "xbt/graphxml.l" /* State names. */ const char* *graphxml_statenames=NULL; -#line 1195 "xbt/graphxml.c" #define INITIAL 0 #define PROLOG 1 @@ -1236,6 +1289,7 @@ const char* *graphxml_statenames=NULL; * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ +/* ANSI headers. */ #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__) # ifndef __STRICT_ANSI__ # include @@ -1250,6 +1304,8 @@ const char* *graphxml_statenames=NULL; #define YY_EXTRA_TYPE void * #endif +static int yy_init_globals (void ); + /* Macros after this point can all be overridden by user definitions in * section 1. */ @@ -1282,7 +1338,7 @@ static int input (void ); static int yy_start_stack_ptr = 0; static int yy_start_stack_depth = 0; - static int *yy_start_stack = 0; + static int *yy_start_stack = NULL; static void yy_push_state (int new_state ); @@ -1391,13 +1447,29 @@ YY_DECL register char *yy_cp, *yy_bp; register int yy_act; -#line 220 "xbt/graphxml.l" - - /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */ SET(PROLOG); + reset_graphxml_parse_err_msg(); + graphxml_bufferstack = (char *) malloc(FLEXML_BUFFERSTACKSIZE); + assert(graphxml_bufferstack); + #ifdef FLEX_DEBUG + { + int i; + for (i = 0; i < blimit; i++) { + graphxml_bufferstack[i] = '\377'; + } + } + #endif + graphxml_bufferstack[0] = '\0'; + indexstack = (int *) malloc(FLEXML_INDEXSTACKSIZE * sizeof(int)); + assert(indexstack); + indexstack[0] = 0; + /* FleXML_init */ - next = bufferstack; + bnext = inext = 1; + graphxml_bufferliteral('\0', &bnext, "-1.0"); + graphxml_bufferliteral('\0', &bnext, "-1.0"); + graphxml_bufferliteral('\0', &bnext, "-1.0"); if(!graphxml_statenames) {graphxml_statenames= (const char **)calloc(IMPOSSIBLE,sizeof(char*)); graphxml_statenames[PROLOG] = NULL; graphxml_statenames[DOCTYPE] = NULL; @@ -1426,11 +1498,9 @@ YY_DECL /* COMMENTS and PIs: handled uniformly for efficiency. */ -#line 1411 "xbt/graphxml.c" - - if ( (yy_init) ) + if ( !(yy_init) ) { - (yy_init) = 0; + (yy_init) = 1; #ifdef YY_USER_INIT YY_USER_INIT; @@ -1521,52 +1591,39 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 255 "xbt/graphxml.l" ENTER(INCOMMENT); YY_BREAK case 2: YY_RULE_SETUP -#line 256 "xbt/graphxml.l" ENTER(INPI); YY_BREAK - case 3: YY_RULE_SETUP -#line 259 "xbt/graphxml.l" LEAVE; YY_BREAK case 4: -#line 261 "xbt/graphxml.l" case 5: -#line 262 "xbt/graphxml.l" case 6: /* rule 6 can match eol */ YY_RULE_SETUP -#line 262 "xbt/graphxml.l" SKIP; YY_BREAK case YY_STATE_EOF(INCOMMENT): -#line 263 "xbt/graphxml.l" FAIL("EOF in comment."); YY_BREAK - case 7: YY_RULE_SETUP -#line 266 "xbt/graphxml.l" LEAVE; YY_BREAK case 8: -#line 268 "xbt/graphxml.l" case 9: /* rule 9 can match eol */ YY_RULE_SETUP -#line 268 "xbt/graphxml.l" SKIP; YY_BREAK case YY_STATE_EOF(INPI): -#line 269 "xbt/graphxml.l" FAIL("EOF in PI (processing instruction)."); YY_BREAK @@ -1574,7 +1631,6 @@ FAIL("EOF in PI (processing instruction)."); case 10: /* rule 10 can match eol */ YY_RULE_SETUP -#line 274 "xbt/graphxml.l" SKIP; YY_BREAK /* PROLOG: determine root element and process it. */ @@ -1582,49 +1638,40 @@ SKIP; case 11: /* rule 11 can match eol */ YY_RULE_SETUP -#line 279 "xbt/graphxml.l" SET(DOCTYPE); YY_BREAK case 12: /* rule 12 can match eol */ YY_RULE_SETUP -#line 280 "xbt/graphxml.l" FAIL("Bad declaration %s.",xbt_graph_parse_text); YY_BREAK - case 13: /* rule 13 can match eol */ YY_RULE_SETUP -#line 284 "xbt/graphxml.l" SET(ROOT_graphxml_edge); YY_BREAK case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 285 "xbt/graphxml.l" SET(ROOT_graphxml_node); YY_BREAK case 15: /* rule 15 can match eol */ YY_RULE_SETUP -#line 286 "xbt/graphxml.l" SET(ROOT_graphxml_graph); YY_BREAK case 16: /* rule 16 can match eol */ YY_RULE_SETUP -#line 287 "xbt/graphxml.l" FAIL("Bad declaration %s.",xbt_graph_parse_text); YY_BREAK case 17: YY_RULE_SETUP -#line 288 "xbt/graphxml.l" FAIL("Unexpected character `%c' in prolog.", xbt_graph_parse_text[0]); YY_BREAK case YY_STATE_EOF(PROLOG): case YY_STATE_EOF(DOCTYPE): -#line 289 "xbt/graphxml.l" FAIL("EOF in prolog."); YY_BREAK @@ -1635,43 +1682,36 @@ FAIL("EOF in prolog."); case 18: /* rule 18 can match eol */ YY_RULE_SETUP -#line 299 "xbt/graphxml.l" { - A_graphxml_graph_isDirected = A_graphxml_graph_isDirected_true; - ENTER(AL_graphxml_graph); + AX_graphxml_graph_isDirected = A_graphxml_graph_isDirected_true; + ENTER(AL_graphxml_graph); pushbuffer(0); } YY_BREAK case 19: /* rule 19 can match eol */ -#line 306 "xbt/graphxml.l" case 20: /* rule 20 can match eol */ YY_RULE_SETUP -#line 306 "xbt/graphxml.l" A_graphxml_graph_isDirected = A_graphxml_graph_isDirected_true; YY_BREAK case 21: /* rule 21 can match eol */ -#line 308 "xbt/graphxml.l" case 22: /* rule 22 can match eol */ YY_RULE_SETUP -#line 308 "xbt/graphxml.l" A_graphxml_graph_isDirected = A_graphxml_graph_isDirected_false; YY_BREAK case 23: YY_RULE_SETUP -#line 310 "xbt/graphxml.l" { - LEAVE; STag_graphxml_graph();graphxml_pcdata = NULL; ENTER(S_graphxml_graph); + LEAVE; STag_graphxml_graph();graphxml_pcdata_ix = 0; ENTER(S_graphxml_graph); } YY_BREAK case 24: YY_RULE_SETUP -#line 313 "xbt/graphxml.l" { - LEAVE; STag_graphxml_graph(); graphxml_pcdata = NULL; ETag_graphxml_graph(); + LEAVE; STag_graphxml_graph(); graphxml_pcdata_ix = 0; ETag_graphxml_graph(); popbuffer(); /* attribute */ switch (YY_START) { case ROOT_graphxml_graph: SET(EPILOG); break; } @@ -1679,27 +1719,23 @@ YY_RULE_SETUP YY_BREAK case 25: YY_RULE_SETUP -#line 319 "xbt/graphxml.l" FAIL("Unexpected character `%c' in attribute list of graph element.", xbt_graph_parse_text[0]); YY_BREAK case 26: YY_RULE_SETUP -#line 320 "xbt/graphxml.l" FAIL("Bad attribute `%s' in `graph' element start tag.",xbt_graph_parse_text); YY_BREAK case YY_STATE_EOF(AL_graphxml_graph): -#line 321 "xbt/graphxml.l" FAIL("EOF in attribute list of `graph' element."); YY_BREAK - case 27: /* rule 27 can match eol */ YY_RULE_SETUP -#line 325 "xbt/graphxml.l" { LEAVE; ETag_graphxml_graph(); + popbuffer(); /* attribute */ switch (YY_START) { case ROOT_graphxml_graph: SET(EPILOG); break; } @@ -1708,12 +1744,10 @@ YY_RULE_SETUP case 28: /* rule 28 can match eol */ YY_RULE_SETUP -#line 332 "xbt/graphxml.l" FAIL("Unexpected end-tag `%s': `' expected.",xbt_graph_parse_text); YY_BREAK case 29: YY_RULE_SETUP -#line 333 "xbt/graphxml.l" FAIL("Unexpected character `%c': `' expected.",xbt_graph_parse_text[0]); YY_BREAK case YY_STATE_EOF(S_graphxml_graph_1): @@ -1721,7 +1755,6 @@ case YY_STATE_EOF(E_graphxml_graph): case YY_STATE_EOF(S_graphxml_graph_3): case YY_STATE_EOF(S_graphxml_graph_5): case YY_STATE_EOF(S_graphxml_graph): -#line 334 "xbt/graphxml.l" FAIL("Premature EOF: `' expected."); YY_BREAK @@ -1734,91 +1767,78 @@ FAIL("Premature EOF: `' expected."); case 30: /* rule 30 can match eol */ YY_RULE_SETUP -#line 344 "xbt/graphxml.l" { - A_graphxml_node_label = NULL; - A_graphxml_node_name = NULL; - A_graphxml_node_data = NULL; - A_graphxml_node_position_x = "-1.0"; - A_graphxml_node_position_y = "-1.0"; - ENTER(AL_graphxml_node); + AX_graphxml_node_label = 0; + AX_graphxml_node_name = 0; + AX_graphxml_node_data = 0; + AX_graphxml_node_position_x = 1; + AX_graphxml_node_position_y = 6; + ENTER(AL_graphxml_node); pushbuffer(0); } YY_BREAK case 31: /* rule 31 can match eol */ YY_RULE_SETUP -#line 354 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_node_label); +ENTER(VALUE1); BUFFERSET(AX_graphxml_node_label); YY_BREAK case 32: /* rule 32 can match eol */ YY_RULE_SETUP -#line 355 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_node_label); +ENTER(VALUE2); BUFFERSET(AX_graphxml_node_label); YY_BREAK case 33: /* rule 33 can match eol */ YY_RULE_SETUP -#line 357 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_node_name); +ENTER(VALUE1); BUFFERSET(AX_graphxml_node_name); YY_BREAK case 34: /* rule 34 can match eol */ YY_RULE_SETUP -#line 358 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_node_name); +ENTER(VALUE2); BUFFERSET(AX_graphxml_node_name); YY_BREAK case 35: /* rule 35 can match eol */ YY_RULE_SETUP -#line 360 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_node_data); +ENTER(VALUE1); BUFFERSET(AX_graphxml_node_data); YY_BREAK case 36: /* rule 36 can match eol */ YY_RULE_SETUP -#line 361 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_node_data); +ENTER(VALUE2); BUFFERSET(AX_graphxml_node_data); YY_BREAK case 37: /* rule 37 can match eol */ YY_RULE_SETUP -#line 363 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_node_position_x); +ENTER(VALUE1); BUFFERSET(AX_graphxml_node_position_x); YY_BREAK case 38: /* rule 38 can match eol */ YY_RULE_SETUP -#line 364 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_node_position_x); +ENTER(VALUE2); BUFFERSET(AX_graphxml_node_position_x); YY_BREAK case 39: /* rule 39 can match eol */ YY_RULE_SETUP -#line 366 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_node_position_y); +ENTER(VALUE1); BUFFERSET(AX_graphxml_node_position_y); YY_BREAK case 40: /* rule 40 can match eol */ YY_RULE_SETUP -#line 367 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_node_position_y); +ENTER(VALUE2); BUFFERSET(AX_graphxml_node_position_y); YY_BREAK case 41: YY_RULE_SETUP -#line 369 "xbt/graphxml.l" { - if (!A_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element."); - LEAVE; STag_graphxml_node();graphxml_pcdata = NULL; ENTER(E_graphxml_node); + if (!AX_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element."); + LEAVE; STag_graphxml_node();graphxml_pcdata_ix = 0; ENTER(E_graphxml_node); } YY_BREAK case 42: YY_RULE_SETUP -#line 373 "xbt/graphxml.l" { - if (!A_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element."); - LEAVE; STag_graphxml_node(); graphxml_pcdata = NULL; ETag_graphxml_node(); + if (!AX_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element."); + LEAVE; STag_graphxml_node(); graphxml_pcdata_ix = 0; ETag_graphxml_node(); popbuffer(); /* attribute */ switch (YY_START) { case S_graphxml_graph_2: case S_graphxml_graph_3: case S_graphxml_graph: SET(S_graphxml_graph_3); break; case ROOT_graphxml_node: SET(EPILOG); break; @@ -1827,27 +1847,23 @@ YY_RULE_SETUP YY_BREAK case 43: YY_RULE_SETUP -#line 381 "xbt/graphxml.l" FAIL("Unexpected character `%c' in attribute list of node element.", xbt_graph_parse_text[0]); YY_BREAK case 44: YY_RULE_SETUP -#line 382 "xbt/graphxml.l" FAIL("Bad attribute `%s' in `node' element start tag.",xbt_graph_parse_text); YY_BREAK case YY_STATE_EOF(AL_graphxml_node): -#line 383 "xbt/graphxml.l" FAIL("EOF in attribute list of `node' element."); YY_BREAK - case 45: /* rule 45 can match eol */ YY_RULE_SETUP -#line 387 "xbt/graphxml.l" { LEAVE; ETag_graphxml_node(); + popbuffer(); /* attribute */ switch (YY_START) { case S_graphxml_graph_2: case S_graphxml_graph_3: case S_graphxml_graph: SET(S_graphxml_graph_3); break; case ROOT_graphxml_node: SET(EPILOG); break; @@ -1857,16 +1873,13 @@ YY_RULE_SETUP case 46: /* rule 46 can match eol */ YY_RULE_SETUP -#line 395 "xbt/graphxml.l" FAIL("Unexpected end-tag `%s': `' expected.",xbt_graph_parse_text); YY_BREAK case 47: YY_RULE_SETUP -#line 396 "xbt/graphxml.l" FAIL("Unexpected character `%c': `' expected.",xbt_graph_parse_text[0]); YY_BREAK case YY_STATE_EOF(E_graphxml_node): -#line 397 "xbt/graphxml.l" FAIL("Premature EOF: `' expected."); YY_BREAK @@ -1880,106 +1893,91 @@ FAIL("Premature EOF: `' expected."); case 48: /* rule 48 can match eol */ YY_RULE_SETUP -#line 408 "xbt/graphxml.l" { - A_graphxml_edge_label = NULL; - A_graphxml_edge_name = NULL; - A_graphxml_edge_source = NULL; - A_graphxml_edge_target = NULL; - A_graphxml_edge_length = "-1.0"; - A_graphxml_edge_data = NULL; - ENTER(AL_graphxml_edge); + AX_graphxml_edge_label = 0; + AX_graphxml_edge_name = 0; + AX_graphxml_edge_source = 0; + AX_graphxml_edge_target = 0; + AX_graphxml_edge_length = 11; + AX_graphxml_edge_data = 0; + ENTER(AL_graphxml_edge); pushbuffer(0); } YY_BREAK case 49: /* rule 49 can match eol */ YY_RULE_SETUP -#line 419 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_edge_label); +ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_label); YY_BREAK case 50: /* rule 50 can match eol */ YY_RULE_SETUP -#line 420 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_edge_label); +ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_label); YY_BREAK case 51: /* rule 51 can match eol */ YY_RULE_SETUP -#line 422 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_edge_name); +ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_name); YY_BREAK case 52: /* rule 52 can match eol */ YY_RULE_SETUP -#line 423 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_edge_name); +ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_name); YY_BREAK case 53: /* rule 53 can match eol */ YY_RULE_SETUP -#line 425 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_edge_source); +ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_source); YY_BREAK case 54: /* rule 54 can match eol */ YY_RULE_SETUP -#line 426 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_edge_source); +ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_source); YY_BREAK case 55: /* rule 55 can match eol */ YY_RULE_SETUP -#line 428 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_edge_target); +ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_target); YY_BREAK case 56: /* rule 56 can match eol */ YY_RULE_SETUP -#line 429 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_edge_target); +ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_target); YY_BREAK case 57: /* rule 57 can match eol */ YY_RULE_SETUP -#line 431 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_edge_length); +ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_length); YY_BREAK case 58: /* rule 58 can match eol */ YY_RULE_SETUP -#line 432 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_edge_length); +ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_length); YY_BREAK case 59: /* rule 59 can match eol */ YY_RULE_SETUP -#line 434 "xbt/graphxml.l" -ENTER(VALUE1); BUFFERSET(A_graphxml_edge_data); +ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_data); YY_BREAK case 60: /* rule 60 can match eol */ YY_RULE_SETUP -#line 435 "xbt/graphxml.l" -ENTER(VALUE2); BUFFERSET(A_graphxml_edge_data); +ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_data); YY_BREAK case 61: YY_RULE_SETUP -#line 437 "xbt/graphxml.l" { - if (!A_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element."); - if (!A_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element."); - LEAVE; STag_graphxml_edge();graphxml_pcdata = NULL; ENTER(E_graphxml_edge); + if (!AX_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element."); + if (!AX_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element."); + LEAVE; STag_graphxml_edge();graphxml_pcdata_ix = 0; ENTER(E_graphxml_edge); } YY_BREAK case 62: YY_RULE_SETUP -#line 442 "xbt/graphxml.l" { - if (!A_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element."); - if (!A_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element."); - LEAVE; STag_graphxml_edge(); graphxml_pcdata = NULL; ETag_graphxml_edge(); + if (!AX_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element."); + if (!AX_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element."); + LEAVE; STag_graphxml_edge(); graphxml_pcdata_ix = 0; ETag_graphxml_edge(); popbuffer(); /* attribute */ switch (YY_START) { case S_graphxml_graph_1: case S_graphxml_graph_3: case S_graphxml_graph_5: case S_graphxml_graph_4: case S_graphxml_graph: SET(S_graphxml_graph_5); break; case ROOT_graphxml_edge: SET(EPILOG); break; @@ -1988,27 +1986,23 @@ YY_RULE_SETUP YY_BREAK case 63: YY_RULE_SETUP -#line 451 "xbt/graphxml.l" FAIL("Unexpected character `%c' in attribute list of edge element.", xbt_graph_parse_text[0]); YY_BREAK case 64: YY_RULE_SETUP -#line 452 "xbt/graphxml.l" FAIL("Bad attribute `%s' in `edge' element start tag.",xbt_graph_parse_text); YY_BREAK case YY_STATE_EOF(AL_graphxml_edge): -#line 453 "xbt/graphxml.l" FAIL("EOF in attribute list of `edge' element."); YY_BREAK - case 65: /* rule 65 can match eol */ YY_RULE_SETUP -#line 457 "xbt/graphxml.l" { LEAVE; ETag_graphxml_edge(); + popbuffer(); /* attribute */ switch (YY_START) { case S_graphxml_graph_1: case S_graphxml_graph_3: case S_graphxml_graph_5: case S_graphxml_graph_4: case S_graphxml_graph: SET(S_graphxml_graph_5); break; case ROOT_graphxml_edge: SET(EPILOG); break; @@ -2018,16 +2012,13 @@ YY_RULE_SETUP case 66: /* rule 66 can match eol */ YY_RULE_SETUP -#line 465 "xbt/graphxml.l" FAIL("Unexpected end-tag `%s': `' expected.",xbt_graph_parse_text); YY_BREAK case 67: YY_RULE_SETUP -#line 466 "xbt/graphxml.l" FAIL("Unexpected character `%c': `' expected.",xbt_graph_parse_text[0]); YY_BREAK case YY_STATE_EOF(E_graphxml_edge): -#line 467 "xbt/graphxml.l" FAIL("Premature EOF: `' expected."); YY_BREAK @@ -2035,11 +2026,9 @@ FAIL("Premature EOF: `' expected."); case 68: YY_RULE_SETUP -#line 473 "xbt/graphxml.l" {SET(PROLOG); yyless(0); CLEANUP; return -1;} YY_BREAK case YY_STATE_EOF(EPILOG): -#line 474 "xbt/graphxml.l" SUCCEED; YY_BREAK @@ -2048,119 +2037,91 @@ SUCCEED; /* Non-defined standard entities... */ case 69: YY_RULE_SETUP -#line 481 "xbt/graphxml.l" BUFFERPUTC('&'); YY_BREAK case 70: YY_RULE_SETUP -#line 482 "xbt/graphxml.l" BUFFERPUTC('<'); YY_BREAK case 71: YY_RULE_SETUP -#line 483 "xbt/graphxml.l" BUFFERPUTC('>'); YY_BREAK case 72: YY_RULE_SETUP -#line 484 "xbt/graphxml.l" BUFFERPUTC('\''); YY_BREAK case 73: YY_RULE_SETUP -#line 485 "xbt/graphxml.l" BUFFERPUTC('"'); YY_BREAK /* Character entities. */ case 74: YY_RULE_SETUP -#line 488 "xbt/graphxml.l" BUFFERPUTC((unsigned char)atoi(xbt_graph_parse_text+2)); YY_BREAK case 75: YY_RULE_SETUP -#line 489 "xbt/graphxml.l" BUFFERPUTC((unsigned char)strtol(xbt_graph_parse_text+3,NULL,16)); YY_BREAK - case 76: /* rule 76 can match eol */ -#line 494 "xbt/graphxml.l" case 77: /* rule 77 can match eol */ -#line 495 "xbt/graphxml.l" case 78: /* rule 78 can match eol */ -#line 496 "xbt/graphxml.l" case 79: /* rule 79 can match eol */ YY_RULE_SETUP -#line 496 "xbt/graphxml.l" BUFFERPUTC('\n'); YY_BREAK - case 80: YY_RULE_SETUP -#line 500 "xbt/graphxml.l" ENTER(CDATA); YY_BREAK case 81: YY_RULE_SETUP -#line 501 "xbt/graphxml.l" FAIL("Unexpected `]""]>' in character data."); YY_BREAK - case 82: YY_RULE_SETUP -#line 505 "xbt/graphxml.l" BUFFERDONE; LEAVE; YY_BREAK case YY_STATE_EOF(VALUE1): -#line 506 "xbt/graphxml.l" FAIL("EOF in literal (\"'\" expected)."); YY_BREAK - case 83: YY_RULE_SETUP -#line 510 "xbt/graphxml.l" BUFFERDONE; LEAVE; YY_BREAK case YY_STATE_EOF(VALUE2): -#line 511 "xbt/graphxml.l" FAIL("EOF in literal (`\"' expected)."); YY_BREAK - case 84: /* rule 84 can match eol */ YY_RULE_SETUP -#line 515 "xbt/graphxml.l" BUFFERPUTC(xbt_graph_parse_text[0]); YY_BREAK case 85: YY_RULE_SETUP -#line 516 "xbt/graphxml.l" FAIL("Spurious `%c' in character data.",xbt_graph_parse_text[0]); YY_BREAK - case 86: YY_RULE_SETUP -#line 520 "xbt/graphxml.l" LEAVE; YY_BREAK /* "]""]" BUFFERPUTC(xbt_graph_parse_text[0]); BUFFERPUTC(xbt_graph_parse_text[1]); */ case 87: YY_RULE_SETUP -#line 522 "xbt/graphxml.l" BUFFERPUTC(xbt_graph_parse_text[0]); YY_BREAK case YY_STATE_EOF(CDATA): -#line 523 "xbt/graphxml.l" FAIL("EOF in CDATA section."); YY_BREAK @@ -2171,16 +2132,13 @@ FAIL("EOF in CDATA section."); case 88: /* rule 88 can match eol */ YY_RULE_SETUP -#line 530 "xbt/graphxml.l" FAIL("Syntax error on character `%c'.", xbt_graph_parse_text[0]); YY_BREAK case 89: YY_RULE_SETUP -#line 533 "xbt/graphxml.l" ECHO; YY_BREAK -#line 2165 "xbt/graphxml.c" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(ROOT_graphxml_graph): case YY_STATE_EOF(S_graphxml_graph_2): @@ -2417,7 +2375,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), num_to_read ); + (yy_n_chars), (size_t) num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } @@ -2696,7 +2654,7 @@ static void xbt_graph_parse__load_buffer_state (void) xbt_graph_parse_free((void *) b ); } -#ifndef __cplusplus +#if !defined(__cplusplus) && !defined(WIN32) extern int isatty (int ); #endif /* __cplusplus */ @@ -2886,16 +2844,16 @@ YY_BUFFER_STATE xbt_graph_parse__scan_buffer (char * base, yy_size_t size ) /** Setup the input buffer state to scan a string. The next call to xbt_graph_parse_lex() will * scan from a @e copy of @a str. - * @param str a NUL-terminated string to scan + * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use * xbt_graph_parse__scan_bytes() instead. */ -YY_BUFFER_STATE xbt_graph_parse__scan_string (yyconst char * yy_str ) +YY_BUFFER_STATE xbt_graph_parse__scan_string (yyconst char * yystr ) { - return xbt_graph_parse__scan_bytes(yy_str,strlen(yy_str) ); + return xbt_graph_parse__scan_bytes(yystr,strlen(yystr) ); } /** Setup the input buffer state to scan the given bytes. The next call to xbt_graph_parse_lex() will @@ -2905,7 +2863,7 @@ YY_BUFFER_STATE xbt_graph_parse__scan_string (yyconst char * yy_str ) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE xbt_graph_parse__scan_bytes (yyconst char * bytes, int len ) +YY_BUFFER_STATE xbt_graph_parse__scan_bytes (yyconst char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; @@ -2913,15 +2871,15 @@ YY_BUFFER_STATE xbt_graph_parse__scan_bytes (yyconst char * bytes, int len ) int i; /* Get memory for full buffer, including space for trailing EOB's. */ - n = len + 2; + n = _yybytes_len + 2; buf = (char *) xbt_graph_parse_alloc(n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in xbt_graph_parse__scan_bytes()" ); - for ( i = 0; i < len; ++i ) - buf[i] = bytes[i]; + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; - buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; b = xbt_graph_parse__scan_buffer(buf,n ); if ( ! b ) @@ -3075,6 +3033,41 @@ void xbt_graph_parse_set_debug (int bdebug ) xbt_graph_parse__flex_debug = bdebug ; } +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from xbt_graph_parse_lex_destroy(), so don't allocate here. + */ + + /* We do not touch xbt_graph_parse_lineno unless the option is enabled. */ + xbt_graph_parse_lineno = 1; + + (yy_buffer_stack) = 0; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = (char *) 0; + (yy_init) = 0; + (yy_start) = 0; + + (yy_start_stack_ptr) = 0; + (yy_start_stack_depth) = 0; + (yy_start_stack) = NULL; + +/* Defined in main.c */ +#ifdef YY_STDINIT + xbt_graph_parse_in = stdin; + xbt_graph_parse_out = stdout; +#else + xbt_graph_parse_in = (FILE *) 0; + xbt_graph_parse_out = (FILE *) 0; +#endif + + /* For future reference: Set errno on error, since we are called by + * xbt_graph_parse_lex_init() + */ + return 0; +} + /* xbt_graph_parse_lex_destroy is for both reentrant and non-reentrant scanners. */ int xbt_graph_parse_lex_destroy (void) { @@ -3094,6 +3087,10 @@ int xbt_graph_parse_lex_destroy (void) xbt_graph_parse_free((yy_start_stack) ); (yy_start_stack) = NULL; + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * xbt_graph_parse_lex() is called, initialization will occur. */ + yy_init_globals( ); + return 0; } @@ -3105,7 +3102,7 @@ int xbt_graph_parse_lex_destroy (void) static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) { register int i; - for ( i = 0; i < n; ++i ) + for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif @@ -3114,7 +3111,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) static int yy_flex_strlen (yyconst char * s ) { register int n; - for ( n = 0; s[n]; ++n ) + for ( n = 0; s[n]; ++n ) ; return n; @@ -3145,22 +3142,6 @@ void xbt_graph_parse_free (void * ptr ) #define YYTABLES_NAME "yytables" -#undef YY_NEW_FILE -#undef YY_FLUSH_BUFFER -#undef yy_set_bol -#undef yy_new_buffer -#undef yy_set_interactive -#undef yytext_ptr -#undef YY_DO_BEFORE_ACTION - -#ifdef YY_DECL_IS_OURS -#undef YY_DECL_IS_OURS -#undef YY_DECL -#endif -#line 533 "xbt/graphxml.l" - - - /* Element context stack lookup. */ int graphxml_element_context(int i) { @@ -3174,19 +3155,39 @@ void print_yy_stack(char* fmt, ...) { int i = 0; va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); - for (i=1; i