loc_line++;			loc_col = 1;		} else			loc_col++;	}	*line = loc_line;	*col = loc_col;}#define	STORE_POS do {							\		yylloc->first_line = yylloc->last_line = my_lineno;	\		yylloc->first_column=my_col;				\		yylloc->last_column=my_col+yyleng-1;			\		my_col+=yyleng;						\	} while (0)#define	STORE_LOC do {					\		yylloc->first_line = my_lineno;		\		yylloc->first_column=my_col;		\		pbcwhere(yytext, &my_lineno, &my_col);	\		yylloc->last_line = my_lineno;		\		yylloc->last_column = my_col - 1;	\	} while (0)#else#define	STORE_POS#define	STORE_LOC#endif#line 884 "ael_lex.c"#define INITIAL 0#define paren 1#define semic 2#define argg 3#define comment 4/* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */#include <unistd.h>#ifndef YY_EXTRA_TYPE#define YY_EXTRA_TYPE void *#endif/* Holds the entire state of the reentrant scanner. */struct yyguts_t    {    /* User-defined. Not touched by flex. */    YY_EXTRA_TYPE yyextra_r;    /* The rest are the same as the globals declared in the non-reentrant scanner. */    FILE *yyin_r, *yyout_r;    size_t yy_buffer_stack_top; /**< index of top of stack. */    size_t yy_buffer_stack_max; /**< capacity of stack. */    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */    char yy_hold_char;    int yy_n_chars;    int yyleng_r;    char *yy_c_buf_p;    int yy_init;    int yy_start;    int yy_did_buffer_switch_on_eof;    int yy_start_stack_ptr;    int yy_start_stack_depth;    int *yy_start_stack;    yy_state_type yy_last_accepting_state;    char* yy_last_accepting_cpos;    int yylineno_r;    int yy_flex_debug_r;    char *yytext_r;    int yy_more_flag;    int yy_more_len;    YYSTYPE * yylval_r;    YYLTYPE * yylloc_r;    }; /* end struct yyguts_t */    /* This must go here because YYSTYPE and YYLTYPE are included     * from bison output in section 1.*/    #    define yylval yyg->yylval_r        #    define yylloc yyg->yylloc_r    /* Accessor methods to globals.   These are made visible to non-reentrant scanners for convenience. */int ael_yylex_destroy (yyscan_t yyscanner );int ael_yyget_debug (yyscan_t yyscanner );void ael_yyset_debug (int debug_flag ,yyscan_t yyscanner );YY_EXTRA_TYPE ael_yyget_extra (yyscan_t yyscanner );void ael_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );FILE *ael_yyget_in (yyscan_t yyscanner );void ael_yyset_in  (FILE * in_str ,yyscan_t yyscanner );FILE *ael_yyget_out (yyscan_t yyscanner );void ael_yyset_out  (FILE * out_str ,yyscan_t yyscanner );int ael_yyget_leng (yyscan_t yyscanner );char *ael_yyget_text (yyscan_t yyscanner );int ael_yyget_lineno (yyscan_t yyscanner );void ael_yyset_lineno (int line_number ,yyscan_t yyscanner );YYSTYPE * ael_yyget_lval (yyscan_t yyscanner );void ael_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );       YYLTYPE *ael_yyget_lloc (yyscan_t yyscanner );            void ael_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );    /* Macros after this point can all be overridden by user definitions in * section 1. */#ifndef YY_SKIP_YYWRAP#ifdef __cplusplusextern "C" int ael_yywrap (yyscan_t yyscanner );#elseextern int ael_yywrap (yyscan_t yyscanner );#endif#endif    static void yyunput (int c,char *buf_ptr  ,yyscan_t yyscanner);    #ifndef yytext_ptrstatic void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);#endif#ifdef YY_NEED_STRLENstatic int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);#endif#ifndef YY_NO_INPUT#ifdef __cplusplusstatic int yyinput (yyscan_t yyscanner );#elsestatic int input (yyscan_t yyscanner );#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_LVALUE->yy_is_interactive ) \		{ \		int c = '*'; \		size_t n; \		for ( n = 0; n < max_size && \			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \			buf[n] = (char) c; \		if ( c == '\n' ) \			buf[n++] = (char) c; \		if ( c == EOF && ferror( yyin ) ) \			YY_FATAL_ERROR( "input in flex scanner failed" ); \		result = n; \		} \	else \		{ \		errno=0; \		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \			{ \			if( errno != EINTR) \				{ \				YY_FATAL_ERROR( "input in flex scanner failed" ); \				break; \				} \			errno=0; \			clearerr(yyin); \			} \		}\\#endif/* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */#ifndef yyterminate#define yyterminate() return YY_NULL#endif/* Number of entries by which start-condition stack grows. */#ifndef YY_START_STACK_INCR#define YY_START_STACK_INCR 25#endif/* Report a fatal error. */#ifndef YY_FATAL_ERROR#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)#endif/* end tables serialization structures and prototypes *//* Default declaration of generated scanner - a define so the user can * easily add parameters. */#ifndef YY_DECL#define YY_DECL_IS_OURS 1extern int ael_yylex (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);#define YY_DECL int ael_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)#endif /* !YY_DECL *//* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */#ifndef YY_USER_ACTION#define YY_USER_ACTION#endif/* Code executed at the end of each rule. */#ifndef YY_BREAK#define YY_BREAK break;#endif#define YY_RULE_SETUP \	YY_USER_ACTION/** The main scanner function which does all the work. */YY_DECL{	register yy_state_type yy_current_state;	register char *yy_cp, *yy_bp;	register int yy_act;    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;#line 173 "ael.flex"#line 1122 "ael_lex.c"    yylval = yylval_param;    yylloc = yylloc_param;	if ( yyg->yy_init )		{		yyg->yy_init = 0;#ifdef YY_USER_INIT		YY_USER_INIT;#endif		if ( ! yyg->yy_start )			yyg->yy_start = 1;	/* first start state */		if ( ! yyin )			yyin = stdin;		if ( ! yyout )			yyout = stdout;		if ( ! YY_CURRENT_BUFFER ) {			ael_yyensure_buffer_stack (yyscanner);			YY_CURRENT_BUFFER_LVALUE =				ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);		}		ael_yy_load_buffer_state(yyscanner );		}	while ( 1 )		/* loops until end-of-file is reached */		{		yyg->yy_more_len = 0;		if ( yyg->yy_more_flag )			{			yyg->yy_more_len = yyg->yy_c_buf_p - yyg->yytext_ptr;			yyg->yy_more_flag = 0;			}		yy_cp = yyg->yy_c_buf_p;		/* Support of yytext. */		*yy_cp = yyg->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 = yyg->yy_start;yy_match:		do			{			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];			if ( yy_accept[yy_current_state] )				{				yyg->yy_last_accepting_state = yy_current_state;				yyg->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 >= 234 )					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_current_state != 233 );		yy_cp = yyg->yy_last_accepting_cpos;		yy_current_state = yyg->yy_last_accepting_state;yy_find_action:		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 = yyg->yy_hold_char;			yy_cp = yyg->yy_last_accepting_cpos;			yy_current_state = yyg->yy_last_accepting_state;			goto yy_find_action;case 1:YY_RULE_SETUP#line 175 "ael.flex"{ STORE_POS; return LC;}	YY_BREAKcase 2:YY_RULE_SETUP#line 176 "ael.flex"{ STORE_POS; return RC;}	YY_BREAKcase 3:YY_RULE_SETUP#line 177 "ael.flex"{ STORE_POS; return LP;}	YY_BREAKcase 4:YY_RULE_SETUP#line 178 "ael.flex"{ STORE_POS; return RP;}	YY_BREAKcase 5:YY_RULE_SETUP#line 179 "ael.flex"{ STORE_POS; return SEMI;}	YY_BREAKcase 6:YY_RULE_SETUP#line 180 "ael.flex"{ STORE_POS; return EQ;}	YY_BREAKcase 7:YY_RULE_SETUP#line 181 "ael.flex"{ STORE_POS; return COMMA;}	YY_BREAKcase 8:YY_RULE_SETUP#line 182 "ael.flex"{ STORE_POS; return COLON;}	YY_BREAKcase 9:YY_RULE_SETUP#line 183 "ael.flex"{ STORE_POS; return AMPER;}	YY_BREAKcase 10:YY_RULE_SETUP#line 184 "ael.flex"{ STORE_POS; return BAR;}	YY_BREAKcase 11:YY_RULE_SETUP#line 185 "ael.flex"{ STORE_POS; return EXTENMARK;}	YY_BREAKcase 12:YY_RULE_SETUP#line 186 "ael.flex"{ STORE_POS; return AT;}	YY_BREAKcase 13:YY_RULE_SETUP#line 187 "ael.flex"{/*comment*/}	YY_BREAKcase 14:YY_RULE_SETUP#line 188 "ael.flex"{ STORE_POS; return KW_CONTEXT;}	YY_BREAKcase 15:YY_RULE_SETUP#line 189 "ael.flex"{ STORE_POS; return KW_ABSTRACT;}