package grammar;

import text.*;
import java.io.*;
import java_cup.runtime.*;

%%

%public
%type		Symbol
%char

%{
	public Symbol token( int tokenType ) {
			Print.error().println( "Obtain token " 
			+ sym.terminal_name( tokenType ) + " \"" + yytext() + "\"" );
		return new Symbol( tokenType, yychar, 
			yychar + yytext().length(), yytext() );
		}
	
	int commentNesting = 0;
%}

%init{
	yybegin( NORMAL );
%init}

intconst	=	[0-9]+
exponent	=	[Ee][\+\-]?[0-9]+
float1		=	[0-9]+\.[0-9]+
float2		=	[0-9]+{exponent}
float3		=	[0-9]+\.[0-9]+{exponent}
octDigit	=	[0-7]
hexDigit	=	[0-9a-fA-F]
escchar		=	\\([ntbrfva\\\'\"\?]|{octDigit}{octDigit}{octDigit}|[xX]{hexDigit}{hexDigit})
schar		=	[^\'\"\\\r\n]|{escchar}
charconst	=	\'{schar}\'
stringconst	=	\"{schar}*\"
ident		=	[A-Za-z][A-Za-z0-9]*
space		=	[\ \t]
newline		=	\r|\n|\r\n
%state NORMAL COMMENT1 COMMENT2 LEXERROR

%%
<NORMAL> {

	{newline}	{ }
	{space}		{ }
	
	"("			{ return token( sym.LEFT ); }
	")"			{ return token( sym.RIGHT ); }
	"{"			{ return token( sym.LEFTBRACE ); }
	"}"			{ return token( sym.RIGHTBRACE ); }
	"["			{ return token( sym.LEFTSQ ); }
	"]"			{ return token( sym.RIGHTSQ ); }
	
	";"			{ return token( sym.SEMICOLON ); }
	","			{ return token( sym.COMMA ); }
	":"			{ return token( sym.COLON ); }
	"."			{ return token( sym.DOT ); }
	".."		{ return token( sym.DOTDOT ); }
	
	"="			{ return token( sym.ASSIGN ); }
	"||"		{ return token( sym.OR ); }
	"&&"		{ return token( sym.AND ); }
	"<"			{ return token( sym.LT ); }
	">"			{ return token( sym.GT ); }
	"<="		{ return token( sym.LE ); }
	">="		{ return token( sym.GE ); }
	"=="		{ return token( sym.EQ ); }
	"!="		{ return token( sym.NE ); }
	"in"		{ return token( sym.IN ); }
	"+"			{ return token( sym.PLUS ); }
	"-"			{ return token( sym.MINUS ); }
	"|"			{ return token( sym.UNION ); }
	\\			{ return token( sym.DIFF ); }
	"*"			{ return token( sym.TIMES ); }
	"/"			{ return token( sym.DIVIDE ); }
	"%"			{ return token( sym.MOD ); }
	"&"			{ return token( sym.INTERSECT ); }
	"~"			{ return token( sym.COMPL ); }
	"!"			{ return token( sym.NOT ); }
	"++"		{ return token( sym.INC ); }
	"--"		{ return token( sym.DEC ); }
	
	size		{ return token( sym.SIZE ); }
	ord			{ return token( sym.ORD ); }
	chr			{ return token( sym.CHR ); }
	new			{ return token( sym.NEW ); }
	null		{ return token( sym.NULL ); }
	true		{ return token( sym.TRUE ); }
	false		{ return token( sym.FALSE ); }
	
	var			{ return token( sym.VAR ); }
	
	int			{ return token( sym.INT ); }
	char		{ return token( sym.CHAR ); }
	bool		{ return token( sym.BOOL ); }
	real		{ return token( sym.REAL ); }
	void		{ return token( sym.VOID ); }
	type		{ return token( sym.TYPE ); }
	struct		{ return token( sym.STRUCT ); }
	enum		{ return token( sym.ENUM ); }
	set			{ return token( sym.SET ); }
	
	read		{ return token( sym.READ ); }
	print		{ return token( sym.PRINT ); }
	println		{ return token( sym.PRINTLN ); }
	
	if			{ return token( sym.IF ); }
	else		{ return token( sym.ELSE ); }
	while		{ return token( sym.WHILE ); }
	until		{ return token( sym.UNTIL ); }
	do			{ return token( sym.DO ); }
	for			{ return token( sym.FOR ); }
	switch		{ return token( sym.SWITCH ); }
	return		{ return token( sym.RETURN ); }
	exit		{ return token( sym.EXIT ); }
	break		{ return token( sym.BREAK ); }
	continue	{ return token( sym.CONTINUE ); }
	
	{intconst}	{ return token( sym.INTVALUE ); }
	{charconst}	{ return token( sym.CHARVALUE ); }
	{stringconst}	{ return token( sym.STRINGVALUE ); }
	{float1}	{ return token( sym.REALVALUE ); }
	{float2}	{ return token( sym.REALVALUE ); }
	{float3}	{ return token( sym.REALVALUE ); }
	{ident}		{ return token( sym.IDENT ); }
	
	"//"		{ yybegin( COMMENT1 ); }
	
	"/*"		{ yybegin( COMMENT2 ); commentNesting++; }
	
	.			{
					yybegin( LEXERROR ); 
					return token( sym.ERROR ); 
				}
	}
	
<LEXERROR> {
	{newline}	{ yybegin( NORMAL ); }
	.			{ }
	}

<COMMENT1> {
	{newline}	{ yybegin( NORMAL ); }
	.			{ }
	}

<COMMENT2> {
	"/*"		{ commentNesting++; }
	"*/"		{ 
					--commentNesting; 
					if ( commentNesting == 0 )
						yybegin( NORMAL ); 
				}
	.			{ }
	{newline}	{ }
	}

<<EOF>>			{ return token( sym.EOF ); }