lexer.hpp

Go to the documentation of this file.

#ifndef FUNC_LEXER_HPP
#define FUNC_LEXER_HPP

#include "func/global.hpp"

enum Token : int {
  tok_id = 256, 
  tok_num,      
  tok_int,      
  tok_op,       

  tok_eol, 
  tok_eof, 

  tok_obrace, 
  tok_cbrace, 
  tok_lambda, 
  tok_atom, 
  tok_literal, 

  tok_if,   
  tok_then, 
  tok_else, 

  tok_let, 
  tok_in, 

  tok_delim, 

  tok_any,  

  tok_err, 
};

enum Operator {
  op_eq, 
  op_leq, 
  op_geq, 
  op_le, 
  op_gt, 

  op_land, 
  op_lor, 

  op_add, 
  op_sub, 
  op_mul, 
  op_div, 
  op_pow, 

  op_asg, 

  op_fn, 
};

class TokenPos {
  size_t start, end, lineStart, lineEnd;
public:
  TokenPos(size_t start, size_t end, size_t lineStart, size_t lineEnd)
    : start{start}, end{end}, lineStart{lineStart}, lineEnd{lineEnd} {}
  TokenPos(const TokenPos &pos0, const TokenPos &pos1)
    : start{pos0.start < pos1.start ? pos0.start : pos1.start},
      end{pos0.end > pos1.end ? pos0.end : pos1.end},
      lineStart{pos0.lineStart < pos1.lineStart ? pos0.lineStart : pos1.lineStart},
      lineEnd{pos0.lineEnd > pos1.lineEnd ? pos0.lineEnd : pos1.lineEnd} {}
  virtual ~TokenPos() {}

  size_t getStart() const noexcept { return start; }
  size_t getEnd() const noexcept { return end; }
  size_t getLineStart() const noexcept { return lineStart; }
  size_t getLineEnd() const noexcept { return lineEnd; }

  TokenPos min() const noexcept {
    return TokenPos(start, end - 1, lineStart, lineEnd);
  }
};

namespace std {
  std::string to_string(Operator op) noexcept;
};

int getOperatorPrecedence(Operator op);

class Lexer {
  std::size_t line;
  std::size_t column;

  std::string lineStr;

  Token curtok;
  Operator curop;
  double curnum;
  int64_t curint;
  std::string curid;

  int curchar;

  std::istream *input;

  size_t token_start, token_end;
  std::vector<std::string>& lines;
public:
  Lexer(std::istream &input, std::vector<std::string> &lines);
  virtual ~Lexer();

  int nextChar();

  int currentChar() const noexcept ;

  Token nextToken();
  
  Token currentToken() const noexcept;

  Operator currentOperator() const noexcept;

  double currentNumber() const noexcept;

  std::int64_t currentInteger() const noexcept;

  size_t currentLine() const noexcept
    { return curchar == -2 || curchar == '\n' || curchar == EOF || curtok == tok_eof ?
        (line == 0 ? 0 : line - 1) : line; }
  size_t getTokenStartPos() const noexcept
    { return curchar < 0 || curchar == '\n' ? token_start :
      (token_start == 0 ? 0 : token_start - 1); }
  size_t getTokenEndPos() const noexcept
    { return curchar < 0 || curchar == '\n' ? token_end :
      (token_end == 0 ? 0 : token_end - 1); }
  const std::vector<std::string> &getLines() { return lines; }

  TokenPos getTokenPos() const noexcept {
    return TokenPos(getTokenStartPos(), getTokenEndPos(),
        currentLine(), currentLine());
  }

  const std::string &currentIdentifier() const noexcept;

  int currentPrecedence();

  Token reportError(const std::string &msg) noexcept;

  Token reportError(const std::string &msg, const TokenPos &pos) noexcept;
  Token reportError(const std::string &msg, size_t start, size_t end) noexcept;

  bool skipNewLine = false;

  std::string skippedNewLinePrefix = "";
};

#endif /* FUNC_LEXER_HPP */