scan.c

来自「操作系统源代码」· C语言 代码 · 共 1,369 行 · 第 1/3 页

       77,  131,   77,   80,   79,  129,   79,  126,   80,  125,
       80,  144,  144,  123,  122,  120,  119,  117,  116,  113,
      112,  111,  110,  108,  105,  104,  103,  101,  100,   99,
       98,   97,   96,   95,   94,   93,   92,   91,   90,   89,
       88,   86,   85,   84,   83,   82,   81,   78,   75,   74,
       73,   72,   70,   69,   68,   67,   66,   65,   63,   62,
       61,   60,   59,   58,   57,   56,   52,   48,   42,   40,
       39,   36,   35,   34,   33,   30,   28,   27,   26,   25,
       24,   23,   22,   21,   20,   18,   12,   10,    9,    8,
        7,    5,    3,  143,  143,  143,  143,  143,  143,  143,

      143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
      143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
      143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
      143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
      143,  143,  143,  143,  143,  143
    } ;

static yy_state_type yy_last_accepting_state;
static YY_CHAR *yy_last_accepting_cpos;

/* 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

/* these variables are all declared out here so that section 3 code can
 * manipulate them
 */
/* points to current character in buffer */
static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
static int yy_init = 1;		/* whether we need to initialize */
static int yy_start = 0;	/* start state number */

/* flag which is used to allow yywrap()'s to do buffer switches
 * instead of setting up a fresh yyin.  A bit of a hack ...
 */
static int yy_did_buffer_switch_on_eof;

static yy_state_type yy_get_previous_state YY_PROTO(( void ));
static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
static int yy_get_next_buffer YY_PROTO(( void ));
static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
void yyrestart YY_PROTO(( FILE *input_file ));
void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
void yy_load_buffer_state YY_PROTO(( void ));
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));

#define yy_new_buffer yy_create_buffer

#ifdef __cplusplus
static int yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO(( void ));
#endif

YY_DECL
    {
    register yy_state_type yy_current_state;
    register YY_CHAR *yy_cp, *yy_bp;
    register int yy_act;



    if ( yy_init )
	{
	YY_USER_INIT;

	if ( ! yy_start )
	    yy_start = 1;	/* first start state */

	if ( ! yyin )
	    yyin = stdin;

	if ( ! yyout )
	    yyout = stdout;

	if ( yy_current_buffer )
	    yy_init_buffer( yy_current_buffer, yyin );
	else
	    yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );

	yy_load_buffer_state();

	yy_init = 0;
	}

    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_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 = yy_def[yy_current_state];
		if ( yy_current_state >= 144 )
		    yy_c = yy_meta[yy_c];
		}
	    yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	    ++yy_cp;
	    }
	while ( yy_base[yy_current_state] != 194 );

yy_find_action:
	yy_act = yy_accept[yy_current_state];

	YY_DO_BEFORE_ACTION;
	YY_USER_ACTION;

do_action:	/* this label is used only to access EOF actions */


	switch ( yy_act )
	    {
	    case 0: /* must backtrack */
	    /* 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:
# line 61 "scan.l"
return(Define);
	YY_BREAK
case 2:
# line 62 "scan.l"
return(Break);
	YY_BREAK
case 3:
# line 63 "scan.l"
return(Quit);
	YY_BREAK
case 4:
# line 64 "scan.l"
return(Length);
	YY_BREAK
case 5:
# line 65 "scan.l"
return(Return);
	YY_BREAK
case 6:
# line 66 "scan.l"
return(For);
	YY_BREAK
case 7:
# line 67 "scan.l"
return(If);
	YY_BREAK
case 8:
# line 68 "scan.l"
return(While);
	YY_BREAK
case 9:
# line 69 "scan.l"
return(Sqrt);
	YY_BREAK
case 10:
# line 70 "scan.l"
return(Scale);
	YY_BREAK
case 11:
# line 71 "scan.l"
return(Ibase);
	YY_BREAK
case 12:
# line 72 "scan.l"
return(Obase);
	YY_BREAK
case 13:
# line 73 "scan.l"
return(Auto);
	YY_BREAK
case 14:
# line 74 "scan.l"
return(Else);
	YY_BREAK
case 15:
# line 75 "scan.l"
return(Read);
	YY_BREAK
case 16:
# line 76 "scan.l"
return(Halt);
	YY_BREAK
case 17:
# line 77 "scan.l"
return(Last);
	YY_BREAK
case 18:
# line 78 "scan.l"
return(Warranty);
	YY_BREAK
case 19:
# line 79 "scan.l"
return(Continue);
	YY_BREAK
case 20:
# line 80 "scan.l"
return(Print);
	YY_BREAK
case 21:
# line 81 "scan.l"
return(Limits);
	YY_BREAK
case 22:
# line 82 "scan.l"
{ yylval.c_value = yytext[0]; 
					      return((int)yytext[0]); }
	YY_BREAK
case 23:
# line 84 "scan.l"
{ return(AND); }
	YY_BREAK
case 24:
# line 85 "scan.l"
{ return(OR); }
	YY_BREAK
case 25:
# line 86 "scan.l"
{ return(NOT); }
	YY_BREAK
case 26:
# line 87 "scan.l"
{ yylval.c_value = yytext[0]; return(MUL_OP); }
	YY_BREAK
case 27:
# line 88 "scan.l"
{ yylval.c_value = yytext[0]; return(ASSIGN_OP); }
	YY_BREAK
case 28:
# line 89 "scan.l"
{ 
#ifdef OLD_EQ_OP
			 char warn_save;
			 warn_save = warn_not_std;
			 warn_not_std = TRUE;
			 warn ("Old fashioned =<op>");
			 warn_not_std = warn_save;
			 yylval.c_value = yytext[1];
#else
			 yylval.c_value = '=';
			 yyless (1);
#endif
			 return(ASSIGN_OP);
		       }
	YY_BREAK
case 29:
# line 103 "scan.l"
{ yylval.s_value = strcopyof(yytext); return(REL_OP); }
	YY_BREAK
case 30:
# line 104 "scan.l"
{ yylval.c_value = yytext[0]; return(INCR_DECR); }
	YY_BREAK
case 31:
# line 105 "scan.l"
{ line_no++; return(NEWLINE); }
	YY_BREAK
case 32:
# line 106 "scan.l"
{  line_no++;  /* ignore a "quoted" newline */ }
	YY_BREAK
case 33:
# line 107 "scan.l"
{ /* ignore spaces and tabs */ }
	YY_BREAK
case 34:
# line 108 "scan.l"
{
	int c;

	for (;;)
	  {
	    while ( ((c=input()) != '*') && (c != EOF)) 
	      /* eat it */
	      if (c == '\n') line_no++;
	    if (c == '*')
 	      {
		while ( (c=input()) == '*') /* eat it*/;
		if (c == '/') break; /* at end of comment */
		if (c == '\n') line_no++;
	      }
	    if (c == EOF)
	      {
		fprintf (stderr,"EOF encountered in a comment.\n");
		break;
	      }
	  }
      }
	YY_BREAK
case 35:
# line 129 "scan.l"
{ yylval.s_value = strcopyof(yytext); return(NAME); }
	YY_BREAK
case 36:
# line 130 "scan.l"
{
 	      unsigned char *look;
	      int count = 0;
	      yylval.s_value = strcopyof(yytext);
	      for (look = yytext; *look != 0; look++)
		{
		  if (*look == '\n') line_no++;
		  if (*look == '"')  count++;
		}
	      if (count != 2) yyerror ("NUL character in string.");
	      return(STRING);
	    }
	YY_BREAK
case 37:
# line 142 "scan.l"
{
	      unsigned char *src, *dst;
	      int len;
	      /* remove a trailing decimal point. */
	      len = strlen(yytext);
	      if (yytext[len-1] == '.')
	        yytext[len-1] = 0;
	      /* remove leading zeros. */
	      src = yytext;
	      dst = yytext;
	      while (*src == '0') src++;
	      if (*src == 0) src--;
	      /* Copy strings removing the newlines. */
	      while (*src != 0)
		{
	          if (*src == '\\')
		    {
		      src++; src++;
		      line_no++;
		    }
		  else
		    *dst++ = *src++;
	        }
	      *dst = 0;
	      yylval.s_value = strcopyof(yytext); 
	      return(NUMBER);
	    }
	YY_BREAK
case 38:
# line 169 "scan.l"
{
	  if (yytext[0] < ' ')
	    yyerror ("illegal character: ^%c",yytext[0] + '@');
	  else
	    if (yytext[0] > '~')
	      yyerror ("illegal character: \\%3d", (int) yytext[0]);
	    else
	      yyerror ("illegal character: %s",yytext);
	}
	YY_BREAK
case 39:
# line 178 "scan.l"
ECHO;
	YY_BREAK
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 = yy_cp - yytext - 1;

		/* undo the effects of YY_DO_BEFORE_ACTION */
		*yy_cp = yy_hold_char;

		/* 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 yyinput().
		 */
		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 + 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 + 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
			{
			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 + YY_MORE_ADJ;

			    yy_act = YY_STATE_EOF((yy_start - 1) / 2);
			    goto do_action;
			    }

			else
			    {
			    if ( ! yy_did_buffer_switch_on_eof )
				YY_NEW_FILE;
			    }