==================================================================== Modification le : Fri Oct 26 12:29:01 CEST 2001 -rw-rw-r-- 1 czo alliance 45235 Oct 26 11:03 /asim/alliance/etc/config.log ==================================================================== diff /asim/alliance/etc/config.log /asim/alliance/etc/orig/config.log 8,10c8,10 < configure:751: checking whether the C compiler (gcc -O -DSolaris ) works < configure:767: gcc -o conftest -O -DSolaris conftest.c 1>&5 < configure:793: checking whether the C compiler (gcc -O -DSolaris ) is a cross-compiler --- > configure:751: checking whether the C compiler (gcc -O -DLinux ) works > configure:767: gcc -o conftest -O -DLinux conftest.c 1>&5 > configure:793: checking whether the C compiler (gcc -O -DLinux ) is a cross-compiler 22,36c22 < configure:1156: gcc -o conftest -O2 -Wall -DSolaris conftest.c -lfl 1>&5 < ld: fatal: library -lfl: not found < ld: fatal: File processing errors. No output written to conftest < collect2: ld returned 1 exit status < configure: failed program was: < #line 1145 "configure" < #include "confdefs.h" < /* Override any gcc2 internal prototype to avoid an error. */ < /* We use char because int might match the return type of a gcc2 < builtin and then its argument prototype would still apply. */ < char yywrap(); < < int main() { < yywrap() < ; return 0; } --- > configure:1156: gcc -o conftest -O2 -Wall -DLinux conftest.c -lfl 1>&5 39c25 < configure:1219: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 --- > configure:1219: gcc -o conftest -O2 -Wall -DLinux conftest.c -lfl 1>&5 41,1542d26 < Undefined first referenced < symbol in file < yywrap /tmp/ccsxp6XH.o < ld: fatal: Symbol referencing errors. No output written to conftest < collect2: ld returned 1 exit status < configure: failed program was: < #line 1212 "configure" < #include "confdefs.h" < /* 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 <stdio.h> < < < /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ < #ifdef c_plusplus < #ifndef __cplusplus < #define __cplusplus < #endif < #endif < < < #ifdef __cplusplus < < #include <stdlib.h> < #include <unistd.h> < < /* 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 <io.h> < #include <stdlib.h> < #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) < < 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 1 < #define YY_END_OF_BUFFER 2 < static yyconst short int yy_accept[6] = < { 0, < 0, 0, 2, 1, 0 < } ; < < static yyconst int yy_ec[256] = < { 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, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, < 1, 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[2] = < { 0, < 1 < } ; < < static yyconst short int yy_base[7] = < { 0, < 0, 0, 2, 3, 3, 0 < } ; < < static yyconst short int yy_def[7] = < { 0, < 6, 6, 5, 5, 0, 5 < } ; < < static yyconst short int yy_nxt[5] = < { 0, < 4, 5, 3, 5 < } ; < < static yyconst short int yy_chk[5] = < { 0, < 6, 3, 5, 5 < } ; < < 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 "<stdin>" < #define INITIAL 0 < #line 363 "lex.yy.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 <stdlib.h> < #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 1 "<stdin>" < < #line 516 "lex.yy.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 >= 6 ) < 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] != 3 ); < < 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 2 "<stdin>" < ECHO; < YY_BREAK < #line 604 "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->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 >= 6 ) < 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 >= 6 ) < 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 == 5); < < 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 2 "<stdin>" < < extern char *yytext; < int main() { < < ; return 0; } 1581,1582d64 < configure:2834: checking whether -R must be followed by a space < configure:2844: gcc -o conftest -O2 -Wall -DSolaris conftest.c -R/usr/openwin/lib 1>&5 1584,1586c66,67 < configure:2918: gcc -o conftest -O2 -Wall -DSolaris conftest.c -ldnet 1>&5 < ld: fatal: library -ldnet: not found < ld: fatal: File processing errors. No output written to conftest --- > configure:2918: gcc -o conftest -O2 -Wall -DLinux conftest.c -ldnet 1>&5 > /usr/bin/ld: cannot find -ldnet 1600,1602c81,82 < configure:2959: gcc -o conftest -O2 -Wall -DSolaris conftest.c -ldnet_stub 1>&5 < ld: fatal: library -ldnet_stub: not found < ld: fatal: File processing errors. No output written to conftest --- > configure:2959: gcc -o conftest -O2 -Wall -DLinux conftest.c -ldnet_stub 1>&5 > /usr/bin/ld: cannot find -ldnet_stub 1616,1646c96 < configure:3016: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 < Undefined first referenced < symbol in file < gethostbyname /tmp/cc1QvRWA.o < ld: fatal: Symbol referencing errors. No output written to conftest < collect2: ld returned 1 exit status < configure: failed program was: < #line 2993 "configure" < #include "confdefs.h" < /* System header to define __stub macros and hopefully few prototypes, < which can conflict with char gethostbyname(); below. */ < #include <assert.h> < /* Override any gcc2 internal prototype to avoid an error. */ < /* We use char because int might match the return type of a gcc2 < builtin and then its argument prototype would still apply. */ < char gethostbyname(); < < int main() { < < /* The GNU C library defines this for functions which it implements < to always fail with ENOSYS. Some functions are actually named < something starting with __ and the normal name is an alias. */ < #if defined (__stub_gethostbyname) || defined (__stub___gethostbyname) < choke me < #else < gethostbyname(); < #endif < < ; return 0; } < configure:3037: checking for gethostbyname in -lnsl < configure:3056: gcc -o conftest -O2 -Wall -DSolaris conftest.c -lnsl 1>&5 --- > configure:3016: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 1648,1678c98 < configure:3114: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 < Undefined first referenced < symbol in file < connect /tmp/ccK20kPl.o < ld: fatal: Symbol referencing errors. No output written to conftest < collect2: ld returned 1 exit status < configure: failed program was: < #line 3091 "configure" < #include "confdefs.h" < /* System header to define __stub macros and hopefully few prototypes, < which can conflict with char connect(); below. */ < #include <assert.h> < /* Override any gcc2 internal prototype to avoid an error. */ < /* We use char because int might match the return type of a gcc2 < builtin and then its argument prototype would still apply. */ < char connect(); < < int main() { < < /* The GNU C library defines this for functions which it implements < to always fail with ENOSYS. Some functions are actually named < something starting with __ and the normal name is an alias. */ < #if defined (__stub_connect) || defined (__stub___connect) < choke me < #else < connect(); < #endif < < ; return 0; } < configure:3135: checking for connect in -lsocket < configure:3154: gcc -o conftest -O2 -Wall -DSolaris conftest.c -lsocket -lnsl 1>&5 --- > configure:3114: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 1680c100 < configure:3206: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 --- > configure:3206: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 1682c102 < configure:3298: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 --- > configure:3298: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 1684c104 < configure:3390: gcc -o conftest -O2 -Wall -DSolaris -L/usr/openwin/lib conftest.c -lICE -lsocket -lnsl 1>&5 --- > configure:3390: gcc -o conftest -O2 -Wall -DLinux -L/usr/X11R6/lib conftest.c -lICE 1>&5 1688,1690c108 < configure:3503: gcc -o conftest -O2 -Wall -DSolaris -I/usr/openwin/include conftest.c -L/usr/openwin/lib -R/usr/openwin/lib -lsocket -lnsl -lSM -lICE -lXt -lX11 1>&5 < In file included from configure:3497: < /usr/openwin/include/X11/Xlib.h:32: warning: ignoring pragma: ident --- > configure:3503: gcc -o conftest -O2 -Wall -DLinux -I/usr/X11R6/include conftest.c -L/usr/X11R6/lib -lSM -lICE -lXt -lX11 1>&5 1693,1697c111 < configure:3548: gcc -o conftest -O2 -Wall -DSolaris -I/usr/openwin/include -I/usr/dt/include conftest.c -L/lib -R /lib -lXm -L/usr/openwin/lib -R/usr/openwin/lib -lsocket -lnsl -lSM -lICE -lXt -lX11 1>&5 < In file included from /usr/openwin/include/X11/Intrinsic.h:56, < from /usr/dt/include/Xm/Xm.h:30, < from configure:3530: < /usr/openwin/include/X11/Xlib.h:32: warning: ignoring pragma: ident --- > configure:3548: gcc -o conftest -O2 -Wall -DLinux -I/usr/X11R6/include -I/usr/X11R6/include conftest.c -L/usr/X11R6/lib -lXm -L/usr/X11R6/lib -lSM -lICE -lXt -lX11 1>&5 1699,1709c113,116 < configure:3658: gcc -o conftest -O2 -Wall -DSolaris -I/usr/openwin/include conftest.c -lXpm -L/usr/openwin/lib -R/usr/openwin/lib -lsocket -lnsl -lSM -lICE -lXt -lX11 1>&5 < configure:3652: X11/xpm.h: No such file or directory < configure: failed program was: < #line 3649 "configure" < #include "confdefs.h" < #include <stdio.h> < #include <stdlib.h> < #include <X11/xpm.h> < int main() { < XpmWriteFileFromPixmap( NULL, NULL, NULL, NULL, NULL ); < ; return 0; } --- > configure:3658: gcc -o conftest -O2 -Wall -DLinux -I/usr/X11R6/include conftest.c -lXpm -L/usr/X11R6/lib -lSM -lICE -lXt -lX11 1>&5 > configure: In function `main': > configure:3654: warning: passing arg 3 of `XpmWriteFileFromPixmap' makes integer from pointer without a cast > configure:3654: warning: passing arg 4 of `XpmWriteFileFromPixmap' makes integer from pointer without a cast 1714c121,123 < configure:3810: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 --- > configure:3810: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 > configure: In function `main': > configure:3805: warning: implicit declaration of function `exit' 1716c125 < configure:3856: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 --- > configure:3856: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 1718c127 < configure:3879: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 --- > configure:3879: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 1720c129 < configure:3903: gcc -o conftest -O2 -Wall -DSolaris conftest.c 1>&5 --- > configure:3903: gcc -o conftest -O2 -Wall -DLinux conftest.c 1>&5 ==================================================================== Ce message est envoyé au personnes abonnées à alliance-programmers Pour plus d'information sur cette mailling-list, visitez : http://www-asim.lip6.fr/alliance/mailing-lists/