/****************************************************************************
*                     U N R E G I S T E R E D   C O P Y
* 
* You are on day 49 of your 30 day trial period.
* 
* This file was produced by an UNREGISTERED COPY of Parser Generator. It is
* for evaluation purposes only. If you continue to use Parser Generator 30
* days after installation then you are required to purchase a license. For
* more information see the online help or go to the Bumble-Bee Software
* homepage at:
* 
* http://www.bumblebeesoftware.com
* 
* This notice must remain present in the file. It cannot be removed.
****************************************************************************/

/****************************************************************************
* scan.c
* C source file generated from scan.l.
* 
* Date: 12/23/08
* Time: 20:50:56
* 
* ALex Version: 2.06
****************************************************************************/

#include <yylex.h>

/* namespaces */
#if defined(__cplusplus) && defined(YYSTDCPPLIB)
using namespace std;
#endif
#if defined(__cplusplus) && defined(YYNAMESPACE)
using namespace yl;
#endif

#define YYFASTLEXER

#line 1 ".\\scan.l"

/****************************************************************************
scan.l
ParserWizard generated Lex file.
BY:計算機科學與技術系 0610386 蒲凌君
Date: 2008年12月22日 星期一
****************************************************************************/

#include "globals.h"
#include "util.h"
#include "scan.h"
#include "parse.h"

char tokenString[MAXTOKENLEN+1];

#line 56 "scan.c"
/* repeated because of possible precompiled header */
#include <yylex.h>

/* namespaces */
#if defined(__cplusplus) && defined(YYSTDCPPLIB)
using namespace std;
#endif
#if defined(__cplusplus) && defined(YYNAMESPACE)
using namespace yl;
#endif

#define YYFASTLEXER

#include ".\scan.h"

#ifndef YYTEXT_SIZE
#define YYTEXT_SIZE 100
#endif
#ifndef YYUNPUT_SIZE
#define YYUNPUT_SIZE YYTEXT_SIZE
#endif
#ifndef YYTEXT_MAX
#define YYTEXT_MAX 0
#endif
#ifndef YYUNPUT_MAX
#define YYUNPUT_MAX YYTEXT_MAX
#endif

/* yytext */
static char YYNEAR yysatext[(YYTEXT_SIZE) + 1];		/* extra char for \0 */
char YYFAR *YYNEAR YYDCDECL yystext = yysatext;
char YYFAR *YYNEAR YYDCDECL yytext = yysatext;
int YYNEAR YYDCDECL yystext_size = (YYTEXT_SIZE);
int YYNEAR YYDCDECL yytext_size = (YYTEXT_SIZE);
int YYNEAR YYDCDECL yytext_max = (YYTEXT_MAX);

/* yystatebuf */
#if (YYTEXT_SIZE) != 0
static int YYNEAR yysastatebuf[(YYTEXT_SIZE)];
int YYFAR *YYNEAR YYDCDECL yysstatebuf = yysastatebuf;
int YYFAR *YYNEAR YYDCDECL yystatebuf = yysastatebuf;
#else
int YYFAR *YYNEAR YYDCDECL yysstatebuf = NULL;
int YYFAR *YYNEAR YYDCDECL yystatebuf = NULL;
#endif

/* yyunputbuf */
#if (YYUNPUT_SIZE) != 0
static int YYNEAR yysaunputbuf[(YYUNPUT_SIZE)];
int YYFAR *YYNEAR YYDCDECL yysunputbufptr = yysaunputbuf;
int YYFAR *YYNEAR YYDCDECL yyunputbufptr = yysaunputbuf;
#else
int YYFAR *YYNEAR YYDCDECL yysunputbufptr = NULL;
int YYFAR *YYNEAR YYDCDECL yyunputbufptr = NULL;
#endif
int YYNEAR YYDCDECL yysunput_size = (YYUNPUT_SIZE);
int YYNEAR YYDCDECL yyunput_size = (YYUNPUT_SIZE);
int YYNEAR YYDCDECL yyunput_max = (YYUNPUT_MAX);

/* backwards compatability with lex */
#ifdef input
#ifdef YYPROTOTYPE
int YYCDECL yyinput(void)
#else
int YYCDECL yyinput()
#endif
{
	return input();
}
#else
#define input yyinput
#endif

#ifdef output
#ifdef YYPROTOTYPE
void YYCDECL yyoutput(int ch)
#else
void YYCDECL yyoutput(ch)
int ch;
#endif
{
	output(ch);
}
#else
#define output yyoutput
#endif

#ifdef unput
#ifdef YYPROTOTYPE
void YYCDECL yyunput(int ch)
#else
void YYCDECL yyunput(ch)
int ch;
#endif
{
	unput(ch);
}
#else
#define unput yyunput
#endif

#ifndef YYNBORLANDWARN
#ifdef __BORLANDC__
#pragma warn -rch		/* <warning: unreachable code> off */
#endif
#endif

#ifdef YYPROTOTYPE
int YYCDECL yylexeraction(int action)
#else
int YYCDECL yylexeraction(action)
int action;
#endif
{
	yyreturnflg = YYTRUE;
	switch (action) {
	case 1:
		{
#line 42 ".\\scan.l"
return INT;
#line 177 "scan.c"
		}
		break;
	case 2:
		{
#line 43 ".\\scan.l"
return DOUBLE;
#line 184 "scan.c"
		}
		break;
	case 3:
		{
#line 44 ".\\scan.l"
return CHAR;
#line 191 "scan.c"
		}
		break;
	case 4:
		{
#line 45 ".\\scan.l"
return VOID;
#line 198 "scan.c"
		}
		break;
	case 5:
		{
#line 46 ".\\scan.l"
return IF;
#line 205 "scan.c"
		}
		break;
	case 6:
		{
#line 47 ".\\scan.l"
return ELSE;
#line 212 "scan.c"
		}
		break;
	case 7:
		{
#line 48 ".\\scan.l"
return WHILE;
#line 219 "scan.c"
		}
		break;
	case 8:
		{
#line 49 ".\\scan.l"
return FOR;
#line 226 "scan.c"
		}
		break;
	case 9:
		{
#line 50 ".\\scan.l"
return RETURN;
#line 233 "scan.c"
		}
		break;
	case 10:
		{
#line 51 ".\\scan.l"
return INPUT;
#line 240 "scan.c"
		}
		break;
	case 11:
		{
#line 52 ".\\scan.l"
return OUTPUT;
#line 247 "scan.c"
		}
		break;
#line 54 ".\\scan.l"
  
#line 252 "scan.c"
	case 12:
		{
#line 55 ".\\scan.l"
return INC;
#line 257 "scan.c"
		}
		break;
	case 13:
		{
#line 56 ".\\scan.l"
return DEC;
#line 264 "scan.c"
		}
		break;
	case 14:
		{
#line 57 ".\\scan.l"
return LT;
#line 271 "scan.c"
		}
		break;
	case 15:
		{
#line 58 ".\\scan.l"
return LE;
#line 278 "scan.c"
		}
		break;
	case 16:
		{
#line 59 ".\\scan.l"
return GT;
#line 285 "scan.c"
		}
		break;
	case 17:
		{
#line 60 ".\\scan.l"
return GE;
#line 292 "scan.c"
		}
		break;
	case 18:
		{
#line 61 ".\\scan.l"
return EQ;
#line 299 "scan.c"
		}
		break;
	case 19:
		{
#line 62 ".\\scan.l"
return PLUS;
#line 306 "scan.c"
		}
		break;
	case 20:
		{
#line 63 ".\\scan.l"
return SUB;
#line 313 "scan.c"
		}
		break;
	case 21:
		{
#line 64 ".\\scan.l"
return MUT;
#line 320 "scan.c"
		}
		break;
	case 22:
		{
#line 65 ".\\scan.l"
return DIV;
#line 327 "scan.c"
		}
		break;
	case 23:
		{
#line 66 ".\\scan.l"
return MOD;
#line 334 "scan.c"
		}
		break;
	case 24:
		{
#line 67 ".\\scan.l"
return NEQ;
#line 341 "scan.c"
		}
		break;
	case 25:
		{
#line 68 ".\\scan.l"
return AND;
#line 348 "scan.c"
		}
		break;
	case 26:
		{
#line 69 ".\\scan.l"
return OR;
#line 355 "scan.c"
		}
		break;
	case 27:
		{
#line 70 ".\\scan.l"
return NOT;
#line 362 "scan.c"
		}
		break;
	case 28:
		{
#line 71 ".\\scan.l"
return B_LEFT;
#line 369 "scan.c"
		}
		break;
	case 29:
		{
#line 72 ".\\scan.l"
return B_RIGHT;
#line 376 "scan.c"
		}
		break;
	case 30:
		{
#line 73 ".\\scan.l"
return B_NOT;
#line 383 "scan.c"
		}
		break;
	case 31:
		{
#line 74 ".\\scan.l"
return B_AND;
#line 390 "scan.c"
		}
		break;
	case 32:
		{
#line 75 ".\\scan.l"
return B_OR;
#line 397 "scan.c"
		}
		break;
	case 33:
		{
#line 76 ".\\scan.l"
return B_XOR;
#line 404 "scan.c"
		}
		break;
	case 34:
		{
#line 77 ".\\scan.l"
return ASSIGN;
#line 411 "scan.c"
		}
		break;
	case 35:
		{
#line 78 ".\\scan.l"
return SEMI;
#line 418 "scan.c"
		}
		break;
	case 36:
		{
#line 79 ".\\scan.l"
return COMMA;
#line 425 "scan.c"
		}
		break;
	case 37:
		{
#line 80 ".\\scan.l"
return LP;
#line 432 "scan.c"
		}
		break;
	case 38:
		{
#line 81 ".\\scan.l"
return RP;
#line 439 "scan.c"
		}
		break;
	case 39:
		{
#line 82 ".\\scan.l"
return LSP;
#line 446 "scan.c"
		}
		break;
	case 40:
		{
#line 83 ".\\scan.l"
return RSP;
#line 453 "scan.c"
		}
		break;
	case 41:
		{
#line 84 ".\\scan.l"
return LFP;
#line 460 "scan.c"
		}
		break;
	case 42:
		{
#line 85 ".\\scan.l"
return RFP;
#line 467 "scan.c"
		}
		break;
	case 43:
		{
#line 86 ".\\scan.l"
return ID;
#line 474 "scan.c"
		}
		break;
	case 44:
		{
#line 87 ".\\scan.l"
return NUM;
#line 481 "scan.c"
		}
		break;
	case 45:
		{
#line 88 ".\\scan.l"
return FNUM;
#line 488 "scan.c"
		}
		break;
	case 46:
		{
#line 89 ".\\scan.l"
return SCHAR;
#line 495 "scan.c"
		}
		break;
	case 47:
		{
#line 90 ".\\scan.l"
lineno++;
#line 502 "scan.c"
		}
		break;
	case 48:
		{
#line 91 ".\\scan.l"

#line 509 "scan.c"
		}
		break;
	case 49:
		{
#line 92 ".\\scan.l"
 char c;
				  while ((c = yyinput()) != '\n')
				    if (c == EOF) return ENDFILE;
				  yyunput(c);
				
#line 520 "scan.c"
		}
		break;
	case 50:
		{
#line 97 ".\\scan.l"
 char c;
                  int done = FALSE;
                  do {
                    while ((c = yyinput()) != '*')
                      if (c == EOF) return ERROR;
                    while ((c = yyinput()) == '*');
                    if (c == '/') done = TRUE;
                  } while (!done);
                
#line 535 "scan.c"
		}
		break;
	case 51:
		{
#line 106 ".\\scan.l"
return ERROR;
#line 542 "scan.c"
		}
		break;
	default:
		yyassert(0);
		break;
	}
	yyreturnflg = YYFALSE;
	return 0;
}

#ifndef YYNBORLANDWARN
#ifdef __BORLANDC__
#pragma warn .rch		/* <warning: unreachable code> to the old state */
#endif
#endif
YYCONST yymatch_t YYNEARFAR YYBASED_CODE YYDCDECL yymatch[] = {
	0
};

int YYNEAR YYDCDECL yytransitionmax = 224;
YYCONST yytransition_t YYNEARFAR YYBASED_CODE YYDCDECL yytransition[] = {
	{ 0, 0 },
	{ 4, 1 },
	{ 5, 1 },
	{ 4, 4 },
	{ 45, 17 },
	{ 41, 13 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 17, 17 },
	{ 43, 16 },
	{ 53, 28 },
	{ 68, 56 },
	{ 55, 29 },
	{ 54, 28 },
	{ 44, 16 },
	{ 69, 56 },
	{ 51, 26 },
	{ 4, 1 },
	{ 6, 1 },
	{ 4, 4 },
	{ 56, 29 },
	{ 52, 27 },
	{ 7, 1 },
	{ 8, 1 },
	{ 9, 1 },
	{ 10, 1 },
	{ 11, 1 },
	{ 12, 1 },
	{ 13, 1 },
	{ 14, 1 },
	{ 15, 1 },
	{ 42, 15 },
	{ 16, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 17, 1 },
	{ 38, 6 },
	{ 18, 1 },
	{ 19, 1 },
	{ 20, 1 },
	{ 21, 1 },
	{ 49, 21 },
	{ 50, 21 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 23, 1 },
	{ 57, 30 },
	{ 24, 1 },
	{ 25, 1 },
	{ 22, 1 },
	{ 58, 31 },
	{ 22, 1 },
	{ 22, 1 },
	{ 26, 1 },
	{ 22, 1 },
	{ 27, 1 },
	{ 28, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 29, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 30, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 31, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 32, 1 },
	{ 33, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 22, 1 },
	{ 34, 1 },
	{ 35, 1 },
	{ 36, 1 },
	{ 37, 1 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 46, 19 },
	{ 47, 19 },
	{ 59, 32 },
	{ 60, 33 },
	{ 61, 35 },
	{ 62, 40 },
	{ 64, 51 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 65, 52 },
	{ 66, 53 },
	{ 67, 54 },
	{ 39, 8 },
	{ 22, 88 },
	{ 70, 57 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 22, 88 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 63, 63 },
	{ 71, 58 },
	{ 72, 59 },
	{ 73, 60 },
	{ 0, 9 },
	{ 74, 64 },
	{ 75, 65 },
	{ 76, 66 },
	{ 77, 68 },
	{ 78, 70 },
	{ 79, 71 },
	{ 80, 72 },
	{ 81, 73 },
	{ 82, 76 },
	{ 83, 77 },
	{ 84, 78 },
	{ 85, 79 },
	{ 86, 81 },
	{ 87, 84 },
	{ 88, 85 },
	{ 48, 20 }
};

YYCONST yystate_t YYNEARFAR YYBASED_CODE YYDCDECL yystate[] = {
	{ 0, 0, 0 },
	{ -3, -8, 0 },
	{ 1, 0, 0 },
	{ 0, 0, 51 },
	{ 0, -6, 48 },
	{ 0, 0, 47 },
	{ 0, -11, 27 },
	{ 0, 0, 23 },
	{ 0, 127, 31 },
	{ -40, 197, 51 },
	{ 0, 0, 37 },
	{ 0, 0, 38 },
	{ 0, 0, 21 },
	{ 0, -38, 19 },
	{ 0, 0, 36 },
	{ 0, -7, 20 },
	{ 0, -26, 22 },
	{ 0, -42, 44 },
	{ 0, 0, 35 },
	{ 0, 69, 14 },
	{ 0, 162, 34 },
	{ 0, -6, 16 },
	{ 88, 0, 43 },
	{ 0, 0, 39 },
	{ 0, 0, 40 },
	{ 0, 0, 33 },
	{ 88, -81, 43 },
	{ 88, -80, 43 },
	{ 88, -91, 43 },
	{ 88, -83, 43 },
	{ 88, -33, 43 },
	{ 88, -13, 43 },
	{ 88, 20, 43 },
	{ 88, 28, 43 },
	{ 0, 0, 41 },
	{ 0, 9, 32 },
	{ 0, 0, 42 },
	{ 0, 0, 30 },
	{ 0, 0, 24 },
	{ 0, 0, 25 },
	{ 0, 95, 0 },
	{ 0, 0, 12 },
	{ 0, 0, 13 },
	{ 0, 0, 50 },
	{ 0, 0, 49 },
	{ 63, 0, 0 },
	{ 0, 0, 28 },
	{ 0, 0, 15 },
	{ 0, 0, 18 },
	{ 0, 0, 17 },
	{ 0, 0, 29 },
	{ 88, 38, 43 },
	{ 88, 47, 43 },
	{ 88, 52, 43 },
	{ 88, 50, 43 },
	{ 88, 0, 5 },
	{ 88, -94, 43 },
	{ 88, 51, 43 },
	{ 88, 88, 43 },
	{ 88, 100, 43 },
	{ 88, 101, 43 },
	{ 0, 0, 26 },
	{ 0, 0, 46 },
	{ 0, 146, 45 },
	{ 88, 94, 43 },
	{ 88, 108, 43 },
	{ 88, 113, 43 },
	{ 88, 0, 8 },
	{ 88, 94, 43 },
	{ 88, 0, 1 },
	{ 88, 100, 43 },
	{ 88, 96, 43 },
	{ 88, 114, 43 },
	{ 88, 107, 43 },
	{ 88, 0, 3 },
	{ 88, 0, 6 },
	{ 88, 100, 43 },
	{ 88, 101, 43 },
	{ 88, 101, 43 },
	{ 88, 105, 43 },
	{ 88, 0, 4 },
	{ 88, 119, 43 },
	{ 88, 0, 2 },
	{ 88, 0, 10 },
	{ 88, 105, 43 },
	{ 88, 112, 43 },
	{ 88, 0, 7 },
	{ 88, 0, 11 },
	{ 0, 71, 9 }
};

YYCONST yybackup_t YYNEARFAR YYBASED_CODE YYDCDECL yybackup[] = {
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0
};

#line 110 ".\\scan.l"


/////////////////////////////////////////////////////////////////////////////
// programs section
TokenType getToken(void)
{
    static int firstTime = TRUE;
    TokenType currentToken;
    if (firstTime) {
        firstTime = FALSE;
        lineno++;
        yyin = source;
        yyout = listing;
    }
    currentToken = yylex();
    strncpy(tokenString, yytext, MAXTOKENLEN);
    if (TraceScan) {
		lineno = yylineno;
        fprintf(listing,"\t%d: ",lineno);
        printToken(currentToken,tokenString);
    }
    return currentToken;
}