tokenize.c

#include "kmcc.h"

char *filename;
char *user_input;
Token *token;

// エラーを報告する関数
// printfと同じ引数を取る．
void error(char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  exit(1);
}

// エラー箇所を報告する
// 下のようなフォーマットでエラーメッセージを表示する．
// foo.c:10: x = y + + 5;
//                   ^ 式ではありません．
static void verror_at(char *loc, char *fmt, va_list ap) {
  // locが含まれている行の開始地点と終了地点を取得
  char *line = loc;
  while (user_input < line && line[-1] != '\n') {
    line--;
  }

  char *end = loc;
  while (*end != '\n') {
    end++;
  }

  //見つかった行が全体の何行目なのかを調べる
  int line_num = 1;
  for (char *p = user_input; p < line; p++) {
    if (*p == '\n') {
      line_num++;
    }
  }

  //見つかった行をファイル名と行番号と一緒に表示
  int indent
      = fprintf(stderr, "%s:%d: ", filename, line_num);
  fprintf(stderr, "%.*s\n", (int)(end - line), line);

  // エラー箇所を"^"で指し示して，エラーメッセージを表示
  int pos = loc - line + indent;
  fprintf(stderr, "%*s", pos, " ");  // pos個の空白を出力
  fprintf(stderr, "^ ");
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
}

// エラー箇所を報告してexit
void error_at(char *loc, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  verror_at(loc, fmt, ap);
  exit(1);
}

void error_tok(Token *tok, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  verror_at(tok->str, fmt, ap);
  exit(1);
}

void warn_tok(Token *tok, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  verror_at(tok->str, fmt, ap);
}

// 現在のトークンがsとマッチした場合，Tokenを返す．
Token *peek(char *s) {
  if (token->kind != TK_RESERVED || strlen(s) != token->len
      || strncmp(token->str, s, token->len)) {
    return NULL;
  }
  return token;
}

// 次のトークンが期待している記号のときは，トークンを1つ読み進めて
// 真を返す．それ以外の場合は偽を返す．
Token *consume(char *op) {
  if (token->kind != TK_RESERVED || strlen(op) != token->len
      || memcmp(token->str, op, token->len))
    return NULL;
  Token *t = token;
  token    = token->next;
  return t;
}

Token *consume_ident() {
  if (token->kind != TK_IDENT)
    return NULL;
  Token *t = token;
  token    = token->next;
  return t;
}

// 次のトークンが期待している記号のときには，トークンを1つ読み進める．
// それ以外の場合には，エラーを報告する．
void expect(char *s) {
  if (!peek(s))
    error_tok(token, "'%s'ではありません．", s);
  token = token->next;
}

// 次のトークンが数値の場合，トークンを1つ読み進めてその数値を返す，
// それ以外の場合にはエラーを報告する．
int expect_number() {
  if (token->kind != TK_NUM)
    error_tok(token, "数ではありません．");
  int val = token->val;
  token   = token->next;
  return val;
}

// 現在のトークンがTK_IDENTであることを確認する．
char *expect_ident() {
  if (token->kind != TK_IDENT)
    error_tok(token, "識別子ではありません．");
  char *s = duplicate(token->str, token->len);
  token   = token->next;
  return s;
}

bool at_eof() {
  return token->kind == TK_EOF;
}

// 新しいトークンを作成してcurに繋げる．
Token *new_token(TokenKind kind,
                 Token *cur,
                 char *str,
                 int len) {
  Token *tok = calloc(1, sizeof(Token));
  tok->kind  = kind;
  tok->str   = str;
  tok->len   = len;
  cur->next  = tok;
  return tok;
}

static bool startswith(char *p, char *q) {
  return memcmp(p, q, strlen(q)) == 0;
}

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

static bool is_alnum(char c) {
  return is_alpha(c) || ('0' <= c && c <= '9');
}

static char *starts_with_reserved(char *p) {
  // Keyword
  static char *kw[] = {"return",
                       "if",
                       "else",
                       "while",
                       "for",
                       "short",
                       "int",
                       "long",
                       "char",
                       "sizeof",
                       "struct",
                       "typedef",
                       "void",
                       "_Bool"};

  for (int i = 0; i < sizeof(kw) / sizeof(*kw); i++) {
    int len = strlen(kw[i]);
    if (startswith(p, kw[i]) && !is_alnum(p[len]))
      return kw[i];
  }

  // Multi-letter punctuator
  static char *ops[] = {"==", "!=", "<=", ">=", "->"};

  for (int i = 0; i < sizeof(ops) / sizeof(*ops); i++) {
    if (startswith(p, ops[i])) {
      // printf("find ops %s\n", ops[i]);
      return ops[i];
    }
  }

  return NULL;
}

static char get_escape_char(char c) {
  switch (c) {
    case 'a':
      return '\a';
    case 'b':
      return '\b';
    case 't':
      return '\t';
    case 'n':
      return '\n';
    case 'v':
      return '\v';
    case 'f':
      return '\f';
    case 'r':
      return '\r';
    case 'e':
      return 27;
    case '0':
      return 0;
    default:
      return c;
  }
}

static Token *read_string_literal(Token *cur, char *start) {
  char *p = start + 1;
  char buf[1024];
  int len = 0;

  for (;;) {
    if (len == sizeof(buf)) {
      error_at(start, "文字列が大きすぎます");
    }
    if (*p == '\0') {
      error_at(start, "文字列が閉じられていません．");
    }
    if (*p == '"') {
      break;
    }

    if (*p == '\\') {
      p++;
      buf[len++] = get_escape_char(*p++);
    } else {
      buf[len++] = *p++;
    }
  }

  Token *tok = new_token(TK_STR, cur, start, p - start + 1);
  tok->contents = malloc(len + 1);
  memcpy(tok->contents, buf, len);
  tok->contents[len] = '\0';
  tok->cont_len      = len + 1;
  return tok;
}

// `user_input`をトークナイズしてそれを返す．
Token *tokenize() {
  char *p = user_input;
  Token head;
  head.next  = NULL;
  Token *cur = &head;

  while (*p) {
    // 空白文字をスキップ
    if (isspace(*p)) {
      p++;
      continue;
    }

    // 行コメントをスキップ
    if (strncmp(p, "//", 2) == 0) {
      p += 2;
      while (*p != '\n') {
        p++;
      }
      continue;
    }

    // ブロックコメントをスキップ
    if (strncmp(p, "/*", 2) == 0) {
      char *q = strstr(p + 2, "*/");
      if (!q) {
        error_at(p, "コメントが閉じられていません．");
      }
      p = q + 2;
      continue;
    }

    // 文字列
    if (*p == '"') {
      cur = read_string_literal(cur, p);
      p += cur->len;
      continue;
    }

    // Keywords or multi-letter punctuators
    char *kw = starts_with_reserved(p);
    if (kw) {
      // printf("find kewords %s\n", kw);
      int len = strlen(kw);
      cur     = new_token(TK_RESERVED, cur, p, len);
      p += len;
      continue;
    }

    // Identifier
    if (is_alpha(*p)) {
      char *q = p++;
      while (is_alnum(*p)) p++;
      cur = new_token(TK_IDENT, cur, q, p - q);
      continue;
    }

    // Single-letter punctuator
    if (ispunct(*p)) {
      cur = new_token(TK_RESERVED, cur, p++, 1);
      continue;
    }

    // Integer literal
    if (isdigit(*p)) {
      cur      = new_token(TK_NUM, cur, p, 0);
      char *q  = p;
      cur->val = strtol(p, &p, 10);
      cur->len = p - q;
      continue;
    }

    error_at(p, "トークナイズできません．");
  }

  new_token(TK_EOF, cur, p, 0);
  return head.next;
}