hl_lex.c++

来自「FreeFem++可以生成高质量的有限元网格。可以用于流体力学」· C++ 代码 · 共 1,865 行 · 第 1/4 页

       58,   57,   54,   48,   37,   21,   20,   17,   10,    9,
        7,    3,   69,   69,   69,   69,   69,   69,   69,   69,
       69,   69,   69,   69,   69,   69,   69,   69,   69,   69,
       69,   69,   69,   69,   69,   69,   69
    } ;

static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;

extern int yy_flex_debug;
int yy_flex_debug = 0;

/* 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 "hl_lex.l++"
/* Color-coding for FreeFem++-cs editor window */
/* Antoine Le Hyaric - LJLL Paris  - [e-mail] */
/* no CVS keyword, to avoid recalling lex&yacc after each cvs commit */
#line 7 "hl_lex.l++"
#include "hl_yacc.h"
#include "highlight.hpp"
#include "hl_lexyacc.hpp"

/* Read from a string rather than from a file */
#undef YY_INPUT
#define YY_INPUT(b,r,ms) (r=my_yyinput(b,ms))
int my_yyinput(char *buf,int maxsize);

/* Tracks at what point of the input string we are, to be able to set
highlights at the corresponding location in the highlight string */

#define YY_USER_ACTION recordlocation(yylloc,yytext);

/* bison-locations work with flex 2.5.31 but not with 2.5.4 (which is
an older version). Machines which only provide flex 2.5.4 should not
try and run flex and just use the provided hl_lex.c++ from CVS */
#line 512 "lex.yy.c"

#define INITIAL 0

#ifndef YY_NO_UNISTD_H
/* 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>
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap (void );
#else
extern int yywrap (void );
#endif
#endif

    static void yyunput (int c,char *buf_ptr  );
    
#ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int );
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * );
#endif

#ifndef YY_NO_INPUT

#ifdef __cplusplus
static int yyinput (void );
#else
static int input (void );
#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 )
#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 1

extern int yylex (YYSTYPE * yylval_param,YYLTYPE * yylloc_param );

#define YY_DECL int yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param )
#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;
    
        YYSTYPE * yylval;
    
        YYLTYPE * yylloc;
    
#line 29 "hl_lex.l++"


			/* We need to detect macros before line
			comments because macros contain a line comment */

#line 673 "lex.yy.c"

    yylval = yylval_param;

    yylloc = yylloc_param;

	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 ) {
			yyensure_buffer_stack ();
			YY_CURRENT_BUFFER_LVALUE =
				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 >= 70 )
					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] != 113 );

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:
/* rule 1 can match eol */
YY_RULE_SETUP
#line 34 "hl_lex.l++"
colorize(*yylloc,highlight_macro);
	YY_BREAK
/* comments */
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
#line 37 "hl_lex.l++"
colorize(*yylloc,highlight_comment);
	YY_BREAK
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
#line 38 "hl_lex.l++"
colorize(*yylloc,highlight_comment);
	YY_BREAK
/* strings */
case 4:
/* rule 4 can match eol */
YY_RULE_SETUP
#line 41 "hl_lex.l++"
colorize(*yylloc,highlight_string);return CONSTANT_STRING;
	YY_BREAK
/* Dynamic type for user-defined names */
case 5:
YY_RULE_SETUP
#line 44 "hl_lex.l++"
return nametoken(yytext,yylval,*yylloc);
	YY_BREAK
case 6:
YY_RULE_SETUP
#line 46 "hl_lex.l++"
return NUMBER;
	YY_BREAK
/* symbols */
case 7:
YY_RULE_SETUP
#line 49 "hl_lex.l++"
return DOTSTAR;
	YY_BREAK
case 8:
YY_RULE_SETUP
#line 50 "hl_lex.l++"
return DOTSLASH;
	YY_BREAK
case 9:
YY_RULE_SETUP
#line 51 "hl_lex.l++"
return LTLT;
	YY_BREAK
case 10:
YY_RULE_SETUP
#line 52 "hl_lex.l++"
return GTGT;
	YY_BREAK
case 11:
YY_RULE_SETUP
#line 53 "hl_lex.l++"
return ANDAND;
	YY_BREAK
case 12:
YY_RULE_SETUP
#line 54 "hl_lex.l++"
return OROR;
	YY_BREAK
case 13:
YY_RULE_SETUP
#line 55 "hl_lex.l++"
return LE;
	YY_BREAK
case 14:
YY_RULE_SETUP
#line 56 "hl_lex.l++"
return GE;
	YY_BREAK
case 15:
YY_RULE_SETUP
#line 57 "hl_lex.l++"
return EQEQ;
	YY_BREAK
case 16:
YY_RULE_SETUP
#line 58 "hl_lex.l++"
return NE;
	YY_BREAK
case 17:
YY_RULE_SETUP
#line 59 "hl_lex.l++"
return PLUSEQ;
	YY_BREAK
case 18:
YY_RULE_SETUP
#line 60 "hl_lex.l++"
return MINUSEQ;
	YY_BREAK
case 19:
YY_RULE_SETUP
#line 61 "hl_lex.l++"
return STAREQ;
	YY_BREAK
case 20:
YY_RULE_SETUP
#line 62 "hl_lex.l++"
return SLASHEQ;
	YY_BREAK
case 21:
YY_RULE_SETUP
#line 63 "hl_lex.l++"
return PLUSPLUS;
	YY_BREAK
case 22:
YY_RULE_SETUP
#line 64 "hl_lex.l++"
return MINUSMINUS;
	YY_BREAK
/* spaces do not need highlighting */
case 23:
/* rule 23 can match eol */
YY_RULE_SETUP
#line 67 "hl_lex.l++"
;
	YY_BREAK
/* for all single-character tokens */
case 24:
YY_RULE_SETUP
#line 70 "hl_lex.l++"
return (int) yytext[0];
	YY_BREAK
case 25:
YY_RULE_SETUP
#line 72 "hl_lex.l++"
ECHO;
	YY_BREAK
#line 896 "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_LVALUE->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_LVALUE->yy_n_chars;
			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
			YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_ch_buf[(yy_n_chars)] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;