Pros of c4

• Extremely compact and concise implementation (less than 500 lines of code)
• Self-contained in a single C file, making it easy to understand and modify
• Demonstrates core compiler concepts with minimal complexity

Cons of c4

• Limited language support compared to acwj's more comprehensive approach
• Lacks detailed explanations and documentation found in acwj
• May be too simplified for learning advanced compiler techniques

Code Comparison

c4:

int *id_name, id_type;
int *id = id_name = malloc(sizeof(int) * (ID_SIZE + 1));
while (tk = *p) {
    p++; Putchar(tk);
    if (tk == 'a' || tk == 'b' || tk == 'c' || tk == 'd' || tk == 'e' || tk == 'f') *id++ = tk;
    else if (tk >= '0' && tk <= '9') { ty = INT; *id++ = tk; }
}

acwj:

static struct ASTnode *primary(void) {
  struct ASTnode *n;
  int id;

  switch (Token.token) {
    case T_INTLIT:
      n = mkastleaf(A_INTLIT, Token.intvalue);
      scan(&Token);
      return (n);
    case T_IDENT:
      id = findglob(Text);
      if (id == -1)
        fatals("Unknown variable", Text);
      n = mkastleaf(A_IDENT, id);
      scan(&Token);
      return (n);
    default:
      fatald("Syntax error, token", Token.token);
  }
}

Pros of write-a-C-interpreter

• Focuses specifically on building a C interpreter, providing a more targeted learning experience
• Includes a step-by-step tutorial in the README, making it easier for beginners to follow along
• Implements a complete C interpreter in a single file, offering a more compact and self-contained project

Cons of write-a-C-interpreter

• Less comprehensive coverage of compiler concepts compared to acwj
• Lacks the detailed explanations and documentation found in acwj's accompanying blog posts
• May not provide as much insight into real-world compiler development practices

Code Comparison

write-a-C-interpreter:

void expression(int level) {
    // ... (implementation details)
}

acwj:

struct ASTnode *binexpr(int ptp) {
    struct ASTnode *left, *right;
    int tokentype;
    // ... (implementation details)
}

The code snippets show different approaches to parsing expressions. write-a-C-interpreter uses a single function with a level parameter, while acwj employs a more structured approach with separate AST nodes and token types.

Pros of lcc

• More mature and feature-complete C compiler
• Extensively documented with a companion book
• Wider platform support and portability

Cons of lcc

• Less beginner-friendly due to complexity
• Not actively maintained (last commit in 2015)
• Larger codebase, potentially harder to understand fully

Code Comparison

lcc (from lcc.c):

int main(int argc, char *argv[]) {
    int i, j, nf;
    static int initted;

    progname = argv[0];
    if (initted++ == 0) {
        // ... initialization code ...
    }
    // ... more code ...
}

acwj (from main.c):

int main(int argc, char *argv[]) {
  int i;

  // Initialise our variables
  init_vars();

  // Scan and parse the input file
  scan(&Token);
  genpreamble();
  statements();
  genpostamble();
  fclose(Outfile);
  exit(0);
}

Summary

lcc is a more comprehensive C compiler with broader support, while acwj is a step-by-step tutorial for building a simple compiler. lcc offers a complete solution but may be overwhelming for beginners, whereas acwj provides a gradual learning experience with a focus on educational value.