-
Notifications
You must be signed in to change notification settings - Fork 0
/
compiler.c
106 lines (86 loc) · 2.21 KB
/
compiler.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <stdio.h>
#include <stdlib.h>
#include "common.h"
#include "compiler.h"
#include "scanner.h"
typedef struct {
Token previous;
Token current;
bool hadError;
bool panicMode;
} Parser;
static Parser parser;
Chunk *compilingChunk;
static Chunk *currentChunk() {
return compilingChunk;
}
static void errorAt(Token *token, const char *message) {
if (parser.panicMode) {
return;
}
parser.panicMode = true;
parser.hadError = 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);
}
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;
for (;;) {
parser.current = scanToken();
if (parser.current.type != TOKEN_ERROR) {
break;
}
errorAtCurrent(parser.current.start);
}
}
static void consume(TokenType type, const char *message) {
if (parser.current.type == type) {
advance();
return;
}
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 void endCompiler() {
emitReturn();
}
static void number() {
double value = strtod(parser.previous.start, NULL);
emitConstant(value);
}
static void expression() {
// What goes here?
}
bool compile(const char *source, Chunk *chunk) {
initScanner(source);
compilingChunk = chunk;
parser.hadError = false;
parser.panicMode = false;
advance();
expression();
consume(TOKEN_EOF, "Expected end of expression.");
endCompiler();
return !parser.hadError;
}