slige/compiler/Lexer.ts

import { Pos, Token } from "./Token.ts";

export class Lexer {
    private index = 0;
    private line = 1;
    private col = 1;


    public constructor (private text: string) {}

    public next(): Token | null {
        if (this.done())
            return null;
        const pos = this.pos();
        if (this.test(/[ \t\n\r]/)) {
            while (!this.done() && this.test(/[ \t\n\r]/))
                this.step();
            return this.next();
        }

        if (this.test(/[a-zA-Z_]/)) {
            let value = "";
            while (!this.done() && this.test(/[a-zA-Z0-9_]/)) {
                value += this.current();
                this.step();
            }
            switch (value) {
                case "break":
                    return this.token("break", pos);
                case "return":
                    return this.token("return", pos);
                case "let":
                    return this.token("let", pos);
                case "fn":
                    return this.token("fn", pos);
                case "loop":
                    return this.token("loop", pos);
                case "if":
                    return this.token("if", pos);
                case "else":
                    return this.token("else", pos);
                default:
                    return { ...this.token("ident", pos), identValue: value };
            }
        }
        if (this.test(/[1-9]/)) {
            let textValue = "";
            while (!this.done() && this.test(/[0-9]/)) {
                textValue += this.current();
                this.step();
            }
            return { ...this.token("int", pos), intValue: parseInt(textValue) };
        }

        if (this.test("0")) {
            this.step()
            if (!this.done() && this.test(/[0-9]/)) {
                console.error(
                    `Lexer: invalid number`
                        + ` at ${pos.line}:${pos.col}`,
                );
                return this.token("error", pos);
            }
            return { ...this.token("int", pos), intValue: 0};
        }

        if (this.test("\"")) {
            this.step();
            let value = "";
            while (!this.done() && !this.test("\"")) {
                if (this.test("\\")) {
                    this.step();
                    if (this.done())
                        break;
                    value += {
                        "n": "\n",
                        "t": "\t",
                        "0": "\0",
                    }[this.current()] ?? this.current();
                } else {
                    value += this.current();
                }
                this.step();
            }
            if (this.done() || !this.test("\"")) {
                console.error(
                    `Lexer: unclosed/malformed string`
                        + ` at ${pos.line}:${pos.col}`,
                );
                return this.token("error", pos);
            }
            this.step();
            return { ...this.token("string", pos), stringValue: value };
        }
        if (this.test(/[\+\{\};=\-\*\(\)\.,:;\[\]><!0]/)) {
            const first = this.current();
            this.step();
            if (first === "=" && !this.done() && this.test("=")) {
                this.step();
                return this.token("==", pos);
            }
            if (first === "<" && !this.done() && this.test("=")) {
                this.step();
                return this.token("<=", pos);
            }
            if (first === ">" && !this.done() && this.test("=")) {
                this.step();
                return this.token(">=", pos);
            }
            if (first === "-" && !this.done()) {
                if (this.test(">")) {
                    this.step();
                    return this.token("->", pos);
                }
                if (this.test("=")) {
                    this.step()
                    return this.token("-=", pos);
                }
            }
            if (first === "!" && !this.done() && this.test("=")) {
                this.step();
                return this.token("!=", pos);
            }
            if (first === "+" && !this.done() && this.test("=")) {
                this.step();
                return this.token("+=", pos);
            }
            return this.token(first, pos);
        }
        if (this.test("/")) {
            this.step()
            if (this.test("/")) {
                while (!this.done() && !this.test("\n"))
                    this.step();
                return this.next()
            }
            return this.token("/", pos)
        }
        if (this.test("false")) {
            this.step();
            return this.token("false", pos);
        }
        if (this.test("true")) {
            this.step();
            return this.token("true", pos);
        }
        if (this.test("null")) {
            this.step();
            return this.token("null", pos);
        }
        if (this.test("or")) {
            this.step();
            return this.token("or", pos);
        }
        if (this.test("and")) {
            this.step();
            return this.token("and", pos);
        }
        if (this.test("not")) {
            this.step();
            return this.token("not", pos);
        }
        if (this.test("loop")) {
            this.step();
            return this.token("loop", pos);
        }
        if (this.test("break")) {
            this.step();
            return this.token("break", pos);
        }
        if (this.test("let")) {
            this.step();
            return this.token("let", pos);
        }
        if (this.test("fn")) {
            this.step();
            return this.token("fn", pos);
        }
        if (this.test("return")) {
            this.step();
            return this.token("return", pos);
        }
        console.error(`Lexer: illegal character '${this.current()}' at ${pos.line}:${pos.col}`);
        this.step();
        return this.next();    
    }
    
    private done(): boolean { return this.index >= this.text.length; }
    
    private current(): string { return this.text[this.index]; }

    public currentPos(): Pos { return this.pos(); }

    private step() {
        if (this.done())
            return;
        if (this.current() === "\n") {
            this.line += 1;
            this.col = 1;
        } else {
            this.col += 1;
        }
        this.index += 1;
    }

    private pos(): Pos {
        return {
            index: this.index,
            line: this.line,
            col: this.col
        }
    }

    private token(type: string, pos: Pos): Token {
        const length = this.index - pos.index;
        return { type, pos, length };
    }

    private test(pattern: RegExp | string): boolean {
        if (typeof pattern === "string")
            return this.current() === pattern;
        else
            return pattern.test(this.current());
    }




}