From aef1aa788e13d8e1f57ed64b9112e42c8a89eb98 Mon Sep 17 00:00:00 2001 From: nbd Date: Wed, 16 May 2012 15:23:12 +0000 Subject: iproute2: update to 3.3.0, drop a few useless old patches, add codel support git-svn-id: svn://svn.openwrt.org/openwrt/trunk@31758 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- package/iproute2/patches/005-flex-generated.patch | 1767 --------------------- 1 file changed, 1767 deletions(-) delete mode 100644 package/iproute2/patches/005-flex-generated.patch (limited to 'package/iproute2/patches/005-flex-generated.patch') diff --git a/package/iproute2/patches/005-flex-generated.patch b/package/iproute2/patches/005-flex-generated.patch deleted file mode 100644 index 34c980044..000000000 --- a/package/iproute2/patches/005-flex-generated.patch +++ /dev/null @@ -1,1767 +0,0 @@ ---- /dev/null -+++ b/tc/emp_ematch.lex.c -@@ -0,0 +1,1764 @@ -+#define yy_create_buffer ematch__create_buffer -+#define yy_delete_buffer ematch__delete_buffer -+#define yy_scan_buffer ematch__scan_buffer -+#define yy_scan_string ematch__scan_string -+#define yy_scan_bytes ematch__scan_bytes -+#define yy_flex_debug ematch__flex_debug -+#define yy_init_buffer ematch__init_buffer -+#define yy_flush_buffer ematch__flush_buffer -+#define yy_load_buffer_state ematch__load_buffer_state -+#define yy_switch_to_buffer ematch__switch_to_buffer -+#define yyin ematch_in -+#define yyleng ematch_leng -+#define yylex ematch_lex -+#define yyout ematch_out -+#define yyrestart ematch_restart -+#define yytext ematch_text -+ -+#line 19 "enp_ematch.lex.c" -+/* A lexical scanner generated by flex */ -+ -+/* Scanner skeleton version: -+ * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ -+ */ -+ -+#define FLEX_SCANNER -+#define YY_FLEX_MAJOR_VERSION 2 -+#define YY_FLEX_MINOR_VERSION 5 -+ -+#include -+ -+ -+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ -+#ifdef c_plusplus -+#ifndef __cplusplus -+#define __cplusplus -+#endif -+#endif -+ -+ -+#ifdef __cplusplus -+ -+#include -+#include -+ -+/* Use prototypes in function declarations. */ -+#define YY_USE_PROTOS -+ -+/* The "const" storage-class-modifier is valid. */ -+#define YY_USE_CONST -+ -+#else /* ! __cplusplus */ -+ -+#if __STDC__ -+ -+#define YY_USE_PROTOS -+#define YY_USE_CONST -+ -+#endif /* __STDC__ */ -+#endif /* ! __cplusplus */ -+ -+#ifdef __TURBOC__ -+ #pragma warn -rch -+ #pragma warn -use -+#include -+#include -+#define YY_USE_CONST -+#define YY_USE_PROTOS -+#endif -+ -+#ifdef YY_USE_CONST -+#define yyconst const -+#else -+#define yyconst -+#endif -+ -+ -+#ifdef YY_USE_PROTOS -+#define YY_PROTO(proto) proto -+#else -+#define YY_PROTO(proto) () -+#endif -+ -+/* Returned upon end-of-file. */ -+#define YY_NULL 0 -+ -+/* Promotes a possibly negative, possibly signed char to an unsigned -+ * integer for use as an array index. If the signed char is negative, -+ * we want to instead treat it as an 8-bit unsigned char, hence the -+ * double cast. -+ */ -+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) -+ -+/* Enter a start condition. This macro really ought to take a parameter, -+ * but we do it the disgusting crufty way forced on us by the ()-less -+ * definition of BEGIN. -+ */ -+#define BEGIN yy_start = 1 + 2 * -+ -+/* Translate the current start state into a value that can be later handed -+ * to BEGIN to return to the state. The YYSTATE alias is for lex -+ * compatibility. -+ */ -+#define YY_START ((yy_start - 1) / 2) -+#define YYSTATE YY_START -+ -+/* Action number for EOF rule of a given start state. */ -+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) -+ -+/* Special action meaning "start processing a new file". */ -+#define YY_NEW_FILE yyrestart( yyin ) -+ -+#define YY_END_OF_BUFFER_CHAR 0 -+ -+/* Size of default input buffer. */ -+#define YY_BUF_SIZE 16384 -+ -+typedef struct yy_buffer_state *YY_BUFFER_STATE; -+ -+extern int yyleng; -+extern FILE *yyin, *yyout; -+ -+#define EOB_ACT_CONTINUE_SCAN 0 -+#define EOB_ACT_END_OF_FILE 1 -+#define EOB_ACT_LAST_MATCH 2 -+ -+/* The funky do-while in the following #define is used to turn the definition -+ * int a single C statement (which needs a semi-colon terminator). This -+ * avoids problems with code like: -+ * -+ * if ( condition_holds ) -+ * yyless( 5 ); -+ * else -+ * do_something_else(); -+ * -+ * Prior to using the do-while the compiler would get upset at the -+ * "else" because it interpreted the "if" statement as being all -+ * done when it reached the ';' after the yyless() call. -+ */ -+ -+/* Return all but the first 'n' matched characters back to the input stream. */ -+ -+#define yyless(n) \ -+ do \ -+ { \ -+ /* Undo effects of setting up yytext. */ \ -+ *yy_cp = yy_hold_char; \ -+ YY_RESTORE_YY_MORE_OFFSET \ -+ yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ -+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ -+ } \ -+ while ( 0 ) -+ -+#define unput(c) yyunput( c, yytext_ptr ) -+ -+/* The following is because we cannot portably get our hands on size_t -+ * (without autoconf's help, which isn't available because we want -+ * flex-generated scanners to compile on their own). -+ */ -+typedef unsigned int yy_size_t; -+ -+ -+struct yy_buffer_state -+ { -+ FILE *yy_input_file; -+ -+ char *yy_ch_buf; /* input buffer */ -+ char *yy_buf_pos; /* current position in input buffer */ -+ -+ /* Size of input buffer in bytes, not including room for EOB -+ * characters. -+ */ -+ yy_size_t yy_buf_size; -+ -+ /* Number of characters read into yy_ch_buf, not including EOB -+ * characters. -+ */ -+ int 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 -+ * delete it. -+ */ -+ int yy_is_our_buffer; -+ -+ /* Whether this is an "interactive" input source; if so, and -+ * if we're using stdio for input, then we want to use getc() -+ * instead of fread(), to make sure we stop fetching input after -+ * each newline. -+ */ -+ int yy_is_interactive; -+ -+ /* Whether we're considered to be at the beginning of a line. -+ * If so, '^' rules will be active on the next match, otherwise -+ * not. -+ */ -+ int yy_at_bol; -+ -+ /* Whether to try to fill the input buffer when we reach the -+ * end of it. -+ */ -+ int yy_fill_buffer; -+ -+ int yy_buffer_status; -+#define YY_BUFFER_NEW 0 -+#define YY_BUFFER_NORMAL 1 -+ /* When an EOF's been seen but there's still some text to process -+ * then we mark the buffer as YY_EOF_PENDING, to indicate that we -+ * shouldn't try reading from the input source any more. We might -+ * still have a bunch of tokens to match, though, because of -+ * possible backing-up. -+ * -+ * When we actually see the EOF, we change the status to "new" -+ * (via yyrestart()), so that the user can continue scanning by -+ * just pointing yyin at a new input file. -+ */ -+#define YY_BUFFER_EOF_PENDING 2 -+ }; -+ -+static YY_BUFFER_STATE yy_current_buffer = 0; -+ -+/* We provide macros for accessing buffer states in case in the -+ * future we want to put the buffer states in a more general -+ * "scanner state". -+ */ -+#define YY_CURRENT_BUFFER yy_current_buffer -+ -+ -+/* yy_hold_char holds the character lost when yytext is formed. */ -+static char yy_hold_char; -+ -+static int yy_n_chars; /* number of characters read into yy_ch_buf */ -+ -+ -+int yyleng; -+ -+/* 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_start = 0; /* start state number */ -+ -+/* Flag which is used to allow yywrap()'s to do buffer switches -+ * instead of setting up a fresh yyin. A bit of a hack ... -+ */ -+static int yy_did_buffer_switch_on_eof; -+ -+void yyrestart YY_PROTO(( FILE *input_file )); -+ -+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); -+void yy_load_buffer_state YY_PROTO(( void )); -+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); -+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); -+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); -+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); -+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) -+ -+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); -+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); -+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); -+ -+static void *yy_flex_alloc YY_PROTO(( yy_size_t )); -+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); -+static void yy_flex_free YY_PROTO(( void * )); -+ -+#define yy_new_buffer yy_create_buffer -+ -+#define yy_set_interactive(is_interactive) \ -+ { \ -+ if ( ! yy_current_buffer ) \ -+ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ -+ yy_current_buffer->yy_is_interactive = is_interactive; \ -+ } -+ -+#define yy_set_bol(at_bol) \ -+ { \ -+ if ( ! yy_current_buffer ) \ -+ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ -+ yy_current_buffer->yy_at_bol = at_bol; \ -+ } -+ -+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) -+ -+ -+#define yywrap() 1 -+#define YY_SKIP_YYWRAP -+typedef unsigned char YY_CHAR; -+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; -+typedef int yy_state_type; -+extern char *yytext; -+#define yytext_ptr yytext -+ -+static yy_state_type yy_get_previous_state YY_PROTO(( void )); -+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); -+static int yy_get_next_buffer YY_PROTO(( void )); -+static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); -+ -+/* Done after the current pattern has been matched and before the -+ * corresponding action - sets up yytext. -+ */ -+#define YY_DO_BEFORE_ACTION \ -+ yytext_ptr = yy_bp; \ -+ yyleng = (int) (yy_cp - yy_bp); \ -+ yy_hold_char = *yy_cp; \ -+ *yy_cp = '\0'; \ -+ yy_c_buf_p = yy_cp; -+ -+#define YY_NUM_RULES 22 -+#define YY_END_OF_BUFFER 23 -+static yyconst short int yy_accept[43] = -+ { 0, -+ 0, 0, 0, 0, 23, 21, 1, 2, 19, 20, -+ 21, 21, 21, 15, 22, 3, 22, 21, 1, 21, -+ 21, 17, 15, 14, 4, 5, 13, 11, 12, 7, -+ 8, 9, 10, 14, 16, 18, 4, 5, 6, 4, -+ 6, 0 -+ } ; -+ -+static yyconst int 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, 1, 1, 1, 1, 1, 5, -+ 6, 1, 1, 1, 1, 1, 1, 7, 7, 7, -+ 7, 7, 7, 7, 7, 8, 8, 1, 1, 1, -+ 1, 1, 1, 1, 9, 10, 10, 11, 10, 10, -+ 1, 1, 1, 1, 1, 1, 1, 12, 13, 1, -+ 1, 14, 1, 15, 1, 1, 1, 1, 1, 1, -+ 1, 16, 1, 1, 1, 1, 17, 18, 10, 11, -+ -+ 10, 19, 1, 1, 1, 1, 1, 1, 1, 20, -+ 13, 1, 1, 21, 1, 22, 1, 23, 1, 24, -+ 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, 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, 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, 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 -+ } ; -+ -+static yyconst int yy_meta[25] = -+ { 0, -+ 1, 2, 3, 4, 2, 2, 5, 5, 5, 5, -+ 5, 1, 1, 1, 1, 4, 5, 5, 5, 1, -+ 1, 1, 1, 1 -+ } ; -+ -+static yyconst short int yy_base[48] = -+ { 0, -+ 0, 0, 22, 24, 89, 0, 27, 0, 91, 91, -+ 19, 75, 20, 0, 91, 91, 41, 0, 30, 72, -+ 51, 0, 0, 91, 28, 60, 91, 91, 91, 91, -+ 91, 91, 91, 0, 0, 0, 62, 64, 0, 67, -+ 91, 91, 75, 80, 85, 77, 32 -+ } ; -+ -+static yyconst short int yy_def[48] = -+ { 0, -+ 42, 1, 43, 43, 42, 44, 42, 44, 42, 42, -+ 44, 44, 44, 45, 42, 42, 42, 44, 42, 44, -+ 44, 44, 45, 42, 42, 42, 42, 42, 42, 42, -+ 42, 42, 42, 46, 44, 44, 42, 42, 47, 42, -+ 42, 0, 42, 42, 42, 42, 42 -+ } ; -+ -+static yyconst short int yy_nxt[116] = -+ { 0, -+ 6, 7, 7, 8, 9, 10, 6, 6, 11, 6, -+ 6, 12, 13, 6, 6, 6, 11, 6, 6, 12, -+ 6, 6, 6, 6, 15, 16, 15, 16, 19, 19, -+ 20, 19, 19, 22, 37, 38, 41, 17, 20, 17, -+ 22, 24, 24, 24, 24, 24, 24, 25, 26, 24, -+ 24, 24, 24, 24, 24, 24, 24, 27, 28, 29, -+ 30, 31, 32, 33, 34, 36, 38, 38, 40, 38, -+ 38, 38, 36, 38, 38, 14, 14, 14, 14, 14, -+ 18, 39, 35, 18, 18, 23, 23, 21, 42, 23, -+ 5, 42, 42, 42, 42, 42, 42, 42, 42, 42, -+ -+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, -+ 42, 42, 42, 42, 42 -+ } ; -+ -+static yyconst short int yy_chk[116] = -+ { 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, 3, 3, 4, 4, 7, 7, -+ 11, 19, 19, 13, 25, 25, 47, 3, 11, 4, -+ 13, 17, 17, 17, 17, 17, 17, 17, 17, 17, -+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, -+ 17, 17, 17, 17, 17, 21, 26, 26, 37, 37, -+ 38, 38, 21, 40, 40, 43, 43, 43, 43, 43, -+ 44, 46, 20, 44, 44, 45, 45, 12, 5, 45, -+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, -+ -+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, -+ 42, 42, 42, 42, 42 -+ } ; -+ -+static yy_state_type yy_last_accepting_state; -+static char *yy_last_accepting_cpos; -+ -+/* The intent behind this definition is that it'll catch -+ * any uses of REJECT which flex missed. -+ */ -+#define REJECT reject_used_but_not_detected -+#define yymore() yymore_used_but_not_detected -+#define YY_MORE_ADJ 0 -+#define YY_RESTORE_YY_MORE_OFFSET -+char *yytext; -+#line 1 "emp_ematch.l" -+#define INITIAL 0 -+#line 2 "emp_ematch.l" -+ #include "emp_ematch.yacc.h" -+ #include "m_ematch.h" -+ -+ extern int ematch_argc; -+ extern char **ematch_argv; -+ -+ #define yylval ematch_lval -+ -+ #define NEXT_EM_ARG() do { ematch_argc--; ematch_argv++; } while(0); -+ -+ #define YY_INPUT(buf, result, max_size) \ -+ { \ -+ next: \ -+ if (ematch_argc <= 0) \ -+ result = YY_NULL; \ -+ else if (**ematch_argv == '\0') { \ -+ NEXT_EM_ARG(); \ -+ goto next; \ -+ } else { \ -+ if (max_size <= strlen(*ematch_argv) + 1) { \ -+ fprintf(stderr, "match argument too long.\n"); \ -+ result = YY_NULL; \ -+ } else { \ -+ strcpy(buf, *ematch_argv); \ -+ result = strlen(*ematch_argv) + 1; \ -+ buf[result-1] = ' '; \ -+ buf[result] = '\0'; \ -+ NEXT_EM_ARG(); \ -+ } \ -+ } \ -+ } -+ -+ static void __attribute__ ((unused)) yyunput (int c,char *buf_ptr ); -+ static void __attribute__ ((unused)) yy_push_state (int new_state ); -+ static void __attribute__ ((unused)) yy_pop_state (void); -+ static int __attribute__ ((unused)) yy_top_state (void ); -+ -+ static char *strbuf; -+ static unsigned int strbuf_size; -+ static unsigned int strbuf_index; -+ -+ static void strbuf_enlarge(void) -+ { -+ strbuf_size += 512; -+ strbuf = realloc(strbuf, strbuf_size); -+ } -+ -+ static void strbuf_append_char(char c) -+ { -+ while (strbuf_index >= strbuf_size) -+ strbuf_enlarge(); -+ strbuf[strbuf_index++] = c; -+ } -+ -+ static void strbuf_append_charp(char *s) -+ { -+ while (strbuf_index >= strbuf_size) -+ strbuf_enlarge(); -+ memcpy(strbuf + strbuf_index, s, strlen(s)); -+ strbuf_index += strlen(s); -+ } -+ -+#define str 1 -+ -+#define YY_STACK_USED 1 -+#line 488 "enp_ematch.lex.c" -+ -+/* Macros after this point can all be overridden by user definitions in -+ * section 1. -+ */ -+ -+#ifndef YY_SKIP_YYWRAP -+#ifdef __cplusplus -+extern "C" int yywrap YY_PROTO(( void )); -+#else -+extern int yywrap YY_PROTO(( void )); -+#endif -+#endif -+ -+#ifndef YY_NO_UNPUT -+static void yyunput YY_PROTO(( int c, char *buf_ptr )); -+#endif -+ -+#ifndef yytext_ptr -+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); -+#endif -+ -+#ifdef YY_NEED_STRLEN -+static int yy_flex_strlen YY_PROTO(( yyconst char * )); -+#endif -+ -+#ifndef YY_NO_INPUT -+#ifdef __cplusplus -+static int yyinput YY_PROTO(( void )); -+#else -+static int input YY_PROTO(( void )); -+#endif -+#endif -+ -+#if YY_STACK_USED -+static int yy_start_stack_ptr = 0; -+static int yy_start_stack_depth = 0; -+static int *yy_start_stack = 0; -+#ifndef YY_NO_PUSH_STATE -+static void yy_push_state YY_PROTO(( int new_state )); -+#endif -+#ifndef YY_NO_POP_STATE -+static void yy_pop_state YY_PROTO(( void )); -+#endif -+#ifndef YY_NO_TOP_STATE -+static int 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 -+#endif -+#else -+/* Just try to get by without declaring the routines. This will fail -+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) -+ * or sizeof(void*) != sizeof(int). -+ */ -+#endif -+#endif -+ -+/* Amount of stuff to slurp up with each read. */ -+#ifndef YY_READ_BUF_SIZE -+#define YY_READ_BUF_SIZE 8192 -+#endif -+ -+/* Copy whatever the last rule matched to the standard output. */ -+ -+#ifndef ECHO -+/* This used to be an fputs(), but since the string might contain NUL's, -+ * we now use fwrite(). -+ */ -+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) -+#endif -+ -+/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, -+ * is returned in "result". -+ */ -+#ifndef YY_INPUT -+#define YY_INPUT(buf,result,max_size) \ -+ if ( yy_current_buffer->yy_is_interactive ) \ -+ { \ -+ int c = '*', n; \ -+ for ( n = 0; n < max_size && \ -+ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ -+ buf[n] = (char) c; \ -+ if ( c == '\n' ) \ -+ buf[n++] = (char) c; \ -+ if ( c == EOF && ferror( yyin ) ) \ -+ YY_FATAL_ERROR( "input in flex scanner failed" ); \ -+ result = n; \ -+ } \ -+ else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ -+ && ferror( yyin ) ) \ -+ YY_FATAL_ERROR( "input in flex scanner failed" ); -+#endif -+ -+/* No semi-colon after return; correct usage is to write "yyterminate();" - -+ * we don't want an extra ';' after the "return" because that will cause -+ * some compilers to complain about unreachable statements. -+ */ -+#ifndef yyterminate -+#define yyterminate() return YY_NULL -+#endif -+ -+/* Number of entries by which start-condition stack grows. */ -+#ifndef YY_START_STACK_INCR -+#define YY_START_STACK_INCR 25 -+#endif -+ -+/* Report a fatal error. */ -+#ifndef YY_FATAL_ERROR -+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) -+#endif -+ -+/* Default declaration of generated scanner - a define so the user can -+ * easily add parameters. -+ */ -+#ifndef YY_DECL -+#define YY_DECL int yylex YY_PROTO(( void )) -+#endif -+ -+/* Code executed at the beginning of each rule, after yytext and yyleng -+ * have been set up. -+ */ -+#ifndef YY_USER_ACTION -+#define YY_USER_ACTION -+#endif -+ -+/* Code executed at the end of each rule. */ -+#ifndef YY_BREAK -+#define YY_BREAK break; -+#endif -+ -+#define YY_RULE_SETUP \ -+ YY_USER_ACTION -+ -+YY_DECL -+ { -+ register yy_state_type yy_current_state; -+ register char *yy_cp, *yy_bp; -+ register int yy_act; -+ -+#line 69 "emp_ematch.l" -+ -+#line 641 "enp_ematch.lex.c" -+ -+ if ( yy_init ) -+ { -+ yy_init = 0; -+ -+#ifdef YY_USER_INIT -+ YY_USER_INIT; -+#endif -+ -+ if ( ! yy_start ) -+ yy_start = 1; /* first start state */ -+ -+ if ( ! yyin ) -+ yyin = stdin; -+ -+ if ( ! yyout ) -+ yyout = stdout; -+ -+ if ( ! yy_current_buffer ) -+ yy_current_buffer = -+ yy_create_buffer( yyin, YY_BUF_SIZE ); -+ -+ yy_load_buffer_state(); -+ } -+ -+ while ( 1 ) /* loops until end-of-file is reached */ -+ { -+ yy_cp = yy_c_buf_p; -+ -+ /* Support of yytext. */ -+ *yy_cp = yy_hold_char; -+ -+ /* yy_bp points to the position in yy_ch_buf of the start of -+ * the current run. -+ */ -+ yy_bp = yy_cp; -+ -+ yy_current_state = yy_start; -+yy_match: -+ do -+ { -+ register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; -+ if ( yy_accept[yy_current_state] ) -+ { -+ yy_last_accepting_state = yy_current_state; -+ yy_last_accepting_cpos = yy_cp; -+ } -+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) -+ { -+ yy_current_state = (int) yy_def[yy_current_state]; -+ if ( yy_current_state >= 43 ) -+ yy_c = yy_meta[(unsigned int) yy_c]; -+ } -+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; -+ ++yy_cp; -+ } -+ while ( yy_base[yy_current_state] != 91 ); -+ -+yy_find_action: -+ yy_act = yy_accept[yy_current_state]; -+ if ( yy_act == 0 ) -+ { /* have to back up */ -+ yy_cp = yy_last_accepting_cpos; -+ yy_current_state = yy_last_accepting_state; -+ yy_act = yy_accept[yy_current_state]; -+ } -+ -+ YY_DO_BEFORE_ACTION; -+ -+ -+do_action: /* This label is used only to access EOF actions. */ -+ -+ -+ switch ( yy_act ) -+ { /* beginning of action switch */ -+ case 0: /* must back up */ -+ /* undo the effects of YY_DO_BEFORE_ACTION */ -+ *yy_cp = yy_hold_char; -+ yy_cp = yy_last_accepting_cpos; -+ yy_current_state = yy_last_accepting_state; -+ goto yy_find_action; -+ -+case 1: -+YY_RULE_SETUP -+#line 70 "emp_ematch.l" -+ -+ YY_BREAK -+case 2: -+YY_RULE_SETUP -+#line 72 "emp_ematch.l" -+{ -+ if (strbuf == NULL) { -+ strbuf_size = 512; -+ strbuf = calloc(1, strbuf_size); -+ if (strbuf == NULL) -+ return ERROR; -+ } -+ strbuf_index = 0; -+ -+ BEGIN(str); -+ } -+ YY_BREAK -+case 3: -+YY_RULE_SETUP -+#line 84 "emp_ematch.l" -+{ -+ BEGIN(INITIAL); -+ yylval.b = bstr_new(strbuf, strbuf_index); -+ yylval.b->quoted = 1; -+ return ATTRIBUTE; -+ } -+ YY_BREAK -+case 4: -+YY_RULE_SETUP -+#line 91 "emp_ematch.l" -+{ /* octal escape sequence */ -+ int res; -+ -+ sscanf(yytext + 1, "%o", &res); -+ if (res > 0xFF) { -+ fprintf(stderr, "error: octal escape sequence" \ -+ " out of range\n"); -+ return ERROR; -+ } -+ strbuf_append_char((unsigned char) res); -+ } -+ YY_BREAK -+case 5: -+YY_RULE_SETUP -+#line 103 "emp_ematch.l" -+{ /* catch wrong octal escape seq. */ -+ fprintf(stderr, "error: invalid octale escape sequence\n"); -+ return ERROR; -+ } -+ YY_BREAK -+case 6: -+YY_RULE_SETUP -+#line 108 "emp_ematch.l" -+{ -+ int res; -+ -+ sscanf(yytext + 2, "%x", &res); -+ -+ if (res > 0xFF) { -+ fprintf(stderr, "error: hexadecimal escape " \ -+ "sequence out of range\n"); -+ return ERROR; -+ } -+ strbuf_append_char((unsigned char) res); -+ } -+ YY_BREAK -+case 7: -+YY_RULE_SETUP -+#line 121 "emp_ematch.l" -+strbuf_append_char('\n'); -+ YY_BREAK -+case 8: -+YY_RULE_SETUP -+#line 122 "emp_ematch.l" -+strbuf_append_char('\r'); -+ YY_BREAK -+case 9: -+YY_RULE_SETUP -+#line 123 "emp_ematch.l" -+strbuf_append_char('\t'); -+ YY_BREAK -+case 10: -+YY_RULE_SETUP -+#line 124 "emp_ematch.l" -+strbuf_append_char('\v'); -+ YY_BREAK -+case 11: -+YY_RULE_SETUP -+#line 125 "emp_ematch.l" -+strbuf_append_char('\b'); -+ YY_BREAK -+case 12: -+YY_RULE_SETUP -+#line 126 "emp_ematch.l" -+strbuf_append_char('\f'); -+ YY_BREAK -+case 13: -+YY_RULE_SETUP -+#line 127 "emp_ematch.l" -+strbuf_append_char('\a'); -+ YY_BREAK -+case 14: -+YY_RULE_SETUP -+#line 129 "emp_ematch.l" -+strbuf_append_char(yytext[1]); -+ YY_BREAK -+case 15: -+YY_RULE_SETUP -+#line 130 "emp_ematch.l" -+strbuf_append_charp(yytext); -+ YY_BREAK -+case 16: -+YY_RULE_SETUP -+#line 132 "emp_ematch.l" -+return AND; -+ YY_BREAK -+case 17: -+YY_RULE_SETUP -+#line 133 "emp_ematch.l" -+return OR; -+ YY_BREAK -+case 18: -+YY_RULE_SETUP -+#line 134 "emp_ematch.l" -+return NOT; -+ YY_BREAK -+case 19: -+#line 136 "emp_ematch.l" -+case 20: -+YY_RULE_SETUP -+#line 136 "emp_ematch.l" -+{ -+ return yylval.i = *yytext; -+ } -+ YY_BREAK -+case 21: -+YY_RULE_SETUP -+#line 139 "emp_ematch.l" -+{ -+ yylval.b = bstr_alloc(yytext); -+ if (yylval.b == NULL) -+ return ERROR; -+ return ATTRIBUTE; -+ } -+ YY_BREAK -+case 22: -+YY_RULE_SETUP -+#line 145 "emp_ematch.l" -+ECHO; -+ YY_BREAK -+#line 877 "enp_ematch.lex.c" -+case YY_STATE_EOF(INITIAL): -+case YY_STATE_EOF(str): -+ yyterminate(); -+ -+ case YY_END_OF_BUFFER: -+ { -+ /* Amount of text matched not including the EOB char. */ -+ int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; -+ -+ /* Undo the effects of YY_DO_BEFORE_ACTION. */ -+ *yy_cp = yy_hold_char; -+ YY_RESTORE_YY_MORE_OFFSET -+ -+ if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) -+ { -+ /* We're scanning a new file or input source. It's -+ * possible that this happened because the user -+ * just pointed yyin at a new source and called -+ * yylex(). If so, then we have to assure -+ * consistency between yy_current_buffer and our -+ * globals. Here is the right place to do so, because -+ * this is the first action (other than possibly a -+ * back-up) that will match for the new input source. -+ */ -+ yy_n_chars = yy_current_buffer->yy_n_chars; -+ yy_current_buffer->yy_input_file = yyin; -+ yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; -+ } -+ -+ /* Note that here we test for yy_c_buf_p "<=" to the position -+ * of the first EOB in the buffer, since yy_c_buf_p will -+ * already have been incremented past the NUL character -+ * (since all states make transitions on EOB to the -+ * end-of-buffer state). Contrast this with the test -+ * in input(). -+ */ -+ if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) -+ { /* This was really a NUL. */ -+ yy_state_type yy_next_state; -+ -+ yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; -+ -+ yy_current_state = yy_get_previous_state(); -+ -+ /* Okay, we're now positioned to make the NUL -+ * transition. We couldn't have -+ * yy_get_previous_state() go ahead and do it -+ * for us because it doesn't know how to deal -+ * with the possibility of jamming (and we don't -+ * want to build jamming into it because then it -+ * will run more slowly). -+ */ -+ -+ yy_next_state = yy_try_NUL_trans( yy_current_state ); -+ -+ yy_bp = yytext_ptr + YY_MORE_ADJ; -+ -+ if ( yy_next_state ) -+ { -+ /* Consume the NUL. */ -+ yy_cp = ++yy_c_buf_p; -+ yy_current_state = yy_next_state; -+ goto yy_match; -+ } -+ -+ else -+ { -+ yy_cp = yy_c_buf_p; -+ goto yy_find_action; -+ } -+ } -+ -+ else switch ( yy_get_next_buffer() ) -+ { -+ case EOB_ACT_END_OF_FILE: -+ { -+ yy_did_buffer_switch_on_eof = 0; -+ -+ if ( yywrap() ) -+ { -+ /* Note: because we've taken care in -+ * yy_get_next_buffer() to have set up -+ * yytext, we can now set up -+ * yy_c_buf_p so that if some total -+ * hoser (like flex itself) wants to -+ * call the scanner after we return the -+ * YY_NULL, it'll still work - another -+ * YY_NULL will get returned. -+ */ -+ yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; -+ -+ yy_act = YY_STATE_EOF(YY_START); -+ goto do_action; -+ } -+ -+ else -+ { -+ if ( ! yy_did_buffer_switch_on_eof ) -+ YY_NEW_FILE; -+ } -+ break; -+ } -+ -+ case EOB_ACT_CONTINUE_SCAN: -+ yy_c_buf_p = -+ yytext_ptr + yy_amount_of_matched_text; -+ -+ yy_current_state = yy_get_previous_state(); -+ -+ yy_cp = yy_c_buf_p; -+ yy_bp = yytext_ptr + YY_MORE_ADJ; -+ goto yy_match; -+ -+ case EOB_ACT_LAST_MATCH: -+ yy_c_buf_p = -+ &yy_current_buffer->yy_ch_buf[yy_n_chars]; -+ -+ yy_current_state = yy_get_previous_state(); -+ -+ yy_cp = yy_c_buf_p; -+ yy_bp = yytext_ptr + YY_MORE_ADJ; -+ goto yy_find_action; -+ } -+ break; -+ } -+ -+ default: -+ YY_FATAL_ERROR( -+ "fatal flex scanner internal error--no action found" ); -+ } /* end of action switch */ -+ } /* end of scanning one token */ -+ } /* end of yylex */ -+ -+ -+/* yy_get_next_buffer - try to read in a new buffer -+ * -+ * Returns a code representing an action: -+ * EOB_ACT_LAST_MATCH - -+ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position -+ * EOB_ACT_END_OF_FILE - end of file -+ */ -+ -+static int yy_get_next_buffer() -+ { -+ register char *dest = yy_current_buffer->yy_ch_buf; -+ register char *source = yytext_ptr; -+ register int number_to_move, i; -+ int ret_val; -+ -+ if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) -+ YY_FATAL_ERROR( -+ "fatal flex scanner internal error--end of buffer missed" ); -+ -+ if ( yy_current_buffer->yy_fill_buffer == 0 ) -+ { /* Don't try to fill the buffer, so this is an EOF. */ -+ if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) -+ { -+ /* We matched a single character, the EOB, so -+ * treat this as a final EOF. -+ */ -+ return EOB_ACT_END_OF_FILE; -+ } -+ -+ else -+ { -+ /* We matched some text prior to the EOB, first -+ * process it. -+ */ -+ return EOB_ACT_LAST_MATCH; -+ } -+ } -+ -+ /* Try to read more data. */ -+ -+ /* First move last chars to start of buffer. */ -+ number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; -+ -+ for ( i = 0; i < number_to_move; ++i ) -+ *(dest++) = *(source++); -+ -+ if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) -+ /* don't do the read, it's not guaranteed to return an EOF, -+ * just force an EOF -+ */ -+ yy_current_buffer->yy_n_chars = yy_n_chars = 0; -+ -+ else -+ { -+ int num_to_read = -+ yy_current_buffer->yy_buf_size - number_to_move - 1; -+ -+ while ( num_to_read <= 0 ) -+ { /* Not enough room in the buffer - grow it. */ -+#ifdef YY_USES_REJECT -+ YY_FATAL_ERROR( -+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); -+#else -+ -+ /* just a shorter name for the current buffer */ -+ YY_BUFFER_STATE b = yy_current_buffer; -+ -+ 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; -+ -+ if ( new_size <= 0 ) -+ b->yy_buf_size += b->yy_buf_size / 8; -+ else -+ b->yy_buf_size *= 2; -+ -+ b->yy_ch_buf = (char *) -+ /* Include room in for 2 EOB chars. */ -+ yy_flex_realloc( (void *) b->yy_ch_buf, -+ b->yy_buf_size + 2 ); -+ } -+ else -+ /* Can't grow it, we don't own it. */ -+ b->yy_ch_buf = 0; -+ -+ if ( ! b->yy_ch_buf ) -+ YY_FATAL_ERROR( -+ "fatal error - scanner input buffer overflow" ); -+ -+ yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; -+ -+ num_to_read = yy_current_buffer->yy_buf_size - -+ number_to_move - 1; -+#endif -+ } -+ -+ if ( num_to_read > YY_READ_BUF_SIZE ) -+ num_to_read = YY_READ_BUF_SIZE; -+ -+ /* Read in more data. */ -+ YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), -+ yy_n_chars, num_to_read ); -+ -+ yy_current_buffer->yy_n_chars = yy_n_chars; -+ } -+ -+ if ( yy_n_chars == 0 ) -+ { -+ if ( number_to_move == YY_MORE_ADJ ) -+ { -+ ret_val = EOB_ACT_END_OF_FILE; -+ yyrestart( yyin ); -+ } -+ -+ else -+ { -+ ret_val = EOB_ACT_LAST_MATCH; -+ yy_current_buffer->yy_buffer_status = -+ YY_BUFFER_EOF_PENDING; -+ } -+ } -+ -+ else -+ ret_val = EOB_ACT_CONTINUE_SCAN; -+ -+ yy_n_chars += number_to_move; -+ yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; -+ yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; -+ -+ yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; -+ -+ return ret_val; -+ } -+ -+ -+/* yy_get_previous_state - get the state just before the EOB char was reached */ -+ -+static yy_state_type yy_get_previous_state() -+ { -+ register yy_state_type yy_current_state; -+ register char *yy_cp; -+ -+ yy_current_state = yy_start; -+ -+ for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) -+ { -+ register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); -+ if ( yy_accept[yy_current_state] ) -+ { -+ yy_last_accepting_state = yy_current_state; -+ yy_last_accepting_cpos = yy_cp; -+ } -+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) -+ { -+ yy_current_state = (int) yy_def[yy_current_state]; -+ if ( yy_current_state >= 43 ) -+ yy_c = yy_meta[(unsigned int) yy_c]; -+ } -+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; -+ } -+ -+ return yy_current_state; -+ } -+ -+ -+/* yy_try_NUL_trans - try to make a transition on the NUL character -+ * -+ * synopsis -+ * next_state = yy_try_NUL_trans( current_state ); -+ */ -+ -+#ifdef YY_USE_PROTOS -+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) -+#else -+static yy_state_type yy_try_NUL_trans( yy_current_state ) -+yy_state_type yy_current_state; -+#endif -+ { -+ register int yy_is_jam; -+ register char *yy_cp = yy_c_buf_p; -+ -+ register YY_CHAR yy_c = 1; -+ if ( yy_accept[yy_current_state] ) -+ { -+ yy_last_accepting_state = yy_current_state; -+ yy_last_accepting_cpos = yy_cp; -+ } -+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) -+ { -+ yy_current_state = (int) yy_def[yy_current_state]; -+ if ( yy_current_state >= 43 ) -+ yy_c = yy_meta[(unsigned int) yy_c]; -+ } -+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; -+ yy_is_jam = (yy_current_state == 42); -+ -+ return yy_is_jam ? 0 : yy_current_state; -+ } -+ -+ -+#ifndef YY_NO_UNPUT -+#ifdef YY_USE_PROTOS -+static void yyunput( int c, register char *yy_bp ) -+#else -+static void yyunput( c, yy_bp ) -+int c; -+register char *yy_bp; -+#endif -+ { -+ register char *yy_cp = yy_c_buf_p; -+ -+ /* undo effects of setting up yytext */ -+ *yy_cp = yy_hold_char; -+ -+ if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) -+ { /* need to shift things up to make room */ -+ /* +2 for EOB chars. */ -+ register int number_to_move = yy_n_chars + 2; -+ register char *dest = &yy_current_buffer->yy_ch_buf[ -+ yy_current_buffer->yy_buf_size + 2]; -+ register char *source = -+ &yy_current_buffer->yy_ch_buf[number_to_move]; -+ -+ while ( source > yy_current_buffer->yy_ch_buf ) -+ *--dest = *--source; -+ -+ yy_cp += (int) (dest - source); -+ yy_bp += (int) (dest - source); -+ yy_current_buffer->yy_n_chars = -+ yy_n_chars = yy_current_buffer->yy_buf_size; -+ -+ if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) -+ YY_FATAL_ERROR( "flex scanner push-back overflow" ); -+ } -+ -+ *--yy_cp = (char) c; -+ -+ -+ yytext_ptr = yy_bp; -+ yy_hold_char = *yy_cp; -+ yy_c_buf_p = yy_cp; -+ } -+#endif /* ifndef YY_NO_UNPUT */ -+ -+ -+#ifdef __cplusplus -+static int yyinput() -+#else -+static int input() -+#endif -+ { -+ int c; -+ -+ *yy_c_buf_p = yy_hold_char; -+ -+ if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) -+ { -+ /* yy_c_buf_p now points to the character we want to return. -+ * If this occurs *before* the EOB characters, then it's a -+ * valid NUL; if not, then we've hit the end of the buffer. -+ */ -+ if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) -+ /* This was really a NUL. */ -+ *yy_c_buf_p = '\0'; -+ -+ else -+ { /* need more input */ -+ int offset = yy_c_buf_p - yytext_ptr; -+ ++yy_c_buf_p; -+ -+ switch ( yy_get_next_buffer() ) -+ { -+ case EOB_ACT_LAST_MATCH: -+ /* This happens because yy_g_n_b() -+ * sees that we've accumulated a -+ * token and flags that we need to -+ * try matching the token before -+ * proceeding. But for input(), -+ * there's no matching to consider. -+ * So convert the EOB_ACT_LAST_MATCH -+ * to EOB_ACT_END_OF_FILE. -+ */ -+ -+ /* Reset buffer status. */ -+ yyrestart( yyin ); -+ -+ /* fall through */ -+ -+ case EOB_ACT_END_OF_FILE: -+ { -+ if ( yywrap() ) -+ return EOF; -+ -+ if ( ! yy_did_buffer_switch_on_eof ) -+ YY_NEW_FILE; -+#ifdef __cplusplus -+ return yyinput(); -+#else -+ return input(); -+#endif -+ } -+ -+ case EOB_ACT_CONTINUE_SCAN: -+ yy_c_buf_p = yytext_ptr + offset; -+ break; -+ } -+ } -+ } -+ -+ c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ -+ *yy_c_buf_p = '\0'; /* preserve yytext */ -+ yy_hold_char = *++yy_c_buf_p; -+ -+ -+ return c; -+ } -+ -+ -+#ifdef YY_USE_PROTOS -+void yyrestart( FILE *input_file ) -+#else -+void yyrestart( input_file ) -+FILE *input_file; -+#endif -+ { -+ if ( ! yy_current_buffer ) -+ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); -+ -+ yy_init_buffer( yy_current_buffer, input_file ); -+ yy_load_buffer_state(); -+ } -+ -+ -+#ifdef YY_USE_PROTOS -+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) -+#else -+void yy_switch_to_buffer( new_buffer ) -+YY_BUFFER_STATE new_buffer; -+#endif -+ { -+ if ( yy_current_buffer == new_buffer ) -+ return; -+ -+ if ( yy_current_buffer ) -+ { -+ /* Flush out information for old buffer. */ -+ *yy_c_buf_p = yy_hold_char; -+ yy_current_buffer->yy_buf_pos = yy_c_buf_p; -+ yy_current_buffer->yy_n_chars = yy_n_chars; -+ } -+ -+ yy_current_buffer = new_buffer; -+ yy_load_buffer_state(); -+ -+ /* We don't actually know whether we did this switch during -+ * EOF (yywrap()) processing, but the only time this flag -+ * is looked at is after yywrap() is called, so it's safe -+ * to go ahead and always set it. -+ */ -+ yy_did_buffer_switch_on_eof = 1; -+ } -+ -+ -+#ifdef YY_USE_PROTOS -+void yy_load_buffer_state( void ) -+#else -+void yy_load_buffer_state() -+#endif -+ { -+ yy_n_chars = yy_current_buffer->yy_n_chars; -+ yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; -+ yyin = yy_current_buffer->yy_input_file; -+ yy_hold_char = *yy_c_buf_p; -+ } -+ -+ -+#ifdef YY_USE_PROTOS -+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) -+#else -+YY_BUFFER_STATE yy_create_buffer( file, size ) -+FILE *file; -+int size; -+#endif -+ { -+ YY_BUFFER_STATE b; -+ -+ b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); -+ if ( ! b ) -+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); -+ -+ b->yy_buf_size = size; -+ -+ /* yy_ch_buf has to be 2 characters longer than the size given because -+ * we need to put in 2 end-of-buffer characters. -+ */ -+ b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); -+ if ( ! b->yy_ch_buf ) -+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); -+ -+ b->yy_is_our_buffer = 1; -+ -+ yy_init_buffer( b, file ); -+ -+ return b; -+ } -+ -+ -+#ifdef YY_USE_PROTOS -+void yy_delete_buffer( YY_BUFFER_STATE b ) -+#else -+void yy_delete_buffer( b ) -+YY_BUFFER_STATE b; -+#endif -+ { -+ if ( ! b ) -+ return; -+ -+ if ( b == yy_current_buffer ) -+ yy_current_buffer = (YY_BUFFER_STATE) 0; -+ -+ if ( b->yy_is_our_buffer ) -+ yy_flex_free( (void *) b->yy_ch_buf ); -+ -+ yy_flex_free( (void *) b ); -+ } -+ -+ -+#ifndef YY_ALWAYS_INTERACTIVE -+#ifndef YY_NEVER_INTERACTIVE -+extern int isatty YY_PROTO(( int )); -+#endif -+#endif -+ -+#ifdef YY_USE_PROTOS -+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) -+#else -+void yy_init_buffer( b, file ) -+YY_BUFFER_STATE b; -+FILE *file; -+#endif -+ -+ -+ { -+ yy_flush_buffer( b ); -+ -+ b->yy_input_file = file; -+ b->yy_fill_buffer = 1; -+ -+#if YY_ALWAYS_INTERACTIVE -+ b->yy_is_interactive = 1; -+#else -+#if YY_NEVER_INTERACTIVE -+ b->yy_is_interactive = 0; -+#else -+ b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; -+#endif -+#endif -+ } -+ -+ -+#ifdef YY_USE_PROTOS -+void yy_flush_buffer( YY_BUFFER_STATE b ) -+#else -+void yy_flush_buffer( b ) -+YY_BUFFER_STATE b; -+#endif -+ -+ { -+ if ( ! b ) -+ return; -+ -+ b->yy_n_chars = 0; -+ -+ /* We always need two end-of-buffer characters. The first causes -+ * a transition to the end-of-buffer state. The second causes -+ * a jam in that state. -+ */ -+ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; -+ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; -+ -+ b->yy_buf_pos = &b->yy_ch_buf[0]; -+ -+ b->yy_at_bol = 1; -+ b->yy_buffer_status = YY_BUFFER_NEW; -+ -+ if ( b == yy_current_buffer ) -+ yy_load_buffer_state(); -+ } -+ -+ -+#ifndef YY_NO_SCAN_BUFFER -+#ifdef YY_USE_PROTOS -+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) -+#else -+YY_BUFFER_STATE yy_scan_buffer( base, size ) -+char *base; -+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 ) -+ /* They forgot to leave room for the EOB's. */ -+ return 0; -+ -+ b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); -+ if ( ! b ) -+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); -+ -+ b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ -+ b->yy_buf_pos = b->yy_ch_buf = base; -+ b->yy_is_our_buffer = 0; -+ b->yy_input_file = 0; -+ b->yy_n_chars = b->yy_buf_size; -+ b->yy_is_interactive = 0; -+ b->yy_at_bol = 1; -+ b->yy_fill_buffer = 0; -+ b->yy_buffer_status = YY_BUFFER_NEW; -+ -+ yy_switch_to_buffer( b ); -+ -+ return b; -+ } -+#endif -+ -+ -+#ifndef YY_NO_SCAN_STRING -+#ifdef YY_USE_PROTOS -+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) -+#else -+YY_BUFFER_STATE yy_scan_string( yy_str ) -+yyconst char *yy_str; -+#endif -+ { -+ int len; -+ for ( len = 0; yy_str[len]; ++len ) -+ ; -+ -+ return yy_scan_bytes( yy_str, len ); -+ } -+#endif -+ -+ -+#ifndef YY_NO_SCAN_BYTES -+#ifdef YY_USE_PROTOS -+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) -+#else -+YY_BUFFER_STATE yy_scan_bytes( bytes, len ) -+yyconst char *bytes; -+int len; -+#endif -+ { -+ YY_BUFFER_STATE b; -+ char *buf; -+ yy_size_t n; -+ int i; -+ -+ /* Get memory for full buffer, including space for trailing EOB's. */ -+ n = len + 2; -+ buf = (char *) yy_flex_alloc( n ); -+ if ( ! buf ) -+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); -+ -+ for ( i = 0; i < len; ++i ) -+ buf[i] = bytes[i]; -+ -+ buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; -+ -+ b = yy_scan_buffer( buf, n ); -+ if ( ! b ) -+ YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); -+ -+ /* It's okay to grow etc. this buffer, and we should throw it -+ * away when we're done. -+ */ -+ b->yy_is_our_buffer = 1; -+ -+ return b; -+ } -+#endif -+ -+ -+#ifndef YY_NO_PUSH_STATE -+#ifdef YY_USE_PROTOS -+static void yy_push_state( int new_state ) -+#else -+static void yy_push_state( new_state ) -+int new_state; -+#endif -+ { -+ if ( yy_start_stack_ptr >= yy_start_stack_depth ) -+ { -+ yy_size_t new_size; -+ -+ yy_start_stack_depth += YY_START_STACK_INCR; -+ new_size = yy_start_stack_depth * sizeof( int ); -+ -+ if ( ! yy_start_stack ) -+ yy_start_stack = (int *) yy_flex_alloc( new_size ); -+ -+ else -+ yy_start_stack = (int *) yy_flex_realloc( -+ (void *) yy_start_stack, new_size ); -+ -+ if ( ! yy_start_stack ) -+ YY_FATAL_ERROR( -+ "out of memory expanding start-condition stack" ); -+ } -+ -+ yy_start_stack[yy_start_stack_ptr++] = YY_START; -+ -+ BEGIN(new_state); -+ } -+#endif -+ -+ -+#ifndef YY_NO_POP_STATE -+static void yy_pop_state() -+ { -+ if ( --yy_start_stack_ptr < 0 ) -+ YY_FATAL_ERROR( "start-condition stack underflow" ); -+ -+ BEGIN(yy_start_stack[yy_start_stack_ptr]); -+ } -+#endif -+ -+ -+#ifndef YY_NO_TOP_STATE -+static int yy_top_state() -+ { -+ return yy_start_stack[yy_start_stack_ptr - 1]; -+ } -+#endif -+ -+#ifndef YY_EXIT_FAILURE -+#define YY_EXIT_FAILURE 2 -+#endif -+ -+#ifdef YY_USE_PROTOS -+static void yy_fatal_error( yyconst char msg[] ) -+#else -+static void yy_fatal_error( msg ) -+char msg[]; -+#endif -+ { -+ (void) fprintf( stderr, "%s\n", msg ); -+ exit( YY_EXIT_FAILURE ); -+ } -+ -+ -+ -+/* Redefine yyless() so it works in section 3 code. */ -+ -+#undef yyless -+#define yyless(n) \ -+ do \ -+ { \ -+ /* Undo effects of setting up yytext. */ \ -+ yytext[yyleng] = yy_hold_char; \ -+ yy_c_buf_p = yytext + n; \ -+ yy_hold_char = *yy_c_buf_p; \ -+ *yy_c_buf_p = '\0'; \ -+ yyleng = n; \ -+ } \ -+ while ( 0 ) -+ -+ -+/* Internal utility routines. */ -+ -+#ifndef yytext_ptr -+#ifdef YY_USE_PROTOS -+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) -+#else -+static void yy_flex_strncpy( s1, s2, n ) -+char *s1; -+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 yy_flex_strlen( yyconst char *s ) -+#else -+static int yy_flex_strlen( s ) -+yyconst char *s; -+#endif -+ { -+ register int n; -+ for ( n = 0; s[n]; ++n ) -+ ; -+ -+ return n; -+ } -+#endif -+ -+ -+#ifdef YY_USE_PROTOS -+static void *yy_flex_alloc( yy_size_t size ) -+#else -+static void *yy_flex_alloc( size ) -+yy_size_t size; -+#endif -+ { -+ return (void *) malloc( size ); -+ } -+ -+#ifdef YY_USE_PROTOS -+static void *yy_flex_realloc( void *ptr, yy_size_t size ) -+#else -+static void *yy_flex_realloc( ptr, size ) -+void *ptr; -+yy_size_t size; -+#endif -+ { -+ /* The cast to (char *) in the following accommodates both -+ * implementations that use char* generic pointers, and those -+ * that use void* generic pointers. It works with the latter -+ * because both ANSI C and C++ allow castless assignment from -+ * any pointer type to void*, and deal with argument conversions -+ * as though doing an assignment. -+ */ -+ return (void *) realloc( (char *) ptr, size ); -+ } -+ -+#ifdef YY_USE_PROTOS -+static void yy_flex_free( void *ptr ) -+#else -+static void yy_flex_free( ptr ) -+void *ptr; -+#endif -+ { -+ free( ptr ); -+ } -+ -+#if YY_MAIN -+int main() -+ { -+ yylex(); -+ return 0; -+ } -+#endif -+#line 145 "emp_ematch.l" -+ -- cgit v1.2.3