Cコンパイラ作成リベンジ

docker container run -it --volume $HOME/workspace/9cc:/9cc --name --platform linux/amd64 9cc ubuntu:22.04 bash

docker container start 9cc
docker container attach 9cc (or, docker container exec -it 9cc bash)

docker container stop 9cc

expr    = mul ("+" mul | "-" mul)*
mul     = primary ("*" primary | "/" primary)*
primary = num | "(" expr ")"

expr    = mul ("+" mul | "-" mul)*
mul     = unary ("*" unary | "/" unary)*
unary   = ("+" | "-")? primary
primary = num | "(" expr ")"

expr       = equality
equality   = relational ("==" relational | "!=" relational)*
relational = add ("<" add | "<=" add | ">" add | ">=" add)*
add        = mul ("+" mul | "-" mul)*
mul        = unary ("*" unary | "/" unary)*
unary      = ("+" | "-")? primary
primary    = num | "(" expr ")"

unary      = ("+" | "-")? unary | primary

case ND_LVAR:
  gen_lval(node);  // 変数処理1

  // 変数処理2
  printf("  pop rax\n"); 
  printf("  mov rax, [rax]\n");
  printf("  push rax\n");
  return;

case ND_ASSIGN:
  gen_lval(node->lhs); // 変数処理1
  gen(node->rhs); // 右辺値を計算

  // アドレスに値をストア
  printf("  pop rdi\n");
  printf("  pop rax\n");
  printf("  mov [rax], rdi\n");
  printf("  push rdi\n");
  return;

assert 3 'a=3;'
assert 3 'a=3; a;'
assert 7 'a=3; z=5; c=7;'
assert 8 'a=3; z=5; a+z;'
assert 8 'a=3; z=5; b=a+z;'

assert 5 "foo = 5;"

assert 8 "
bar = 8; 
bar;
"

assert 10 "
foo = 4;
bar = 6;
foo + bar;
"

stmt = expr ";"
         | "return" expr ";"

case ND_RETURN:
  gen(node->lhs);
  return;

assert 4 "return 4;"
assert 5 "foo = 5; foo;"
assert 8 "
bar = 8; 
return bar;
"

assert 10 "
bar = 8; 
return bar + 2;
"

assert 10 "
foo = 4;
bar = 6;
return foo + bar;
"

program = stmt*
stmt    = expr ";"
        | "if" "(" expr ")" stmt ("else" stmt)?
        | "while" "(" expr ")" stmt
        | "for" "(" expr? ";" expr? ";" expr? ")" stmt
        | ...
...

    if (starts_with(p, "while") && !is_alnum(p[5])) {
      cur = new_token(TK_WHILE, cur, p, 5);
      p += 5;
      continue;
    }

if (consume_if()) {
    Node *node = new_node(ND_IF, NULL, NULL);
    expect("(");
    node->lhs = expr();
    expect(")");
    node->rhs = stmt();
    // if (A) B
    //    node->lhs = A, node->rhs = B
    // if (A) B else C
    //    node->lhs = A, node->rhs->lhs = B, node->rhs->rhs = C
    if (consume_else()) {
      Node *else_node = new_node(ND_ELSE, NULL, NULL);
      else_node->lhs = node->rhs;
      else_node->rhs = stmt();
      node->rhs = else_node;
    }
    return node;
  }

  if (consume_for()) {
    // for (A; B; C) D
    Node *for_node_left = new_node(ND_FOR_LEFT, NULL, NULL);
    Node *for_node_right = new_node(ND_FOR_RIGHT, NULL, NULL);
    expect("(");
    if (!consume(";")) {
      for_node_left->lhs = expr();  // A
      expect(";");
    }
    if (!consume(";")) {
      for_node_left->rhs = expr();  // B
      expect(";");
    }
    if (!consume(")")) {
      for_node_right->lhs = expr();  // C
      expect(")");
    }
    for_node_right->rhs = stmt();  // D

    Node *node = new_node(ND_FOR, for_node_left, for_node_right);
    return node;
  }

  stmt = expr ";"
       | "{" stmt* "}"

  if (consume("{")) {
    Node *node = new_node(ND_BLOCK, NULL, NULL);
    int stmt_count = 0;
    while (!consume("}")) {
      node->block = realloc(node->block, sizeof(Node *) * (stmt_count + 1));
      node->block[stmt_count] = stmt();
      stmt_count += 1;
    }
    node->block_count = stmt_count;
    return node;
  }

    case ND_BLOCK:
      for (int i = 0; i < node->block_count; i++) {
        gen(node->block[i]);
        printf("  pop rax\n");
      }
      return;

case ND_FUNCCALL:
      for (int i = 0; i < node->arg_count; i++) {
        gen(node->args[i]);
      }
      for (int i = node->arg_count - 1; i >= 0; i--) {
        printf("  pop %s\n", argreg[i]);
      }

      printf("  call %s\n", node->funcname);
      printf("  push rax\n");
      return;