Ruby » Backport191

This file contains any messages produced by compilers while

running configure, to aid debugging if configure makes a mistake.

It was created by configure, which was

generated by GNU Autoconf 2.63. Invocation command line was

$ ./configure

## --------- ##

## Platform. ##

## --------- ##

hostname = mmm

uname -m = i686

uname -r = 2.6.31-ARCH

uname -s = Linux

uname -v = #1 SMP PREEMPT Tue Nov 10 19:48:17 CET 2009

/usr/bin/uname -p = unknown

/bin/uname -X = unknown

/bin/arch = i686

/usr/bin/arch -k = unknown

/usr/convex/getsysinfo = unknown

/usr/bin/hostinfo = unknown

/bin/machine = unknown

/usr/bin/oslevel = unknown

/bin/universe = unknown

PATH: /bin

PATH: /usr/bin

PATH: /sbin

PATH: /usr/sbin

PATH: /opt/java/bin

PATH: /opt/java/jre/bin

PATH: /opt/kde/bin

PATH: /usr/bin/perlbin/site

PATH: /usr/bin/perlbin/vendor

PATH: /usr/bin/perlbin/core

PATH: /opt/qt/bin

## ----------- ##

## Core tests. ##

## ----------- ##

configure:2872: checking build system type

configure:2890: result: i686-pc-linux-gnu

configure:2912: checking host system type

configure:2927: result: i686-pc-linux-gnu

configure:2949: checking target system type

configure:2964: result: i686-pc-linux-gnu

configure:3030: checking for a BSD-compatible install

configure:3098: result: /bin/install -c

configure:3109: checking whether build environment is sane

configure:3169: result: yes

configure:3310: checking for a thread-safe mkdir -p

configure:3349: result: /bin/mkdir -p

configure:3362: checking for gawk

configure:3378: found /bin/gawk

configure:3389: result: gawk

configure:3400: checking whether make sets $(MAKE)

configure:3422: result: yes

configure:3507: checking whether to enable maintainer-specific portions of Makefiles

configure:3516: result: no

configure:3580: checking for gcc

configure:3596: found /usr/bin/gcc

configure:3607: result: gcc

configure:3839: checking for C compiler version

configure:3847: gcc --version >&5

gcc (GCC) 4.4.2

Copyright (C) 2009 Free Software Foundation, Inc.

This is free software; see the source for copying conditions. There is NO

warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

configure:3851: $? = 0

configure:3858: gcc -v >&5

Using built-in specs.

Target: i686-pc-linux-gnu

Configured with: ../configure --prefix=/usr --enable-shared --enable-languages=c,c++,fortran,objc,obj-c++,ada --enable-threads=posix --mandir=/usr/share/man --infodir=/usr/share/info --enable-__cxa_atexit --disable-multilib --libdir=/usr/lib --libexecdir=/usr/lib --enable-clocale=gnu --disable-libstdcxx-pch --with-tune=generic

Thread model: posix

gcc version 4.4.2 (GCC)

configure:3862: $? = 0

configure:3869: gcc -V >&5

gcc: '-V' option must have argument

configure:3873: $? = 1

configure:3896: checking for C compiler default output file name

configure:3918: gcc conftest.c >&5

configure:3922: $? = 0

configure:3960: result: a.out

configure:3979: checking whether the C compiler works

configure:3989: ./a.out

configure:3993: $? = 0

configure:4012: result: yes

configure:4019: checking whether we are cross compiling

configure:4021: result: no

configure:4024: checking for suffix of executables

configure:4031: gcc -o conftest conftest.c >&5

configure:4035: $? = 0

configure:4061: result:

configure:4067: checking for suffix of object files

configure:4093: gcc -c conftest.c >&5

configure:4097: $? = 0

configure:4122: result: o

configure:4126: checking whether we are using the GNU C compiler

configure:4155: gcc -c conftest.c >&5

configure:4162: $? = 0

configure:4179: result: yes

configure:4188: checking whether gcc accepts -g

configure:4218: gcc -c -g conftest.c >&5

configure:4225: $? = 0

configure:4326: result: yes

configure:4343: checking for gcc option to accept ISO C89

configure:4417: gcc -c -g -O2 conftest.c >&5

configure:4424: $? = 0

configure:4447: result: none needed

configure:4476: checking for style of include used by make

configure:4504: result: GNU

configure:4529: checking dependency style of gcc

configure:4639: result: gcc3

configure:4712: checking for g++

configure:4728: found /usr/bin/g++

configure:4739: result: g++

configure:4766: checking for C++ compiler version

configure:4774: g++ --version >&5

g++ (GCC) 4.4.2

Copyright (C) 2009 Free Software Foundation, Inc.

This is free software; see the source for copying conditions. There is NO

warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

configure:4778: $? = 0

configure:4785: g++ -v >&5

Using built-in specs.

Target: i686-pc-linux-gnu

Configured with: ../configure --prefix=/usr --enable-shared --enable-languages=c,c++,fortran,objc,obj-c++,ada --enable-threads=posix --mandir=/usr/share/man --infodir=/usr/share/info --enable-__cxa_atexit --disable-multilib --libdir=/usr/lib --libexecdir=/usr/lib --enable-clocale=gnu --disable-libstdcxx-pch --with-tune=generic

Thread model: posix

gcc version 4.4.2 (GCC)

configure:4789: $? = 0

configure:4796: g++ -V >&5

g++: '-V' option must have argument

configure:4800: $? = 1

configure:4803: checking whether we are using the GNU C++ compiler

configure:4832: g++ -c conftest.cpp >&5

configure:4839: $? = 0

configure:4856: result: yes

configure:4865: checking whether g++ accepts -g

configure:4895: g++ -c -g conftest.cpp >&5

configure:4902: $? = 0

configure:5003: result: yes

configure:5028: checking dependency style of g++

configure:5138: result: gcc3

configure:5167: checking for a BSD-compatible install

configure:5235: result: /bin/install -c

configure:5246: checking whether make sets $(MAKE)

configure:5268: result: yes

configure:5282: checking for flex

configure:5298: found /usr/bin/flex

configure:5309: result: flex

configure:5346: flex conftest.l

configure:5350: $? = 0

configure:5352: checking lex output file root

configure:5368: result: lex.yy

configure:5373: checking lex library

configure:5392: gcc -o conftest -g -O2 conftest.c >&5

/tmp/ccodoYuC.o: In function `input':

/home/manicman/abs/libprelude/libprelude-0.9.24.1/lex.yy.c:1168: undefined reference to `yywrap'

/tmp/ccodoYuC.o: In function `yylex':

/home/manicman/abs/libprelude/libprelude-0.9.24.1/lex.yy.c:867: undefined reference to `yywrap'

/tmp/ccodoYuC.o: In function `main':

/home/manicman/abs/libprelude/libprelude-0.9.24.1/conftest.l:17: undefined reference to `yywrap'

collect2: ld returned 1 exit status

configure:5399: $? = 1

configure: failed program was:

|

| #line 3 "lex.yy.c"

|

| #define YY_INT_ALIGNED short int

|

| /* A lexical scanner generated by flex */

|

| #define FLEX_SCANNER

| #define YY_FLEX_MAJOR_VERSION 2

| #define YY_FLEX_MINOR_VERSION 5

| #define YY_FLEX_SUBMINOR_VERSION 35

| #if YY_FLEX_SUBMINOR_VERSION > 0

| #define FLEX_BETA

| #endif

|

| /* First, we deal with platform-specific or compiler-specific issues. */

|

| /* begin standard C headers. */

| #include <stdio.h>

| #include <string.h>

| #include <errno.h>

| #include <stdlib.h>

|

| /* end standard C headers. */

|

| /* flex integer type definitions */

|

| #ifndef FLEXINT_H

| #define FLEXINT_H

|

| /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */

|

| #if defined (__STDC_VERSION__) && __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 <inttypes.h>

| typedef int8_t flex_int8_t;

| typedef uint8_t flex_uint8_t;

| typedef int16_t flex_int16_t;

| typedef uint16_t flex_uint16_t;

| typedef int32_t flex_int32_t;

| typedef uint32_t flex_uint32_t;

| #else

| typedef signed char flex_int8_t;

| typedef short int flex_int16_t;

| typedef int flex_int32_t;

| typedef unsigned char flex_uint8_t;

| typedef unsigned short int flex_uint16_t;

| typedef unsigned int flex_uint32_t;

| #endif /* ! C99 */

|

| /* Limits of integral types. */

| #ifndef INT8_MIN

| #define INT8_MIN (-128)

| #endif

| #ifndef INT16_MIN

| #define INT16_MIN (-32767-1)

| #endif

| #ifndef INT32_MIN

| #define INT32_MIN (-2147483647-1)

| #endif

| #ifndef INT8_MAX

| #define INT8_MAX (127)

| #endif

| #ifndef INT16_MAX

| #define INT16_MAX (32767)

| #endif

| #ifndef INT32_MAX

| #define INT32_MAX (2147483647)

| #endif

| #ifndef UINT8_MAX

| #define UINT8_MAX (255U)

| #endif

| #ifndef UINT16_MAX

| #define UINT16_MAX (65535U)

| #endif

| #ifndef UINT32_MAX

| #define UINT32_MAX (4294967295U)

| #endif

|

| #endif /* ! FLEXINT_H */

|

| #ifdef __cplusplus

|

| /* The "const" storage-class-modifier is valid. */

| #define YY_USE_CONST

|

| #else /* ! __cplusplus */

|

| /* C99 requires __STDC__ to be defined as 1. */

| #if defined (__STDC__)

|

| #define YY_USE_CONST

|

| #endif /* defined (__STDC__) */

| #endif /* ! __cplusplus */

|

| #ifdef YY_USE_CONST

| #define yyconst const

| #else

| #define yyconst

| #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. */

| #ifndef YY_BUF_SIZE

| #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;

| #endif

|

| 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

|

| #define YY_LESS_LINENO(n)

|

| /* Return all but the first "n" matched characters back to the input stream. */

| #define yyless(n) \

| do \

| { \

| /* Undo effects of setting up yytext. */ \

| int yyless_macro_arg = (n); \

| YY_LESS_LINENO(yyless_macro_arg);\

| *yy_cp = (yy_hold_char); \

| YY_RESTORE_YY_MORE_OFFSET \

| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \

| YY_DO_BEFORE_ACTION; /* set up yytext again */ \

| } \

| while ( 0 )

|

| #define unput(c) yyunput( c, (yytext_ptr) )

|

| #ifndef YY_TYPEDEF_YY_SIZE_T

| #define YY_TYPEDEF_YY_SIZE_T

| typedef size_t yy_size_t;

| #endif

|

| #ifndef YY_STRUCT_YY_BUFFER_STATE

| #define YY_STRUCT_YY_BUFFER_STATE

| struct yy_buffer_state

| {

| 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;

|

| int yy_bs_lineno; /**< The line count. */

| int yy_bs_column; /**< The column count. */

|

| /* 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

|

| };

| #endif /* !YY_STRUCT_YY_BUFFER_STATE */

|

| /* Stack of input buffers. */

| static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */

| static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */

| static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */

|

| /* 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".

| *

| * Returns the top of the stack, or NULL.

| */

| #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \

| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \

| : NULL)

|

| /* Same as previous macro, but useful when we know that the buffer stack is not

| * NULL or when we need an lvalue. For internal use only.

| */

| #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

|

| /* 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 = 0; /* 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 (FILE *input_file );

| void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );

| YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );

| void yy_delete_buffer (YY_BUFFER_STATE b );

| void yy_flush_buffer (YY_BUFFER_STATE b );

| void yypush_buffer_state (YY_BUFFER_STATE new_buffer );

| void yypop_buffer_state (void );

|

| static void yyensure_buffer_stack (void );

| static void yy_load_buffer_state (void );

| static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );

|

| #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )

|

| YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );

| YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );

| YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len );

|

| void *yyalloc (yy_size_t );

| void *yyrealloc (void *,yy_size_t );

| void yyfree (void * );

|

| #define yy_new_buffer yy_create_buffer

|

| #define yy_set_interactive(is_interactive) \

| { \

| if ( ! YY_CURRENT_BUFFER ){ \

| yyensure_buffer_stack (); \

| YY_CURRENT_BUFFER_LVALUE = \

| yy_create_buffer(yyin,YY_BUF_SIZE ); \

| } \

| YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \

| }

|

| #define yy_set_bol(at_bol) \

| { \

| if ( ! YY_CURRENT_BUFFER ){\

| yyensure_buffer_stack (); \

| YY_CURRENT_BUFFER_LVALUE = \

| yy_create_buffer(yyin,YY_BUF_SIZE ); \

| } \

| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \

| }

|

| #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

|

| /* Begin user sect3 */

|

| typedef unsigned char YY_CHAR;

|

| FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;

|

| typedef int yy_state_type;

|

| extern int yylineno;

|

| int yylineno = 1;

|

| extern char *yytext;

| #define yytext_ptr yytext

|

| static yy_state_type yy_get_previous_state (void );

| static yy_state_type yy_try_NUL_trans (yy_state_type current_state );

| static int yy_get_next_buffer (void );

| static void yy_fatal_error (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; \

| (yytext_ptr) -= (yy_more_len); \

| yyleng = (size_t) (yy_cp - (yytext_ptr)); \

| (yy_hold_char) = *yy_cp; \

| *yy_cp = '\0'; \

| (yy_c_buf_p) = yy_cp;

|

| #define YY_NUM_RULES 8

| #define YY_END_OF_BUFFER 9

| /* This struct is not used in this scanner,

| but its presence is necessary. */

| struct yy_trans_info

| {

| flex_int32_t yy_verify;

| flex_int32_t yy_nxt;

| };

| static yyconst flex_int16_t yy_acclist[23] =

| { 0,

| 9, 7, 8, 8, 1, 7, 8, 2, 7, 8,

| 3, 7, 8, 4, 7, 8, 5, 7, 8, 6,

| 7, 8

| } ;

|

| static yyconst flex_int16_t yy_accept[14] =

| { 0,

| 1, 1, 1, 2, 4, 5, 8, 11, 14, 17,

| 20, 23, 23

| } ;

|

| static yyconst flex_int32_t yy_ec[256] =

| { 0,

| 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,

| 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, 3, 4, 5, 6,

|

| 7, 8, 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, 1, 1, 1,

| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

| 1, 1, 1, 1, 1

| } ;

|

| static yyconst flex_int32_t yy_meta[9] =

| { 0,

| 1, 1, 1, 1, 1, 1, 1, 1

| } ;

|

| static yyconst flex_int16_t yy_base[13] =

| { 0,

| 0, 0, 9, 10, 10, 10, 10, 10, 10, 10,

| 10, 10

| } ;

|

| static yyconst flex_int16_t yy_def[13] =

| { 0,

| 12, 1, 12, 12, 12, 12, 12, 12, 12, 12,

| 12, 0

| } ;

|

| static yyconst flex_int16_t yy_nxt[19] =

| { 0,

| 4, 5, 6, 7, 8, 9, 10, 11, 12, 3,

| 12, 12, 12, 12, 12, 12, 12, 12

| } ;

|

| static yyconst flex_int16_t yy_chk[19] =

| { 0,

| 1, 1, 1, 1, 1, 1, 1, 1, 3, 12,

| 12, 12, 12, 12, 12, 12, 12, 12

| } ;

|

| extern int yy_flex_debug;

| int yy_flex_debug = 0;

|

| static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;

| static char *yy_full_match;

| static int yy_lp;

| #define REJECT \

| { \

| *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \

| yy_cp = (yy_full_match); /* restore poss. backed-over text */ \

| ++(yy_lp); \

| goto find_rule; \

| }

|

| static int yy_more_flag = 0;

| static int yy_more_len = 0;

| #define yymore() ((yy_more_flag) = 1)

| #define YY_MORE_ADJ (yy_more_len)

| #define YY_RESTORE_YY_MORE_OFFSET

| char *yytext;

| #line 1 "conftest.l"

| #line 468 "lex.yy.c"

|

| #define INITIAL 0

|

| #ifndef YY_NO_UNISTD_H

| /* Special case for "unistd.h", since it is non-ANSI. We include it way

| * 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.

| */

| #include <unistd.h>

| #endif

|

| #ifndef YY_EXTRA_TYPE

| #define YY_EXTRA_TYPE void *

| #endif

|

| static int yy_init_globals (void );

|

| /* Accessor methods to globals.

| These are made visible to non-reentrant scanners for convenience. */

|

| int yylex_destroy (void );

|

| int yyget_debug (void );

|

| void yyset_debug (int debug_flag );

|

| YY_EXTRA_TYPE yyget_extra (void );

|

| void yyset_extra (YY_EXTRA_TYPE user_defined );

|

| FILE *yyget_in (void );

|

| void yyset_in (FILE * in_str );

|

| FILE *yyget_out (void );

|

| void yyset_out (FILE * out_str );

|

| int yyget_leng (void );

|

| char *yyget_text (void );

|

| int yyget_lineno (void );

|

| void yyset_lineno (int line_number );

|

| /* Macros after this point can all be overridden by user definitions in

| * section 1.

| */

|

| #ifndef YY_SKIP_YYWRAP

| #ifdef __cplusplus

| extern "C" int yywrap (void );

| #else

| extern int yywrap (void );

| #endif

| #endif

|

| static void yyunput (int c,char *buf_ptr );

|

| #ifndef yytext_ptr

| static void yy_flex_strncpy (char *,yyconst char *,int );

| #endif

|

| #ifdef YY_NEED_STRLEN

| static int yy_flex_strlen (yyconst char * );

| #endif

|

| #ifndef YY_NO_INPUT

|

| #ifdef __cplusplus

| static int yyinput (void );

| #else

| static int input (void );

| #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 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_LVALUE->yy_is_interactive ) \

| { \

| int c = '*'; \

| int 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 \

| { \

| errno=0; \

| while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \

| { \

| if( errno != EINTR) \

| { \

| YY_FATAL_ERROR( "input in flex scanner failed" ); \

| break; \

| } \

| errno=0; \

| clearerr(yyin); \

| } \

| }\

| \

|

| #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

|

| /* end tables serialization structures and prototypes */

|

| /* Default declaration of generated scanner - a define so the user can

| * easily add parameters.

| */

| #ifndef YY_DECL

| #define YY_DECL_IS_OURS 1

|

| extern int yylex (void);

|

| #define YY_DECL int yylex (void)

| #endif /* !YY_DECL */

|

| /* 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

|

| /** The main scanner function which does all the work.

| */

| YY_DECL

| {

| register yy_state_type yy_current_state;

| register char *yy_cp, *yy_bp;

| register int yy_act;

|

| #line 1 "conftest.l"

|

| #line 652 "lex.yy.c"

|

| if ( !(yy_init) )

| {

| (yy_init) = 1;

|

| #ifdef YY_USER_INIT

| YY_USER_INIT;

| #endif

|

| /* Create the reject buffer large enough to save one state per allowed character. */

| if ( ! (yy_state_buf) )

| (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE );

| if ( ! (yy_state_buf) )

| YY_FATAL_ERROR( "out of dynamic memory in yylex()" );

|

| if ( ! (yy_start) )

| (yy_start) = 1; /* first start state */

|

| if ( ! yyin )

| yyin = stdin;

|

| if ( ! yyout )

| yyout = stdout;

|

| if ( ! YY_CURRENT_BUFFER ) {

| yyensure_buffer_stack ();

| YY_CURRENT_BUFFER_LVALUE =

| yy_create_buffer(yyin,YY_BUF_SIZE );

| }

|

| yy_load_buffer_state( );

| }

|

| while ( 1 ) /* loops until end-of-file is reached */

| {

| (yy_more_len) = 0;

| if ( (yy_more_flag) )

| {

| (yy_more_len) = (yy_c_buf_p) - (yytext_ptr);

| (yy_more_flag) = 0;

| }

| 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_state_ptr) = (yy_state_buf);

| *(yy_state_ptr)++ = yy_current_state;

|

| yy_match:

| do

| {

| register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*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 >= 13 )

| yy_c = yy_meta[(unsigned int) yy_c];

| }

| yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];

| *(yy_state_ptr)++ = yy_current_state;

| ++yy_cp;

| }

| while ( yy_base[yy_current_state] != 10 );

|

| yy_find_action:

| yy_current_state = *--(yy_state_ptr);

| (yy_lp) = yy_accept[yy_current_state];

| find_rule: /* we branch to this label when backing up */

| for ( ; ; ) /* until we find what rule we matched */

| {

| if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )

| {

| yy_act = yy_acclist[(yy_lp)];

| {

| (yy_full_match) = yy_cp;

| break;

| }

| }

| --yy_cp;

| yy_current_state = *--(yy_state_ptr);

| (yy_lp) = 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 1:

| YY_RULE_SETUP

| #line 2 "conftest.l"

| { ECHO; }

| YY_BREAK

| case 2:

| YY_RULE_SETUP

| #line 3 "conftest.l"

| { REJECT; }

| YY_BREAK

| case 3:

| YY_RULE_SETUP

| #line 4 "conftest.l"

| { yymore (); }

| YY_BREAK

| case 4:

| YY_RULE_SETUP

| #line 5 "conftest.l"

| { yyless (1); }

| YY_BREAK

| case 5:

| YY_RULE_SETUP

| #line 6 "conftest.l"

| { yyless (input () != 0); }

| YY_BREAK

| case 6:

| YY_RULE_SETUP

| #line 7 "conftest.l"

| { unput (yytext[0]); }

| YY_BREAK

| case 7:

| YY_RULE_SETUP

| #line 8 "conftest.l"

| { BEGIN INITIAL; }

| YY_BREAK

| case 8:

| YY_RULE_SETUP

| #line 9 "conftest.l"

| ECHO;

| YY_BREAK

| #line 790 "lex.yy.c"

| case YY_STATE_EOF(INITIAL):

| 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_LVALUE->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_LVALUE->yy_n_chars;

| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;

| YY_CURRENT_BUFFER_LVALUE->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_LVALUE->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_LVALUE->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 (void)

| {

| register char *dest = YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )

| YY_FATAL_ERROR(

| "fatal flex scanner internal error--end of buffer missed" );

|

| if ( YY_CURRENT_BUFFER_LVALUE->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_LVALUE->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_LVALUE->yy_n_chars = (yy_n_chars) = 0;

|

| else

| {

| int num_to_read =

| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

|

| while ( num_to_read <= 0 )

| { /* Not enough room in the buffer - grow it. */

|

| YY_FATAL_ERROR(

| "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );

|

| }

|

| if ( num_to_read > YY_READ_BUF_SIZE )

| num_to_read = YY_READ_BUF_SIZE;

|

| /* Read in more data. */

| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),

| (yy_n_chars), (size_t) num_to_read );

|

| YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_buffer_status =

| YY_BUFFER_EOF_PENDING;

| }

| }

|

| else

| ret_val = EOB_ACT_CONTINUE_SCAN;

|

| if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {

| /* Extend the array by 50%, plus the number we really need. */

| yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);

| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );

| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )

| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );

| }

|

| (yy_n_chars) += number_to_move;

| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;

| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

|

| (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->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 (void)

| {

| register yy_state_type yy_current_state;

| register char *yy_cp;

|

| yy_current_state = (yy_start);

|

| (yy_state_ptr) = (yy_state_buf);

| *(yy_state_ptr)++ = yy_current_state;

|

| 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);

| 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 >= 13 )

| yy_c = yy_meta[(unsigned int) yy_c];

| }

| yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];

| *(yy_state_ptr)++ = yy_current_state;

| }

|

| 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 );

| */

| static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )

| {

| register int yy_is_jam;

|

| register YY_CHAR yy_c = 1;

| 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 >= 13 )

| 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 == 12);

| if ( ! yy_is_jam )

| *(yy_state_ptr)++ = yy_current_state;

|

| return yy_is_jam ? 0 : yy_current_state;

| }

|

| static void yyunput (int c, register char * yy_bp )

| {

| register char *yy_cp;

|

| yy_cp = (yy_c_buf_p);

|

| /* undo effects of setting up yytext */

| *yy_cp = (yy_hold_char);

|

| if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_ch_buf[

| YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];

| register char *source =

| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

|

| while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )

| *--dest = *--source;

|

| yy_cp += (int) (dest - source);

| yy_bp += (int) (dest - source);

| YY_CURRENT_BUFFER_LVALUE->yy_n_chars =

| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

|

| if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->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;

| }

|

| #ifndef YY_NO_INPUT

| #ifdef __cplusplus

| static int yyinput (void)

| #else

| static int input (void)

| #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_LVALUE->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 );

|

| /*FALLTHROUGH*/

|

| 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;

| }

| #endif /* ifndef YY_NO_INPUT */

|

| /** Immediately switch to a different input stream.

| * @param input_file A readable stream.

| *

| * @note This function does not reset the start condition to @c INITIAL .

| */

| void yyrestart (FILE * input_file )

| {

|

| if ( ! YY_CURRENT_BUFFER ){

| yyensure_buffer_stack ();

| YY_CURRENT_BUFFER_LVALUE =

| yy_create_buffer(yyin,YY_BUF_SIZE );

| }

|

| yy_init_buffer(YY_CURRENT_BUFFER,input_file );

| yy_load_buffer_state( );

| }

|

| /** Switch to a different input buffer.

| * @param new_buffer The new input buffer.

| *

| */

| void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )

| {

|

| /* TODO. We should be able to replace this entire function body

| * with

| * yypop_buffer_state();

| * yypush_buffer_state(new_buffer);

| */

| yyensure_buffer_stack ();

| 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_LVALUE->yy_buf_pos = (yy_c_buf_p);

| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);

| }

|

| YY_CURRENT_BUFFER_LVALUE = 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;

| }

|

| static void yy_load_buffer_state (void)

| {

| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;

| (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;

| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;

| (yy_hold_char) = *(yy_c_buf_p);

| }

|

| /** Allocate and initialize an input buffer state.

| * @param file A readable stream.

| * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.

| *

| * @return the allocated buffer state.

| */

| YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )

| {

| YY_BUFFER_STATE b;

|

| b = (YY_BUFFER_STATE) yyalloc(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 *) yyalloc(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;

| }

|

| /** Destroy the buffer.

| * @param b a buffer created with yy_create_buffer()

| *

| */

| void yy_delete_buffer (YY_BUFFER_STATE b )

| {

|

| if ( ! b )

| return;

|

| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */

| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

|

| if ( b->yy_is_our_buffer )

| yyfree((void *) b->yy_ch_buf );

|

| yyfree((void *) b );

| }

|

| #ifndef __cplusplus

| extern int isatty (int );

| #endif /* __cplusplus */

|

| /* Initializes or reinitializes a buffer.

| * This function is sometimes called more than once on the same buffer,

| * such as during a yyrestart() or at EOF.

| */

| static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )

|

| {

| int oerrno = errno;

|

| yy_flush_buffer(b );

|

| b->yy_input_file = file;

| b->yy_fill_buffer = 1;

|

| /* If b is the current buffer, then yy_init_buffer was _probably_

| * called from yyrestart() or through yy_get_next_buffer.

| * In that case, we don't want to reset the lineno or column.

| */

| if (b != YY_CURRENT_BUFFER){

| b->yy_bs_lineno = 1;

| b->yy_bs_column = 0;

| }

|

| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;

|

| errno = oerrno;

| }

|

| /** Discard all buffered characters. On the next scan, YY_INPUT will be called.

| * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.

| *

| */

| void yy_flush_buffer (YY_BUFFER_STATE b )

| {

| 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( );

| }

|

| /** Pushes the new state onto the stack. The new state becomes

| * the current state. This function will allocate the stack

| * if necessary.

| * @param new_buffer The new state.

| *

| */

| void yypush_buffer_state (YY_BUFFER_STATE new_buffer )

| {

| if (new_buffer == NULL)

| return;

|

| yyensure_buffer_stack();

|

| /* This block is copied from yy_switch_to_buffer. */

| if ( YY_CURRENT_BUFFER )

| {

| /* Flush out information for old buffer. */

| *(yy_c_buf_p) = (yy_hold_char);

| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);

| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);

| }

|

| /* Only push if top exists. Otherwise, replace top. */

| if (YY_CURRENT_BUFFER)

| (yy_buffer_stack_top)++;

| YY_CURRENT_BUFFER_LVALUE = new_buffer;

|

| /* copied from yy_switch_to_buffer. */

| yy_load_buffer_state( );

| (yy_did_buffer_switch_on_eof) = 1;

| }

|

| /** Removes and deletes the top of the stack, if present.

| * The next element becomes the new top.

| *

| */

| void yypop_buffer_state (void)

| {

| if (!YY_CURRENT_BUFFER)

| return;

|

| yy_delete_buffer(YY_CURRENT_BUFFER );

| YY_CURRENT_BUFFER_LVALUE = NULL;

| if ((yy_buffer_stack_top) > 0)

| --(yy_buffer_stack_top);

|

| if (YY_CURRENT_BUFFER) {

| yy_load_buffer_state( );