compiler-frontend

Compiler frontend

Contract

Inputs

1. Language description (required): the token set, the grammar or a set of example programs, and the operators with their precedence and associativity.
2. Implementation language (required): C or Rust. C samples below use the LLVM C API in llvm-c/; in Rust use the inkwell or llvm-sys crates.
3. Requested stages (required): any subset of lexer, parser, symbol table, type checker, IR emitter.
4. Test inputs (required): at least one valid program per stage and one program with an error the stage must report.

Procedure

1. Fix the pipeline: source to lexer (tokens) to parser (AST) to type checker to IR generator to LLVM IR. Write down which stages this task delivers. Done when: the delivered stages and their input and output types are listed.

2. Write the lexer as a hand-written state machine. Tokens carry a kind, a pointer into the source, a length, and any literal value. Skip whitespace, then dispatch on the first character: digits build an integer, letters build an identifier, single characters map to punctuation.

   typedef enum { TOK_EOF, TOK_INT, TOK_IDENT, TOK_PLUS, TOK_MINUS,
                  TOK_LPAREN, TOK_RPAREN, TOK_SEMI, TOK_EQ, TOK_RETURN } TokenKind;
   
   typedef struct { TokenKind kind; const char *start; int length; int64_t int_val; } Token;
   typedef struct { const char *src; int pos; int line; } Lexer;
   
   Token lexer_next(Lexer *l) {
       while (l->src[l->pos] == ' ' || l->src[l->pos] == '\n') l->pos++;
       const char *start = &l->src[l->pos];
       if (isdigit((unsigned char)l->src[l->pos])) {
           int64_t val = 0;
           while (isdigit((unsigned char)l->src[l->pos]))
               val = val * 10 + (l->src[l->pos++] - '0');
           return (Token){ TOK_INT, start, (int)(&l->src[l->pos] - start), val };
       }
       if (isalpha((unsigned char)l->src[l->pos])) {
           while (isalnum((unsigned char)l->src[l->pos])) l->pos++;
           return (Token){ TOK_IDENT, start, (int)(&l->src[l->pos] - start), 0 };
       }
       switch (l->src[l->pos++]) {
           case '+': return (Token){ TOK_PLUS, start, 1, 0 };
           case '(': return (Token){ TOK_LPAREN, start, 1, 0 };
           case ')': return (Token){ TOK_RPAREN, start, 1, 0 };
           case ';': return (Token){ TOK_SEMI, start, 1, 0 };
           default:  return (Token){ TOK_EOF, start, 0, 0 };
       }
   }