v23i043: Flex, a fast lex replacement, Part07/10
Rich Salz
rsalz at bbn.com
Fri Oct 12 01:29:24 AEST 1990
Submitted-by: Vern Paxson <vern at cs.cornell.edu>
Posting-number: Volume 23, Issue 43
Archive-name: flex2.3/part07
#! /bin/sh
# This is a shell archive. Remove anything before this line, then feed it
# into a shell via "sh file" or similar. To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to comp-sources-unix at uunet.uu.net if you want that tool.
# Contents: initscan.c.02 sym.c tblcmp.c
# Wrapped by rsalz at litchi.bbn.com on Wed Oct 10 13:24:03 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
echo If this archive is complete, you will see the following message:
echo ' "shar: End of archive 7 (of 10)."'
if test -f 'initscan.c.02' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'initscan.c.02'\"
else
echo shar: Extracting \"'initscan.c.02'\" \(18105 characters\)
sed "s/^X//" >'initscan.c.02' <<'END_OF_FILE'
X*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
Xyy_c_buf_p = yy_cp = yy_bp + 1;
XYY_DO_BEFORE_ACTION; /* set up yytext again */
X# line 367 "scan.l"
XBEGIN(CARETISBOL); return ( '>' );
X YY_BREAK
Xcase 72:
X# line 368 "scan.l"
XRETURNNAME;
X YY_BREAK
Xcase 73:
X# line 369 "scan.l"
Xsynerr( "bad start condition name" );
X YY_BREAK
Xcase 74:
X# line 371 "scan.l"
XBEGIN(SECT2); return ( '^' );
X YY_BREAK
Xcase 75:
X# line 374 "scan.l"
XRETURNCHAR;
X YY_BREAK
Xcase 76:
X# line 375 "scan.l"
XBEGIN(SECT2); return ( '"' );
X YY_BREAK
Xcase 77:
X# line 377 "scan.l"
X{
X synerr( "missing quote" );
X BEGIN(SECT2);
X ++linenum;
X return ( '"' );
X }
X YY_BREAK
Xcase 78:
X*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
Xyy_c_buf_p = yy_cp = yy_bp + 1;
XYY_DO_BEFORE_ACTION; /* set up yytext again */
X# line 385 "scan.l"
XBEGIN(CCL); return ( '^' );
X YY_BREAK
Xcase 79:
X*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
Xyy_c_buf_p = yy_cp = yy_bp + 1;
XYY_DO_BEFORE_ACTION; /* set up yytext again */
X# line 386 "scan.l"
Xreturn ( '^' );
X YY_BREAK
Xcase 80:
X# line 387 "scan.l"
XBEGIN(CCL); yylval = '-'; return ( CHAR );
X YY_BREAK
Xcase 81:
X# line 388 "scan.l"
XBEGIN(CCL); RETURNCHAR;
X YY_BREAK
Xcase 82:
X*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
Xyy_c_buf_p = yy_cp = yy_bp + 1;
XYY_DO_BEFORE_ACTION; /* set up yytext again */
X# line 390 "scan.l"
Xreturn ( '-' );
X YY_BREAK
Xcase 83:
X# line 391 "scan.l"
XRETURNCHAR;
X YY_BREAK
Xcase 84:
X# line 392 "scan.l"
XBEGIN(SECT2); return ( ']' );
X YY_BREAK
Xcase 85:
X# line 395 "scan.l"
X{
X yylval = myctoi( yytext );
X return ( NUMBER );
X }
X YY_BREAK
Xcase 86:
X# line 400 "scan.l"
Xreturn ( ',' );
X YY_BREAK
Xcase 87:
X# line 401 "scan.l"
XBEGIN(SECT2); return ( '}' );
X YY_BREAK
Xcase 88:
X# line 403 "scan.l"
X{
X synerr( "bad character inside {}'s" );
X BEGIN(SECT2);
X return ( '}' );
X }
X YY_BREAK
Xcase 89:
X# line 409 "scan.l"
X{
X synerr( "missing }" );
X BEGIN(SECT2);
X ++linenum;
X return ( '}' );
X }
X YY_BREAK
Xcase 90:
X# line 417 "scan.l"
Xsynerr( "bad name in {}'s" ); BEGIN(SECT2);
X YY_BREAK
Xcase 91:
X# line 418 "scan.l"
Xsynerr( "missing }" ); ++linenum; BEGIN(SECT2);
X YY_BREAK
Xcase 92:
X# line 421 "scan.l"
Xbracelevel = 0;
X YY_BREAK
Xcase 93:
X# line 422 "scan.l"
X{
X ACTION_ECHO;
X CHECK_REJECT(yytext);
X }
X YY_BREAK
Xcase 94:
X# line 426 "scan.l"
X{
X ACTION_ECHO;
X CHECK_YYMORE(yytext);
X }
X YY_BREAK
Xcase 95:
X# line 430 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 96:
X# line 431 "scan.l"
X{
X ++linenum;
X ACTION_ECHO;
X if ( bracelevel == 0 ||
X (doing_codeblock && indented_code) )
X {
X if ( ! doing_codeblock )
X fputs( "\tYY_BREAK\n", temp_action_file );
X
X doing_codeblock = false;
X BEGIN(SECT2);
X }
X }
X YY_BREAK
X /* Reject and YYmore() are checked for above, in PERCENT_BRACE_ACTION */
Xcase 97:
X# line 447 "scan.l"
XACTION_ECHO; ++bracelevel;
X YY_BREAK
Xcase 98:
X# line 448 "scan.l"
XACTION_ECHO; --bracelevel;
X YY_BREAK
Xcase 99:
X# line 449 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 100:
X# line 450 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 101:
X# line 451 "scan.l"
XACTION_ECHO; BEGIN(ACTION_COMMENT);
X YY_BREAK
Xcase 102:
X# line 452 "scan.l"
XACTION_ECHO; /* character constant */
X YY_BREAK
Xcase 103:
X# line 453 "scan.l"
XACTION_ECHO; BEGIN(ACTION_STRING);
X YY_BREAK
Xcase 104:
X# line 454 "scan.l"
X{
X ++linenum;
X ACTION_ECHO;
X if ( bracelevel == 0 )
X {
X fputs( "\tYY_BREAK\n", temp_action_file );
X BEGIN(SECT2);
X }
X }
X YY_BREAK
Xcase 105:
X# line 463 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 106:
X# line 465 "scan.l"
XACTION_ECHO; BEGIN(ACTION);
X YY_BREAK
Xcase 107:
X# line 466 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 108:
X# line 467 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 109:
X# line 468 "scan.l"
X++linenum; ACTION_ECHO;
X YY_BREAK
Xcase 110:
X# line 469 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 111:
X# line 471 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 112:
X# line 472 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase 113:
X# line 473 "scan.l"
X++linenum; ACTION_ECHO;
X YY_BREAK
Xcase 114:
X# line 474 "scan.l"
XACTION_ECHO; BEGIN(ACTION);
X YY_BREAK
Xcase 115:
X# line 475 "scan.l"
XACTION_ECHO;
X YY_BREAK
Xcase YY_STATE_EOF(ACTION):
Xcase YY_STATE_EOF(ACTION_COMMENT):
Xcase YY_STATE_EOF(ACTION_STRING):
X# line 477 "scan.l"
X{
X synerr( "EOF encountered inside an action" );
X yyterminate();
X }
X YY_BREAK
Xcase 117:
X# line 483 "scan.l"
X{
X yylval = myesc( yytext );
X return ( CHAR );
X }
X YY_BREAK
Xcase 118:
X# line 488 "scan.l"
X{
X yylval = myesc( yytext );
X BEGIN(CCL);
X return ( CHAR );
X }
X YY_BREAK
Xcase 119:
X# line 495 "scan.l"
XECHO;
X YY_BREAK
Xcase 120:
X# line 496 "scan.l"
XYY_FATAL_ERROR( "flex scanner jammed" );
X YY_BREAK
Xcase YY_STATE_EOF(INITIAL):
Xcase YY_STATE_EOF(SECT2):
Xcase YY_STATE_EOF(SECT3):
Xcase YY_STATE_EOF(CODEBLOCK):
Xcase YY_STATE_EOF(PICKUPDEF):
Xcase YY_STATE_EOF(SC):
Xcase YY_STATE_EOF(CARETISBOL):
Xcase YY_STATE_EOF(NUM):
Xcase YY_STATE_EOF(QUOTE):
Xcase YY_STATE_EOF(FIRSTCCL):
Xcase YY_STATE_EOF(CCL):
Xcase YY_STATE_EOF(RECOVER):
Xcase YY_STATE_EOF(BRACEERROR):
Xcase YY_STATE_EOF(C_COMMENT):
Xcase YY_STATE_EOF(PERCENT_BRACE_ACTION):
Xcase YY_STATE_EOF(USED_LIST):
Xcase YY_STATE_EOF(CODEBLOCK_2):
Xcase YY_STATE_EOF(XLATION):
X yyterminate();
X
X case YY_END_OF_BUFFER:
X {
X /* amount of text matched not including the EOB char */
X int yy_amount_of_matched_text = yy_cp - yytext - 1;
X
X /* undo the effects of YY_DO_BEFORE_ACTION */
X *yy_cp = yy_hold_char;
X
X /* note that here we test for yy_c_buf_p "<=" to the position
X * of the first EOB in the buffer, since yy_c_buf_p will
X * already have been incremented past the NUL character
X * (since all states make transitions on EOB to the end-
X * of-buffer state). Contrast this with the test in yyinput().
X */
X if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
X /* this was really a NUL */
X {
X yy_state_type yy_next_state;
X
X yy_c_buf_p = yytext + yy_amount_of_matched_text;
X
X yy_current_state = yy_get_previous_state();
X
X /* okay, we're now positioned to make the
X * NUL transition. We couldn't have
X * yy_get_previous_state() go ahead and do it
X * for us because it doesn't know how to deal
X * with the possibility of jamming (and we
X * don't want to build jamming into it because
X * then it will run more slowly)
X */
X
X yy_next_state = yy_try_NUL_trans( yy_current_state );
X
X yy_bp = yytext + YY_MORE_ADJ;
X
X if ( yy_next_state )
X {
X /* consume the NUL */
X yy_cp = ++yy_c_buf_p;
X yy_current_state = yy_next_state;
X goto yy_match;
X }
X
X else
X {
X yy_cp = yy_last_accepting_cpos;
X yy_current_state = yy_last_accepting_state;
X goto yy_find_action;
X }
X }
X
X else switch ( yy_get_next_buffer() )
X {
X case EOB_ACT_END_OF_FILE:
X {
X yy_did_buffer_switch_on_eof = 0;
X
X if ( yywrap() )
X {
X /* note: because we've taken care in
X * yy_get_next_buffer() to have set up yytext,
X * we can now set up yy_c_buf_p so that if some
X * total hoser (like flex itself) wants
X * to call the scanner after we return the
X * YY_NULL, it'll still work - another YY_NULL
X * will get returned.
X */
X yy_c_buf_p = yytext + YY_MORE_ADJ;
X
X yy_act = YY_STATE_EOF((yy_start - 1) / 2);
X goto do_action;
X }
X
X else
X {
X if ( ! yy_did_buffer_switch_on_eof )
X YY_NEW_FILE;
X }
X }
X break;
X
X case EOB_ACT_CONTINUE_SCAN:
X yy_c_buf_p = yytext + yy_amount_of_matched_text;
X
X yy_current_state = yy_get_previous_state();
X
X yy_cp = yy_c_buf_p;
X yy_bp = yytext + YY_MORE_ADJ;
X goto yy_match;
X
X case EOB_ACT_LAST_MATCH:
X yy_c_buf_p =
X &yy_current_buffer->yy_ch_buf[yy_n_chars];
X
X yy_current_state = yy_get_previous_state();
X
X yy_cp = yy_c_buf_p;
X yy_bp = yytext + YY_MORE_ADJ;
X goto yy_find_action;
X }
X break;
X }
X
X default:
X#ifdef FLEX_DEBUG
X printf( "action # %d\n", yy_act );
X#endif
X YY_FATAL_ERROR(
X "fatal flex scanner internal error--no action found" );
X }
X }
X }
X
X
X/* yy_get_next_buffer - try to read in a new buffer
X *
X * synopsis
X * int yy_get_next_buffer();
X *
X * returns a code representing an action
X * EOB_ACT_LAST_MATCH -
X * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
X * EOB_ACT_END_OF_FILE - end of file
X */
X
Xstatic int yy_get_next_buffer()
X
X {
X register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
X register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
X register int number_to_move, i;
X int ret_val;
X
X if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
X YY_FATAL_ERROR(
X "fatal flex scanner internal error--end of buffer missed" );
X
X /* try to read more data */
X
X /* first move last chars to start of buffer */
X number_to_move = yy_c_buf_p - yytext;
X
X for ( i = 0; i < number_to_move; ++i )
X *(dest++) = *(source++);
X
X if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
X /* don't do the read, it's not guaranteed to return an EOF,
X * just force an EOF
X */
X yy_n_chars = 0;
X
X else
X {
X int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
X
X if ( num_to_read > YY_READ_BUF_SIZE )
X num_to_read = YY_READ_BUF_SIZE;
X
X else if ( num_to_read <= 0 )
X YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
X
X /* read in more data */
X YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
X yy_n_chars, num_to_read );
X }
X
X if ( yy_n_chars == 0 )
X {
X if ( number_to_move == 1 )
X {
X ret_val = EOB_ACT_END_OF_FILE;
X yy_current_buffer->yy_eof_status = EOF_DONE;
X }
X
X else
X {
X ret_val = EOB_ACT_LAST_MATCH;
X yy_current_buffer->yy_eof_status = EOF_PENDING;
X }
X }
X
X else
X ret_val = EOB_ACT_CONTINUE_SCAN;
X
X yy_n_chars += number_to_move;
X yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
X yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
X
X /* yytext begins at the second character in yy_ch_buf; the first
X * character is the one which preceded it before reading in the latest
X * buffer; it needs to be kept around in case it's a newline, so
X * yy_get_previous_state() will have with '^' rules active
X */
X
X yytext = &yy_current_buffer->yy_ch_buf[1];
X
X return ( ret_val );
X }
X
X
X/* yy_get_previous_state - get the state just before the EOB char was reached
X *
X * synopsis
X * yy_state_type yy_get_previous_state();
X */
X
Xstatic yy_state_type yy_get_previous_state()
X
X {
X register yy_state_type yy_current_state;
X register YY_CHAR *yy_cp;
X
X register YY_CHAR *yy_bp = yytext;
X
X yy_current_state = yy_start;
X if ( yy_bp[-1] == '\n' )
X ++yy_current_state;
X
X for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
X {
X register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
X if ( yy_accept[yy_current_state] )
X {
X yy_last_accepting_state = yy_current_state;
X yy_last_accepting_cpos = yy_cp;
X }
X while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
X {
X yy_current_state = yy_def[yy_current_state];
X if ( yy_current_state >= 341 )
X yy_c = yy_meta[yy_c];
X }
X yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
X }
X
X return ( yy_current_state );
X }
X
X
X/* yy_try_NUL_trans - try to make a transition on the NUL character
X *
X * synopsis
X * next_state = yy_try_NUL_trans( current_state );
X */
X
X#ifdef YY_USE_PROTOS
Xstatic yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
X#else
Xstatic yy_state_type yy_try_NUL_trans( yy_current_state )
Xregister yy_state_type yy_current_state;
X#endif
X
X {
X register int yy_is_jam;
X register YY_CHAR *yy_cp = yy_c_buf_p;
X
X register YY_CHAR yy_c = 1;
X if ( yy_accept[yy_current_state] )
X {
X yy_last_accepting_state = yy_current_state;
X yy_last_accepting_cpos = yy_cp;
X }
X while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
X {
X yy_current_state = yy_def[yy_current_state];
X if ( yy_current_state >= 341 )
X yy_c = yy_meta[yy_c];
X }
X yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
X yy_is_jam = (yy_current_state == 340);
X
X return ( yy_is_jam ? 0 : yy_current_state );
X }
X
X
X#ifdef YY_USE_PROTOS
Xstatic void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
X#else
Xstatic void yyunput( c, yy_bp )
XYY_CHAR c;
Xregister YY_CHAR *yy_bp;
X#endif
X
X {
X register YY_CHAR *yy_cp = yy_c_buf_p;
X
X /* undo effects of setting up yytext */
X *yy_cp = yy_hold_char;
X
X if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
X { /* need to shift things up to make room */
X register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
X register YY_CHAR *dest =
X &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
X register YY_CHAR *source =
X &yy_current_buffer->yy_ch_buf[number_to_move];
X
X while ( source > yy_current_buffer->yy_ch_buf )
X *--dest = *--source;
X
X yy_cp += dest - source;
X yy_bp += dest - source;
X yy_n_chars = yy_current_buffer->yy_buf_size;
X
X if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
X YY_FATAL_ERROR( "flex scanner push-back overflow" );
X }
X
X if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
X yy_cp[-2] = '\n';
X
X *--yy_cp = c;
X
X /* note: the formal parameter *must* be called "yy_bp" for this
X * macro to now work correctly
X */
X YY_DO_BEFORE_ACTION; /* set up yytext again */
X }
X
X
X#ifdef __cplusplus
Xstatic int yyinput()
X#else
Xstatic int input()
X#endif
X
X {
X int c;
X YY_CHAR *yy_cp = yy_c_buf_p;
X
X *yy_cp = yy_hold_char;
X
X if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
X {
X /* yy_c_buf_p now points to the character we want to return.
X * If this occurs *before* the EOB characters, then it's a
X * valid NUL; if not, then we've hit the end of the buffer.
X */
X if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
X /* this was really a NUL */
X *yy_c_buf_p = '\0';
X
X else
X { /* need more input */
X yytext = yy_c_buf_p;
X ++yy_c_buf_p;
X
X switch ( yy_get_next_buffer() )
X {
X case EOB_ACT_END_OF_FILE:
X {
X if ( yywrap() )
X {
X yy_c_buf_p = yytext + YY_MORE_ADJ;
X return ( EOF );
X }
X
X YY_NEW_FILE;
X
X#ifdef __cplusplus
X return ( yyinput() );
X#else
X return ( input() );
X#endif
X }
X break;
X
X case EOB_ACT_CONTINUE_SCAN:
X yy_c_buf_p = yytext + YY_MORE_ADJ;
X break;
X
X case EOB_ACT_LAST_MATCH:
X#ifdef __cplusplus
X YY_FATAL_ERROR( "unexpected last match in yyinput()" );
X#else
X YY_FATAL_ERROR( "unexpected last match in input()" );
X#endif
X }
X }
X }
X
X c = *yy_c_buf_p;
X yy_hold_char = *++yy_c_buf_p;
X
X return ( c );
X }
X
X
X#ifdef YY_USE_PROTOS
Xvoid yyrestart( FILE *input_file )
X#else
Xvoid yyrestart( input_file )
XFILE *input_file;
X#endif
X
X {
X yy_init_buffer( yy_current_buffer, input_file );
X yy_load_buffer_state();
X }
X
X
X#ifdef YY_USE_PROTOS
Xvoid yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
X#else
Xvoid yy_switch_to_buffer( new_buffer )
XYY_BUFFER_STATE new_buffer;
X#endif
X
X {
X if ( yy_current_buffer == new_buffer )
X return;
X
X if ( yy_current_buffer )
X {
X /* flush out information for old buffer */
X *yy_c_buf_p = yy_hold_char;
X yy_current_buffer->yy_buf_pos = yy_c_buf_p;
X yy_current_buffer->yy_n_chars = yy_n_chars;
X }
X
X yy_current_buffer = new_buffer;
X yy_load_buffer_state();
X
X /* we don't actually know whether we did this switch during
X * EOF (yywrap()) processing, but the only time this flag
X * is looked at is after yywrap() is called, so it's safe
X * to go ahead and always set it.
X */
X yy_did_buffer_switch_on_eof = 1;
X }
X
X
X#ifdef YY_USE_PROTOS
Xvoid yy_load_buffer_state( void )
X#else
Xvoid yy_load_buffer_state()
X#endif
X
X {
X yy_n_chars = yy_current_buffer->yy_n_chars;
X yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
X yyin = yy_current_buffer->yy_input_file;
X yy_hold_char = *yy_c_buf_p;
X }
X
X
X#ifdef YY_USE_PROTOS
XYY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
X#else
XYY_BUFFER_STATE yy_create_buffer( file, size )
XFILE *file;
Xint size;
X#endif
X
X {
X YY_BUFFER_STATE b;
X
X b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
X
X if ( ! b )
X YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
X
X b->yy_buf_size = size;
X
X /* yy_ch_buf has to be 2 characters longer than the size given because
X * we need to put in 2 end-of-buffer characters.
X */
X b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
X
X if ( ! b->yy_ch_buf )
X YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
X
X yy_init_buffer( b, file );
X
X return ( b );
X }
X
X
X#ifdef YY_USE_PROTOS
Xvoid yy_delete_buffer( YY_BUFFER_STATE b )
X#else
Xvoid yy_delete_buffer( b )
XYY_BUFFER_STATE b;
X#endif
X
X {
X if ( b == yy_current_buffer )
X yy_current_buffer = (YY_BUFFER_STATE) 0;
X
X free( (char *) b->yy_ch_buf );
X free( (char *) b );
X }
X
X
X#ifdef YY_USE_PROTOS
Xvoid yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
X#else
Xvoid yy_init_buffer( b, file )
XYY_BUFFER_STATE b;
XFILE *file;
X#endif
X
X {
X b->yy_input_file = file;
X
X /* we put in the '\n' and start reading from [1] so that an
X * initial match-at-newline will be true.
X */
X
X b->yy_ch_buf[0] = '\n';
X b->yy_n_chars = 1;
X
X /* we always need two end-of-buffer characters. The first causes
X * a transition to the end-of-buffer state. The second causes
X * a jam in that state.
X */
X b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
X b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
X
X b->yy_buf_pos = &b->yy_ch_buf[1];
X
X b->yy_eof_status = EOF_NOT_SEEN;
X }
X# line 496 "scan.l"
X
X
X
Xint yywrap()
X
X {
X if ( --num_input_files > 0 )
X {
X set_input_file( *++input_files );
X return ( 0 );
X }
X
X else
X return ( 1 );
X }
X
X
X/* set_input_file - open the given file (if NULL, stdin) for scanning */
X
Xvoid set_input_file( file )
Xchar *file;
X
X {
X if ( file )
X {
X infilename = file;
X yyin = fopen( infilename, "r" );
X
X if ( yyin == NULL )
X lerrsf( "can't open %s", file );
X }
X
X else
X {
X yyin = stdin;
X infilename = "<stdin>";
X }
X }
END_OF_FILE
if test 18105 -ne `wc -c <'initscan.c.02'`; then
echo shar: \"'initscan.c.02'\" unpacked with wrong size!
fi
# end of 'initscan.c.02'
fi
if test -f 'sym.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'sym.c'\"
else
echo shar: Extracting \"'sym.c'\" \(7527 characters\)
sed "s/^X//" >'sym.c' <<'END_OF_FILE'
X/* sym - symbol table routines */
X
X/*-
X * Copyright (c) 1990 The Regents of the University of California.
X * All rights reserved.
X *
X * This code is derived from software contributed to Berkeley by
X * Vern Paxson.
X *
X * The United States Government has rights in this work pursuant
X * to contract no. DE-AC03-76SF00098 between the United States
X * Department of Energy and the University of California.
X *
X * Redistribution and use in source and binary forms are permitted provided
X * that: (1) source distributions retain this entire copyright notice and
X * comment, and (2) distributions including binaries display the following
X * acknowledgement: ``This product includes software developed by the
X * University of California, Berkeley and its contributors'' in the
X * documentation or other materials provided with the distribution and in
X * all advertising materials mentioning features or use of this software.
X * Neither the name of the University nor the names of its contributors may
X * be used to endorse or promote products derived from this software without
X * specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
X * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
X * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#ifndef lint
Xstatic char rcsid[] =
X "@(#) $Header: /usr/fsys/odin/a/vern/flex/RCS/sym.c,v 2.4 90/06/27 23:48:36 vern Exp $ (LBL)";
X#endif
X
X#include "flexdef.h"
X
X
X/* declare functions that have forward references */
X
Xint hashfunct PROTO((register char[], int));
X
X
Xstruct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
Xstruct hash_entry *sctbl[START_COND_HASH_SIZE];
Xstruct hash_entry *ccltab[CCL_HASH_SIZE];
X
Xstruct hash_entry *findsym();
X
X
X/* addsym - add symbol and definitions to symbol table
X *
X * synopsis
X * char sym[], *str_def;
X * int int_def;
X * hash_table table;
X * int table_size;
X * 0 / -1 = addsym( sym, def, int_def, table, table_size );
X *
X * -1 is returned if the symbol already exists, and the change not made.
X */
X
Xint addsym( sym, str_def, int_def, table, table_size )
Xregister char sym[];
Xchar *str_def;
Xint int_def;
Xhash_table table;
Xint table_size;
X
X {
X int hash_val = hashfunct( sym, table_size );
X register struct hash_entry *sym_entry = table[hash_val];
X register struct hash_entry *new_entry;
X register struct hash_entry *successor;
X
X while ( sym_entry )
X {
X if ( ! strcmp( sym, sym_entry->name ) )
X { /* entry already exists */
X return ( -1 );
X }
X
X sym_entry = sym_entry->next;
X }
X
X /* create new entry */
X new_entry = (struct hash_entry *) malloc( sizeof( struct hash_entry ) );
X
X if ( new_entry == NULL )
X flexfatal( "symbol table memory allocation failed" );
X
X if ( (successor = table[hash_val]) )
X {
X new_entry->next = successor;
X successor->prev = new_entry;
X }
X else
X new_entry->next = NULL;
X
X new_entry->prev = NULL;
X new_entry->name = sym;
X new_entry->str_val = str_def;
X new_entry->int_val = int_def;
X
X table[hash_val] = new_entry;
X
X return ( 0 );
X }
X
X
X/* cclinstal - save the text of a character class
X *
X * synopsis
X * Char ccltxt[];
X * int cclnum;
X * cclinstal( ccltxt, cclnum );
X */
X
Xvoid cclinstal( ccltxt, cclnum )
XChar ccltxt[];
Xint cclnum;
X
X {
X /* we don't bother checking the return status because we are not called
X * unless the symbol is new
X */
X Char *copy_unsigned_string();
X
X (void) addsym( (char *) copy_unsigned_string( ccltxt ), (char *) 0, cclnum,
X ccltab, CCL_HASH_SIZE );
X }
X
X
X/* ccllookup - lookup the number associated with character class text
X *
X * synopsis
X * Char ccltxt[];
X * int ccllookup, cclval;
X * cclval/0 = ccllookup( ccltxt );
X */
X
Xint ccllookup( ccltxt )
XChar ccltxt[];
X
X {
X return ( findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val );
X }
X
X
X/* findsym - find symbol in symbol table
X *
X * synopsis
X * char sym[];
X * hash_table table;
X * int table_size;
X * struct hash_entry *sym_entry, *findsym();
X * sym_entry = findsym( sym, table, table_size );
X */
X
Xstruct hash_entry *findsym( sym, table, table_size )
Xregister char sym[];
Xhash_table table;
Xint table_size;
X
X {
X register struct hash_entry *sym_entry = table[hashfunct( sym, table_size )];
X static struct hash_entry empty_entry =
X {
X (struct hash_entry *) 0, (struct hash_entry *) 0, NULL, NULL, 0,
X } ;
X
X while ( sym_entry )
X {
X if ( ! strcmp( sym, sym_entry->name ) )
X return ( sym_entry );
X sym_entry = sym_entry->next;
X }
X
X return ( &empty_entry );
X }
X
X
X/* hashfunct - compute the hash value for "str" and hash size "hash_size"
X *
X * synopsis
X * char str[];
X * int hash_size, hash_val;
X * hash_val = hashfunct( str, hash_size );
X */
X
Xint hashfunct( str, hash_size )
Xregister char str[];
Xint hash_size;
X
X {
X register int hashval;
X register int locstr;
X
X hashval = 0;
X locstr = 0;
X
X while ( str[locstr] )
X hashval = ((hashval << 1) + str[locstr++]) % hash_size;
X
X return ( hashval );
X }
X
X
X/* ndinstal - install a name definition
X *
X * synopsis
X * char nd[];
X * Char def[];
X * ndinstal( nd, def );
X */
X
Xvoid ndinstal( nd, def )
Xchar nd[];
XChar def[];
X
X {
X char *copy_string();
X Char *copy_unsigned_string();
X
X if ( addsym( copy_string( nd ), (char *) copy_unsigned_string( def ), 0,
X ndtbl, NAME_TABLE_HASH_SIZE ) )
X synerr( "name defined twice" );
X }
X
X
X/* ndlookup - lookup a name definition
X *
X * synopsis
X * char nd[], *def;
X * char *ndlookup();
X * def/NULL = ndlookup( nd );
X */
X
XChar *ndlookup( nd )
Xchar nd[];
X
X {
X return ( (Char *) findsym( nd, ndtbl, NAME_TABLE_HASH_SIZE )->str_val );
X }
X
X
X/* scinstal - make a start condition
X *
X * synopsis
X * char str[];
X * int xcluflg;
X * scinstal( str, xcluflg );
X *
X * NOTE
X * the start condition is Exclusive if xcluflg is true
X */
X
Xvoid scinstal( str, xcluflg )
Xchar str[];
Xint xcluflg;
X
X {
X char *copy_string();
X
X /* bit of a hack. We know how the default start-condition is
X * declared, and don't put out a define for it, because it
X * would come out as "#define 0 1"
X */
X /* actually, this is no longer the case. The default start-condition
X * is now called "INITIAL". But we keep the following for the sake
X * of future robustness.
X */
X
X if ( strcmp( str, "0" ) )
X printf( "#define %s %d\n", str, lastsc );
X
X if ( ++lastsc >= current_max_scs )
X {
X current_max_scs += MAX_SCS_INCREMENT;
X
X ++num_reallocs;
X
X scset = reallocate_integer_array( scset, current_max_scs );
X scbol = reallocate_integer_array( scbol, current_max_scs );
X scxclu = reallocate_integer_array( scxclu, current_max_scs );
X sceof = reallocate_integer_array( sceof, current_max_scs );
X scname = reallocate_char_ptr_array( scname, current_max_scs );
X actvsc = reallocate_integer_array( actvsc, current_max_scs );
X }
X
X scname[lastsc] = copy_string( str );
X
X if ( addsym( scname[lastsc], (char *) 0, lastsc,
X sctbl, START_COND_HASH_SIZE ) )
X format_pinpoint_message( "start condition %s declared twice", str );
X
X scset[lastsc] = mkstate( SYM_EPSILON );
X scbol[lastsc] = mkstate( SYM_EPSILON );
X scxclu[lastsc] = xcluflg;
X sceof[lastsc] = false;
X }
X
X
X/* sclookup - lookup the number associated with a start condition
X *
X * synopsis
X * char str[], scnum;
X * int sclookup;
X * scnum/0 = sclookup( str );
X */
X
Xint sclookup( str )
Xchar str[];
X
X {
X return ( findsym( str, sctbl, START_COND_HASH_SIZE )->int_val );
X }
END_OF_FILE
if test 7527 -ne `wc -c <'sym.c'`; then
echo shar: \"'sym.c'\" unpacked with wrong size!
fi
# end of 'sym.c'
fi
if test -f 'tblcmp.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'tblcmp.c'\"
else
echo shar: Extracting \"'tblcmp.c'\" \(25169 characters\)
sed "s/^X//" >'tblcmp.c' <<'END_OF_FILE'
X/* tblcmp - table compression routines */
X
X/*-
X * Copyright (c) 1990 The Regents of the University of California.
X * All rights reserved.
X *
X * This code is derived from software contributed to Berkeley by
X * Vern Paxson.
X *
X * The United States Government has rights in this work pursuant
X * to contract no. DE-AC03-76SF00098 between the United States
X * Department of Energy and the University of California.
X *
X * Redistribution and use in source and binary forms are permitted provided
X * that: (1) source distributions retain this entire copyright notice and
X * comment, and (2) distributions including binaries display the following
X * acknowledgement: ``This product includes software developed by the
X * University of California, Berkeley and its contributors'' in the
X * documentation or other materials provided with the distribution and in
X * all advertising materials mentioning features or use of this software.
X * Neither the name of the University nor the names of its contributors may
X * be used to endorse or promote products derived from this software without
X * specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
X * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
X * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#ifndef lint
Xstatic char rcsid[] =
X "@(#) $Header: /usr/fsys/odin/a/vern/flex/RCS/tblcmp.c,v 2.5 90/06/27 23:48:38 vern Exp $ (LBL)";
X#endif
X
X#include "flexdef.h"
X
X
X/* declarations for functions that have forward references */
X
Xvoid mkentry PROTO((register int*, int, int, int, int));
Xvoid mkprot PROTO((int[], int, int));
Xvoid mktemplate PROTO((int[], int, int));
Xvoid mv2front PROTO((int));
Xint tbldiff PROTO((int[], int, int[]));
X
X
X/* bldtbl - build table entries for dfa state
X *
X * synopsis
X * int state[numecs], statenum, totaltrans, comstate, comfreq;
X * bldtbl( state, statenum, totaltrans, comstate, comfreq );
X *
X * State is the statenum'th dfa state. It is indexed by equivalence class and
X * gives the number of the state to enter for a given equivalence class.
X * totaltrans is the total number of transitions out of the state. Comstate
X * is that state which is the destination of the most transitions out of State.
X * Comfreq is how many transitions there are out of State to Comstate.
X *
X * A note on terminology:
X * "protos" are transition tables which have a high probability of
X * either being redundant (a state processed later will have an identical
X * transition table) or nearly redundant (a state processed later will have
X * many of the same out-transitions). A "most recently used" queue of
X * protos is kept around with the hope that most states will find a proto
X * which is similar enough to be usable, and therefore compacting the
X * output tables.
X * "templates" are a special type of proto. If a transition table is
X * homogeneous or nearly homogeneous (all transitions go to the same
X * destination) then the odds are good that future states will also go
X * to the same destination state on basically the same character set.
X * These homogeneous states are so common when dealing with large rule
X * sets that they merit special attention. If the transition table were
X * simply made into a proto, then (typically) each subsequent, similar
X * state will differ from the proto for two out-transitions. One of these
X * out-transitions will be that character on which the proto does not go
X * to the common destination, and one will be that character on which the
X * state does not go to the common destination. Templates, on the other
X * hand, go to the common state on EVERY transition character, and therefore
X * cost only one difference.
X */
X
Xvoid bldtbl( state, statenum, totaltrans, comstate, comfreq )
Xint state[], statenum, totaltrans, comstate, comfreq;
X
X {
X int extptr, extrct[2][CSIZE + 1];
X int mindiff, minprot, i, d;
X int checkcom;
X
X /* If extptr is 0 then the first array of extrct holds the result of the
X * "best difference" to date, which is those transitions which occur in
X * "state" but not in the proto which, to date, has the fewest differences
X * between itself and "state". If extptr is 1 then the second array of
X * extrct hold the best difference. The two arrays are toggled
X * between so that the best difference to date can be kept around and
X * also a difference just created by checking against a candidate "best"
X * proto.
X */
X
X extptr = 0;
X
X /* if the state has too few out-transitions, don't bother trying to
X * compact its tables
X */
X
X if ( (totaltrans * 100) < (numecs * PROTO_SIZE_PERCENTAGE) )
X mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
X
X else
X {
X /* checkcom is true if we should only check "state" against
X * protos which have the same "comstate" value
X */
X
X checkcom = comfreq * 100 > totaltrans * CHECK_COM_PERCENTAGE;
X
X minprot = firstprot;
X mindiff = totaltrans;
X
X if ( checkcom )
X {
X /* find first proto which has the same "comstate" */
X for ( i = firstprot; i != NIL; i = protnext[i] )
X if ( protcomst[i] == comstate )
X {
X minprot = i;
X mindiff = tbldiff( state, minprot, extrct[extptr] );
X break;
X }
X }
X
X else
X {
X /* since we've decided that the most common destination out
X * of "state" does not occur with a high enough frequency,
X * we set the "comstate" to zero, assuring that if this state
X * is entered into the proto list, it will not be considered
X * a template.
X */
X comstate = 0;
X
X if ( firstprot != NIL )
X {
X minprot = firstprot;
X mindiff = tbldiff( state, minprot, extrct[extptr] );
X }
X }
X
X /* we now have the first interesting proto in "minprot". If
X * it matches within the tolerances set for the first proto,
X * we don't want to bother scanning the rest of the proto list
X * to see if we have any other reasonable matches.
X */
X
X if ( mindiff * 100 > totaltrans * FIRST_MATCH_DIFF_PERCENTAGE )
X { /* not a good enough match. Scan the rest of the protos */
X for ( i = minprot; i != NIL; i = protnext[i] )
X {
X d = tbldiff( state, i, extrct[1 - extptr] );
X if ( d < mindiff )
X {
X extptr = 1 - extptr;
X mindiff = d;
X minprot = i;
X }
X }
X }
X
X /* check if the proto we've decided on as our best bet is close
X * enough to the state we want to match to be usable
X */
X
X if ( mindiff * 100 > totaltrans * ACCEPTABLE_DIFF_PERCENTAGE )
X {
X /* no good. If the state is homogeneous enough, we make a
X * template out of it. Otherwise, we make a proto.
X */
X
X if ( comfreq * 100 >= totaltrans * TEMPLATE_SAME_PERCENTAGE )
X mktemplate( state, statenum, comstate );
X
X else
X {
X mkprot( state, statenum, comstate );
X mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
X }
X }
X
X else
X { /* use the proto */
X mkentry( extrct[extptr], numecs, statenum,
X prottbl[minprot], mindiff );
X
X /* if this state was sufficiently different from the proto
X * we built it from, make it, too, a proto
X */
X
X if ( mindiff * 100 >= totaltrans * NEW_PROTO_DIFF_PERCENTAGE )
X mkprot( state, statenum, comstate );
X
X /* since mkprot added a new proto to the proto queue, it's possible
X * that "minprot" is no longer on the proto queue (if it happened
X * to have been the last entry, it would have been bumped off).
X * If it's not there, then the new proto took its physical place
X * (though logically the new proto is at the beginning of the
X * queue), so in that case the following call will do nothing.
X */
X
X mv2front( minprot );
X }
X }
X }
X
X
X/* cmptmps - compress template table entries
X *
X * synopsis
X * cmptmps();
X *
X * template tables are compressed by using the 'template equivalence
X * classes', which are collections of transition character equivalence
X * classes which always appear together in templates - really meta-equivalence
X * classes. until this point, the tables for templates have been stored
X * up at the top end of the nxt array; they will now be compressed and have
X * table entries made for them.
X */
X
Xvoid cmptmps()
X
X {
X int tmpstorage[CSIZE + 1];
X register int *tmp = tmpstorage, i, j;
X int totaltrans, trans;
X
X peakpairs = numtemps * numecs + tblend;
X
X if ( usemecs )
X {
X /* create equivalence classes base on data gathered on template
X * transitions
X */
X
X nummecs = cre8ecs( tecfwd, tecbck, numecs );
X }
X
X else
X nummecs = numecs;
X
X if ( lastdfa + numtemps + 1 >= current_max_dfas )
X increase_max_dfas();
X
X /* loop through each template */
X
X for ( i = 1; i <= numtemps; ++i )
X {
X totaltrans = 0; /* number of non-jam transitions out of this template */
X
X for ( j = 1; j <= numecs; ++j )
X {
X trans = tnxt[numecs * i + j];
X
X if ( usemecs )
X {
X /* the absolute value of tecbck is the meta-equivalence class
X * of a given equivalence class, as set up by cre8ecs
X */
X if ( tecbck[j] > 0 )
X {
X tmp[tecbck[j]] = trans;
X
X if ( trans > 0 )
X ++totaltrans;
X }
X }
X
X else
X {
X tmp[j] = trans;
X
X if ( trans > 0 )
X ++totaltrans;
X }
X }
X
X /* it is assumed (in a rather subtle way) in the skeleton that
X * if we're using meta-equivalence classes, the def[] entry for
X * all templates is the jam template, i.e., templates never default
X * to other non-jam table entries (e.g., another template)
X */
X
X /* leave room for the jam-state after the last real state */
X mkentry( tmp, nummecs, lastdfa + i + 1, JAMSTATE, totaltrans );
X }
X }
X
X
X
X/* expand_nxt_chk - expand the next check arrays */
X
Xvoid expand_nxt_chk()
X
X {
X register int old_max = current_max_xpairs;
X
X current_max_xpairs += MAX_XPAIRS_INCREMENT;
X
X ++num_reallocs;
X
X nxt = reallocate_integer_array( nxt, current_max_xpairs );
X chk = reallocate_integer_array( chk, current_max_xpairs );
X
X bzero( (char *) (chk + old_max),
X MAX_XPAIRS_INCREMENT * sizeof( int ) / sizeof( char ) );
X }
X
X
X/* find_table_space - finds a space in the table for a state to be placed
X *
X * synopsis
X * int *state, numtrans, block_start;
X * int find_table_space();
X *
X * block_start = find_table_space( state, numtrans );
X *
X * State is the state to be added to the full speed transition table.
X * Numtrans is the number of out-transitions for the state.
X *
X * find_table_space() returns the position of the start of the first block (in
X * chk) able to accommodate the state
X *
X * In determining if a state will or will not fit, find_table_space() must take
X * into account the fact that an end-of-buffer state will be added at [0],
X * and an action number will be added in [-1].
X */
X
Xint find_table_space( state, numtrans )
Xint *state, numtrans;
X
X {
X /* firstfree is the position of the first possible occurrence of two
X * consecutive unused records in the chk and nxt arrays
X */
X register int i;
X register int *state_ptr, *chk_ptr;
X register int *ptr_to_last_entry_in_state;
X
X /* if there are too many out-transitions, put the state at the end of
X * nxt and chk
X */
X if ( numtrans > MAX_XTIONS_FULL_INTERIOR_FIT )
X {
X /* if table is empty, return the first available spot in chk/nxt,
X * which should be 1
X */
X if ( tblend < 2 )
X return ( 1 );
X
X i = tblend - numecs; /* start searching for table space near the
X * end of chk/nxt arrays
X */
X }
X
X else
X i = firstfree; /* start searching for table space from the
X * beginning (skipping only the elements
X * which will definitely not hold the new
X * state)
X */
X
X while ( 1 ) /* loops until a space is found */
X {
X if ( i + numecs > current_max_xpairs )
X expand_nxt_chk();
X
X /* loops until space for end-of-buffer and action number are found */
X while ( 1 )
X {
X if ( chk[i - 1] == 0 ) /* check for action number space */
X {
X if ( chk[i] == 0 ) /* check for end-of-buffer space */
X break;
X
X else
X i += 2; /* since i != 0, there is no use checking to
X * see if (++i) - 1 == 0, because that's the
X * same as i == 0, so we skip a space
X */
X }
X
X else
X ++i;
X
X if ( i + numecs > current_max_xpairs )
X expand_nxt_chk();
X }
X
X /* if we started search from the beginning, store the new firstfree for
X * the next call of find_table_space()
X */
X if ( numtrans <= MAX_XTIONS_FULL_INTERIOR_FIT )
X firstfree = i + 1;
X
X /* check to see if all elements in chk (and therefore nxt) that are
X * needed for the new state have not yet been taken
X */
X
X state_ptr = &state[1];
X ptr_to_last_entry_in_state = &chk[i + numecs + 1];
X
X for ( chk_ptr = &chk[i + 1]; chk_ptr != ptr_to_last_entry_in_state;
X ++chk_ptr )
X if ( *(state_ptr++) != 0 && *chk_ptr != 0 )
X break;
X
X if ( chk_ptr == ptr_to_last_entry_in_state )
X return ( i );
X
X else
X ++i;
X }
X }
X
X
X/* inittbl - initialize transition tables
X *
X * synopsis
X * inittbl();
X *
X * Initializes "firstfree" to be one beyond the end of the table. Initializes
X * all "chk" entries to be zero. Note that templates are built in their
X * own tbase/tdef tables. They are shifted down to be contiguous
X * with the non-template entries during table generation.
X */
Xvoid inittbl()
X
X {
X register int i;
X
X bzero( (char *) chk, current_max_xpairs * sizeof( int ) / sizeof( char ) );
X
X tblend = 0;
X firstfree = tblend + 1;
X numtemps = 0;
X
X if ( usemecs )
X {
X /* set up doubly-linked meta-equivalence classes
X * these are sets of equivalence classes which all have identical
X * transitions out of TEMPLATES
X */
X
X tecbck[1] = NIL;
X
X for ( i = 2; i <= numecs; ++i )
X {
X tecbck[i] = i - 1;
X tecfwd[i - 1] = i;
X }
X
X tecfwd[numecs] = NIL;
X }
X }
X
X
X/* mkdeftbl - make the default, "jam" table entries
X *
X * synopsis
X * mkdeftbl();
X */
X
Xvoid mkdeftbl()
X
X {
X int i;
X
X jamstate = lastdfa + 1;
X
X ++tblend; /* room for transition on end-of-buffer character */
X
X if ( tblend + numecs > current_max_xpairs )
X expand_nxt_chk();
X
X /* add in default end-of-buffer transition */
X nxt[tblend] = end_of_buffer_state;
X chk[tblend] = jamstate;
X
X for ( i = 1; i <= numecs; ++i )
X {
X nxt[tblend + i] = 0;
X chk[tblend + i] = jamstate;
X }
X
X jambase = tblend;
X
X base[jamstate] = jambase;
X def[jamstate] = 0;
X
X tblend += numecs;
X ++numtemps;
X }
X
X
X/* mkentry - create base/def and nxt/chk entries for transition array
X *
X * synopsis
X * int state[numchars + 1], numchars, statenum, deflink, totaltrans;
X * mkentry( state, numchars, statenum, deflink, totaltrans );
X *
X * "state" is a transition array "numchars" characters in size, "statenum"
X * is the offset to be used into the base/def tables, and "deflink" is the
X * entry to put in the "def" table entry. If "deflink" is equal to
X * "JAMSTATE", then no attempt will be made to fit zero entries of "state"
X * (i.e., jam entries) into the table. It is assumed that by linking to
X * "JAMSTATE" they will be taken care of. In any case, entries in "state"
X * marking transitions to "SAME_TRANS" are treated as though they will be
X * taken care of by whereever "deflink" points. "totaltrans" is the total
X * number of transitions out of the state. If it is below a certain threshold,
X * the tables are searched for an interior spot that will accommodate the
X * state array.
X */
X
Xvoid mkentry( state, numchars, statenum, deflink, totaltrans )
Xregister int *state;
Xint numchars, statenum, deflink, totaltrans;
X
X {
X register int minec, maxec, i, baseaddr;
X int tblbase, tbllast;
X
X if ( totaltrans == 0 )
X { /* there are no out-transitions */
X if ( deflink == JAMSTATE )
X base[statenum] = JAMSTATE;
X else
X base[statenum] = 0;
X
X def[statenum] = deflink;
X return;
X }
X
X for ( minec = 1; minec <= numchars; ++minec )
X {
X if ( state[minec] != SAME_TRANS )
X if ( state[minec] != 0 || deflink != JAMSTATE )
X break;
X }
X
X if ( totaltrans == 1 )
X {
X /* there's only one out-transition. Save it for later to fill
X * in holes in the tables.
X */
X stack1( statenum, minec, state[minec], deflink );
X return;
X }
X
X for ( maxec = numchars; maxec > 0; --maxec )
X {
X if ( state[maxec] != SAME_TRANS )
X if ( state[maxec] != 0 || deflink != JAMSTATE )
X break;
X }
X
X /* Whether we try to fit the state table in the middle of the table
X * entries we have already generated, or if we just take the state
X * table at the end of the nxt/chk tables, we must make sure that we
X * have a valid base address (i.e., non-negative). Note that not only are
X * negative base addresses dangerous at run-time (because indexing the
X * next array with one and a low-valued character might generate an
X * array-out-of-bounds error message), but at compile-time negative
X * base addresses denote TEMPLATES.
X */
X
X /* find the first transition of state that we need to worry about. */
X if ( totaltrans * 100 <= numchars * INTERIOR_FIT_PERCENTAGE )
X { /* attempt to squeeze it into the middle of the tabls */
X baseaddr = firstfree;
X
X while ( baseaddr < minec )
X {
X /* using baseaddr would result in a negative base address below
X * find the next free slot
X */
X for ( ++baseaddr; chk[baseaddr] != 0; ++baseaddr )
X ;
X }
X
X if ( baseaddr + maxec - minec >= current_max_xpairs )
X expand_nxt_chk();
X
X for ( i = minec; i <= maxec; ++i )
X if ( state[i] != SAME_TRANS )
X if ( state[i] != 0 || deflink != JAMSTATE )
X if ( chk[baseaddr + i - minec] != 0 )
X { /* baseaddr unsuitable - find another */
X for ( ++baseaddr;
X baseaddr < current_max_xpairs &&
X chk[baseaddr] != 0;
X ++baseaddr )
X ;
X
X if ( baseaddr + maxec - minec >= current_max_xpairs )
X expand_nxt_chk();
X
X /* reset the loop counter so we'll start all
X * over again next time it's incremented
X */
X
X i = minec - 1;
X }
X }
X
X else
X {
X /* ensure that the base address we eventually generate is
X * non-negative
X */
X baseaddr = max( tblend + 1, minec );
X }
X
X tblbase = baseaddr - minec;
X tbllast = tblbase + maxec;
X
X if ( tbllast >= current_max_xpairs )
X expand_nxt_chk();
X
X base[statenum] = tblbase;
X def[statenum] = deflink;
X
X for ( i = minec; i <= maxec; ++i )
X if ( state[i] != SAME_TRANS )
X if ( state[i] != 0 || deflink != JAMSTATE )
X {
X nxt[tblbase + i] = state[i];
X chk[tblbase + i] = statenum;
X }
X
X if ( baseaddr == firstfree )
X /* find next free slot in tables */
X for ( ++firstfree; chk[firstfree] != 0; ++firstfree )
X ;
X
X tblend = max( tblend, tbllast );
X }
X
X
X/* mk1tbl - create table entries for a state (or state fragment) which
X * has only one out-transition
X *
X * synopsis
X * int state, sym, onenxt, onedef;
X * mk1tbl( state, sym, onenxt, onedef );
X */
X
Xvoid mk1tbl( state, sym, onenxt, onedef )
Xint state, sym, onenxt, onedef;
X
X {
X if ( firstfree < sym )
X firstfree = sym;
X
X while ( chk[firstfree] != 0 )
X if ( ++firstfree >= current_max_xpairs )
X expand_nxt_chk();
X
X base[state] = firstfree - sym;
X def[state] = onedef;
X chk[firstfree] = state;
X nxt[firstfree] = onenxt;
X
X if ( firstfree > tblend )
X {
X tblend = firstfree++;
X
X if ( firstfree >= current_max_xpairs )
X expand_nxt_chk();
X }
X }
X
X
X/* mkprot - create new proto entry
X *
X * synopsis
X * int state[], statenum, comstate;
X * mkprot( state, statenum, comstate );
X */
X
Xvoid mkprot( state, statenum, comstate )
Xint state[], statenum, comstate;
X
X {
X int i, slot, tblbase;
X
X if ( ++numprots >= MSP || numecs * numprots >= PROT_SAVE_SIZE )
X {
X /* gotta make room for the new proto by dropping last entry in
X * the queue
X */
X slot = lastprot;
X lastprot = protprev[lastprot];
X protnext[lastprot] = NIL;
X }
X
X else
X slot = numprots;
X
X protnext[slot] = firstprot;
X
X if ( firstprot != NIL )
X protprev[firstprot] = slot;
X
X firstprot = slot;
X prottbl[slot] = statenum;
X protcomst[slot] = comstate;
X
X /* copy state into save area so it can be compared with rapidly */
X tblbase = numecs * (slot - 1);
X
X for ( i = 1; i <= numecs; ++i )
X protsave[tblbase + i] = state[i];
X }
X
X
X/* mktemplate - create a template entry based on a state, and connect the state
X * to it
X *
X * synopsis
X * int state[], statenum, comstate, totaltrans;
X * mktemplate( state, statenum, comstate, totaltrans );
X */
X
Xvoid mktemplate( state, statenum, comstate )
Xint state[], statenum, comstate;
X
X {
X int i, numdiff, tmpbase, tmp[CSIZE + 1];
X Char transset[CSIZE + 1];
X int tsptr;
X
X ++numtemps;
X
X tsptr = 0;
X
X /* calculate where we will temporarily store the transition table
X * of the template in the tnxt[] array. The final transition table
X * gets created by cmptmps()
X */
X
X tmpbase = numtemps * numecs;
X
X if ( tmpbase + numecs >= current_max_template_xpairs )
X {
X current_max_template_xpairs += MAX_TEMPLATE_XPAIRS_INCREMENT;
X
X ++num_reallocs;
X
X tnxt = reallocate_integer_array( tnxt, current_max_template_xpairs );
X }
X
X for ( i = 1; i <= numecs; ++i )
X if ( state[i] == 0 )
X tnxt[tmpbase + i] = 0;
X else
X {
X transset[tsptr++] = i;
X tnxt[tmpbase + i] = comstate;
X }
X
X if ( usemecs )
X mkeccl( transset, tsptr, tecfwd, tecbck, numecs, 0 );
X
X mkprot( tnxt + tmpbase, -numtemps, comstate );
X
X /* we rely on the fact that mkprot adds things to the beginning
X * of the proto queue
X */
X
X numdiff = tbldiff( state, firstprot, tmp );
X mkentry( tmp, numecs, statenum, -numtemps, numdiff );
X }
X
X
X/* mv2front - move proto queue element to front of queue
X *
X * synopsis
X * int qelm;
X * mv2front( qelm );
X */
X
Xvoid mv2front( qelm )
Xint qelm;
X
X {
X if ( firstprot != qelm )
X {
X if ( qelm == lastprot )
X lastprot = protprev[lastprot];
X
X protnext[protprev[qelm]] = protnext[qelm];
X
X if ( protnext[qelm] != NIL )
X protprev[protnext[qelm]] = protprev[qelm];
X
X protprev[qelm] = NIL;
X protnext[qelm] = firstprot;
X protprev[firstprot] = qelm;
X firstprot = qelm;
X }
X }
X
X
X/* place_state - place a state into full speed transition table
X *
X * synopsis
X * int *state, statenum, transnum;
X * place_state( state, statenum, transnum );
X *
X * State is the statenum'th state. It is indexed by equivalence class and
X * gives the number of the state to enter for a given equivalence class.
X * Transnum is the number of out-transitions for the state.
X */
X
Xvoid place_state( state, statenum, transnum )
Xint *state, statenum, transnum;
X
X {
X register int i;
X register int *state_ptr;
X int position = find_table_space( state, transnum );
X
X /* base is the table of start positions */
X base[statenum] = position;
X
X /* put in action number marker; this non-zero number makes sure that
X * find_table_space() knows that this position in chk/nxt is taken
X * and should not be used for another accepting number in another state
X */
X chk[position - 1] = 1;
X
X /* put in end-of-buffer marker; this is for the same purposes as above */
X chk[position] = 1;
X
X /* place the state into chk and nxt */
X state_ptr = &state[1];
X
X for ( i = 1; i <= numecs; ++i, ++state_ptr )
X if ( *state_ptr != 0 )
X {
X chk[position + i] = i;
X nxt[position + i] = *state_ptr;
X }
X
X if ( position + numecs > tblend )
X tblend = position + numecs;
X }
X
X
X/* stack1 - save states with only one out-transition to be processed later
X *
X * synopsis
X * int statenum, sym, nextstate, deflink;
X * stack1( statenum, sym, nextstate, deflink );
X *
X * if there's room for another state one the "one-transition" stack, the
X * state is pushed onto it, to be processed later by mk1tbl. If there's
X * no room, we process the sucker right now.
X */
X
Xvoid stack1( statenum, sym, nextstate, deflink )
Xint statenum, sym, nextstate, deflink;
X
X {
X if ( onesp >= ONE_STACK_SIZE - 1 )
X mk1tbl( statenum, sym, nextstate, deflink );
X
X else
X {
X ++onesp;
X onestate[onesp] = statenum;
X onesym[onesp] = sym;
X onenext[onesp] = nextstate;
X onedef[onesp] = deflink;
X }
X }
X
X
X/* tbldiff - compute differences between two state tables
X *
X * synopsis
X * int state[], pr, ext[];
X * int tbldiff, numdifferences;
X * numdifferences = tbldiff( state, pr, ext )
X *
X * "state" is the state array which is to be extracted from the pr'th
X * proto. "pr" is both the number of the proto we are extracting from
X * and an index into the save area where we can find the proto's complete
X * state table. Each entry in "state" which differs from the corresponding
X * entry of "pr" will appear in "ext".
X * Entries which are the same in both "state" and "pr" will be marked
X * as transitions to "SAME_TRANS" in "ext". The total number of differences
X * between "state" and "pr" is returned as function value. Note that this
X * number is "numecs" minus the number of "SAME_TRANS" entries in "ext".
X */
X
Xint tbldiff( state, pr, ext )
Xint state[], pr, ext[];
X
X {
X register int i, *sp = state, *ep = ext, *protp;
X register int numdiff = 0;
X
X protp = &protsave[numecs * (pr - 1)];
X
X for ( i = numecs; i > 0; --i )
X {
X if ( *++protp == *++sp )
X *++ep = SAME_TRANS;
X else
X {
X *++ep = *sp;
X ++numdiff;
X }
X }
X
X return ( numdiff );
X }
END_OF_FILE
if test 25169 -ne `wc -c <'tblcmp.c'`; then
echo shar: \"'tblcmp.c'\" unpacked with wrong size!
fi
# end of 'tblcmp.c'
fi
echo shar: End of archive 7 \(of 10\).
cp /dev/null ark7isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 10 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still must unpack the following archives:
echo " " ${MISSING}
fi
exit 0
exit 0 # Just in case...
--
Please send comp.sources.unix-related mail to rsalz at uunet.uu.net.
Use a domain-based address or give alternate paths, or you may lose out.
More information about the Comp.sources.unix
mailing list