scanner.c

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

#include "scanner.h"
#include "utils.h"

typedef struct Scanner {
  FILE *f;
  Token t;
  int c;
  const char *filename;
  int line, col, t_line, t_col;
} Scanner;

static const char *KEYWORDS[] = {
    "begin", "do",     "else",    "end",  "for", "function", "if", "integer",
    "mod",   "output", "program", "then", "to",  "var",      NULL,
};

static bool is_whitespace(int c) {
  switch (c) {
  case 0:
  case ' ':
  case '\t':
  case '\r':
  case '\n':
    return 1;
  default:
    return 0;
  }
}

static bool is_alpha(int c) {
  return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
}

static bool is_digit(int c) { return '0' <= c && c <= '9'; }

static bool is_ident_start(int c) { return is_alpha(c) || c == '_'; }

static bool is_ident(int c) { return is_ident_start(c) || is_digit(c); }

static bool is_keyword(const char *s) {
  const char **p = KEYWORDS;
  while (*p != NULL) {
    if (strcmp(s, *p) == 0) {
      return 1;
    }
    p++;
  }
  return 0;
}

static char to_lower(char c) {
  if ('A' <= c && c <= 'Z') {
    c |= 0x20;
  }
  return c;
}

Scanner *scanner_new(FILE *f, const char *filename) {
  Scanner *s = malloc(sizeof(Scanner));
  s->f = f;
  s->c = 0;
  s->t = NULL_TOKEN;
  s->filename = filename;
  s->line = 1;
  s->col = 0;
  s->t_line = 0;
  s->t_col = 0;
  return s;
}

void scanner_free(Scanner *s) {
  token_free(s->t);
  free(s);
}

void token_print(const Token *t) {
  switch (t->type) {
  case TOKEN_KEYWORD:
    printf("keyword `%s`", t->value);
    break;
  case TOKEN_IDENT:
    printf("ident `%s`", t->value);
    break;
  case TOKEN_STR:
    printf("string `\"%s\"`", t->value);
    break;
  case TOKEN_INT:
    printf("integer `%s`", t->value);
    break;
  default:
    printf("%s", token_print_type(t->type));
    break;
  }
}

const char *token_print_type(TokenType t) {
  switch (t) {
  case TOKEN_NULL:
    return "<null>";
  case TOKEN_EOF:
    return "<eof>";
  case TOKEN_KEYWORD:
    return "keyword";
  case TOKEN_IDENT:
    return "ident";
  case TOKEN_STR:
    return "string";
  case TOKEN_INT:
    return "integer";
  case TOKEN_LPAREN:
    return "`(`";
  case TOKEN_RPAREN:
    return "`)`";
  case TOKEN_SEMI:
    return "`;`";
  case TOKEN_COLON:
    return "`:`";
  case TOKEN_ASSIGN:
    return "`:=`";
  case TOKEN_COMMA:
    return "`,`";
  case TOKEN_DOT:
    return "`.`";
  case TOKEN_EQ:
    return "`=`";
  case TOKEN_LT:
    return "`<`";
  case TOKEN_LE:
    return "`<=`";
  case TOKEN_GT:
    return "`>`";
  case TOKEN_GE:
    return "`>=`";
  }
  return "?";
}

void token_free(Token t) {
  if (t.value) {
    free(t.value);
  }
}

static void nextc(Scanner *s) {
  s->c = getc(s->f);

  s->col++;
  if (s->c == '\n') {
    s->line++;
    s->col = 0;
  }
}

const Token *scanner_peek(Scanner *s) {
  if (s->t.type != 0) {
    return &s->t;
  }

  while (is_whitespace(s->c)) {
    nextc(s);
  }

  s->t_line = s->line;
  s->t_col = s->col;

  switch (s->c) {
  case -1:
    s->t.type = TOKEN_EOF;
    return &s->t;
  case '/':
    nextc(s);
    switch (s->c) {
    case '/':
      do {
        nextc(s);
      } while (s->c != -1 && s->c != '\n');
      return scanner_peek(s);
    default:
      printf("unknown token '/%c'\n", s->c);
      scanner_print_pos(s);
      exit(EXIT_SYNTAX);
    }
  case '\'': {
    StrBuf b = EMPTY_STRBUF;
    nextc(s);
    while (s->c != -1 && s->c != '\'') {
      strbuf_push(&b, s->c);
      nextc(s);
    }
    nextc(s);

    s->t.type = TOKEN_STR;
    s->t.value = strbuf_finish(b);
    return &s->t;
  }
  case '(':
    nextc(s);
    switch (s->c) {
    case '*':
      nextc(s);
      while (1) {
        if (s->c == -1) {
          printf("unterminated comment\n");
          exit(EXIT_SYNTAX);
        } else if (s->c == '*') {
          nextc(s);
          if (s->c == ')') {
            nextc(s);
            break;
          }
        } else {
          nextc(s);
        }
      }
      return scanner_peek(s);
    default:
      s->t.type = TOKEN_LPAREN;
      return &s->t;
    }
  case ')':
    nextc(s);
    s->t.type = TOKEN_RPAREN;
    return &s->t;
  case ';':
    nextc(s);
    s->t.type = TOKEN_SEMI;
    return &s->t;
  case ':':
    nextc(s);
    switch (s->c) {
    case '=':
      nextc(s);
      s->t.type = TOKEN_ASSIGN;
      return &s->t;
    default:
      s->t.type = TOKEN_COLON;
      return &s->t;
    }
  case ',':
    nextc(s);
    s->t.type = TOKEN_COMMA;
    return &s->t;
  case '.':
    nextc(s);
    s->t.type = TOKEN_DOT;
    return &s->t;
  case '=':
    nextc(s);
    s->t.type = TOKEN_EQ;
    return &s->t;
  case '<':
    nextc(s);
    switch (s->c) {
    case '=':
      nextc(s);
      s->t.type = TOKEN_LE;
      return &s->t;
    default:
      s->t.type = TOKEN_LT;
      return &s->t;
    }
  case '>':
    nextc(s);
    switch (s->c) {
    case '=':
      nextc(s);
      s->t.type = TOKEN_GE;
      return &s->t;
    default:
      s->t.type = TOKEN_GT;
      return &s->t;
    }
  default:
    if (is_ident_start(s->c)) {
      StrBuf b = EMPTY_STRBUF;
      do {
        strbuf_push(&b, to_lower(s->c));
        nextc(s);
      } while (is_ident(s->c));

      s->t.type = TOKEN_IDENT;
      s->t.value = strbuf_finish(b);

      if (is_keyword(s->t.value)) {
        s->t.type = TOKEN_KEYWORD;
      }

      return &s->t;
    } else if (is_digit(s->c)) {
      StrBuf b = EMPTY_STRBUF;
      do {
        strbuf_push(&b, s->c);
        nextc(s);
      } while (is_digit(s->c));

      s->t.type = TOKEN_INT;
      s->t.value = strbuf_finish(b);
      return &s->t;
    }
    printf("unknown token '%c'\n", s->c);
    scanner_print_pos(s);
    exit(EXIT_SYNTAX);
  }
}

Token scanner_consume(Scanner *s) {
  scanner_peek(s);

  Token temp = s->t;
  s->t = NULL_TOKEN;

  return temp;
}

void scanner_print_pos(const Scanner *s) {
  printf("at %s:%d:%d\n", s->filename, s->t_line, s->t_col);
}