#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5
#include <stdio.h>
#include <unistd.h>
#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#endif
#endif
#ifdef __cplusplus
#include <stdlib.h>
#define YY_USE_PROTOS
#define YY_USE_CONST
#else
#if __STDC__
#define YY_USE_PROTOS
#define YY_USE_CONST
#endif
#endif
#ifdef __TURBOC__
#pragma warn -rch
#pragma warn -use
#include <io.h>
#include <stdlib.h>
#define YY_USE_CONST
#define YY_USE_PROTOS
#endif
#ifdef YY_USE_CONST
#define incr_yyconst const
#else
#define incr_yyconst
#endif
#ifdef YY_USE_PROTOS
#define YY_PROTO(proto) proto
#else
#define YY_PROTO(proto) ()
#endif
#define YY_NULL 0
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
#define BEGIN incr_yy_start = 1 + 2 *
#define YY_START ((incr_yy_start - 1) / 2)
#define YYSTATE YY_START
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
#define YY_NEW_FILE incr_yyrestart( incr_yyin )
#define YY_END_OF_BUFFER_CHAR 0
#define YY_BUF_SIZE 16384
typedef struct incr_yy_buffer_state *YY_BUFFER_STATE;
extern int incr_yyleng;
extern FILE *incr_yyin, *incr_yyout;
#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
#define incr_yyless(n) \
do \
{ \
\
*incr_yy_cp = incr_yy_hold_char; \
YY_RESTORE_YY_MORE_OFFSET \
incr_yy_c_buf_p = incr_yy_cp = incr_yy_bp + n - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; \
} \
while ( 0 )
#define unput(c) incr_yyunput( c, incr_yytext_ptr )
typedef unsigned int incr_yy_size_t;
struct incr_yy_buffer_state
{
FILE *incr_yy_input_file;
char *incr_yy_ch_buf;
char *incr_yy_buf_pos;
incr_yy_size_t incr_yy_buf_size;
int incr_yy_n_chars;
int incr_yy_is_our_buffer;
int incr_yy_is_interactive;
int incr_yy_at_bol;
int incr_yy_fill_buffer;
int incr_yy_buffer_status;
#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
#define YY_BUFFER_EOF_PENDING 2
};
static YY_BUFFER_STATE incr_yy_current_buffer = 0;
#define YY_CURRENT_BUFFER incr_yy_current_buffer
static char incr_yy_hold_char;
static int incr_yy_n_chars;
int incr_yyleng;
static char *incr_yy_c_buf_p = (char *) 0;
static int incr_yy_init = 1;
static int incr_yy_start = 0;
static int incr_yy_did_buffer_switch_on_eof;
void incr_yyrestart YY_PROTO(( FILE *input_file ));
void incr_yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
void incr_yy_load_buffer_state YY_PROTO(( void ));
YY_BUFFER_STATE incr_yy_create_buffer YY_PROTO(( FILE *file, int size ));
void incr_yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
void incr_yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
void incr_yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
#define YY_FLUSH_BUFFER incr_yy_flush_buffer( incr_yy_current_buffer )
YY_BUFFER_STATE incr_yy_scan_buffer YY_PROTO(( char *base, incr_yy_size_t size ));
YY_BUFFER_STATE incr_yy_scan_string YY_PROTO(( incr_yyconst char *incr_yy_str ));
YY_BUFFER_STATE incr_yy_scan_bytes YY_PROTO(( incr_yyconst char *bytes, int len ));
static void *incr_yy_flex_alloc YY_PROTO(( incr_yy_size_t ));
static void *incr_yy_flex_realloc YY_PROTO(( void *, incr_yy_size_t ));
static void incr_yy_flex_free YY_PROTO(( void * ));
#define incr_yy_new_buffer incr_yy_create_buffer
#define incr_yy_set_interactive(is_interactive) \
{ \
if ( ! incr_yy_current_buffer ) \
incr_yy_current_buffer = incr_yy_create_buffer( incr_yyin, YY_BUF_SIZE ); \
incr_yy_current_buffer->incr_yy_is_interactive = is_interactive; \
}
#define incr_yy_set_bol(at_bol) \
{ \
if ( ! incr_yy_current_buffer ) \
incr_yy_current_buffer = incr_yy_create_buffer( incr_yyin, YY_BUF_SIZE ); \
incr_yy_current_buffer->incr_yy_at_bol = at_bol; \
}
#define YY_AT_BOL() (incr_yy_current_buffer->incr_yy_at_bol)
typedef unsigned char YY_CHAR;
FILE *incr_yyin = (FILE *) 0, *incr_yyout = (FILE *) 0;
typedef int incr_yy_state_type;
extern char *incr_yytext;
#define incr_yytext_ptr incr_yytext
static incr_yy_state_type incr_yy_get_previous_state YY_PROTO(( void ));
static incr_yy_state_type incr_yy_try_NUL_trans YY_PROTO(( incr_yy_state_type current_state ));
static int incr_yy_get_next_buffer YY_PROTO(( void ));
static void incr_yy_fatal_error YY_PROTO(( incr_yyconst char msg[] ));
#define YY_DO_BEFORE_ACTION \
incr_yytext_ptr = incr_yy_bp; \
incr_yyleng = (int) (incr_yy_cp - incr_yy_bp); \
incr_yy_hold_char = *incr_yy_cp; \
*incr_yy_cp = '\0'; \
incr_yy_c_buf_p = incr_yy_cp;
#define YY_NUM_RULES 32
#define YY_END_OF_BUFFER 33
static incr_yyconst short int incr_yy_accept[117] =
{ 0,
0, 0, 5, 5, 30, 30, 33, 31, 10, 2,
27, 9, 31, 31, 31, 26, 1, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
5, 3, 6, 30, 3, 28, 32, 9, 25, 0,
26, 26, 4, 8, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
5, 6, 6, 7, 30, 30, 29, 8, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 12, 26, 26, 21, 26,
26, 11, 18, 26, 26, 26, 20, 19, 26, 13,
26, 26, 26, 23, 26, 26, 15, 16, 26, 17,
26, 22, 24, 26, 14, 0
} ;
static incr_yyconst int incr_yy_ec[256] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 2, 1, 4, 5, 1, 1, 1, 1, 1,
1, 6, 1, 1, 7, 8, 9, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 1, 1, 1,
1, 11, 1, 12, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1, 14, 1, 1, 13, 1, 15, 16, 17, 18,
19, 20, 21, 22, 23, 13, 24, 25, 26, 27,
28, 29, 13, 30, 31, 32, 33, 34, 35, 13,
36, 13, 1, 1, 1, 1, 1, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13
} ;
static incr_yyconst int incr_yy_meta[37] =
{ 0,
1, 1, 2, 3, 1, 4, 1, 1, 1, 5,
1, 1, 5, 3, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5
} ;
static incr_yyconst short int incr_yy_base[126] =
{ 0,
0, 0, 34, 35, 39, 41, 164, 165, 165, 165,
165, 0, 39, 153, 42, 44, 165, 0, 137, 142,
142, 129, 131, 129, 37, 128, 126, 38, 127, 130,
0, 165, 52, 0, 0, 165, 149, 0, 165, 141,
52, 140, 165, 0, 139, 0, 120, 122, 125, 130,
113, 126, 111, 123, 122, 120, 117, 121, 111, 116,
0, 57, 58, 165, 0, 165, 165, 0, 124, 102,
113, 112, 101, 110, 104, 96, 103, 106, 97, 90,
101, 93, 85, 100, 86, 0, 95, 86, 0, 100,
94, 0, 0, 94, 82, 91, 0, 0, 80, 0,
61, 69, 52, 0, 68, 46, 0, 0, 50, 0,
39, 0, 0, 37, 0, 165, 71, 76, 81, 34,
86, 91, 96, 101, 106
} ;
static incr_yyconst short int incr_yy_def[126] =
{ 0,
116, 1, 117, 117, 118, 118, 116, 116, 116, 116,
116, 119, 116, 116, 116, 116, 116, 120, 120, 120,
120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
121, 116, 122, 123, 123, 116, 124, 119, 116, 116,
116, 116, 116, 125, 116, 120, 120, 120, 120, 120,
120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
121, 122, 122, 116, 123, 116, 116, 125, 116, 120,
120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
120, 120, 120, 120, 120, 0, 116, 116, 116, 116,
116, 116, 116, 116, 116
} ;
static incr_yyconst short int incr_yy_nxt[202] =
{ 0,
8, 9, 10, 11, 12, 8, 13, 14, 15, 16,
8, 17, 18, 8, 18, 18, 19, 20, 21, 18,
22, 18, 23, 18, 24, 25, 26, 27, 18, 18,
28, 18, 29, 30, 18, 18, 32, 32, 46, 33,
33, 35, 36, 35, 36, 39, 40, 43, 41, 39,
44, 45, 37, 41, 37, 53, 57, 63, 115, 45,
64, 41, 116, 63, 54, 116, 64, 114, 113, 112,
58, 31, 31, 31, 31, 31, 34, 34, 34, 34,
34, 38, 111, 38, 38, 38, 61, 110, 61, 109,
61, 62, 108, 62, 62, 62, 65, 65, 107, 65,
65, 66, 66, 66, 66, 66, 68, 106, 68, 68,
68, 105, 104, 103, 102, 101, 100, 99, 98, 97,
96, 95, 94, 93, 92, 91, 90, 89, 88, 87,
86, 85, 84, 69, 83, 82, 81, 80, 79, 78,
77, 76, 75, 74, 73, 72, 71, 70, 69, 42,
42, 67, 60, 59, 56, 55, 52, 51, 50, 49,
48, 47, 42, 116, 7, 116, 116, 116, 116, 116,
116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
116
} ;
static incr_yyconst short int incr_yy_chk[202] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 3, 4, 120, 3,
4, 5, 5, 6, 6, 13, 13, 15, 13, 13,
15, 16, 5, 16, 6, 25, 28, 33, 114, 41,
33, 41, 62, 63, 25, 62, 63, 111, 109, 106,
28, 117, 117, 117, 117, 117, 118, 118, 118, 118,
118, 119, 105, 119, 119, 119, 121, 103, 121, 102,
121, 122, 101, 122, 122, 122, 123, 123, 99, 123,
123, 124, 124, 124, 124, 124, 125, 96, 125, 125,
125, 95, 94, 91, 90, 88, 87, 85, 84, 83,
82, 81, 80, 79, 78, 77, 76, 75, 74, 73,
72, 71, 70, 69, 60, 59, 58, 57, 56, 55,
54, 53, 52, 51, 50, 49, 48, 47, 45, 42,
40, 37, 30, 29, 27, 26, 24, 23, 22, 21,
20, 19, 14, 7, 116, 116, 116, 116, 116, 116,
116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
116
} ;
static incr_yy_state_type incr_yy_last_accepting_state;
static char *incr_yy_last_accepting_cpos;
#define REJECT reject_used_but_not_detected
#define incr_yymore() incr_yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
char *incr_yytext;
#line 1 "incrscan.lpp"
#define INITIAL 0
#line 3 "incrscan.lpp"
#pragma prototyped
#include <stdio.h>
extern "C" {
#include "agraph.h"
}
#include "incrface/incrgram.h"
#include "common/StringDict.h"
#include "incrface/incrxep.h"
#define isatty(x) 1
#define GRAPH_EOF_TOKEN '@'
#ifndef incr_yywrap
#define incr_yywrap() 1
#endif
static int line_num = 1;
static char *Sbuf,*Sptr,*Send;
static void beginstr(void) {
if (Sbuf == NIL(char*)) {
Sbuf = (char*)malloc(BUFSIZ);
Send = Sbuf + BUFSIZ;
}
Sptr = Sbuf;
*Sptr = 0; }
static void addstr(char *src) {
char c;
if (Sptr > Sbuf) Sptr--;
do {
do {c = *Sptr++ = *src++;} while (c && (Sptr < Send));
if (c) {
long sz = long(Send - Sbuf);
long off = long(Sptr - Sbuf);
sz *= 2;
Sbuf = (char*)realloc(Sbuf,sz);
Send = Sbuf + sz;
Sptr = Sbuf + off;
}
} while (c);
}
static void endstr(void) {
incr_yylval.str = (char*)agstrdup(NIL(Agraph_t*),Sbuf);
}
#define comment 1
#define qstring 2
#line 500 "lex.incr_yy.c"
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int incr_yywrap YY_PROTO(( void ));
#else
extern int incr_yywrap YY_PROTO(( void ));
#endif
#endif
#ifndef YY_NO_UNPUT
static void incr_yyunput YY_PROTO(( int c, char *buf_ptr ));
#endif
#ifndef incr_yytext_ptr
static void incr_yy_flex_strncpy YY_PROTO(( char *, incr_yyconst char *, int ));
#endif
#ifdef YY_NEED_STRLEN
static int incr_yy_flex_strlen YY_PROTO(( incr_yyconst char * ));
#endif
#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int incr_yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO(( void ));
#endif
#endif
#if YY_STACK_USED
static int incr_yy_start_stack_ptr = 0;
static int incr_yy_start_stack_depth = 0;
static int *incr_yy_start_stack = 0;
#ifndef YY_NO_PUSH_STATE
static void incr_yy_push_state YY_PROTO(( int new_state ));
#endif
#ifndef YY_NO_POP_STATE
static void incr_yy_pop_state YY_PROTO(( void ));
#endif
#ifndef YY_NO_TOP_STATE
static int incr_yy_top_state YY_PROTO(( void ));
#endif
#else
#define YY_NO_PUSH_STATE 1
#define YY_NO_POP_STATE 1
#define YY_NO_TOP_STATE 1
#endif
#ifdef YY_MALLOC_DECL
YY_MALLOC_DECL
#else
#if __STDC__
#ifndef __cplusplus
#include <stdlib.h>
#endif
#else
#endif
#endif
#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif
#ifndef ECHO
#define ECHO (void) fwrite( incr_yytext, incr_yyleng, 1, incr_yyout )
#endif
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
if ( incr_yy_current_buffer->incr_yy_is_interactive ) \
{ \
int c = '*', n; \
for ( n = 0; n < max_size && \
(c = getc( incr_yyin )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \
if ( c == '\n' ) \
buf[n++] = (char) c; \
if ( c == EOF && ferror( incr_yyin ) ) \
YY_FATAL_ERROR( "input in flex scanner failed" ); \
result = n; \
} \
else if ( ((result = fread( buf, 1, max_size, incr_yyin )) == 0) \
&& ferror( incr_yyin ) ) \
YY_FATAL_ERROR( "input in flex scanner failed" );
#endif
#ifndef incr_yyterminate
#define incr_yyterminate() return YY_NULL
#endif
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) incr_yy_fatal_error( msg )
#endif
#ifndef YY_DECL
#define YY_DECL int incr_yylex YY_PROTO(( void ))
#endif
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif
#ifndef YY_BREAK
#define YY_BREAK break;
#endif
#define YY_RULE_SETUP \
YY_USER_ACTION
YY_DECL
{
register incr_yy_state_type incr_yy_current_state;
register char *incr_yy_cp = NULL, *incr_yy_bp = NULL;
register int incr_yy_act;
#line 58 "incrscan.lpp"
#line 653 "lex.incr_yy.c"
if ( incr_yy_init )
{
incr_yy_init = 0;
#ifdef YY_USER_INIT
YY_USER_INIT;
#endif
if ( ! incr_yy_start )
incr_yy_start = 1;
if ( ! incr_yyin )
incr_yyin = stdin;
if ( ! incr_yyout )
incr_yyout = stdout;
if ( ! incr_yy_current_buffer )
incr_yy_current_buffer =
incr_yy_create_buffer( incr_yyin, YY_BUF_SIZE );
incr_yy_load_buffer_state();
}
while ( 1 )
{
incr_yy_cp = incr_yy_c_buf_p;
*incr_yy_cp = incr_yy_hold_char;
incr_yy_bp = incr_yy_cp;
incr_yy_current_state = incr_yy_start;
incr_yy_match:
do
{
register YY_CHAR incr_yy_c = incr_yy_ec[YY_SC_TO_UI(*incr_yy_cp)];
if ( incr_yy_accept[incr_yy_current_state] )
{
incr_yy_last_accepting_state = incr_yy_current_state;
incr_yy_last_accepting_cpos = incr_yy_cp;
}
while ( incr_yy_chk[incr_yy_base[incr_yy_current_state] + incr_yy_c] != incr_yy_current_state )
{
incr_yy_current_state = (int) incr_yy_def[incr_yy_current_state];
if ( incr_yy_current_state >= 117 )
incr_yy_c = incr_yy_meta[(unsigned int) incr_yy_c];
}
incr_yy_current_state = incr_yy_nxt[incr_yy_base[incr_yy_current_state] + (unsigned int) incr_yy_c];
++incr_yy_cp;
}
while ( incr_yy_base[incr_yy_current_state] != 165 );
incr_yy_find_action:
incr_yy_act = incr_yy_accept[incr_yy_current_state];
if ( incr_yy_act == 0 )
{
incr_yy_cp = incr_yy_last_accepting_cpos;
incr_yy_current_state = incr_yy_last_accepting_state;
incr_yy_act = incr_yy_accept[incr_yy_current_state];
}
YY_DO_BEFORE_ACTION;
do_action:
switch ( incr_yy_act )
{
case 0:
*incr_yy_cp = incr_yy_hold_char;
incr_yy_cp = incr_yy_last_accepting_cpos;
incr_yy_current_state = incr_yy_last_accepting_state;
goto incr_yy_find_action;
case 1:
YY_RULE_SETUP
#line 59 "incrscan.lpp"
return(EOF);
YY_BREAK
case 2:
YY_RULE_SETUP
#line 60 "incrscan.lpp"
{line_num++; return(incr_yytext[0]);}
YY_BREAK
case 3:
YY_RULE_SETUP
#line 61 "incrscan.lpp"
line_num++;
YY_BREAK
case 4:
YY_RULE_SETUP
#line 62 "incrscan.lpp"
BEGIN(comment);
YY_BREAK
case 5:
YY_RULE_SETUP
#line 63 "incrscan.lpp"
YY_BREAK
case 6:
YY_RULE_SETUP
#line 64 "incrscan.lpp"
YY_BREAK
case 7:
YY_RULE_SETUP
#line 65 "incrscan.lpp"
BEGIN(INITIAL);
YY_BREAK
case 8:
YY_RULE_SETUP
#line 66 "incrscan.lpp"
YY_BREAK
case 9:
YY_RULE_SETUP
#line 67 "incrscan.lpp"
YY_BREAK
case 10:
YY_RULE_SETUP
#line 68 "incrscan.lpp"
YY_BREAK
case 11:
YY_RULE_SETUP
#line 69 "incrscan.lpp"
return(T_node);
YY_BREAK
case 12:
YY_RULE_SETUP
#line 70 "incrscan.lpp"
return(T_edge);
YY_BREAK
case 13:
YY_RULE_SETUP
#line 71 "incrscan.lpp"
return(T_graph);
YY_BREAK
case 14:
YY_RULE_SETUP
#line 72 "incrscan.lpp"
return(T_subgraph);
YY_BREAK
case 15:
YY_RULE_SETUP
#line 74 "incrscan.lpp"
return(T_delete);
YY_BREAK
case 16:
YY_RULE_SETUP
#line 75 "incrscan.lpp"
return(T_insert);
YY_BREAK
case 17:
YY_RULE_SETUP
#line 76 "incrscan.lpp"
return(T_modify);
YY_BREAK
case 18:
YY_RULE_SETUP
#line 77 "incrscan.lpp"
return(T_open);
YY_BREAK
case 19:
YY_RULE_SETUP
#line 78 "incrscan.lpp"
return(T_close);
YY_BREAK
case 20:
YY_RULE_SETUP
#line 79 "incrscan.lpp"
return(T_view);
YY_BREAK
case 21:
YY_RULE_SETUP
#line 80 "incrscan.lpp"
return(T_lock);
YY_BREAK
case 22:
YY_RULE_SETUP
#line 81 "incrscan.lpp"
return(T_unlock);
YY_BREAK
case 23:
YY_RULE_SETUP
#line 82 "incrscan.lpp"
return(T_segue);
YY_BREAK
case 24:
YY_RULE_SETUP
#line 83 "incrscan.lpp"
return(T_message);
YY_BREAK
case 25:
YY_RULE_SETUP
#line 85 "incrscan.lpp"
return(T_edgeop);
YY_BREAK
case 26:
YY_RULE_SETUP
#line 86 "incrscan.lpp"
{ incr_yylval.str = agstrdup(NIL(Agraph_t*),incr_yytext); return(T_id); }
YY_BREAK
case 27:
YY_RULE_SETUP
#line 87 "incrscan.lpp"
BEGIN(qstring); beginstr();
YY_BREAK
case 28:
YY_RULE_SETUP
#line 88 "incrscan.lpp"
BEGIN(INITIAL); endstr(); return (T_id);
YY_BREAK
case 29:
YY_RULE_SETUP
#line 89 "incrscan.lpp"
line_num++;
YY_BREAK
case 30:
YY_RULE_SETUP
#line 90 "incrscan.lpp"
addstr(incr_yytext);
YY_BREAK
case 31:
YY_RULE_SETUP
#line 91 "incrscan.lpp"
return (incr_yytext[0]);
YY_BREAK
case 32:
YY_RULE_SETUP
#line 92 "incrscan.lpp"
ECHO;
YY_BREAK
#line 896 "lex.incr_yy.c"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(comment):
case YY_STATE_EOF(qstring):
incr_yyterminate();
case YY_END_OF_BUFFER:
{
int incr_yy_amount_of_matched_text = (int) (incr_yy_cp - incr_yytext_ptr) - 1;
*incr_yy_cp = incr_yy_hold_char;
YY_RESTORE_YY_MORE_OFFSET
if ( incr_yy_current_buffer->incr_yy_buffer_status == YY_BUFFER_NEW )
{
incr_yy_n_chars = incr_yy_current_buffer->incr_yy_n_chars;
incr_yy_current_buffer->incr_yy_input_file = incr_yyin;
incr_yy_current_buffer->incr_yy_buffer_status = YY_BUFFER_NORMAL;
}
if ( incr_yy_c_buf_p <= &incr_yy_current_buffer->incr_yy_ch_buf[incr_yy_n_chars] )
{
incr_yy_state_type incr_yy_next_state;
incr_yy_c_buf_p = incr_yytext_ptr + incr_yy_amount_of_matched_text;
incr_yy_current_state = incr_yy_get_previous_state();
incr_yy_next_state = incr_yy_try_NUL_trans( incr_yy_current_state );
incr_yy_bp = incr_yytext_ptr + YY_MORE_ADJ;
if ( incr_yy_next_state )
{
incr_yy_cp = ++incr_yy_c_buf_p;
incr_yy_current_state = incr_yy_next_state;
goto incr_yy_match;
}
else
{
incr_yy_cp = incr_yy_c_buf_p;
goto incr_yy_find_action;
}
}
else switch ( incr_yy_get_next_buffer() )
{
case EOB_ACT_END_OF_FILE:
{
incr_yy_did_buffer_switch_on_eof = 0;
if ( incr_yywrap() )
{
incr_yy_c_buf_p = incr_yytext_ptr + YY_MORE_ADJ;
incr_yy_act = YY_STATE_EOF(YY_START);
goto do_action;
}
else
{
if ( ! incr_yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
}
break;
}
case EOB_ACT_CONTINUE_SCAN:
incr_yy_c_buf_p =
incr_yytext_ptr + incr_yy_amount_of_matched_text;
incr_yy_current_state = incr_yy_get_previous_state();
incr_yy_cp = incr_yy_c_buf_p;
incr_yy_bp = incr_yytext_ptr + YY_MORE_ADJ;
goto incr_yy_match;
case EOB_ACT_LAST_MATCH:
incr_yy_c_buf_p =
&incr_yy_current_buffer->incr_yy_ch_buf[incr_yy_n_chars];
incr_yy_current_state = incr_yy_get_previous_state();
incr_yy_cp = incr_yy_c_buf_p;
incr_yy_bp = incr_yytext_ptr + YY_MORE_ADJ;
goto incr_yy_find_action;
}
break;
}
default:
YY_FATAL_ERROR(
"fatal flex scanner internal error--no action found" );
}
}
}
static int incr_yy_get_next_buffer()
{
register char *dest = incr_yy_current_buffer->incr_yy_ch_buf;
register char *source = incr_yytext_ptr;
register int number_to_move, i;
int ret_val;
if ( incr_yy_c_buf_p > &incr_yy_current_buffer->incr_yy_ch_buf[incr_yy_n_chars + 1] )
YY_FATAL_ERROR(
"fatal flex scanner internal error--end of buffer missed" );
if ( incr_yy_current_buffer->incr_yy_fill_buffer == 0 )
{
if ( incr_yy_c_buf_p - incr_yytext_ptr - YY_MORE_ADJ == 1 )
{
return EOB_ACT_END_OF_FILE;
}
else
{
return EOB_ACT_LAST_MATCH;
}
}
number_to_move = (int) (incr_yy_c_buf_p - incr_yytext_ptr) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
if ( incr_yy_current_buffer->incr_yy_buffer_status == YY_BUFFER_EOF_PENDING )
incr_yy_current_buffer->incr_yy_n_chars = incr_yy_n_chars = 0;
else
{
int num_to_read =
incr_yy_current_buffer->incr_yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
{
#ifdef YY_USES_REJECT
YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else
YY_BUFFER_STATE b = incr_yy_current_buffer;
int incr_yy_c_buf_p_offset =
(int) (incr_yy_c_buf_p - b->incr_yy_ch_buf);
if ( b->incr_yy_is_our_buffer )
{
int new_size = b->incr_yy_buf_size * 2;
if ( new_size <= 0 )
b->incr_yy_buf_size += b->incr_yy_buf_size / 8;
else
b->incr_yy_buf_size *= 2;
b->incr_yy_ch_buf = (char *)
incr_yy_flex_realloc( (void *) b->incr_yy_ch_buf,
b->incr_yy_buf_size + 2 );
}
else
b->incr_yy_ch_buf = 0;
if ( ! b->incr_yy_ch_buf )
YY_FATAL_ERROR(
"fatal error - scanner input buffer overflow" );
incr_yy_c_buf_p = &b->incr_yy_ch_buf[incr_yy_c_buf_p_offset];
num_to_read = incr_yy_current_buffer->incr_yy_buf_size -
number_to_move - 1;
#endif
}
if ( num_to_read > YY_READ_BUF_SIZE )
num_to_read = YY_READ_BUF_SIZE;
YY_INPUT( (&incr_yy_current_buffer->incr_yy_ch_buf[number_to_move]),
incr_yy_n_chars, num_to_read );
incr_yy_current_buffer->incr_yy_n_chars = incr_yy_n_chars;
}
if ( incr_yy_n_chars == 0 )
{
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
incr_yyrestart( incr_yyin );
}
else
{
ret_val = EOB_ACT_LAST_MATCH;
incr_yy_current_buffer->incr_yy_buffer_status =
YY_BUFFER_EOF_PENDING;
}
}
else
ret_val = EOB_ACT_CONTINUE_SCAN;
incr_yy_n_chars += number_to_move;
incr_yy_current_buffer->incr_yy_ch_buf[incr_yy_n_chars] = YY_END_OF_BUFFER_CHAR;
incr_yy_current_buffer->incr_yy_ch_buf[incr_yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
incr_yytext_ptr = &incr_yy_current_buffer->incr_yy_ch_buf[0];
return ret_val;
}
static incr_yy_state_type incr_yy_get_previous_state()
{
register incr_yy_state_type incr_yy_current_state;
register char *incr_yy_cp;
incr_yy_current_state = incr_yy_start;
for ( incr_yy_cp = incr_yytext_ptr + YY_MORE_ADJ; incr_yy_cp < incr_yy_c_buf_p; ++incr_yy_cp )
{
register YY_CHAR incr_yy_c = (*incr_yy_cp ? incr_yy_ec[YY_SC_TO_UI(*incr_yy_cp)] : 1);
if ( incr_yy_accept[incr_yy_current_state] )
{
incr_yy_last_accepting_state = incr_yy_current_state;
incr_yy_last_accepting_cpos = incr_yy_cp;
}
while ( incr_yy_chk[incr_yy_base[incr_yy_current_state] + incr_yy_c] != incr_yy_current_state )
{
incr_yy_current_state = (int) incr_yy_def[incr_yy_current_state];
if ( incr_yy_current_state >= 117 )
incr_yy_c = incr_yy_meta[(unsigned int) incr_yy_c];
}
incr_yy_current_state = incr_yy_nxt[incr_yy_base[incr_yy_current_state] + (unsigned int) incr_yy_c];
}
return incr_yy_current_state;
}
#ifdef YY_USE_PROTOS
static incr_yy_state_type incr_yy_try_NUL_trans( incr_yy_state_type incr_yy_current_state )
#else
static incr_yy_state_type incr_yy_try_NUL_trans( incr_yy_current_state )
incr_yy_state_type incr_yy_current_state;
#endif
{
register int incr_yy_is_jam;
register char *incr_yy_cp = incr_yy_c_buf_p;
register YY_CHAR incr_yy_c = 1;
if ( incr_yy_accept[incr_yy_current_state] )
{
incr_yy_last_accepting_state = incr_yy_current_state;
incr_yy_last_accepting_cpos = incr_yy_cp;
}
while ( incr_yy_chk[incr_yy_base[incr_yy_current_state] + incr_yy_c] != incr_yy_current_state )
{
incr_yy_current_state = (int) incr_yy_def[incr_yy_current_state];
if ( incr_yy_current_state >= 117 )
incr_yy_c = incr_yy_meta[(unsigned int) incr_yy_c];
}
incr_yy_current_state = incr_yy_nxt[incr_yy_base[incr_yy_current_state] + (unsigned int) incr_yy_c];
incr_yy_is_jam = (incr_yy_current_state == 116);
return incr_yy_is_jam ? 0 : incr_yy_current_state;
}
#ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS
static void incr_yyunput( int c, register char *incr_yy_bp )
#else
static void incr_yyunput( c, incr_yy_bp )
int c;
register char *incr_yy_bp;
#endif
{
register char *incr_yy_cp = incr_yy_c_buf_p;
*incr_yy_cp = incr_yy_hold_char;
if ( incr_yy_cp < incr_yy_current_buffer->incr_yy_ch_buf + 2 )
{
register int number_to_move = incr_yy_n_chars + 2;
register char *dest = &incr_yy_current_buffer->incr_yy_ch_buf[
incr_yy_current_buffer->incr_yy_buf_size + 2];
register char *source =
&incr_yy_current_buffer->incr_yy_ch_buf[number_to_move];
while ( source > incr_yy_current_buffer->incr_yy_ch_buf )
*--dest = *--source;
incr_yy_cp += (int) (dest - source);
incr_yy_bp += (int) (dest - source);
incr_yy_current_buffer->incr_yy_n_chars =
incr_yy_n_chars = incr_yy_current_buffer->incr_yy_buf_size;
if ( incr_yy_cp < incr_yy_current_buffer->incr_yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
}
*--incr_yy_cp = (char) c;
incr_yytext_ptr = incr_yy_bp;
incr_yy_hold_char = *incr_yy_cp;
incr_yy_c_buf_p = incr_yy_cp;
}
#endif
#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int incr_yyinput()
#else
static int input()
#endif
{
int c;
*incr_yy_c_buf_p = incr_yy_hold_char;
if ( *incr_yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
{
if ( incr_yy_c_buf_p < &incr_yy_current_buffer->incr_yy_ch_buf[incr_yy_n_chars] )
*incr_yy_c_buf_p = '\0';
else
{
int offset = incr_yy_c_buf_p - incr_yytext_ptr;
++incr_yy_c_buf_p;
switch ( incr_yy_get_next_buffer() )
{
case EOB_ACT_LAST_MATCH:
incr_yyrestart( incr_yyin );
case EOB_ACT_END_OF_FILE:
{
if ( incr_yywrap() )
return EOF;
if ( ! incr_yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
#ifdef __cplusplus
return incr_yyinput();
#else
return input();
#endif
}
case EOB_ACT_CONTINUE_SCAN:
incr_yy_c_buf_p = incr_yytext_ptr + offset;
break;
}
}
}
c = *(unsigned char *) incr_yy_c_buf_p;
*incr_yy_c_buf_p = '\0';
incr_yy_hold_char = *++incr_yy_c_buf_p;
return c;
}
#endif
#ifdef YY_USE_PROTOS
void incr_yyrestart( FILE *input_file )
#else
void incr_yyrestart( input_file )
FILE *input_file;
#endif
{
if ( ! incr_yy_current_buffer )
incr_yy_current_buffer = incr_yy_create_buffer( incr_yyin, YY_BUF_SIZE );
incr_yy_init_buffer( incr_yy_current_buffer, input_file );
incr_yy_load_buffer_state();
}
#ifdef YY_USE_PROTOS
void incr_yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
#else
void incr_yy_switch_to_buffer( new_buffer )
YY_BUFFER_STATE new_buffer;
#endif
{
if ( incr_yy_current_buffer == new_buffer )
return;
if ( incr_yy_current_buffer )
{
*incr_yy_c_buf_p = incr_yy_hold_char;
incr_yy_current_buffer->incr_yy_buf_pos = incr_yy_c_buf_p;
incr_yy_current_buffer->incr_yy_n_chars = incr_yy_n_chars;
}
incr_yy_current_buffer = new_buffer;
incr_yy_load_buffer_state();
incr_yy_did_buffer_switch_on_eof = 1;
}
#ifdef YY_USE_PROTOS
void incr_yy_load_buffer_state( void )
#else
void incr_yy_load_buffer_state()
#endif
{
incr_yy_n_chars = incr_yy_current_buffer->incr_yy_n_chars;
incr_yytext_ptr = incr_yy_c_buf_p = incr_yy_current_buffer->incr_yy_buf_pos;
incr_yyin = incr_yy_current_buffer->incr_yy_input_file;
incr_yy_hold_char = *incr_yy_c_buf_p;
}
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE incr_yy_create_buffer( FILE *file, int size )
#else
YY_BUFFER_STATE incr_yy_create_buffer( file, size )
FILE *file;
int size;
#endif
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) incr_yy_flex_alloc( sizeof( struct incr_yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in incr_yy_create_buffer()" );
b->incr_yy_buf_size = size;
b->incr_yy_ch_buf = (char *) incr_yy_flex_alloc( b->incr_yy_buf_size + 2 );
if ( ! b->incr_yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in incr_yy_create_buffer()" );
b->incr_yy_is_our_buffer = 1;
incr_yy_init_buffer( b, file );
return b;
}
#ifdef YY_USE_PROTOS
void incr_yy_delete_buffer( YY_BUFFER_STATE b )
#else
void incr_yy_delete_buffer( b )
YY_BUFFER_STATE b;
#endif
{
if ( ! b )
return;
if ( b == incr_yy_current_buffer )
incr_yy_current_buffer = (YY_BUFFER_STATE) 0;
if ( b->incr_yy_is_our_buffer )
incr_yy_flex_free( (void *) b->incr_yy_ch_buf );
incr_yy_flex_free( (void *) b );
}
#ifdef YY_USE_PROTOS
void incr_yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
#else
void incr_yy_init_buffer( b, file )
YY_BUFFER_STATE b;
FILE *file;
#endif
{
incr_yy_flush_buffer( b );
b->incr_yy_input_file = file;
b->incr_yy_fill_buffer = 1;
#if YY_ALWAYS_INTERACTIVE
b->incr_yy_is_interactive = 1;
#else
#if YY_NEVER_INTERACTIVE
b->incr_yy_is_interactive = 0;
#else
b->incr_yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
#endif
#endif
}
#ifdef YY_USE_PROTOS
void incr_yy_flush_buffer( YY_BUFFER_STATE b )
#else
void incr_yy_flush_buffer( b )
YY_BUFFER_STATE b;
#endif
{
if ( ! b )
return;
b->incr_yy_n_chars = 0;
b->incr_yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->incr_yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->incr_yy_buf_pos = &b->incr_yy_ch_buf[0];
b->incr_yy_at_bol = 1;
b->incr_yy_buffer_status = YY_BUFFER_NEW;
if ( b == incr_yy_current_buffer )
incr_yy_load_buffer_state();
}
#ifndef YY_NO_SCAN_BUFFER
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE incr_yy_scan_buffer( char *base, incr_yy_size_t size )
#else
YY_BUFFER_STATE incr_yy_scan_buffer( base, size )
char *base;
incr_yy_size_t size;
#endif
{
YY_BUFFER_STATE b;
if ( size < 2 ||
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR )
return 0;
b = (YY_BUFFER_STATE) incr_yy_flex_alloc( sizeof( struct incr_yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in incr_yy_scan_buffer()" );
b->incr_yy_buf_size = size - 2;
b->incr_yy_buf_pos = b->incr_yy_ch_buf = base;
b->incr_yy_is_our_buffer = 0;
b->incr_yy_input_file = 0;
b->incr_yy_n_chars = b->incr_yy_buf_size;
b->incr_yy_is_interactive = 0;
b->incr_yy_at_bol = 1;
b->incr_yy_fill_buffer = 0;
b->incr_yy_buffer_status = YY_BUFFER_NEW;
incr_yy_switch_to_buffer( b );
return b;
}
#endif
#ifndef YY_NO_SCAN_STRING
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE incr_yy_scan_string( incr_yyconst char *incr_yy_str )
#else
YY_BUFFER_STATE incr_yy_scan_string( incr_yy_str )
incr_yyconst char *incr_yy_str;
#endif
{
int len;
for ( len = 0; incr_yy_str[len]; ++len )
;
return incr_yy_scan_bytes( incr_yy_str, len );
}
#endif
#ifndef YY_NO_SCAN_BYTES
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE incr_yy_scan_bytes( incr_yyconst char *bytes, int len )
#else
YY_BUFFER_STATE incr_yy_scan_bytes( bytes, len )
incr_yyconst char *bytes;
int len;
#endif
{
YY_BUFFER_STATE b;
char *buf;
incr_yy_size_t n;
int i;
n = len + 2;
buf = (char *) incr_yy_flex_alloc( n );
if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in incr_yy_scan_bytes()" );
for ( i = 0; i < len; ++i )
buf[i] = bytes[i];
buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
b = incr_yy_scan_buffer( buf, n );
if ( ! b )
YY_FATAL_ERROR( "bad buffer in incr_yy_scan_bytes()" );
b->incr_yy_is_our_buffer = 1;
return b;
}
#endif
#ifndef YY_NO_PUSH_STATE
#ifdef YY_USE_PROTOS
static void incr_yy_push_state( int new_state )
#else
static void incr_yy_push_state( new_state )
int new_state;
#endif
{
if ( incr_yy_start_stack_ptr >= incr_yy_start_stack_depth )
{
incr_yy_size_t new_size;
incr_yy_start_stack_depth += YY_START_STACK_INCR;
new_size = incr_yy_start_stack_depth * sizeof( int );
if ( ! incr_yy_start_stack )
incr_yy_start_stack = (int *) incr_yy_flex_alloc( new_size );
else
incr_yy_start_stack = (int *) incr_yy_flex_realloc(
(void *) incr_yy_start_stack, new_size );
if ( ! incr_yy_start_stack )
YY_FATAL_ERROR(
"out of memory expanding start-condition stack" );
}
incr_yy_start_stack[incr_yy_start_stack_ptr++] = YY_START;
BEGIN(new_state);
}
#endif
#ifndef YY_NO_POP_STATE
static void incr_yy_pop_state()
{
if ( --incr_yy_start_stack_ptr < 0 )
YY_FATAL_ERROR( "start-condition stack underflow" );
BEGIN(incr_yy_start_stack[incr_yy_start_stack_ptr]);
}
#endif
#ifndef YY_NO_TOP_STATE
static int incr_yy_top_state()
{
return incr_yy_start_stack[incr_yy_start_stack_ptr - 1];
}
#endif
#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif
#ifdef YY_USE_PROTOS
static void incr_yy_fatal_error( incr_yyconst char msg[] )
#else
static void incr_yy_fatal_error( msg )
char msg[];
#endif
{
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
#undef incr_yyless
#define incr_yyless(n) \
do \
{ \
\
incr_yytext[incr_yyleng] = incr_yy_hold_char; \
incr_yy_c_buf_p = incr_yytext + n; \
incr_yy_hold_char = *incr_yy_c_buf_p; \
*incr_yy_c_buf_p = '\0'; \
incr_yyleng = n; \
} \
while ( 0 )
#ifndef incr_yytext_ptr
#ifdef YY_USE_PROTOS
static void incr_yy_flex_strncpy( char *s1, incr_yyconst char *s2, int n )
#else
static void incr_yy_flex_strncpy( s1, s2, n )
char *s1;
incr_yyconst char *s2;
int n;
#endif
{
register int i;
for ( i = 0; i < n; ++i )
s1[i] = s2[i];
}
#endif
#ifdef YY_NEED_STRLEN
#ifdef YY_USE_PROTOS
static int incr_yy_flex_strlen( incr_yyconst char *s )
#else
static int incr_yy_flex_strlen( s )
incr_yyconst char *s;
#endif
{
register int n;
for ( n = 0; s[n]; ++n )
;
return n;
}
#endif
#ifdef YY_USE_PROTOS
static void *incr_yy_flex_alloc( incr_yy_size_t size )
#else
static void *incr_yy_flex_alloc( size )
incr_yy_size_t size;
#endif
{
return (void *) malloc( size );
}
#ifdef YY_USE_PROTOS
static void *incr_yy_flex_realloc( void *ptr, incr_yy_size_t size )
#else
static void *incr_yy_flex_realloc( ptr, size )
void *ptr;
incr_yy_size_t size;
#endif
{
return (void *) realloc( (char *) ptr, size );
}
#ifdef YY_USE_PROTOS
static void incr_yy_flex_free( void *ptr )
#else
static void incr_yy_flex_free( ptr )
void *ptr;
#endif
{
free( ptr );
}
#if YY_MAIN
int main()
{
incr_yylex();
return 0;
}
#endif
#line 92 "incrscan.lpp"
void incr_yyerror(const char *str)
{
char buf[300];
sprintf(buf,"incr: %s in line %d near '%s'\n",str,line_num,incr_yytext);
throw IncrError(buf);
}
void lexeof() { unput(GRAPH_EOF_TOKEN); }