/* SCCS - @(#)alpha.lex	1.18 - 09/15/99 - 10:39:54 */

%{
/* 
 * SCCS @(#)alpha.lex	1.12 - 08/05/99 - 15:01:14
 *
 * $Log: alpha.lex,v $
 *
 * 98/9/28 sn: added \r to NONNEWLINE_WHITE_SPACE_CHAR	list  because
 * PC's add an extra \r to newlines
 *
 * Revision 1.6  1998/01/30 20:02:58  erhan
 * ver 5
 *
 * Revision 1.5  1997/12/13 01:30:31  erhan
 * aa - commited files for erhan. erhan will comment when he comes back
 *
 * Revision 1.4  1997/11/06 03:21:55  erhan
 * NSL3.0.b
 *
 * Revision 1.3  1997/07/30 21:10:33  erhan
 * nsl3.0
 *
 * Revision 1.2  1997/06/13 22:46:57  erhan
 * 'NslMain takes model name as a parameter, npp:verbatim_on verbatim_off semi-column stuff, NslModule: method to setup display variables '
 *
 * Revision 1.1.1.1  1997/03/12 23:09:23  nsl
 * changed dir struct
 *
 * Revision 1.1.1.1  1997/02/20 08:04:35  nsl
 *  Importng npp
 *
*/

package npp.src;

import java.lang.System;
import java.io.*;
import java.util.*;
import npp.src.util.*;
import pp.src.jbf.*;

class Utility {
  public static void assert
    (
     boolean expr
     )
      { 
	if (false == expr) {
	  throw (new Error("Error: Assertion failed."));
	}
      }
  
  private static final String errorMsg[] = {
    "Error: Unmatched end-of-comment punctuation.",
    "Error: Unmatched start-of-comment punctuation.",
    "Error: Unclosed string.",
    "Error: Illegal character."
    };
  
  public static final int E_ENDCOMMENT = 0; 
  public static final int E_STARTCOMMENT = 1; 
  public static final int E_UNCLOSEDSTR = 2; 
  public static final int E_UNMATCHED = 3; 

  public static void error
    (
     int code
     )
      {
	System.out.println(errorMsg[code]);
      }
}
//<COMMENT>{COMMENT_TEXT} { }
%}


%s COMMENT
%s VERB_ON
%s VERB_SCAN
%s VERB_IGN

IDENTIFIER		[A-Za-z_$][A-Za-z_$0-9]*
ALPHA			[A-Za-z]
DIGIT			[0-9]
HEXDIGIT		[A-Fa-f0-9]
OCTDIGIT		[0-7]
DECNUMBER		[1-9]{DIGIT}*
HEXNUMBER		0[Xx]{HEXDIGIT}+
OCTNUMBER		0{OCTDIGIT}*
DECLONG		{DECNUMBER}[Ll]
HEXLONG		{HEXNUMBER}[Ll]
OCTLONG		{OCTNUMBER}[Ll]
EXPONENT		[Ee][+-]?{DIGIT}+

FLOATBASE		((({DIGIT}+\.{DIGIT}*)|({DIGIT}*\.{DIGIT}+)){EXPONENT})|({DIGIT}+{EXPONENT})|({DIGIT}+\.{DIGIT}*)|({DIGIT}*\.{DIGIT}+)

DOUBLE        	({FLOATBASE}[Dd]?)|({DIGIT}+[Dd])
FLOAT            	({FLOATBASE}|({DIGIT}+))[Ff]

UNICODE_CHARACTER   	\\u{HEXDIGIT}{HEXDIGIT}{HEXDIGIT}{HEXDIGIT}
ONECHAR 		[\^'\"]|(\\.)|.|(\\[0123]?{OCTDIGIT}{OCTDIGIT}?)|{UNICODE_CHARACTER}
CHARLITCHAR		{ONECHAR}|"\""
CHARACTER		'[\^'\"]'|'(\\.)'|'.'|'(\\[0123]?{OCTDIGIT}{OCTDIGIT}?)'|'{UNICODE_CHARACTER}'
STRINGCHAR		{ONECHAR}|'
STRING		"\""{STRINGCHAR}*"\""
CHAR_OP		[,;()[\].&|!~=+*/%<>^?:@]
WHITESPACE		[ \n\r\t]+




NONNEWLINE_WHITE_SPACE_CHAR	[\ \t\b\012\r]
WHITE_SPACE_CHAR	[\n\ \t\b\012]

STRING_TEXT (\\"\""|[^\n\"]|\\{WHITE_SPACE_CHAR}+\\)*
COMMENT_TEXT ([^"/"*\n]|[^*\n]"/"[^*\n]|[^/\n]"*"[^/\n]|"*"[^/\n]|"/"[^*\n])*


%% 



<INITIAL>{NONNEWLINE_WHITE_SPACE_CHAR}+ ;

<INITIAL,COMMENT>\n ;

<INITIAL>"/*" { yybegin(COMMENT); comment_count = comment_count + 1; }

<COMMENT>"/*" { comment_count = comment_count + 1; }
<COMMENT>"*/" { 
	comment_count = comment_count - 1; 
	Utility.assert(comment_count >= 0);
	if (comment_count == 0) {
    		yybegin(INITIAL);
	}
}
<COMMENT>. { }
<INITIAL>"//".* { }

<INITIAL>\"{STRING_TEXT}\" {
//	Utility.assert(str.length() == lexeme().length() - 2);
	yyreturn((YYtoken)(new String_Token(YYtokentypes.STRING_LITERAL,yytext)));
}
<INITIAL>\"{STRING_TEXT} {
	//	Utility.error(Utility.E_UNCLOSEDSTR);
	//Utility.assert(str.length() == lexeme().length() - 1);
	yyreturn((YYtoken)(new String_Token(YYtokentypes.STRING_LITERAL,yytext)));
}
			
    		
<INITIAL>{FLOAT} {
/*
	String str;
	if (lexeme().endsWith("f") || lexeme().endsWith("F")) {
		str =  lexeme().substring(0,lexeme().length()-1);
		Utility.assert(str.length() == lexeme().length() - 1);
	}
	else
		str = lexeme();

*/
	Float_Token t = new Float_Token(YYtokentypes.FLOAT_LITERAL,yytext);
/*
	try {
		t.m_float = java.lang.Float.valueOf(str).floatValue();
	} catch (NumberFormatException e) {
	System.err.println("Unexpected integer number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + str.length()));
	}
*/
	yyreturn ((YYtoken)t);
	}

<INITIAL>{DOUBLE} {
/*	
String str;
	if (lexeme().endsWith("d") || lexeme().endsWith("D")) {
		str =  lexeme().substring(0,lexeme().length()-1);
		Utility.assert(str.length() == lexeme().length() - 1);
	}
	else
		str = lexeme();
*/

	Double_Token t = new Double_Token(YYtokentypes.DOUBLE_LITERAL,yytext);
/*	
try {
		t.m_double = java.lang.Double.valueOf(str).doubleValue();
	} catch (NumberFormatException e) {
	System.err.println("Unexpected integer number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + str.length()));
	}
*/	
yyreturn((YYtoken)(t));
	}

	   
<INITIAL>{DECLONG} {
//	String str = lexeme().substring(0,lexeme().length() - 1);
	DecLong_Token t = new DecLong_Token(YYtokentypes.LONG_LITERAL,yytext);
/*	
Utility.assert(str.length() == lexeme().length() - 1);
	try {
		t.m_long = java.lang.Long.valueOf(str).longValue();
	} catch (NumberFormatException e) {
	System.err.println("Unexpected long number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + str.length()));
	}
*/	
yyreturn((YYtoken)(t));
	
}
<INITIAL>{HEXLONG} {
/*
	String str = lexeme().substring(2,lexeme().length() - 1);
	Long_Token t = new Long_Token(YYtokentypes.LONG_LITERAL,yytext);
	Utility.assert(str.length() == lexeme().length() - 2);
	try {
		t.m_long = java.lang.Long.valueOf(str, 16).longValue();
	} catch (NumberFormatException e) {
	System.err.println("Unexpected long number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + str.length()));
	}
*/
	yyreturn((YYtoken)( new HexLong_Token(YYtokentypes.LONG_LITERAL,yytext)));
	
}
<INITIAL>{OCTLONG} {
/*
	String str = lexeme().substring(1,lexeme().length() - 1);
	Long_Token t = new Long_Token(YYtokentypes.LONG_LITERAL,yytext);
	Utility.assert(str.length() == lexeme().length() - 2);
	try {
		t.m_long = java.lang.Long.valueOf(str, 8).longValue();
	} catch (NumberFormatException e) {
	System.err.println("Unexpected long number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + str.length()));
	}
	yyreturn((YYtoken)(t));
*/
yyreturn((YYtoken)(new OctLong_Token(YYtokentypes.LONG_LITERAL,yytext)));	
	
}
<INITIAL>{DECNUMBER} {
/*	
Int_Token t = new Int_Token(YYtokentypes.INT_LITERAL,yytext);
	try {
		t.m_int = java.lang.Integer.parseInt(lexeme());
	} catch (NumberFormatException e) {
	System.err.println("Unexpected 10-based integer number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + lexeme().length())+"str "+lexeme());
	}
	yyreturn((YYtoken)(t));
*/	
yyreturn((YYtoken)(new DecInt_Token(YYtokentypes.INT_LITERAL,yytext)));
}


<INITIAL>{HEXNUMBER} {
/*
	String str = lexeme().substring(2,lexeme().length());
	Int_Token t = new Int_Token(YYtokentypes.INT_LITERAL,yytext);
	Utility.assert(str.length() == lexeme().length() - 2);

	try {
		t.m_int = java.lang.Integer.parseInt(str, 16);
	} catch (NumberFormatException e) {
	System.err.println("Unexpected 16-based integer number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + str.length()));
	}
	yyreturn((YYtoken)(t));
	*/
yyreturn((YYtoken)(new OctInt_Token(YYtokentypes.INT_LITERAL,yytext)));
}

<INITIAL>{OCTNUMBER} {
/*
	String str = lexeme();
	Int_Token t = new Int_Token(YYtokentypes.INT_LITERAL,yytext);
	//Utility.assert(str.length() == lexeme().length() - 1);
	try {
		t.m_int = java.lang.Integer.parseInt(str, 8);
	} catch (NumberFormatException e) {
	System.err.println("Unexpected 8-based integer number parse error at line:"
		+yyline+" char:"+yychar()+" to "+(yychar() + str.length()));
	}
	yyreturn((YYtoken)(t));
	*/
	yyreturn((YYtoken)(new DecInt_Token(YYtokentypes.INT_LITERAL,yytext)));


}
 
<INITIAL>{CHARACTER} {
//	String str =  lexeme().substring(1,lexeme().length()-1);
//	Utility.assert(str.length() == lexeme().length() - 2);
	yyreturn((YYtoken)(new Char_Token(YYtokentypes.CHARACTER_LITERAL,yytext)));
}
	

<VERB_ON>[.\n] { }
<VERB_ON>"verbatim_off"{WHITESPACE}*";" { yybegin(INITIAL);
                        yyreturn(new YYtoken(YYtokentypes.VERBATIM_OFF,yytext)); }
<INITIAL>"verbatim_NSLJ"{WHITESPACE}*";" {  // yybegin(VERB_SCAN);
                            yybegin(VERB_ON);
			yyreturn(new YYtoken(YYtokentypes.VERBATIM_NSLJ,yytext));}
<INITIAL>"verbatim_NSLC"{WHITESPACE}*";" {  // yybegin(VERB_SCAN);
                            yybegin(VERB_ON);
			yyreturn(new YYtoken(YYtokentypes.VERBATIM_NSLC,yytext));}
<INITIAL>"NSLJ"  { yyreturn(new YYtoken(YYtokentypes.NSLJ,yytext));}

<INITIAL>"special" {yyreturn(new YYtoken(YYtokentypes.SPECIAL,yytext));}
<INITIAL>"SPECIAL" {yyreturn(new YYtoken(YYtokentypes.SPECIAL,yytext));}
<INITIAL>"ARRAY" {yyreturn(new YYtoken(YYtokentypes.ARRAY,yytext));}
<INITIAL>"ARRAY new" {yyreturn(new YYtoken(YYtokentypes.NEW,yytext));}
<INITIAL>"nslModule" {yyreturn(new YYtoken(YYtokentypes.NSLMODULE,yytext));}
<INITIAL>"nslInModule" {yyreturn(new YYtoken(YYtokentypes.NSLMODULE,yytext));}
<INITIAL>"nslOutModule" {yyreturn(new YYtoken(YYtokentypes.NSLMODULE,yytext));}
<INITIAL>"nslModel" {yyreturn(new YYtoken(YYtokentypes.NSLMODEL,yytext));}
<INITIAL>"nslClass" {yyreturn(new YYtoken(YYtokentypes.NSLCLASS,yytext));}
<INITIAL>"connect" { yyreturn(new YYtoken(YYtokentypes.CONNECT,yytext));}
<INITIAL>"nslConnect" { yyreturn(new YYtoken(YYtokentypes.CONNECT,yytext));}
<INITIAL>"nslRelabel" { yyreturn(new YYtoken(YYtokentypes.CONNECT,yytext));}
<INITIAL>"nslprint" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslprintln" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"NslPrintln" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"NslPrint" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslPrintln" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslPrint" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslAdd" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslConv" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslConvzero" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslConvW" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslConvC" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslDiv" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslDiff" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslFillColumns" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslFillRows" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMath" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMaxValue" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMinValue" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMul" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslProd" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslProduct" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslRamp" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSaturation" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSigmoid" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSigmoid2" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslStep" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSub" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslTrans" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSum" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSumRows" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSumColumns" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMaxElem" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMinElem" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslGetSector" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSetSector" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslElemMult" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslElemDiv" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslConcatenateRows" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslConcatenateColumns" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslGetRow" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslGetColumn" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslRandom" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslGuassian" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslRint" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslAbs" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslExp" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslArcCos" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslArcSin" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslArcTan" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslCos" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSin" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslTan" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslLog" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMaxMerge" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslMinMerge" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslPow" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSome" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslNone" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslAll" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"=>".*  { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslSqrt" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslDistance" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslBound" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}
<INITIAL>"nslDotProd" { yyreturn(new YYtoken(YYtokentypes.NSLMULTI,yytext));}






<INITIAL>"abstract" { yyreturn(new YYtoken(YYtokentypes.ABSTRACT,yytext));}
<INITIAL>"boolean" { yyreturn(new YYtoken(YYtokentypes.BOOLEAN,yytext));}
<INITIAL>"break" { yyreturn(new YYtoken(YYtokentypes.BREAK,yytext));}
<INITIAL>"byte" { yyreturn(new YYtoken(YYtokentypes.BYTE,yytext));}
<INITIAL>"case" { yyreturn(new YYtoken(YYtokentypes.CASE,yytext));}   
<INITIAL>"catch" { yyreturn(new YYtoken(YYtokentypes.CATCH,yytext));}
<INITIAL>"char" { yyreturn(new YYtoken(YYtokentypes.CHAR, yytext));}
<INITIAL>"class" { yyreturn(new YYtoken(YYtokentypes.CLASS,yytext));}
<INITIAL>"continue" { yyreturn(new YYtoken(YYtokentypes.CONTINUE,yytext));}
<INITIAL>"default" { yyreturn(new YYtoken(YYtokentypes.DEFAULT, yytext));}
<INITIAL>"do" { yyreturn(new YYtoken(YYtokentypes.DO  , yytext));}
<INITIAL>"double" { yyreturn(new YYtoken(YYtokentypes.DOUBLE, yytext));}
<INITIAL>"extends" { yyreturn(new YYtoken(YYtokentypes.EXTENDS, yytext));}
<INITIAL>"else" { yyreturn(new YYtoken(YYtokentypes.ELSE, yytext));}

<INITIAL>"false" { yyreturn(new YYtoken(YYtokentypes.FALSE_TOKEN, yytext));}

<INITIAL>"final" { yyreturn(new YYtoken(YYtokentypes.FINAL, yytext));}
<INITIAL>"finally" { yyreturn(new YYtoken(YYtokentypes.FINALLY, yytext));}
<INITIAL>"float" { yyreturn(new YYtoken(YYtokentypes.FLOAT , yytext));}
<INITIAL>"for" { yyreturn(new YYtoken(YYtokentypes.FOR  , yytext));}
<INITIAL>"if" { yyreturn(new YYtoken(YYtokentypes.IF   , yytext));}
<INITIAL>"implements" { yyreturn(new YYtoken(YYtokentypes.IMPLEMENTS, yytext));}
<INITIAL>"nslImport" { yyreturn(new YYtoken(YYtokentypes.NSLIMPORT  , yytext));}
<INITIAL>"instanceof" { yyreturn(new YYtoken(YYtokentypes.INSTANCEOF, yytext));}
<INITIAL>"int" { yyreturn(new YYtoken(YYtokentypes.INT     , yytext));}
<INITIAL>"interface" { yyreturn(new YYtoken(YYtokentypes.INTERFACE, yytext));}
<INITIAL>"long" { yyreturn(new YYtoken(YYtokentypes.LONG    , yytext));}
<INITIAL>"native" { yyreturn(new YYtoken(YYtokentypes.NATIVE  , yytext));}
<INITIAL>"new" { yyreturn(new YYtoken(YYtokentypes.NEW  , yytext));}
<INITIAL>"null" { yyreturn(new YYtoken(YYtokentypes.NULL_TOKEN  , yytext));}

<INITIAL>"package" { yyreturn(new YYtoken(YYtokentypes.PACKAGE , yytext));}
<INITIAL>"private" { yyreturn(new YYtoken(YYtokentypes.PRIVATE , yytext));}
<INITIAL>"protected" { yyreturn(new YYtoken(YYtokentypes.PROTECTED, yytext));}
<INITIAL>"public" { yyreturn(new YYtoken(YYtokentypes.PUBLIC  , yytext));}
<INITIAL>"return" { yyreturn(new YYtoken(YYtokentypes.RETURN , yytext));}
<INITIAL>"short" { yyreturn(new YYtoken(YYtokentypes.SHORT   , yytext));}
<INITIAL>"static" { yyreturn(new YYtoken(YYtokentypes.STATIC  , yytext));}
<INITIAL>"super" { yyreturn(new YYtoken(YYtokentypes.SUPER   , yytext));}
<INITIAL>"switch" { yyreturn(new YYtoken(YYtokentypes.SWITCH  , yytext));}
<INITIAL>"synchronized" { yyreturn(new YYtoken(YYtokentypes.SYNCHRONIZED, yytext));}
<INITIAL>"this" { yyreturn(new YYtoken(YYtokentypes.THIS    , yytext));}
<INITIAL>"throw" { yyreturn(new YYtoken(YYtokentypes.THROW   , yytext));}
<INITIAL>"throws" { yyreturn(new YYtoken(YYtokentypes.THROWS  , yytext));}
<INITIAL>"transient" { yyreturn(new YYtoken(YYtokentypes.TRANSIENT, yytext));}
<INITIAL>"volatile" { yyreturn(new YYtoken(YYtokentypes.VOLATILE , yytext));}
<INITIAL>"true" { yyreturn(new YYtoken(YYtokentypes.TRUE_TOKEN, yytext));}
<INITIAL>"try" { yyreturn(new YYtoken(YYtokentypes.TRY     , yytext));}
<INITIAL>"void" { yyreturn(new YYtoken(YYtokentypes.VOID    , yytext));}
<INITIAL>"while" { yyreturn(new YYtoken(YYtokentypes.WHILE   , yytext));}

<INITIAL>">>=" { yyreturn(new YYtoken(YYtokentypes.SHIFT_RIGHT_EQUALS, yytext));}
<INITIAL>">>>=" { yyreturn(new YYtoken(YYtokentypes.FILL_SHIFT_RIGHT_EQUALS, yytext));}
<INITIAL>"<<=" { yyreturn(new YYtoken(YYtokentypes.SHIFT_LEFT_EQUALS, yytext));}
<INITIAL>"+=" { yyreturn(new YYtoken(YYtokentypes.ADD_EQUALS, yytext));}
<INITIAL>"-=" { yyreturn(new YYtoken(YYtokentypes.SUB_EQUALS, yytext));}
<INITIAL>"*=" { yyreturn(new YYtoken(YYtokentypes.MUL_EQUALS, yytext));}
<INITIAL>"/=" { yyreturn(new YYtoken(YYtokentypes.DIV_EQUALS, yytext));}
<INITIAL>"%=" { yyreturn(new YYtoken(YYtokentypes.MOD_EQUALS, yytext));}
<INITIAL>"&=" { yyreturn(new YYtoken(YYtokentypes.AND_EQUALS, yytext));}
<INITIAL>"^=" { yyreturn(new YYtoken(YYtokentypes.XOR_EQUALS, yytext));}
<INITIAL>"|=" { yyreturn(new YYtoken(YYtokentypes.OR_EQUALS, yytext));}
<INITIAL>">>" { yyreturn(new YYtoken(YYtokentypes.BITSHIFT_RIGHT, yytext));}
<INITIAL>">>>" { yyreturn(new YYtoken(YYtokentypes.FILL_SHIFT_RIGHT, yytext));}
<INITIAL>"<<" { yyreturn(new YYtoken(YYtokentypes.SHIFT_LEFT, yytext));}
<INITIAL>"++" { yyreturn(new YYtoken(YYtokentypes.INCR, yytext));}
<INITIAL>"--" { yyreturn(new YYtoken(YYtokentypes.DECR, yytext));}
<INITIAL>"&&" { yyreturn(new YYtoken(YYtokentypes.AND, yytext));}
<INITIAL>"||" { yyreturn(new YYtoken(YYtokentypes.OR, yytext));}
<INITIAL>"<=" { yyreturn(new YYtoken(YYtokentypes.LTEQ, yytext));}
<INITIAL>">=" { yyreturn(new YYtoken(YYtokentypes.GTEQ, yytext));}
<INITIAL>"==" { yyreturn(new YYtoken(YYtokentypes.EQUAL_COMPARE, yytext));}
<INITIAL>"!=" { yyreturn(new YYtoken(YYtokentypes.NOT_EQUAL, yytext));}
<INITIAL>{CHAR_OP} { yyreturn(new YYtoken((yytext.lexeme()).charAt(0), yytext));}
<INITIAL>"{" { yyreturn(new YYtoken((yytext.lexeme()).charAt(0), yytext));}
<INITIAL>"}" { yyreturn(new YYtoken((yytext.lexeme()).charAt(0), yytext));}
<INITIAL>"-" { yyreturn(new YYtoken((yytext.lexeme()).charAt(0), yytext));}
<INITIAL>".*" { yyreturn(new YYtoken(YYtokentypes.BIT_MUL, yytext));}

<INITIAL>"NslCharString" { yyreturn(new YYtoken(YYtokentypes.STRING, yytext));}
<INITIAL>"charString" { yyreturn(new YYtoken(YYtokentypes.STRING, yytext));}

<INITIAL>{IDENTIFIER} {
YYtoken t =new YYtoken(YYtokentypes.SYMBOL, yytext);
yyreturn(t);
}



<INITIAL,COMMENT>. {
        System.out.println("Illegal character: <" + yytext.lexeme() + "> at line "+yyline());
	Utility.error(Utility.E_UNMATCHED);
}

%%
  private int comment_count = 0;
NslPreProcessor npp;

public
void init(NslPreProcessor npp) {
npp.setWholeBuffer(yytext.wholebuffer);
}