From fc57421057fcdcc80080dbc59fae633fc49e0ca5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Andr=C3=A9=20Tanner?= Date: Mon, 8 Sep 2014 14:11:55 +0200 Subject: Unify variable naming Only textual substitution no functional changes. --- text.c | 390 ++++++++++++++++++++++++++++++++--------------------------------- text.h | 14 +-- 2 files changed, 202 insertions(+), 202 deletions(-) diff --git a/text.c b/text.c index 4a4cd80..8c775da 100644 --- a/text.c +++ b/text.c @@ -51,10 +51,10 @@ struct Buffer { * All active pieces chained together form the whole content of the document. * At the beginning there exists only one piece, spanning the whole document. * Upon insertion/delition new pieces will be created to represent the changes. - * Generally pieces are never destroyed, but kept around to peform undo/redo operations. + * Generally pieces are never destroytxt, but kept around to peform undo/redo operations. */ struct Piece { - Text *editor; /* editor to which this piece belongs */ + Text *text; /* text to which this piece belongs */ Piece *prev, *next; /* pointers to the logical predecessor/successor */ Piece *global_prev; /* double linked list in order of allocation, */ Piece *global_next; /* used to free individual pieces */ @@ -122,42 +122,42 @@ struct Text { }; /* buffer management */ -static Buffer *buffer_alloc(Text *ed, size_t size); +static Buffer *buffer_alloc(Text *txt, size_t size); static void buffer_free(Buffer *buf); static bool buffer_capacity(Buffer *buf, size_t len); static const char *buffer_append(Buffer *buf, const char *data, size_t len); static bool buffer_insert(Buffer *buf, size_t pos, const char *data, size_t len); static bool buffer_delete(Buffer *buf, size_t pos, size_t len); -static const char *buffer_store(Text *ed, const char *data, size_t len); +static const char *buffer_store(Text *txt, const char *data, size_t len); /* cache layer */ -static void cache_piece(Text *ed, Piece *p); -static bool cache_contains(Text *ed, Piece *p); -static bool cache_insert(Text *ed, Piece *p, size_t off, const char *data, size_t len); -static bool cache_delete(Text *ed, Piece *p, size_t off, size_t len); +static void cache_piece(Text *txt, Piece *p); +static bool cache_contains(Text *txt, Piece *p); +static bool cache_insert(Text *txt, Piece *p, size_t off, const char *data, size_t len); +static bool cache_delete(Text *txt, Piece *p, size_t off, size_t len); /* piece management */ -static Piece *piece_alloc(Text *ed); +static Piece *piece_alloc(Text *txt); static void piece_free(Piece *p); static void piece_init(Piece *p, Piece *prev, Piece *next, const char *data, size_t len); -static Location piece_get_intern(Text *ed, size_t pos); -static Location piece_get_extern(Text *ed, size_t pos); +static Location piece_get_intern(Text *txt, size_t pos); +static Location piece_get_extern(Text *txt, size_t pos); /* span management */ static void span_init(Span *span, Piece *start, Piece *end); -static void span_swap(Text *ed, Span *old, Span *new); +static void span_swap(Text *txt, Span *old, Span *new); /* change management */ -static Change *change_alloc(Text *ed); +static Change *change_alloc(Text *txt); static void change_free(Change *c); /* action management */ -static Action *action_alloc(Text *ed); +static Action *action_alloc(Text *txt); static void action_free(Action *a); static void action_push(Action **stack, Action *action); static Action *action_pop(Action **stack); /* logical line counting cache */ static void lineno_cache_invalidate(LineCache *cache); -static size_t lines_skip_forward(Text *ed, size_t pos, size_t lines); -static size_t lines_count(Text *ed, size_t pos, size_t len); +static size_t lines_skip_forward(Text *txt, size_t pos, size_t lines); +static size_t lines_count(Text *txt, size_t pos, size_t len); /* allocate a new buffer of MAX(size, BUFFER_SIZE) bytes */ -static Buffer *buffer_alloc(Text *ed, size_t size) { +static Buffer *buffer_alloc(Text *txt, size_t size) { Buffer *buf = calloc(1, sizeof(Buffer)); if (!buf) return NULL; @@ -168,8 +168,8 @@ static Buffer *buffer_alloc(Text *ed, size_t size) { return NULL; } buf->size = size; - buf->next = ed->buffers; - ed->buffers = buf; + buf->next = txt->buffers; + txt->buffers = buf; return buf; } @@ -194,9 +194,9 @@ static const char *buffer_append(Buffer *buf, const char *data, size_t len) { /* stores the given data in a buffer, allocates a new one if necessary. returns * a pointer to the storage location or NULL if allocation failed. */ -static const char *buffer_store(Text *ed, const char *data, size_t len) { - Buffer *buf = ed->buffers; - if ((!buf || !buffer_capacity(buf, len)) && !(buf = buffer_alloc(ed, len))) +static const char *buffer_store(Text *txt, const char *data, size_t len) { + Buffer *buf = txt->buffers; + if ((!buf || !buffer_capacity(buf, len)) && !(buf = buffer_alloc(txt, len))) return NULL; return buffer_append(buf, data, len); } @@ -231,18 +231,18 @@ static bool buffer_delete(Buffer *buf, size_t pos, size_t len) { } /* cache the given piece if it is the most recently changed one */ -static void cache_piece(Text *ed, Piece *p) { - Buffer *buf = ed->buffers; +static void cache_piece(Text *txt, Piece *p) { + Buffer *buf = txt->buffers; if (!buf || p->data < buf->data || p->data + p->len != buf->data + buf->len) return; - ed->cache = p; + txt->cache = p; } /* check whether the given piece was the most recently modified one */ -static bool cache_contains(Text *ed, Piece *p) { - Buffer *buf = ed->buffers; - Action *a = ed->current_action; - if (!buf || !ed->cache || ed->cache != p || !a || !a->change) +static bool cache_contains(Text *txt, Piece *p) { + Buffer *buf = txt->buffers; + Action *a = txt->current_action; + if (!buf || !txt->cache || txt->cache != p || !a || !a->change) return false; Piece *start = a->change->new.start; @@ -261,16 +261,16 @@ static bool cache_contains(Text *ed, Piece *p) { /* try to insert a junk of data at a given piece offset. the insertion is only * performed if the piece is the most recenetly changed one. the legnth of the * piece, the span containing it and the whole text is adjusted accordingly */ -static bool cache_insert(Text *ed, Piece *p, size_t off, const char *data, size_t len) { - if (!cache_contains(ed, p)) +static bool cache_insert(Text *txt, Piece *p, size_t off, const char *data, size_t len) { + if (!cache_contains(txt, p)) return false; - Buffer *buf = ed->buffers; + Buffer *buf = txt->buffers; size_t bufpos = p->data + off - buf->data; if (!buffer_insert(buf, bufpos, data, len)) return false; p->len += len; - ed->current_action->change->new.len += len; - ed->size += len; + txt->current_action->change->new.len += len; + txt->size += len; return true; } @@ -278,16 +278,16 @@ static bool cache_insert(Text *ed, Piece *p, size_t off, const char *data, size_ * performed if the piece is the most recenetly changed one and the whole * affected range lies within it. the legnth of the piece, the span containing it * and the whole text is adjusted accordingly */ -static bool cache_delete(Text *ed, Piece *p, size_t off, size_t len) { - if (!cache_contains(ed, p)) +static bool cache_delete(Text *txt, Piece *p, size_t off, size_t len) { + if (!cache_contains(txt, p)) return false; - Buffer *buf = ed->buffers; + Buffer *buf = txt->buffers; size_t bufpos = p->data + off - buf->data; if (off + len > p->len || !buffer_delete(buf, bufpos, len)) return false; p->len -= len; - ed->current_action->change->new.len -= len; - ed->size -= len; + txt->current_action->change->new.len -= len; + txt->size -= len; return true; } @@ -311,7 +311,7 @@ static void span_init(Span *span, Piece *start, Piece *end) { * * adjusts the document size accordingly. */ -static void span_swap(Text *ed, Span *old, Span *new) { +static void span_swap(Text *txt, Span *old, Span *new) { /* TODO use a balanced search tree to keep the pieces instead of a doubly linked list. */ @@ -330,8 +330,8 @@ static void span_swap(Text *ed, Span *old, Span *new) { old->start->prev->next = new->start; old->end->next->prev = new->end; } - ed->size -= old->len; - ed->size += new->len; + txt->size -= old->len; + txt->size += new->len; } static void action_push(Action **stack, Action *action) { @@ -348,16 +348,16 @@ static Action *action_pop(Action **stack) { /* allocate a new action, empty the redo stack and push the new action onto * the undo stack. all further changes will be associated with this action. */ -static Action *action_alloc(Text *ed) { +static Action *action_alloc(Text *txt) { Action *old, *new = calloc(1, sizeof(Action)); if (!new) return NULL; new->time = time(NULL); /* throw a away all old redo operations */ - while ((old = action_pop(&ed->redo))) + while ((old = action_pop(&txt->redo))) action_free(old); - ed->current_action = new; - action_push(&ed->undo, new); + txt->current_action = new; + action_push(&txt->undo, new); return new; } @@ -371,16 +371,16 @@ static void action_free(Action *a) { free(a); } -static Piece *piece_alloc(Text *ed) { +static Piece *piece_alloc(Text *txt) { Piece *p = calloc(1, sizeof(Piece)); if (!p) return NULL; - p->editor = ed; - p->index = ++ed->piece_count; - p->global_next = ed->pieces; - if (ed->pieces) - ed->pieces->global_prev = p; - ed->pieces = p; + p->text = txt; + p->index = ++txt->piece_count; + p->global_next = txt->pieces; + if (txt->pieces) + txt->pieces->global_prev = p; + txt->pieces = p; return p; } @@ -391,10 +391,10 @@ static void piece_free(Piece *p) { p->global_prev->global_next = p->global_next; if (p->global_next) p->global_next->global_prev = p->global_prev; - if (p->editor->pieces == p) - p->editor->pieces = p->global_next; - if (p->editor->cache == p) - p->editor->cache = NULL; + if (p->text->pieces == p) + p->text->pieces = p->global_next; + if (p->text->cache == p) + p->text->cache = NULL; free(p); } @@ -413,9 +413,9 @@ static void piece_init(Piece *p, Piece *prev, Piece *next, const char *data, siz * * in particular if pos is zero, the begin sentinel piece is returned. */ -static Location piece_get_intern(Text *ed, size_t pos) { +static Location piece_get_intern(Text *txt, size_t pos) { size_t cur = 0; - for (Piece *p = &ed->begin; p->next; p = p->next) { + for (Piece *p = &txt->begin; p->next; p = p->next) { if (cur <= pos && pos <= cur + p->len) return (Location){ .piece = p, .off = pos - cur }; cur += p->len; @@ -426,9 +426,9 @@ static Location piece_get_intern(Text *ed, size_t pos) { /* similiar to piece_get_intern but usable as a public API. returns the piece * holding the text at byte offset pos. never returns a sentinel piece. */ -static Location piece_get_extern(Text *ed, size_t pos) { +static Location piece_get_extern(Text *txt, size_t pos) { size_t cur = 0; - for (Piece *p = ed->begin.next; p->next; p = p->next) { + for (Piece *p = txt->begin.next; p->next; p = p->next) { if (cur <= pos && pos < cur + p->len) return (Location){ .piece = p, .off = pos - cur }; cur += p->len; @@ -439,10 +439,10 @@ static Location piece_get_extern(Text *ed, size_t pos) { /* allocate a new change, associate it with current action or a newly * allocated one if none exists. */ -static Change *change_alloc(Text *ed) { - Action *a = ed->current_action; +static Change *change_alloc(Text *txt) { + Action *a = txt->current_action; if (!a) { - a = action_alloc(ed); + a = action_alloc(txt); if (!a) return NULL; } @@ -489,23 +489,23 @@ static void change_free(Change *c) { * | | |short| | existing text | | | * \-+ <-- +-----+ <-- +---------------+ <-- +-/ */ -bool text_insert_raw(Text *ed, size_t pos, const char *data, size_t len) { - if (pos > ed->size) +bool text_insert_raw(Text *txt, size_t pos, const char *data, size_t len) { + if (pos > txt->size) return false; - if (pos < ed->lines.pos) - lineno_cache_invalidate(&ed->lines); + if (pos < txt->lines.pos) + lineno_cache_invalidate(&txt->lines); - Location loc = piece_get_intern(ed, pos); + Location loc = piece_get_intern(txt, pos); Piece *p = loc.piece; size_t off = loc.off; - if (cache_insert(ed, p, off, data, len)) + if (cache_insert(txt, p, off, data, len)) return true; - Change *c = change_alloc(ed); + Change *c = change_alloc(txt); if (!c) return false; - if (!(data = buffer_store(ed, data, len))) + if (!(data = buffer_store(txt, data, len))) return false; Piece *new = NULL; @@ -513,7 +513,7 @@ bool text_insert_raw(Text *ed, size_t pos, const char *data, size_t len) { if (off == p->len) { /* insert between two existing pieces, hence there is nothing to * remove, just add a new piece holding the extra text */ - if (!(new = piece_alloc(ed))) + if (!(new = piece_alloc(txt))) return false; piece_init(new, p, p->next, data, len); span_init(&c->new, new, new); @@ -524,9 +524,9 @@ bool text_insert_raw(Text *ed, size_t pos, const char *data, size_t len) { * before the insertion point then one holding the newly inserted * text and one holding the content after the insertion point. */ - Piece *before = piece_alloc(ed); - new = piece_alloc(ed); - Piece *after = piece_alloc(ed); + Piece *before = piece_alloc(txt); + new = piece_alloc(txt); + Piece *after = piece_alloc(txt); if (!before || !new || !after) return false; piece_init(before, p->prev, new, p->data, off); @@ -537,40 +537,40 @@ bool text_insert_raw(Text *ed, size_t pos, const char *data, size_t len) { span_init(&c->old, p, p); } - cache_piece(ed, new); - span_swap(ed, &c->old, &c->new); + cache_piece(txt, new); + span_swap(txt, &c->old, &c->new); return true; } -bool text_insert(Text *ed, size_t pos, const char *data) { - return text_insert_raw(ed, pos, data, strlen(data)); +bool text_insert(Text *txt, size_t pos, const char *data) { + return text_insert_raw(txt, pos, data, strlen(data)); } /* undo all changes of the last action, return whether changes existed */ -bool text_undo(Text *ed) { - Action *a = action_pop(&ed->undo); +bool text_undo(Text *txt) { + Action *a = action_pop(&txt->undo); if (!a) return false; for (Change *c = a->change; c; c = c->next) { - span_swap(ed, &c->new, &c->old); + span_swap(txt, &c->new, &c->old); } - action_push(&ed->redo, a); - lineno_cache_invalidate(&ed->lines); + action_push(&txt->redo, a); + lineno_cache_invalidate(&txt->lines); return true; } /* redo all changes of the last action, return whether changes existed */ -bool text_redo(Text *ed) { - Action *a = action_pop(&ed->redo); +bool text_redo(Text *txt) { + Action *a = action_pop(&txt->redo); if (!a) return false; for (Change *c = a->change; c; c = c->next) { - span_swap(ed, &c->old, &c->new); + span_swap(txt, &c->old, &c->new); } - action_push(&ed->undo, a); - lineno_cache_invalidate(&ed->lines); + action_push(&txt->undo, a); + lineno_cache_invalidate(&txt->lines); return true; } @@ -578,7 +578,7 @@ bool text_redo(Text *ed) { * a file called `.filename.tmp` and then atomically moved to its final * (possibly alredy existing) destination using rename(2). */ -int text_save(Text *ed, const char *filename) { +int text_save(Text *txt, const char *filename) { size_t len = strlen(filename) + 10; char tmpname[len]; snprintf(tmpname, len, ".%s.tmp", filename); @@ -587,29 +587,29 @@ int text_save(Text *ed, const char *filename) { int fd = open(tmpname, O_CREAT|O_RDWR|O_TRUNC, S_IRUSR|S_IWUSR); if (fd == -1) return -1; - if (ftruncate(fd, ed->size) == -1) + if (ftruncate(fd, txt->size) == -1) goto err; - if (ed->size > 0) { - void *buf = mmap(NULL, ed->size, PROT_WRITE, MAP_SHARED, fd, 0); + if (txt->size > 0) { + void *buf = mmap(NULL, txt->size, PROT_WRITE, MAP_SHARED, fd, 0); if (buf == MAP_FAILED) goto err; char *cur = buf; - text_iterate(ed, it, 0) { + text_iterate(txt, it, 0) { size_t len = it.end - it.start; memcpy(cur, it.start, len); cur += len; } - if (munmap(buf, ed->size) == -1) + if (munmap(buf, txt->size) == -1) goto err; } if (close(fd) == -1) return -1; if (rename(tmpname, filename) == -1) return -1; - ed->saved_action = ed->undo; - text_snapshot(ed); + txt->saved_action = txt->undo; + text_snapshot(txt); return 0; err: close(fd); @@ -619,43 +619,43 @@ err: /* load the given file as starting point for further editing operations. * to start with an empty document, pass NULL as filename. */ Text *text_load(const char *filename) { - Text *ed = calloc(1, sizeof(Text)); - if (!ed) + Text *txt = calloc(1, sizeof(Text)); + if (!txt) return NULL; - ed->begin.index = 1; - ed->end.index = 2; - ed->piece_count = 2; - piece_init(&ed->begin, NULL, &ed->end, NULL, 0); - piece_init(&ed->end, &ed->begin, NULL, NULL, 0); - lineno_cache_invalidate(&ed->lines); + txt->begin.index = 1; + txt->end.index = 2; + txt->piece_count = 2; + piece_init(&txt->begin, NULL, &txt->end, NULL, 0); + piece_init(&txt->end, &txt->begin, NULL, NULL, 0); + lineno_cache_invalidate(&txt->lines); if (filename) { - ed->filename = strdup(filename); - ed->fd = open(filename, O_RDONLY); - if (ed->fd == -1) + txt->filename = strdup(filename); + txt->fd = open(filename, O_RDONLY); + if (txt->fd == -1) goto out; - if (fstat(ed->fd, &ed->info) == -1) + if (fstat(txt->fd, &txt->info) == -1) goto out; - if (!S_ISREG(ed->info.st_mode)) + if (!S_ISREG(txt->info.st_mode)) goto out; // XXX: use lseek(fd, 0, SEEK_END); instead? - ed->buf.size = ed->info.st_size; - ed->buf.data = mmap(NULL, ed->info.st_size, PROT_READ, MAP_SHARED, ed->fd, 0); - if (ed->buf.data == MAP_FAILED) + txt->buf.size = txt->info.st_size; + txt->buf.data = mmap(NULL, txt->info.st_size, PROT_READ, MAP_SHARED, txt->fd, 0); + if (txt->buf.data == MAP_FAILED) goto out; - Piece *p = piece_alloc(ed); + Piece *p = piece_alloc(txt); if (!p) goto out; - piece_init(&ed->begin, NULL, p, NULL, 0); - piece_init(p, &ed->begin, &ed->end, ed->buf.data, ed->buf.size); - piece_init(&ed->end, p, NULL, NULL, 0); - ed->size = ed->buf.size; + piece_init(&txt->begin, NULL, p, NULL, 0); + piece_init(p, &txt->begin, &txt->end, txt->buf.data, txt->buf.size); + piece_init(&txt->end, p, NULL, NULL, 0); + txt->size = txt->buf.size; } - return ed; + return txt; out: - if (ed->fd > 2) - close(ed->fd); - text_free(ed); + if (txt->fd > 2) + close(txt->fd); + text_free(txt); return NULL; } @@ -669,8 +669,8 @@ static void print_piece(Piece *p) { write(2, "\n", 1); } -void text_debug(Text *ed) { - for (Piece *p = &ed->begin; p; p = p->next) { +void text_debug(Text *txt) { + for (Piece *p = &txt->begin; p; p = p->next) { print_piece(p); } } @@ -689,22 +689,22 @@ void text_debug(Text *ed) { * | | | exi| |t | | | * \-+ <-- +----+ <-- +--+ <-- +-/ */ -bool text_delete(Text *ed, size_t pos, size_t len) { +bool text_delete(Text *txt, size_t pos, size_t len) { if (len == 0) return true; - if (pos + len > ed->size) + if (pos + len > txt->size) return false; - if (pos < ed->lines.pos) - lineno_cache_invalidate(&ed->lines); + if (pos < txt->lines.pos) + lineno_cache_invalidate(&txt->lines); - Location loc = piece_get_intern(ed, pos); + Location loc = piece_get_intern(txt, pos); Piece *p = loc.piece; size_t off = loc.off; - if (cache_delete(ed, p, off, len)) + if (cache_delete(txt, p, off, len)) return true; size_t cur; // how much has already been deleted bool midway_start = false, midway_end = false; - Change *c = change_alloc(ed); + Change *c = change_alloc(txt); if (!c) return false; Piece *before, *after; // unmodified pieces before / after deletion point @@ -719,7 +719,7 @@ bool text_delete(Text *ed, size_t pos, size_t len) { midway_start = true; cur = p->len - off; start = p; - before = piece_alloc(ed); + before = piece_alloc(txt); } /* skip all pieces which fall into deletion range */ while (cur < len) { @@ -735,7 +735,7 @@ bool text_delete(Text *ed, size_t pos, size_t len) { /* deletion stops midway through a piece */ midway_end = true; end = p; - after = piece_alloc(ed); + after = piece_alloc(txt); piece_init(after, before, p->next, p->data + p->len - (cur - len), cur - len); } @@ -758,46 +758,46 @@ bool text_delete(Text *ed, size_t pos, size_t len) { span_init(&c->new, new_start, new_end); span_init(&c->old, start, end); - span_swap(ed, &c->old, &c->new); + span_swap(txt, &c->old, &c->new); return true; } /* preserve the current text content such that it can be restored by * means of undo/redo operations */ -void text_snapshot(Text *ed) { - ed->current_action = NULL; - ed->cache = NULL; +void text_snapshot(Text *txt) { + txt->current_action = NULL; + txt->cache = NULL; } -void text_free(Text *ed) { - if (!ed) +void text_free(Text *txt) { + if (!txt) return; Action *a; - while ((a = action_pop(&ed->undo))) + while ((a = action_pop(&txt->undo))) action_free(a); - while ((a = action_pop(&ed->redo))) + while ((a = action_pop(&txt->redo))) action_free(a); - for (Piece *next, *p = ed->pieces; p; p = next) { + for (Piece *next, *p = txt->pieces; p; p = next) { next = p->global_next; piece_free(p); } - for (Buffer *next, *buf = ed->buffers; buf; buf = next) { + for (Buffer *next, *buf = txt->buffers; buf; buf = next) { next = buf->next; buffer_free(buf); } - if (ed->buf.data) - munmap(ed->buf.data, ed->buf.size); + if (txt->buf.data) + munmap(txt->buf.data, txt->buf.size); - free((char*)ed->filename); - free(ed); + free((char*)txt->filename); + free(txt); } -bool text_modified(Text *ed) { - return ed->saved_action != ed->undo; +bool text_modified(Text *txt) { + return txt->saved_action != txt->undo; } static bool text_iterator_init(Iterator *it, size_t pos, Piece *p, size_t off) { @@ -811,9 +811,9 @@ static bool text_iterator_init(Iterator *it, size_t pos, Piece *p, size_t off) { return text_iterator_valid(it); } -Iterator text_iterator_get(Text *ed, size_t pos) { +Iterator text_iterator_get(Text *txt, size_t pos) { Iterator it; - Location loc = piece_get_extern(ed, pos); + Location loc = piece_get_extern(txt, pos); text_iterator_init(&it, pos, loc.piece, loc.off); return it; } @@ -836,7 +836,7 @@ bool text_iterator_prev(Iterator *it) { bool text_iterator_valid(const Iterator *it) { /* filter out sentinel nodes */ - return it->piece && it->piece->editor; + return it->piece && it->piece->text; } bool text_iterator_byte_next(Iterator *it, char *b) { @@ -891,16 +891,16 @@ bool text_iterator_char_prev(Iterator *it, char *c) { return false; } -bool text_byte_get(Text *ed, size_t pos, char *buf) { - return text_bytes_get(ed, pos, 1, buf); +bool text_byte_get(Text *txt, size_t pos, char *buf) { + return text_bytes_get(txt, pos, 1, buf); } -size_t text_bytes_get(Text *ed, size_t pos, size_t len, char *buf) { +size_t text_bytes_get(Text *txt, size_t pos, size_t len, char *buf) { if (!buf) return 0; char *cur = buf; size_t rem = len; - text_iterate(ed, it, pos) { + text_iterate(txt, it, pos) { if (rem == 0) break; size_t piece_len = it.end - it.text; @@ -913,14 +913,14 @@ size_t text_bytes_get(Text *ed, size_t pos, size_t len, char *buf) { return len - rem; } -size_t text_size(Text *ed) { - return ed->size; +size_t text_size(Text *txt) { + return txt->size; } /* count the number of new lines '\n' in range [pos, pos+len) */ -static size_t lines_count(Text *ed, size_t pos, size_t len) { +static size_t lines_count(Text *txt, size_t pos, size_t len) { size_t lines = 0; - text_iterate(ed, it, pos) { + text_iterate(txt, it, pos) { const char *start = it.text; while (len > 0 && start < it.end) { size_t n = MIN(len, (size_t)(it.end - start)); @@ -941,8 +941,8 @@ static size_t lines_count(Text *ed, size_t pos, size_t len) { } /* skip n lines forward and return position afterwards */ -static size_t lines_skip_forward(Text *ed, size_t pos, size_t lines) { - text_iterate(ed, it, pos) { +static size_t lines_skip_forward(Text *txt, size_t pos, size_t lines) { + text_iterate(txt, it, pos) { const char *start = it.text; while (lines > 0 && start < it.end) { size_t n = it.end - start; @@ -970,58 +970,58 @@ static void lineno_cache_invalidate(LineCache *cache) { cache->lineno = 1; } -size_t text_pos_by_lineno(Text *ed, size_t lineno) { - LineCache *cache = &ed->lines; +size_t text_pos_by_lineno(Text *txt, size_t lineno) { + LineCache *cache = &txt->lines; if (lineno <= 1) return 0; if (lineno > cache->lineno) { - cache->pos = lines_skip_forward(ed, cache->pos, lineno - cache->lineno); + cache->pos = lines_skip_forward(txt, cache->pos, lineno - cache->lineno); } else if (lineno < cache->lineno) { #if 0 // TODO does it make sense to scan memory backwards here? size_t diff = cache->lineno - lineno; if (diff < lineno) { - lines_skip_backward(ed, cache->pos, diff); + lines_skip_backward(txt, cache->pos, diff); } else #endif - cache->pos = lines_skip_forward(ed, 0, lineno - 1); + cache->pos = lines_skip_forward(txt, 0, lineno - 1); } cache->lineno = lineno; return cache->pos; } -size_t text_lineno_by_pos(Text *ed, size_t pos) { - LineCache *cache = &ed->lines; - if (pos > ed->size) - pos = ed->size; +size_t text_lineno_by_pos(Text *txt, size_t pos) { + LineCache *cache = &txt->lines; + if (pos > txt->size) + pos = txt->size; if (pos < cache->pos) { size_t diff = cache->pos - pos; if (diff < pos) - cache->lineno -= lines_count(ed, pos, diff); + cache->lineno -= lines_count(txt, pos, diff); else - cache->lineno = lines_count(ed, 0, pos) + 1; + cache->lineno = lines_count(txt, 0, pos) + 1; } else if (pos > cache->pos) { - cache->lineno += lines_count(ed, cache->pos, pos - cache->pos); + cache->lineno += lines_count(txt, cache->pos, pos - cache->pos); } cache->pos = pos; return cache->lineno; } -void text_mark_set(Text *ed, Mark mark, size_t pos) { - if (mark < 0 || mark >= LENGTH(ed->marks)) +void text_mark_set(Text *txt, Mark mark, size_t pos) { + if (mark < 0 || mark >= LENGTH(txt->marks)) return; - Location loc = piece_get_extern(ed, pos); + Location loc = piece_get_extern(txt, pos); if (!loc.piece) return; - ed->marks[mark] = loc.piece->data + loc.off; + txt->marks[mark] = loc.piece->data + loc.off; } -size_t text_mark_get(Text *ed, Mark mark) { - if (mark < 0 || mark >= LENGTH(ed->marks)) +size_t text_mark_get(Text *txt, Mark mark) { + if (mark < 0 || mark >= LENGTH(txt->marks)) return -1; - const char *pos = ed->marks[mark]; + const char *pos = txt->marks[mark]; size_t cur = 0; - for (Piece *p = ed->begin.next; p->next; p = p->next) { + for (Piece *p = txt->begin.next; p->next; p = p->next) { if (p->data <= pos && pos < p->data + p->len) return cur + (pos - p->data); cur += p->len; @@ -1030,19 +1030,19 @@ size_t text_mark_get(Text *ed, Mark mark) { return -1; } -void text_mark_clear(Text *ed, Mark mark) { - if (mark < 0 || mark >= LENGTH(ed->marks)) +void text_mark_clear(Text *txt, Mark mark) { + if (mark < 0 || mark >= LENGTH(txt->marks)) return; - ed->marks[mark] = NULL; + txt->marks[mark] = NULL; } -void text_mark_clear_all(Text *ed) { - for (Mark mark = 0; mark < LENGTH(ed->marks); mark++) - text_mark_clear(ed, mark); +void text_mark_clear_all(Text *txt) { + for (Mark mark = 0; mark < LENGTH(txt->marks); mark++) + text_mark_clear(txt, mark); } -const char *text_filename(Text *ed) { - return ed->filename; +const char *text_filename(Text *txt) { + return txt->filename; } Regex *text_regex_new(void) { @@ -1058,11 +1058,11 @@ void text_regex_free(Regex *r) { regfree(&r->regex); } -int text_search_forward(Text *ed, size_t pos, size_t len, Regex *r, size_t nmatch, RegexMatch pmatch[], int eflags) { +int text_search_forward(Text *txt, size_t pos, size_t len, Regex *r, size_t nmatch, RegexMatch pmatch[], int eflags) { char *buf = malloc(len + 1); if (!buf) return REG_NOMATCH; - len = text_bytes_get(ed, pos, len, buf); + len = text_bytes_get(txt, pos, len, buf); buf[len] = '\0'; regmatch_t match[nmatch]; int ret = regexec(&r->regex, buf, nmatch, match, eflags); @@ -1076,11 +1076,11 @@ int text_search_forward(Text *ed, size_t pos, size_t len, Regex *r, size_t nmatc return ret; } -int text_search_backward(Text *ed, size_t pos, size_t len, Regex *r, size_t nmatch, RegexMatch pmatch[], int eflags) { +int text_search_backward(Text *txt, size_t pos, size_t len, Regex *r, size_t nmatch, RegexMatch pmatch[], int eflags) { char *buf = malloc(len + 1); if (!buf) return REG_NOMATCH; - len = text_bytes_get(ed, pos, len, buf); + len = text_bytes_get(txt, pos, len, buf); buf[len] = '\0'; regmatch_t match[nmatch]; char *cur = buf; diff --git a/text.h b/text.h index 9d4fa34..27693ef 100644 --- a/text.h +++ b/text.h @@ -19,8 +19,8 @@ typedef struct { size_t pos; /* global position in bytes from start of file */ } Iterator; -#define text_iterate(ed, it, pos) \ - for (Iterator it = text_iterator_get((ed), (pos)); \ +#define text_iterate(txt, it, pos) \ + for (Iterator it = text_iterator_get((txt), (pos)); \ text_iterator_valid(&it); \ text_iterator_next(&it)) @@ -36,7 +36,7 @@ bool text_redo(Text*); size_t text_pos_by_lineno(Text*, size_t lineno); size_t text_lineno_by_pos(Text*, size_t pos); -bool text_byte_get(Text *ed, size_t pos, char *buf); +bool text_byte_get(Text*, size_t pos, char *buf); size_t text_bytes_get(Text*, size_t pos, size_t len, char *buf); Iterator text_iterator_get(Text*, size_t pos); @@ -44,12 +44,12 @@ bool text_iterator_valid(const Iterator*); bool text_iterator_next(Iterator*); bool text_iterator_prev(Iterator*); -bool text_iterator_byte_get(Iterator *it, char *b); +bool text_iterator_byte_get(Iterator*, char *b); bool text_iterator_byte_next(Iterator*, char *b); bool text_iterator_byte_prev(Iterator*, char *b); -bool text_iterator_char_next(Iterator *it, char *c); -bool text_iterator_char_prev(Iterator *it, char *c); +bool text_iterator_char_next(Iterator*, char *c); +bool text_iterator_char_prev(Iterator*, char *c); typedef int Mark; void text_mark_set(Text*, Mark, size_t pos); @@ -76,6 +76,6 @@ int text_search_forward(Text*, size_t pos, size_t len, Regex *r, size_t nmatch, int text_search_backward(Text*, size_t pos, size_t len, Regex *r, size_t nmatch, RegexMatch pmatch[], int eflags); // TMP -void text_debug(Text *ed); +void text_debug(Text*); #endif -- cgit v1.2.3