hadeed/kilo
Archived
1
Fork 0
Code Activity

Refactor a lot

Browse source 
Doesn't compile yet. Dreading the time when it does and there's an error
in the hundreds of lines I changed. For future: commit small changes
that can be compiled and tested atomically.
This commit is contained in:
Hadeed 2023-09-08 20:45:34 +05:00
parent e3fb954aeb
commit fc5e50e4db
8 changed files with 282 additions and 229 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

@ -3,5 +3,5 @@ kilo
.cache
.clangd
.nvim.lua
compile_commands.json
test_file

31
include/buffer.h
View file

@ -5,34 +5,27 @@
#include <stddef.h>
#include "utils.h"
struct erow {
char *chars;
int n_chars;
char *rchars;
int n_rchars;
};
#include "erow.h"
struct buffer {
char *filename;
struct erow *rows;
int cx, cy, rx;
int row_off, col_off;
struct erow **rows;
int n_rows;
bool modified;
};
struct buffer *buffer_create(void);
void buffer_read_file(struct buffer *buffer, const char *filename);
void buffer_insert_row(struct buffer *buffer, const char *chars, int n_chars, int at);
ERRCODE buffer_read_file(struct buffer *buffer, const char *filename);
ERRCODE buffer_write_file(struct buffer *buffer, size_t *bytes_written);
void buffer_insert_row(struct buffer *buffer, struct erow *erow, int at);
void buffer_delete_row(struct buffer *buffer, int at);
ERRCODE buffer_write_file(struct buffer *buffer, int *bytes_written);
struct erow *buffer_get_crow(struct buffer *buffer);
void buffer_free(struct buffer *buffer);
void erow_update_rendering(struct erow *erow);
void erow_append_string(struct erow *erow, const char *s, size_t s_len);
void erow_insert_char(struct erow *erow, int at, char c);
void erow_delete_char(struct erow *erow, int at);
int erow_cx_to_rx(struct erow *erow, int cx);
int erow_rx_to_cx(struct erow *erow, int rx);
void erow_free(struct erow *erow);
#endif // BUFFER_H

23
include/erow.h Normal file
View file

@ -0,0 +1,23 @@
#ifndef EROW_H
#define EROW_H
#include <stdlib.h>
struct erow {
char *chars;
size_t n_chars;
char *rchars;
size_t n_rchars;
struct buffer *buffer;
};
struct erow *erow_create(const char* chars, size_t n_chars, struct buffer *buffer);
void erow_insert_chars(struct erow *erow, const char *chars, size_t n_chars, int at);
void erow_delete_char(struct erow *erow, int at);
int erow_cx_to_rx(struct erow *erow, int cx);
int erow_rx_to_cx(struct erow *erow, int rx);
void erow_free(struct erow *erow);
#endif // EROW_H

2
include/kilo.h
View file

@ -7,8 +7,6 @@
#include <time.h>
struct editor_state {
int cx, cy, rx;
int row_off, col_off;
int screenrows, screencols;
int quit_times;

273
src/buffer.c
View file

@ -1,12 +1,8 @@
#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "buffer.h"
#include "kilo.h"
#include "erow.h"
#include "utils.h"
static void buffer_free_rows(struct buffer *buffer);
@ -16,75 +12,89 @@ struct buffer *buffer_create(void) {
struct buffer *buffer = malloc(sizeof(struct buffer));
buffer->filename = NULL;
buffer->cx = buffer->cy = buffer->rx = 0;
buffer->row_off = buffer->col_off = 0;
buffer->rows = NULL;
buffer->n_rows = 0;
buffer->modified = false;
return buffer;
}
void buffer_read_file(struct buffer *buffer, const char *filename) { // TODO: Add error handling
if (buffer->filename)
free(buffer->filename);
if (buffer->rows)
buffer_free_rows(buffer);
ERRCODE buffer_read_file(struct buffer *buffer, const char *filename) {
ERRCODE errcode = 0;
if (buffer->filename) free(buffer->filename);
size_t filename_len = strlen(filename);
buffer->filename = malloc(filename_len);
memcpy(buffer->filename, filename, filename_len);
if (buffer->rows)
buffer_free_rows(buffer);
size_t buf_cap = 64;
size_t buf_size = 0;
char *buf = malloc(buf_cap);
FILE *file = fopen(filename, "r");
if (!file) die("fopen");
if (file == NULL)
RETURN(-1);
size_t line_buffer_size = 64;
char *line_buffer = malloc(line_buffer_size);
bool file_remaining = true;
while (file_remaining) {
while (true) {
char c;
int i;
for (i = 0; (c = getc(file)) != '\n' && c != EOF; i++) {
if (i >= (int) line_buffer_size)
line_buffer = realloc(line_buffer, line_buffer_size *= 2);
while ((c = getc(file)) != '\n' && c != EOF) {
if (buf_size >= buf_cap)
buf = realloc(buf, buf_cap *= 2);
line_buffer[i] = c;
buf[buf_size++] = c;
}
buffer_insert_row(buffer, line_buffer, i, buffer->n_rows);
file_remaining = (c != EOF);
struct erow* erow = erow_create(buf, buf_size, buffer);
buffer_insert_row(buffer, erow, buffer->n_rows);
if (c == EOF)
break;
}
free(line_buffer);
fclose(file);
END:
if (file != NULL)
fclose(file);
if (buf != NULL)
free(buf);
buffer->modified = false;
return errcode;
}
ERRCODE buffer_write_file(struct buffer *buffer, int *bytes_written) {
ERRCODE buffer_write_file(struct buffer *buffer, size_t *bytes_written) {
ERRCODE errcode = 0;
int fd = -1;
FILE *file = NULL;
char *write_buffer = NULL;
if (buffer->filename == NULL)
RETURN(-1);
size_t len;
write_buffer = buffer_get_string(buffer, &len);
size_t n_chars;
write_buffer = buffer_get_string(buffer, &n_chars);
fd = open(buffer->filename, O_RDWR | O_TRUNC | O_CREAT, 0644);
if (fd == -1)
file = fopen(buffer->filename, "w");
if (file == NULL)
RETURN(-2);
*bytes_written = write(fd, write_buffer, len);
if (*bytes_written != (ssize_t) len)
*bytes_written = fwrite(write_buffer, 1, n_chars, file);
if (*bytes_written != n_chars)
RETURN(-3);
END:
if (fd != -1)
close(fd);
if (file != NULL)
fclose(file);
if (write_buffer)
free(write_buffer);
@ -95,21 +105,41 @@ END:
return errcode;
}
void buffer_insert_row(struct buffer *buffer, const char *chars, int n_chars, int at) { // TODO: Make this take an erow
buffer->rows = realloc(buffer->rows, sizeof(struct erow) * (buffer->n_rows + 1));
memmove(buffer->rows + at + 1, buffer->rows + at, sizeof(struct erow) * (buffer->n_rows - at));
struct erow *erow = buffer->rows + at;
ERRCODE buffer_get_row_chars(struct buffer *buffer, char **chars, size_t *n_chars, int at) {
if (buffer == NULL)
return -1;
erow->chars = malloc(n_chars);
memcpy(erow->chars, chars, n_chars);
erow->n_chars = n_chars;
if (!(0 <= at && at <= buffer->n_rows))
return -2;
erow->rchars = NULL;
erow->n_rchars = 0;
if (chars) *chars = buffer->rows[at]->chars;
if (n_chars) *n_chars = buffer->rows[at]->n_chars;
erow_update_rendering(erow);
return 0;
}
ERRCODE buffer_get_row_rchars(struct buffer *buffer, char **rchars, size_t *n_rchars, int at) {
if (buffer == NULL)
return -1;
if (!(0 <= at && at <= buffer->n_rows))
return -2;
if (rchars) *rchars = buffer->rows[at]->rchars;
if (n_rchars) *n_rchars = buffer->rows[at]->n_rchars;
return 0;
}
void buffer_insert_row(struct buffer *buffer, struct erow *erow, int at) {
if (!(0 <= at && at <= buffer->n_rows))
return;
buffer->rows = realloc(buffer->rows, sizeof(struct erow *) * (buffer->n_rows + 1));
memmove(buffer->rows + at + 1, buffer->rows + at, sizeof(struct erow *) * (buffer->n_rows - at));
buffer->rows[at] = erow;
buffer->modified = true;
buffer->n_rows++;
}
@ -117,150 +147,47 @@ void buffer_delete_row(struct buffer *buffer, int at) {
if (!(0 <= at && at < buffer->n_rows))
return;
erow_free(buffer->rows + at);
memmove(buffer->rows + at, buffer->rows + at + 1, sizeof(struct erow) * (buffer->n_rows - at - 1));
erow_free(buffer->rows[at]);
memmove(buffer->rows + at, buffer->rows + at + 1, sizeof(struct erow *) * (buffer->n_rows - at - 1));
buffer->n_rows--;
buffer->modified = true;
}
struct erow *buffer_get_crow(struct buffer *buffer) {
return (buffer->cy < buffer->n_rows ? buffer->rows[buffer->cy]: NULL);
}
void buffer_free(struct buffer *buffer) {
free(buffer->filename);
buffer_free_rows(buffer);
}
static void buffer_free_rows(struct buffer *buffer) {
for (int i = 0; i < buffer->n_rows; i++)
erow_free(buffer->rows + i);
erow_free(buffer->rows[i]);
free(buffer->rows);
buffer->rows = NULL;
buffer->n_rows = 0;
}
static char *buffer_get_string(struct buffer *buffer, size_t *len_p) {
*len_p = 0;
static char *buffer_get_string(struct buffer *buffer, size_t *n_chars) {
*n_chars = 0;
for (int i = 0; i < buffer->n_rows; i++)
*len_p += buffer->rows[i].n_chars + 1;
*n_chars += buffer->rows[i]->n_chars + 1;
char *write_buffer = malloc(*len_p);
char *p = write_buffer;
for (int i = 0; i < buffer->n_rows; i++) {
struct erow *row = buffer->rows+i;
memcpy(p, row->chars, row->n_chars);
p += row->n_chars;
*p = '\n';
p++;
char *write_buffer = malloc(*n_chars);
for (int i = 0, j = 0; i < buffer->n_rows; j++, i++) {
struct erow *row = buffer->rows[i];
memcpy(write_buffer + j, row->chars, row->n_chars);
j += row->n_chars;
write_buffer[j++] = '\n';
}
return write_buffer;
}
/*****************************************************************************/
void erow_update_rendering(struct erow *erow) {
size_t line_buffer_size = 64;
char *line_buffer = malloc(line_buffer_size);
size_t n_rchars = 0;
for (int i = 0; i < erow->n_chars; i++) {
switch (erow->chars[i]) {
case '\t': {
int spaces = KILO_TAB_STOP - (n_rchars % KILO_TAB_STOP);
while (spaces--) {
if (n_rchars >= line_buffer_size)
line_buffer = realloc(line_buffer, 2*line_buffer_size);
line_buffer[n_rchars++] = ' ';
}
break;
}
default:
if (n_rchars >= line_buffer_size)
line_buffer = realloc(line_buffer, 2*line_buffer_size);
line_buffer[n_rchars++] = erow->chars[i];
}
}
if (erow->rchars)
free(erow->rchars);
erow->rchars = malloc(n_rchars);
erow->n_rchars = n_rchars;
memcpy(erow->rchars, line_buffer, n_rchars);
free(line_buffer);
}
void erow_append_string(struct erow *erow, const char *s, size_t s_len) {
erow->n_chars = erow->n_chars + s_len;
erow->chars = realloc(erow->chars, erow->n_chars);
memcpy(erow->chars + erow->n_chars - s_len, s, s_len);
erow_update_rendering(erow);
E.current_buf->modified = true; // TODO
}
void erow_insert_char(struct erow *erow, int at, char c) {
if (!(0 <= at && at <= erow->n_chars))
return;
erow->chars = realloc(erow->chars, erow->n_chars + 1);
memmove(erow->chars + at + 1, erow->chars + at, erow->n_chars - at);
erow->chars[at] = c;
erow->n_chars++;
erow_update_rendering(erow);
E.current_buf->modified = true; // TODO
}
void erow_delete_char(struct erow *erow, int at) {
if (!(0 <= at && at < erow->n_chars))
return;
memmove(erow->chars + at, erow->chars + at + 1, erow->n_chars - at);
erow->n_chars--;
erow->chars = realloc(erow->chars, erow->n_chars);
E.cx--;
erow_update_rendering(erow);
E.current_buf->modified = true; // TODO
}
int erow_cx_to_rx(struct erow *erow, int cx) {
int rx = 0;
if (erow == NULL)
return 0;
for (int i = 0; i < MIN(cx, erow->n_chars); i++) {
if (erow->chars[i] == '\t')
rx += KILO_TAB_STOP - (rx % KILO_TAB_STOP);
else rx++;
}
return rx;
}
int erow_rx_to_cx(struct erow *erow, int rx) {
int cx = 0, _rx = 0;
if (erow == NULL)
return 0;
while (_rx < rx && cx < erow->n_chars) {
if (erow->chars[cx] == '\t') {
_rx += KILO_TAB_STOP - (_rx % KILO_TAB_STOP);
} else _rx++;
cx++;
}
return (_rx >= rx ? cx : erow->n_chars);
}
void erow_free(struct erow *erow) {
if (erow->chars) free(erow->chars);
if (erow->rchars) free(erow->rchars);
}

111
src/erow.c Normal file
View file

@ -0,0 +1,111 @@
#include <stdlib.h>
#include <string.h>
#include "buffer.h"
#include "erow.h"
#include "kilo.h"
static void erow_update_rchars(struct erow *erow);
struct erow *erow_create(const char* chars, size_t n_chars, struct buffer *buffer) {
struct erow *erow = malloc(sizeof(struct erow));
erow->chars = malloc(n_chars);
erow->n_chars = n_chars;
memcpy(erow->chars, chars, erow->n_chars);
erow_update_rchars(erow);
erow->buffer = buffer;
return erow;
}
void erow_insert_chars(struct erow *erow, const char *chars, size_t n_chars, int at) {
erow->chars = realloc(erow->chars, erow->n_chars + n_chars);
memmove(erow->chars + at + n_chars, erow->chars + at, n_chars - at);
memcpy(erow->chars + at, chars, n_chars);
erow->n_chars += n_chars;
erow_update_rchars(erow);
if (erow->buffer)
erow->buffer->modified = true;
}
void erow_delete_char(struct erow *erow, int at) {
memmove(erow->chars + at, erow->chars + at + 1, erow->n_chars - at);
erow->chars = realloc(erow->chars, --erow->n_chars);
erow_update_rchars(erow);
if (erow->buffer)
erow->buffer->modified = true;
}
int erow_cx_to_rx(struct erow *erow, int cx) {
int rx = 0;
for (char *c = erow->chars; c < erow->chars + cx; c++) {
if (*c == '\t')
rx += KILO_TAB_STOP - (rx % KILO_TAB_STOP);
else
rx++;
}
return rx;
}
int erow_rx_to_cx(struct erow *erow, int rx) {
if ((size_t) rx >= erow->n_rchars)
return erow->n_chars;
int c_rx = 0;
for (int cx = 0; (size_t) cx < erow->n_chars; cx++) {
if (erow->chars[cx] == '\t')
c_rx += KILO_TAB_STOP - (c_rx % KILO_TAB_STOP);
else
c_rx++;
if (c_rx >= rx)
return cx;
}
return erow->n_chars;
}
void erow_free(struct erow *erow) {
if (erow->chars) free(erow->chars);
if (erow->rchars) free(erow->rchars);
}
static void erow_update_rchars(struct erow *erow) {
if (erow->rchars)
free(erow->rchars);
size_t n_rchars_max = 16;
erow->rchars = malloc(erow->n_rchars);
erow->n_rchars = 0;
for (char *c = erow->chars; c < erow->chars + erow->n_chars; c++) {
if (*c == '\t') {
int spaces = KILO_TAB_STOP - (erow->n_rchars % KILO_TAB_STOP);
while (erow->n_rchars + spaces > n_rchars_max)
erow->rchars = realloc(erow->rchars, n_rchars_max *= 2);
memset(erow->rchars + erow->n_rchars, ' ', spaces);
erow->n_rchars += spaces;
} else {
if (erow->n_rchars + 1 > n_rchars_max)
erow->rchars = realloc(erow->rchars, n_rchars_max *= 2);
erow->rchars[erow->n_rchars++] = *c;
}
}
erow->rchars = realloc(erow->rchars, erow->n_rchars);
}

50
src/kilo.c
View file

@ -36,9 +36,6 @@ void editor_init(char *filename) {
if (terminal_enable_raw() == -1) die("term_enable_raw");
E.cx = E.cy = E.rx = 0;
E.row_off = E.col_off = 0;
if (terminal_get_win_size(&E.screenrows, &E.screencols) == -1)
die("term_get_win_size");
E.screenrows -= 2;
@ -61,39 +58,40 @@ void editor_set_message(const char *fmt, ...) {
E.message_time = time(NULL);
}
// TODO: Implement a fully featured line editor
// TODO: Implement a fully featured line editor here
char *editor_prompt(const char *prompt) {
size_t buffer_size = 64;
char *buffer = malloc(buffer_size);
size_t buf_cap = 64;
size_t buf_size = 0;
char *buf = malloc(buf_cap);
size_t buffer_len = 0;
buffer[buffer_len] = '\0';
buf[buf_size] = '\0';
while (true) {
editor_set_message(prompt, buffer);
editor_set_message(prompt, buf);
ui_draw_screen();
KEY key = terminal_read_key();
if (key == ESCAPE) {
editor_set_message("");
free(buffer);
return NULL;
} else if (key == ENTER) {
if (buffer_len > 0) {
editor_set_message("");
buffer = realloc(buffer, buffer_len + 1);
return buffer;
}
if (key == ESCAPE) goto failure;
else if (key == ENTER) {
if (buf_size > 0) goto success;
else goto failure;
} else if (isprint(key)) {
if (buffer_len >= buffer_size - 1) {
buffer_size *= 2;
buffer = realloc(buffer, buffer_size);
}
if (buf_size + 1 >= buf_cap)
buf = realloc(buf, buf_cap *= 2);
buffer[buffer_len++] = key;
buffer[buffer_len] = '\0';
buf[buf_size] = key;
buf_size++;
buf[buf_size] = '\0';
}
}
return buffer;
failure:
free(buf);
buf = NULL;
success:
if (buf)
buf = realloc(buf, buf_size + 1);
editor_set_message("");
return buf;
}

19
src/ui.c
View file

@ -28,8 +28,8 @@ void ui_draw_screen(void) {
write(STDIN_FILENO, draw_buf->chars, draw_buf->n_chars);
ab_free(draw_buf);
int row_pos = E.cy - E.row_off + 1;
int col_pos = E.rx - E.col_off + 1;
int row_pos = E.current_buf->cy - E.current_buf->row_off + 1;
int col_pos = E.current_buf->rx - E.current_buf->col_off + 1;
if (terminal_set_cursor_pos(row_pos, col_pos) == -1)
die("term_set_cursor_pos");
@ -40,14 +40,17 @@ void ui_draw_screen(void) {
static void ui_draw_rows(struct append_buf *draw_buf) {
terminal_set_cursor_pos(1, 1);
for (int y = 0; y < E.screenrows; y++) {
bool in_file = (y < E.current_buf->n_rows - E.row_off);
bool no_file = (E.current_buf->n_rows == 0);
bool in_file = (y < E.current_buf->n_rows - E.current_buf->row_off);
bool no_file = (E.current_buf->filename == NULL && E.current_buf->n_rows == 0);
if (in_file) {
struct erow erow = E.current_buf->rows[y + E.row_off];
int max_len = MIN(erow.n_rchars - E.col_off, E.screencols);
struct erow *crow = buffer_get_crow(E.current_buf);
ab_append(draw_buf, erow.rchars + E.col_off, MAX(max_len, 0));
size_t len = crow->n_rchars - E.current_buf->col_off;
len = MIN(len, (size_t) E.screencols);
len = MAX(len, 0);
ab_append(draw_buf, crow->rchars + E.current_buf->col_off, len);
} else if (no_file && y == E.screenrows / 2) {
char welcome[64];
int len = snprintf(welcome, sizeof(welcome),
@ -78,7 +81,7 @@ static void ui_draw_statusbar(struct append_buf *draw_buf) {
len = sprintf(buf, "%s %s-- %d lines", display, modified, n_rows);
memcpy(status_buf, buf, len);
len = sprintf(buf, "%d:%d", E.cy + 1, E.rx + 1);
len = sprintf(buf, "%d:%d", E.current_buf->cy + 1, E.current_buf->rx + 1);
memcpy(status_buf + E.screencols - len, buf, len);
ab_append(draw_buf, status_buf, E.screencols);