sbrowser.c

这是一个Linux下的集成开发环境

#line 72 "sbrowser.l"



	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_current_state += YY_AT_BOL();
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 >= 48 )
					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] != 118 );

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 74 "sbrowser.l"
{			/* a comment */

  yytext[yyleng - 1] = '\0';

  sn_insert_comment(NULL, ruleset, sn_current_file(), yytext,
		    sn_line(), sn_column());
  
  sn_advance_line();
  sn_reset_column();
}
	YY_BREAK
case 2:
YY_RULE_SETUP
#line 85 "sbrowser.l"
{
  p = strchr(yytext, ',');
  *p = '\0';

  p = yytext + 1;

  sn_insert_symbol(SN_FUNC_DEF, NULL, p, sn_current_file(),
		   sn_line(), sn_column() + 1, sn_line(), 
		   sn_column() + strlen(p), 0, NULL, NULL, NULL, NULL,
		   sn_line(), sn_column() + 1, sn_line(),
		   sn_column() + strlen(p) + 1);

  sn_advance_line();
  sn_reset_column();
}
	YY_BREAK
case 3:
YY_RULE_SETUP
#line 101 "sbrowser.l"
{
  char buf[2] = { 0, 0 };
  
  buf[0] = yytext[1];
  
  sn_insert_symbol(SN_MACRO_DEF, NULL, buf, sn_current_file(),
                   sn_line(), 1, sn_line(), 2, 0, NULL, NULL, NULL,
                   NULL, sn_line(), 1, sn_line(), 2);

  sn_advance_line();
  sn_reset_column();
}
	YY_BREAK
case 4:
YY_RULE_SETUP
#line 114 "sbrowser.l"
{
  char * filename;
  unsigned margin;

  p = strchr(yytext, '\n');
  *p = '\0';

  p = sn_afterlastwspace(yytext);
  margin = p - yytext;

  filename = ckalloc(strlen(p) + 1);
  strcpy(filename, p);

  p = strchr(yytext, '}') + 1;
  *p = '\0';

  p = yytext + 1; /* jump over `F' */

  sn_insert_symbol(SN_MACRO_DEF, NULL, p, sn_current_file(),
		   sn_line(), sn_column() + 1, sn_line(),
		   sn_column() + 1 + strlen(p), 0,
		   NULL, NULL, NULL, NULL, sn_line(), sn_column() + 1,
		   sn_line(), sn_column() + 1 + strlen(p));
 
  /* need to include an include db entry too */
  sn_insert_symbol(SN_INCLUDE_DEF, NULL, filename, sn_current_file(),
		   sn_line(), sn_column() + margin, sn_line(), yyleng - 1, 0,
		   NULL, NULL, NULL, NULL, sn_line(), sn_column() + margin,
		   sn_line(), yyleng - 1);

  sn_advance_line();
  sn_reset_column();

  ckfree(filename);
}
	YY_BREAK
case 5:
YY_RULE_SETUP
#line 150 "sbrowser.l"
{
  unsigned margin;
  char * filename;
  char buf[2] = { 0, 0 };

  p = strchr(yytext, '\n');
  *p = '\0';

  buf[0] = yytext[1];

  filename = sn_afterlastwspace(yytext);

  sn_insert_symbol(SN_MACRO_DEF, NULL, buf, sn_current_file(),
		   sn_line(), sn_column() + 1, sn_line(), sn_column() + 2, 0,
		   NULL, NULL, NULL, NULL, sn_line(), sn_column() + 1,
		   sn_line(), sn_column() + 2);

  margin = filename - yytext;

  /* need to include an include db entry too */
  sn_insert_symbol(SN_INCLUDE_DEF, NULL, filename, sn_current_file(),
		   sn_line(), sn_column() + margin, sn_line(), yyleng - 1, 0,
		   NULL, NULL, NULL, NULL, sn_line(), sn_column() + margin,
		   sn_line(), yyleng - 1);
 
  sn_advance_line();
  sn_reset_column();
}
	YY_BREAK
case 6:
YY_RULE_SETUP
#line 179 "sbrowser.l"
{
  if (flag)
  {
    long line = sn_pop_line();
    sn_insert_symbol(SN_SUBR_DEF, NULL, ruleset, sn_current_file(),
                     line, 0, sn_line(), 0, 0, NULL, NULL, NULL,
		     NULL, line, 0, line, strlen(ruleset));
    flag = 0;
  }

  sn_push_line();

  p = strchr(yytext, '\n');
  *p = '\0';

  p = yytext;
  while (*p != ' ' && *p != '\t') { p++; }
  while (*p == ' ' || *p == '\t') { p++; }
  
  /* go back one position */
  p--;
  *p = 'S';
 
  strcpy(ruleset, yytext);
  flag = 1;

  sn_advance_line();
  sn_reset_column();
}
	YY_BREAK
case 7:
YY_RULE_SETUP
#line 209 "sbrowser.l"
{
  sn_advance_column(yyleng);
  BEGIN(RULE);
}
	YY_BREAK
case 8:
YY_RULE_SETUP
#line 214 "sbrowser.l"
{
  p = yytext;
  while (*p != ' ' && *p != '\t') { p++; }

  *p = '\0';

  sn_insert_xref(SN_REF_TO_FUNCTION, SN_SUBR_DEF, SN_REF_SCOPE_GLOBAL,
		 NULL, ruleset, NULL, NULL, &yytext[2], NULL, sn_current_file(),
		 sn_line(), SN_REF_PASS);

  sn_advance_column(yyleng); 
}
	YY_BREAK
case 9:
YY_RULE_SETUP
#line 227 "sbrowser.l"
{
  p = yytext + 1;
  if (*p == '=') { p++; }

  sn_insert_xref(SN_REF_TO_DEFINE, SN_SUBR_DEF, SN_REF_SCOPE_GLOBAL,
		 NULL, ruleset, NULL, NULL, p, NULL, sn_current_file(),
		 sn_line(), SN_REF_READ);

  sn_advance_column(yyleng);
}
	YY_BREAK
case 10:
YY_RULE_SETUP
#line 238 "sbrowser.l"
{
  p = yytext + 1;
  if (*p == '=') { p++; }

  sn_insert_xref(SN_REF_TO_DEFINE, SN_SUBR_DEF, SN_REF_SCOPE_GLOBAL,
		 NULL, ruleset, NULL, NULL, p, NULL, sn_current_file(),
		 sn_line(), SN_REF_READ);

  sn_advance_column(yyleng);
}
	YY_BREAK
case 11:
YY_RULE_SETUP
#line 249 "sbrowser.l"
{
  p = strchr(yytext, '>');
  *p = 'S';			/* we know this for sure */

  sn_insert_xref(SN_REF_TO_SUBROUTINE, SN_SUBR_DEF, SN_REF_SCOPE_GLOBAL,
		 NULL, ruleset, NULL, NULL, p, NULL, sn_current_file(),
		 sn_line(), SN_REF_PASS);

  sn_advance_column(yyleng);
}
	YY_BREAK
case 12:
YY_RULE_SETUP
#line 260 "sbrowser.l"
{
  sn_advance_line();
  sn_reset_column();
  BEGIN(INITIAL);
}
	YY_BREAK
case 13:
YY_RULE_SETUP
#line 266 "sbrowser.l"
{ /* eat whitespace */
  sn_advance_column(yyleng);
}
	YY_BREAK
case 14:
YY_RULE_SETUP
#line 270 "sbrowser.l"
{
   sn_advance_line();
   sn_reset_column();
}
	YY_BREAK
case 15:
YY_RULE_SETUP
#line 275 "sbrowser.l"
;
	YY_BREAK
case 16:
YY_RULE_SETUP
#line 277 "sbrowser.l"
{ sn_advance_column(yyleng); }
	YY_BREAK
case 17:
YY_RULE_SETUP
#line 279 "sbrowser.l"
ECHO;
	YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(RULE):
	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;
	yy_current_state += YY_AT_BOL();