package code.loader.parser.txtParser;

%%

%public
%line
%type Token
%state COMMENT

%{

  /**
   *  Indentifier string can contain any character except new line.
   *  Both backspace and double quote characters are escaped by
   *  by a backslash.  To unescape them, simply remove the backslash.
   *
   *  Also, the argument is still surrounded by double quotes.
   *  Simply remove them, by skipping the first and last character.
   */ 
  private String clean(String in) {
    char [] buffer = new char[in.length()-2];
    int count = 0;
    int i = 1;
    while (i < in.length()-1) {
      char current = in.charAt(i++);
      if (current == '\\') {
	// skip backslash, place the next character into the buffer
	current = in.charAt(i++);
      }
      buffer[count++] = current;
    }
    return String.copyValueOf(buffer, 0, count);
  }

%}

%yylexthrow{
  ParseError
%yylexthrow}

%eofval{
    return (new Token(0, yyline));
%eofval}

WHITE_SPACE=([ \t\b\r])+
DIGIT=[0-9]
ALPHA=[a-zA-Z]
NEWLINE=[\n]
INT=({DIGIT})+
FLOAT=({DIGIT})+\.({DIGIT})+
BACKSLASH=\\\\
QUOTE=\\\"
IDENTIFIER=({BACKSLASH}|{QUOTE}|[^\n\\\"])+
UNQUAL_ID = \"{IDENTIFIER}\"

%%
<YYINITIAL> COMMENT { yybegin(COMMENT); }
<COMMENT> . {}
<COMMENT> {NEWLINE}+ { yybegin(YYINITIAL); }

<YYINITIAL> {NEWLINE}+ {}

<YYINITIAL> NAME { return (new Token(Token.NAME, yyline+1)); }
<YYINITIAL> COMPILED { return (new Token(Token.COMPILED, yyline+1)); }
<YYINITIAL> true { return (new Token(Token.TRUE, yyline+1)); }
<YYINITIAL> false { return (new Token(Token.FALSE, yyline+1)); }
<YYINITIAL> TIME { return (new Token(Token.TIME, yyline+1)); }
<YYINITIAL> IMPORT { return (new Token(Token.IMPORT, yyline+1)); }
<YYINITIAL> TYPE { return (new Token(Token.TYPE, yyline+1)); }
<YYINITIAL> CONSTRUCTOR { return (new Token(Token.CONSTRUCTOR, yyline+1)); }
<YYINITIAL> OPERATION { return (new Token(Token.OPERATION, yyline+1)); }
<YYINITIAL> public { return (new Token(Token.PUBLIC, yyline+1)); }
<YYINITIAL> private { return (new Token(Token.PRIVATE, yyline+1)); }
<YYINITIAL> left { return (new Token(Token.LEFT, yyline+1)); }
<YYINITIAL> right { return (new Token(Token.RIGHT, yyline+1)); }
<YYINITIAL> nonassoc { return (new Token(Token.NONASSOC, yyline+1)); }

<YYINITIAL> Branch { return (new Token(Token.BRANCH, yyline+1)); }
<YYINITIAL> Choice { return (new Token(Token.CHOICE, yyline+1)); }
<YYINITIAL> Fail { return (new Token(Token.FAIL, yyline+1)); }
<YYINITIAL> Load { return (new Token(Token.LOAD, yyline+1)); }
<YYINITIAL> MakeRef { return (new Token(Token.MAKEREF, yyline+1)); }
<YYINITIAL> MakeAnon { return (new Token(Token.MAKEANON, yyline+1)); }
<YYINITIAL> MakeChar { return (new Token(Token.MAKECHAR, yyline+1)); }
<YYINITIAL> MakeInt { return (new Token(Token.MAKEINT, yyline+1)); }
<YYINITIAL> MakeFloat { return (new Token(Token.MAKEFLOAT, yyline+1)); }
<YYINITIAL> MakePartial { return (new Token(Token.MAKEPARTIAL, yyline+1)); }
<YYINITIAL> MakeTerm { return (new Token(Token.MAKETERM, yyline+1)); }
<YYINITIAL> MakeVar { return (new Token(Token.MAKEVAR, yyline+1)); }
<YYINITIAL> Narrow { return (new Token(Token.NARROW, yyline+1)); }
<YYINITIAL> Pop { return (new Token(Token.POP, yyline+1)); }
<YYINITIAL> Push { return (new Token(Token.PUSH, yyline+1)); }
<YYINITIAL> Replace { return (new Token(Token.REPLACE, yyline+1)); }
<YYINITIAL> Residuate { return (new Token(Token.RESIDUATE, yyline+1)); }
<YYINITIAL> StoreVar { return (new Token(Token.STOREVAR, yyline+1)); }

<YYINITIAL> "::" { return (new Token(Token.COLONCOLON, yyline+1)); }
<YYINITIAL> "->" { return (new Token(Token.ARROW, yyline+1)); }
<YYINITIAL> "(" { return (new Token(Token.LPAREN, yyline+1)); }
<YYINITIAL> ")" { return (new Token(Token.RPAREN, yyline+1)); }
<YYINITIAL> "{" { return (new Token(Token.LCUBRA, yyline+1)); }
<YYINITIAL> "}" { return (new Token(Token.RCUBRA, yyline+1)); }
<YYINITIAL> "," { return (new Token(Token.COMMA, yyline+1)); }
<YYINITIAL> "." { return (new Token(Token.DOT, yyline+1)); }

<YYINITIAL> {WHITE_SPACE} {}

<YYINITIAL> {INT} {
  double MAX = (Math.pow(2,31)-1);
  try {
    if(Integer.parseInt(yytext()) < MAX) 
      return (new Token(Token.INTEGER, yyline+1, Integer.valueOf(yytext())));
  } catch(Exception e) {
      throw new ParseError("Error at line "+(yyline+1)+
			   ": Integer value out of range!");
  }
}

<YYINITIAL> {FLOAT} {
  double MAX = (Math.pow(2,31)-1);

  try {
    if(Float.parseFloat(yytext()) < MAX) 
      return (new Token(Token.FLOAT, yyline+1, Float.valueOf(yytext())));
  } catch(Exception e) {
      throw new ParseError("Error at line "+(yyline+1)+
			   ": Float value out of range!");
  }
}

<YYINITIAL> {UNQUAL_ID} {
  try {
    if(yytext().length() < 255) {
      String cleaned = clean(yytext());
      String tmp = yytext().substring(1,yytext().length()-1);
      // System.err.println("Token ---"+cleaned+"---");
      return (new Token(Token.UNQUAL_ID, yyline+1, cleaned));
    } else {
      throw new ParseError("Error at line "+(yyline+1)+
			   ": Identifier length out of range!");
    }
  }catch(Exception e) {
    throw new ParseError("Exception error at line "+(yyline+1));
  }
}

<YYINITIAL> . {
  throw new ParseError("Error at line "+(yyline+1)+": Illegal input"); 
}