crafting-interpreters/clox/src/compiler.c

150 lines
3.1 KiB
C
Raw Normal View History

2021-08-02 18:09:03 -07:00
#include <stdio.h>
2021-08-16 22:17:40 -07:00
#include <stdlib.h>
2021-08-02 18:09:03 -07:00
#include "common.h"
#include "compiler.h"
#include "scanner.h"
2021-08-16 22:17:40 -07:00
typedef struct {
Token current;
Token previous;
bool hadError;
bool panicMode;
} Parser;
typedef enum {
PREC_NONE,
PREC_ASSIGNMENT, /* = */
PREC_OR, /* or */
PREC_AND, /* and */
PREC_EQUALITY, /* == != */
PREC_COMPARISON, /* < > <= >= */
PREC_TERM, /* + - */
PREC_FACTOR, /* * / */
PREC_UNARY, /* ! - */
PREC_CALL, /* . () */
PREC_PRIMARY
} Precedence;
Parser parser;
Chunk *compilingChunk;
static Chunk *currentChunk() { return compilingChunk; }
static void errorAt(Token *token, const char *message) {
if (parser.panicMode)
return;
parser.panicMode = true;
fprintf(stderr, "[line %d] Error", token->line);
if (token->type == TOKEN_EOF) {
fprintf(stderr, " at end");
} else if (token->type == TOKEN_ERROR) {
/* Nothing */
} else {
fprintf(stderr, " at '%.*s'", token->length, token->start);
}
fprintf(stderr, ": %s\n", message);
parser.hadError = true;
}
static void error(const char *message) { errorAt(&parser.previous, message); }
static void errorAtCurrent(const char *message) {
errorAt(&parser.current, message);
}
static void advance() {
parser.previous = parser.current;
2021-08-02 18:35:10 -07:00
for (;;) {
2021-08-16 22:17:40 -07:00
parser.current = scanToken();
if (parser.current.type != TOKEN_ERROR)
2021-08-02 18:35:10 -07:00
break;
2021-08-16 22:17:40 -07:00
errorAtCurrent(parser.current.start);
}
}
static void consume(TokenType type, const char *message) {
if (parser.current.type == type) {
advance();
return;
2021-08-02 18:35:10 -07:00
}
2021-08-16 22:17:40 -07:00
errorAtCurrent(message);
}
static void emitByte(uint8_t byte) {
writeChunk(currentChunk(), byte, parser.previous.line);
}
static void emitBytes(uint8_t byte1, uint8_t byte2) {
emitByte(byte1);
emitByte(byte2);
}
static void emitReturn() { emitByte(OP_RETURN); }
static uint8_t makeConstant(Value value) {
int constant = addConstant(currentChunk(), value);
if (constant > UINT8_MAX) {
error("Too many constants in one chunk.");
return 0;
}
return (uint8_t)constant;
}
static void emitConstant(Value value) {
emitBytes(OP_CONSTANT, makeConstant(value));
}
static void endCompiler() { emitReturn(); }
static void parsePrecedence(Precedence precedence) {
// What goes here?
}
static void expression() { parsePrecedence(PREC_ASSIGNMENT); }
static void number() {
double value = strtod(parser.previous.start, NULL);
emitConstant(value);
}
static void unary() {
TokenType operatorType = parser.previous.type;
// Compile the operand.
parsePrecedence(PREC_UNARY);
// Emit the operator instruction.
switch (operatorType) {
case TOKEN_MINUS:
emitByte(OP_NEGATE);
break;
default:
return; // Unreachable.
}
}
static void grouping() {
expression();
consume(TOKEN_RIGHT_PAREN, "Expect ')' after expression.");
}
bool compile(const char *source, Chunk *chunk) {
initScanner(source);
compilingChunk = chunk;
parser.hadError = false;
parser.panicMode = false;
advance();
expression();
consume(TOKEN_EOF, "Expect end of expression.");
endCompiler();
return !parser.hadError;
2021-08-02 18:35:10 -07:00
}