hadeed/kilo
Archived
1
Fork 0
Code Activity

Finish chapter 3

Browse source
This commit is contained in:
Hadeed 2023-08-26 03:49:55 +05:00
parent 5c708df504
commit 472398fb25
2 changed files with 171 additions and 149 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Makefile
View file

@ -1,7 +1,7 @@
CCFLAGS := -Wall -Wextra -Wpedantic -Werror -std=c99 -D_DEFAULT_SOURCE CFLAGS := -Wall -Wextra -Wpedantic -Werror -std=c99
kilo: kilo.c kilo: kilo.c
$(CC) $(CCFLAGS) kilo.c -o kilo $(CC) $(CFLAGS) kilo.c -o kilo
clean: clean:
rm -f ./kilo rm -f ./kilo

308
kilo.c
View file

@ -1,6 +1,11 @@
#define _BSD_SOURCE
#define _DEFAULT_SOURCE
#define _GNU_SOURCE
#include <ctype.h> #include <ctype.h>
#include <errno.h> #include <errno.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -12,12 +17,17 @@
/*****************************************************************************/ /*****************************************************************************/
struct screen_buf;
struct input_buf;
typedef uint16_t KEY;
struct { struct {
struct termios orig_termios; struct termios orig_termios;
int rows;
int cols;
int cx, cy;
struct input_buf *ib; struct input_buf *ib;
int screenrows, screencols;
int cx, cy;
bool running;
} E; } E;
enum keys { enum keys {
@ -33,16 +43,24 @@ enum keys {
NOP NOP
}; };
struct screen_buf;
struct input_buf;
/*****************************************************************************/ /*****************************************************************************/
void editor_init(); void editor_init();
void editor_redraw_screen(); void editor_redraw_screen();
void editor_draw_rows(struct screen_buf *); void editor_draw_rows(struct screen_buf *);
void editor_process_key(); void editor_process_key();
int editor_read_key(); void editor_free();
struct screen_buf *sb_init();
void sb_append(struct screen_buf *, const char *);
void sb_write(struct screen_buf *);
void sb_free(struct screen_buf *);
struct input_buf *ib_init(size_t);
KEY ib_read(struct input_buf *);
void ib_write(struct input_buf *, KEY);
bool ib_empty(struct input_buf *);
void ib_free(struct input_buf *);
int term_enable_raw(); int term_enable_raw();
void term_disable_raw(); void term_disable_raw();
@ -51,17 +69,8 @@ int term_cursor_hidden(bool);
int term_get_win_size(int *, int *); int term_get_win_size(int *, int *);
int term_get_cursor_pos(int *, int *); int term_get_cursor_pos(int *, int *);
int term_set_cursor_pos(int, int); int term_set_cursor_pos(int, int);
KEY term_read_key();
struct screen_buf *sb_init();
void sb_append(struct screen_buf *, const char *);
void sb_free(struct screen_buf *);
void sb_write(struct screen_buf *);
struct input_buf *ib_init(size_t);
int ib_read(struct input_buf *);
void ib_write(struct input_buf *, int);
bool ib_empty(struct input_buf *);
void ib_free(struct input_buf *);
void die(const char *); void die(const char *);
@ -70,11 +79,12 @@ void die(const char *);
int main() { int main() {
editor_init(); editor_init();
while (1) { while (E.running) {
editor_redraw_screen(); editor_redraw_screen();
editor_process_key(); editor_process_key();
} }
editor_free();
return 0; return 0;
} }
@ -87,10 +97,12 @@ void editor_init() {
} }
if (term_enable_raw() == -1) die("term_enable_raw"); if (term_enable_raw() == -1) die("term_enable_raw");
if (term_get_win_size(&E.rows, &E.cols) == -1) die("term_get_win_size");
if (term_get_win_size(&E.screenrows, &E.screencols) == -1) die("term_get_win_size");
E.cx = E.cy = 0; E.cx = E.cy = 0;
E.ib = ib_init(128); E.ib = ib_init(128);
E.running = true;
} }
void editor_redraw_screen() { void editor_redraw_screen() {
@ -108,92 +120,133 @@ void editor_redraw_screen() {
void editor_draw_rows(struct screen_buf *sb) { void editor_draw_rows(struct screen_buf *sb) {
term_set_cursor_pos(1, 1); term_set_cursor_pos(1, 1);
for (int y = 0; y < E.rows; y++) { for (int y = 0; y < E.screenrows; y++) {
sb_append(sb, "~"); sb_append(sb, "~");
sb_append(sb, "\x1b[K"); // Clear rest of the line sb_append(sb, "\x1b[K"); // Clear rest of the line
if (y < E.rows - 1) sb_append(sb, "\r\n"); if (y < E.screenrows - 1) sb_append(sb, "\r\n");
} }
} }
void editor_process_key() { void editor_process_key() {
int c = editor_read_key(); KEY c = ib_read(E.ib);
switch (c) { switch (c) {
case CTRL_KEY('Q'):
term_clear();
exit(0);
break;
case ARROW_LEFT: case ARROW_LEFT:
if (E.cx > 0) E.cx--; if (E.cx > 0) E.cx--;
break; break;
case ARROW_DOWN: case ARROW_DOWN:
if (E.cy < E.rows - 1) E.cy++; if (E.cy < E.screenrows - 1) E.cy++;
break; break;
case ARROW_UP: case ARROW_UP:
if (E.cy > 0) E.cy--; if (E.cy > 0) E.cy--;
break; break;
case ARROW_RIGHT: case ARROW_RIGHT:
if (E.cx < E.cols - 1) E.cx++; if (E.cx < E.screencols - 1) E.cx++;
break;
case HOME:
E.cx = 0;
break;
case END:
E.cx = E.screencols - 1;
break;
case PG_UP:
case PG_DOWN:
for (int i = 0; i < E.screenrows; i++)
ib_write(E.ib, (c == PG_UP ? ARROW_UP : ARROW_DOWN));
break;
case CTRL_KEY('Q'):
E.running = false;
break; break;
} }
} }
int editor_read_key() { void editor_free() {
// TODO: There's better ways to do this. term_clear();
// Somehow make everything go through the input buffer ib_free(E.ib);
if (!ib_empty(E.ib))
return ib_read(E.ib);
char c;
while (read(STDIN_FILENO, &c, 1) == 0);
if (c == '\x1b') {
char buf[8];
for (size_t i = 0; i < sizeof(buf); i++) {
if (read(STDIN_FILENO, buf+i, 1) == 0) {
buf[i] = '\0';
break;
}
} }
char escape_char; /*****************************************************************************/
if (sscanf(buf, "[%c~", &escape_char) != EOF) {
switch (escape_char) { struct screen_buf {
case 'A': return ARROW_UP; char *s;
case 'B': return ARROW_DOWN; size_t size;
case 'C': return ARROW_RIGHT; };
case 'D': return ARROW_LEFT;
case 'H': return HOME; struct screen_buf *sb_init() {
case 'F': return END; struct screen_buf *sb = (struct screen_buf *) malloc(sizeof(struct screen_buf));
}
sb->s = NULL;
sb->size = 0;
return sb;
} }
int escape_int; void sb_append(struct screen_buf *sb, const char *s) {
if (sscanf(buf, "[%d~", &escape_int) != EOF) { int size = strlen(s);
switch (escape_int) {
case 1: sb->s = realloc(sb->s, sb->size + size);
case 7: memcpy(sb->s + sb->size, s, size);
return HOME;
case 3: sb->size += size;
return DEL;
case 4:
case 8:
return END;
case 5:
return PG_UP;
case 6:
return PG_DOWN;
}
} }
return NOP; void sb_write(struct screen_buf *sb) {
write(STDOUT_FILENO, sb->s, sb->size);
} }
return (int) c; void sb_free(struct screen_buf *sb) {
free(sb->s);
free(sb);
}
struct input_buf {
KEY *carr; // Circular array
int read_i;
int write_i;
size_t capacity; // Actual capacity is one less
};
struct input_buf *ib_init(size_t capacity) {
struct input_buf *ib = (struct input_buf *) malloc(sizeof(struct input_buf));
ib->carr = (KEY *) malloc(sizeof(KEY) * capacity);
ib->write_i = 0;
ib->read_i = 0;
ib->capacity = capacity;
return ib;
}
void ib_write(struct input_buf *ib, KEY key) {
if ((ib->write_i + 1) % (int) ib->capacity == ib->read_i) // Buffer full
die("ib_write");
ib->carr[ib->write_i] = key;
ib->write_i = (ib->write_i + 1) % ib->capacity;
}
KEY ib_read(struct input_buf *ib) {
if (ib_empty(ib)) ib_write(ib, term_read_key());
KEY key = ib->carr[ib->read_i];
ib->read_i = (ib->read_i + 1) % ib->capacity;
return key;
}
bool ib_empty(struct input_buf *ib) {
return ib->write_i == ib->read_i;
}
void ib_free(struct input_buf *ib) {
free(ib->carr);
free(ib);
} }
/*****************************************************************************/ /*****************************************************************************/
@ -206,7 +259,7 @@ int term_enable_raw() {
cfmakeraw(&raw); cfmakeraw(&raw);
raw.c_cc[VMIN] = 0; raw.c_cc[VMIN] = 0;
raw.c_cc[VTIME] = 1; raw.c_cc[VTIME] = 10;
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) == -1) return -1; if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) == -1) return -1;
@ -275,83 +328,52 @@ int term_set_cursor_pos(int row, int col) {
return 0; return 0;
} }
/*****************************************************************************/ KEY term_read_key() {
char c;
while (read(STDIN_FILENO, &c, 1) == 0);
struct screen_buf { if (c == '\x1b') {
char *s; char buf[8] = { '\0' };
size_t size;
};
struct screen_buf *sb_init() { // Inefficient but I like the way it looks
struct screen_buf *sb = (struct screen_buf *) malloc(sizeof(struct screen_buf)); for (size_t i = 0; i < sizeof(buf); i++) {
if (read(STDIN_FILENO, buf+i, 1) == 0) break;
sb->s = NULL; char escape_char;
sb->size = 0; if (sscanf(buf, "[%c~", &escape_char) != EOF) {
switch (escape_char) {
return sb; case 'A': return ARROW_UP;
case 'B': return ARROW_DOWN;
case 'C': return ARROW_RIGHT;
case 'D': return ARROW_LEFT;
case 'H': return HOME;
case 'F': return END;
}
} }
void sb_append(struct screen_buf *sb, const char *s) { int escape_int;
int size = strlen(s); if (sscanf(buf, "[%d~", &escape_int) != EOF) {
switch (escape_int) {
sb->s = realloc(sb->s, sb->size + size); case 1:
memcpy(sb->s + sb->size, s, size); case 7:
return HOME;
sb->size += size; case 3:
return DEL;
case 4:
case 8:
return END;
case 5:
return PG_UP;
case 6:
return PG_DOWN;
}
}
} }
void sb_write(struct screen_buf *sb) { return NOP;
write(STDOUT_FILENO, sb->s, sb->size);
} }
void sb_free(struct screen_buf *sb) { return (KEY) c;
free(sb->s);
free(sb);
}
struct input_buf {
int *carr; // Circular array
int read_i;
int write_i;
size_t capacity; // Actual capacity is one less
};
struct input_buf *ib_init(size_t capacity) {
struct input_buf *ib = (struct input_buf *) malloc(sizeof(struct input_buf));
ib->carr = (int *) malloc(sizeof(int) * capacity);
ib->write_i = 0;
ib->read_i = 0;
ib->capacity = capacity;
return ib;
}
void ib_write(struct input_buf *ib, int key) {
if ((ib->write_i + 1) % (int) ib->capacity == ib->read_i) // Buffer full
die("ib_write");
ib->carr[ib->write_i] = key;
ib->write_i = (ib->write_i + 1) % ib->capacity;
}
int ib_read(struct input_buf *ib) {
if (ib_empty(ib)) die("ib_read");
int key = ib->carr[ib->read_i];
ib->read_i = (ib->read_i + 1) % ib->capacity;
return key;
}
bool ib_empty(struct input_buf *ib) {
return ib->write_i == ib->read_i;
}
void ib_free(struct input_buf *ib) {
free(ib->carr);
free(ib);
} }
/*****************************************************************************/ /*****************************************************************************/