lexer grammar CoolLexer;

tokens { ERROR }

@members{
    private void raiseError(String msg) {
        setText(msg);
        setType(ERROR);
    }

    private void raiseUnmatchedChar(String other) {
        raiseError("Invalid character: " + other);
    }

    private void processString(String msg) {
        String value = msg.substring(1, msg.length()-1);

        value = value.replace("\\n", "\n");
        value = value.replace("\\t", "\t");
        value = value.replace("\\b", "\b");
        value = value.replace("\\f", "\f");

        for (int i = 0; i < value.length(); i++) {

            if (value.charAt(i) == '\\' && value.charAt(i+1) != '\\') {
                value = value.substring(0, i) + value.substring(i+1);
            }

//            if (value.charAt(i) == '\n') {
//                raiseError("Unterminated string constant");
//                return;
//            }

            if (value.charAt(i) == '\u0000') {
                raiseError("String contains null character");
                return;
            }
        }

        if (value.length() > 1024) {
            raiseError("String constant too long");

        } else {
            setText(value);
        }
    }
}

CLASS:      'class';
INHERITS:   'inherits';
IF:         'if';
THEN:       'then';
ELSE:       'else';
FI:         'fi';
WHILE:      'while';
LOOP:       'loop';
POOL:       'pool';
LET:        'let';
IN:         'in';
CASE:       'case';
OF:         'of';
ESAC:       'esac';
NEW:        'new';
ISVOID:     'isvoid';
TRUE:       'true';
FALSE:      'false';
NOT:        'not';

AT :    '@';
SC:     ';';
COLON:  ':';
COMMA:  ',';
GETS:   '<-';

MUL :   '*' ; // assigns token name to '*' used above in grammar
DIV :   '/' ;
MOD :   '%' ;
ADD :   '+' ;
SUB :   '-' ;

TILD:   '~';
LESSEQ: '<=';
LESS:   '<';
EQUAL:  '=';

RES:        '=>';
DOT:        '.';
OPENBR:     '(';
CLOSEDBR:   ')';
OPENCBR:    '{';
CLOSEDCBR:  '}';

fragment LOWERCASE_LETTER: [a-z];
fragment UPPERCASE_LETTER: [A-Z];
TYPE : UPPERCASE_LETTER (LOWERCASE_LETTER | UPPERCASE_LETTER | DIGIT)* | 'SELF_TYPE';

fragment LETTER: LOWERCASE_LETTER | UPPERCASE_LETTER;
fragment DIGIT : [0-9];
fragment NZDIGIT : [1-9];
ID : (LETTER | '_') (LETTER | DIGIT | '_')*;

INTEGER : '0' | NZDIGIT (DIGIT)*;

STRING : '"' ('\\"' |.)*?
        ('"' {processString(getText());}
            | EOF {raiseError("EOF in string constant");}
            | '\u0000' {raiseError("EOF in string constant");});

WS
    :   [ \n\f\r\t]+ -> skip
    ;

BLOCK_COMMENT
    : '(*' (BLOCK_COMMENT|.)*? ('*)' {setType(SKIP);}| EOF {raiseError("EOF in comment");});

SINGLECOMM: '--'(.)*?'\n' -> skip;

ERRORCOMM: '*)' {raiseError("Unmatched *)");};
OTHER: .{raiseUnmatchedChar(getText());};