rem: current_function,
add: (current_function[0] == '\0') ? NULL : current_function,
context: YY_DECL	{	register yy_state_type yy_current_state;	register char *yy_cp = NULL, *yy_bp = NULL;	register int yy_act;#line 107 "m4browser.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 >= 93 )					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] != 189 );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 109 "m4browser.l"{  matched_pattern("(", yytext);  sn_advance_column(yyleng);  current_function_paren_count++;}	YY_BREAKcase 2:YY_RULE_SETUP#line 115 "m4browser.l"{  matched_pattern(")", yytext);  sn_advance_column(yyleng);  assert(current_function_paren_count > 0);  current_function_paren_count--;  if (current_function_paren_count == 0) {    current_function_line_end = sn_line();    current_function_column_end = sn_column();    dump_function_definition();    BEGIN(INITIAL);  }}	YY_BREAKcase 3:YY_RULE_SETUP#line 130 "m4browser.l"{  matched_pattern(".", yytext);  sn_advance_column(yyleng); /* eat text */}	YY_BREAKcase 4:YY_RULE_SETUP#line 135 "m4browser.l"{  matched_pattern("\\$", yytext);  sn_advance_column(yyleng); /* ignore \$ */}	YY_BREAKcase 5:YY_RULE_SETUP#line 140 "m4browser.l"{  matched_pattern("\\n", yytext);  sn_advance_line();  sn_reset_column();}	YY_BREAKcase 6:YY_RULE_SETUP#line 146 "m4browser.l"{  char * x = (char *) yytext;  char * y = x + yyleng - 1;  matched_pattern("{ws}*(#|dnl{ws}).*\\n", yytext);  while (*x == '\t' || *x == ' ') { x++; }  /* Insert comment highlight */  sn_highlight(SN_HIGH_COMMENT,      sn_line(),      sn_column() + (x - yytext),      sn_line(),      sn_column() + yyleng - 1);  if (*x == '#') {    x++;  } else if (*x == 'd') {    x += 3;  }  while (*x == '\t' || *x == ' ') { x++; }  sn_advance_column(x - yytext);  assert(*y == '\n');  *y = '\0';  sn_insert_comment(    /* classname */ NULL,    /* funcname */ NULL,    sn_current_file(),    x,    sn_line(),    sn_column());  sn_advance_line();  sn_reset_column();}	YY_BREAKcase 7:YY_RULE_SETUP#line 185 "m4browser.l"{  char * x = (char *) yytext;  matched_pattern("${symbol}", yytext);  /* Add global var highlight */    sn_highlight(SN_HIGH_VAR_GLOBAL,      sn_line(), sn_column(),      sn_line(), sn_column() + yyleng);  /* Trim leading $ off the front of the symbol */  assert(*x == '$');  x++;  /* FIXME: The second argument to sn_insert_xref must be one of SN_FUNC_DEF,   * SN_MBR_FUNC_DEF, or SN_SUBR_DEF. This is too restrictive, there   * needs to be an option to pass when not in a function. Currently,   * we just pretend to be in a function named "GLOBAL".   */  result = sn_insert_xref(SN_REF_TO_GLOB_VAR,                 SN_FUNC_DEF, /* Not really in a function definition */                 SN_REF_SCOPE_GLOBAL,                 NULL,                 current_function,                 NULL,                 NULL,                 x, /* refsymbol */                 NULL,                 sn_current_file(),                 sn_line(),                 SN_REF_READ);  assert(result == 0);  sn_advance_column(yyleng);}	YY_BREAKcase 8:YY_RULE_SETUP#line 225 "m4browser.l"{  char * x = (char *) yytext;  char * y;    matched_pattern("{symbol}=", yytext);  /* Add global var highlight */  sn_highlight(SN_HIGH_VAR_GLOBAL,      sn_line(), sn_column(),      sn_line(), sn_column() + yyleng - 1);  /* Trim the '=' off the end of the string */    for (y=x; *y ; y++) {      if (*y == '=') {          *y = 0;	  break;      }  }  /* Setting a global variable should emit     a symbol declaration. I am not really     sure if we should emit just one symbol     declaration, or multiple ones. Multiple     ones breaks xref but it does present     the symbol multiple times in the     file's symbol list which would be     nice if it worked correctly */  result = sn_insert_symbol(SN_GLOB_VAR_DEF,                            NULL,			    x,			    sn_current_file(),			    sn_line(), sn_column(),			    sn_line(), sn_column() + (y - x),			    0,			    NULL,			    NULL,			    NULL,			    NULL,			    sn_line(), sn_column(),			    sn_line(), sn_column() + (y - x));  assert(result == 0);  /* FIXME: The second argument to sn_insert_xref must be one of SN_FUNC_DEF,   * SN_MBR_FUNC_DEF, or SN_SUBR_DEF. This is too restrictive, there   * needs to be an option to pass when not in a function. Currently,   * we just pretend to be in a function named "GLOBAL".   */  result = sn_insert_xref(SN_REF_TO_GLOB_VAR,                 SN_FUNC_DEF, /* Not really in a function definition */                 SN_REF_SCOPE_GLOBAL,                 NULL,                 current_function,                 NULL,                 NULL,                 x, /* refsymbol */                 NULL,                 sn_current_file(),                 sn_line(),                 SN_REF_WRITE);  assert(result == 0);  sn_advance_column(yyleng);}	YY_BREAKcase 9:YY_RULE_SETUP#line 294 "m4browser.l"{  char * x = (char *) yytext;  char * y;  matched_pattern("^{ws}*{func-decl}\({ws}*{quoted-symbol}{ws}*,", yytext);  /* FIXME : Insert an xref for the AC_DEFUN call. */  current_function_line_start = sn_line();  current_function_column_start = sn_column();  /* Skip AC_DEFUN( */  for ( ; *x ; x++) {      if (*x == '(') {          x++;          break;      }  }  /* Skip {ws} and optional [ */  for ( ; *x ; x++) {      if (*x != ' ' &&          *x != '\t' &&          *x != '[') {          break;      }  }  /* x now points to the start of the macro name, find the end */  sn_advance_column(x - yytext);  for (y=x ; *y ; y++) {      if (*y == ' ' ||          *y == '\t' ||          *y == ']' ||          *y == ',') {          *y = 0;          break;      }  }  /* x is now the name of the macro that is being defined */  strncpy(current_function, x, MAX_SIZE-1);  current_function_highlight_line = sn_line();  current_function_highlight_column_start = sn_column();  current_function_highlight_column_end = sn_column() + (y - x);  sn_advance_column((yytext + yyleng) - x);  current_function_paren_count = 1;  BEGIN(FUNCTION);}	YY_BREAKcase 10:YY_RULE_SETUP#line 354 "m4browser.l"{  char * x = (char *) yytext;  char * y;  matched_pattern("{symbol}(", yytext);  for (y=x; *y ; y++) {      if (*y == '(') {          *y = 0;          break;      }  }  /* x is now the name of the macro to be invoked */  result = sn_insert_xref(SN_REF_TO_FUNCTION,                 SN_FUNC_DEF,                 SN_REF_SCOPE_GLOBAL,                 NULL,                 current_function,                 NULL,                 NULL,                 x,                 NULL,                  sn_current_file(),                 sn_line(),                 SN_REF_PASS);  assert(result == 0);  sn_advance_column(yyleng);  current_function_paren_count++;}	YY_BREAKcase 11:YY_RULE_SETUP#line 389 "m4browser.l"ECHO;	YY_BREAKcase YY_STATE_EOF(INITIAL):case YY_STATE_EOF(FUNCTION):	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 */