git.mutantstargoat.com Git - visor/blob - libvisor/src/visor.c

   1 /*
   2 visor - lightweight system-independent embeddable text editor framework
   3 Copyright (C)  2019 John Tsiombikas <nuclear@member.fsf.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program.  If not, see <https://www.gnu.org/licenses/>.
  17 */
  18
  19 #include "vilibc.h"
  20 #include "visor.h"
  21 #include "vimpl.h"
  22
  23 #define vi_malloc       vi->mm.malloc
  24 #define vi_free         vi->mm.free
  25 #define vi_realloc      vi->mm.realloc
  26
  27 #define vi_open         vi->fop.open
  28 #define vi_size         vi->fop.size
  29 #define vi_close        vi->fop.close
  30 #define vi_map          vi->fop.map
  31 #define vi_unmap        vi->fop.unmap
  32 #define vi_read         vi->fop.read
  33 #define vi_write        vi->fop.write
  34 #define vi_seek         vi->fop.seek
  35
  36 #define vi_clear()                      vi->tty.clear(vi->tty_cls)
  37 #define vi_clear_line()         vi->tty.clear_line(vi->tty_cls)
  38 #define vi_clear_line_at(y)     vi->tty.clear_line_at(y, vi->tty_cls)
  39 #define vi_setcursor(x, y)      vi->tty.setcursor(x, y, vi->tty_cls)
  40 #define vi_putchar(c)           vi->tty.putchar(c, vi->tty_cls)
  41 #define vi_putchar_at(x, y, c)  v->tty.putchar_at(x, y, c, vi->tty_cls)
  42 #define vi_scroll(n)            vi->tty.scroll(n, vi->tty_cls)
  43 #define vi_del_back()           vi->tty.del_back(vi->tty_cls)
  44 #define vi_del_fwd()            vi->tty.del_fwd(vi->tty_cls)
  45 #define vi_status(s)            vi->tty.status(s, vi->tty_cls)
  46
  47 static int remove_buf(struct visor *vi, struct vi_buffer *vb);
  48 static int add_span(struct vi_buffer *vb, vi_addr at, int src, vi_addr start, unsigned long size);
  49
  50 #ifdef HAVE_LIBC
  51 static const struct vi_alloc stdalloc = { malloc, free, realloc };
  52 #endif
  53
  54 struct visor *vi_create(struct vi_alloc *mm)
  55 {
  56         struct visor *vi;
  57
  58 #ifdef HAVE_LIBC
  59         if(!mm) mm = &stdalloc;
  60 #else
  61         if(!mm) return 0;
  62 #endif
  63
  64         if(!(vi = mm->malloc(sizeof *vi))) {
  65                 return 0;
  66         }
  67         memset(vi, 0, sizeof *vi);
  68         vi->mm = *mm;
  69
  70         vi->term_width = 80;
  71         vi->term_height = 24;
  72
  73         return vi;
  74 }
  75
  76 void vi_destroy(struct visor *vi)
  77 {
  78         while(vi->buflist) {
  79                 vi_delete_buf(vi, vi->buflist);
  80         }
  81         vi_free(vi);
  82 }
  83
  84 void vi_set_fileops(struct visor *vi, struct vi_fileops *fop)
  85 {
  86         vi->fop = *fop;
  87 }
  88
  89 void vi_set_ttyops(struct visor *vi, struct vi_ttyops *tty)
  90 {
  91         vi->tty = *tty;
  92 }
  93
  94 void vi_term_size(struct visor *vi, int xsz, int ysz)
  95 {
  96         vi->term_width = xsz;
  97         vi->term_height = ysz;
  98 }
  99
 100 void vi_redraw(struct visor *vi)
 101 {
 102         struct vi_buffer *vb;
 103         struct vi_span *sp, *spend;
 104         vi_addr spoffs;
 105
 106         vb = vi->buflist;
 107         if(!(sp = vi_buf_find_span(vb, vi->view_start, &spoffs))) {
 108                 sp = vb->spans;
 109                 spoffs = 0;
 110         }
 111         spend = vb->spans + vb->num_spans;
 112
 113         vi_clear();
 114
 115         for(i=0; i<term_heig
 116 }
 117
 118 struct vi_buffer *vi_new_buf(struct visor *vi, const char *path)
 119 {
 120         struct vi_buffer *nb;
 121
 122         if(!(nb = vi_malloc(sizeof *nb))) {
 123                 vi_error(vi, "failed to allocate new buffer\n");
 124                 return 0;
 125         }
 126         memset(nb, 0, sizeof *nb);
 127         nb->vi = vi;
 128
 129         if(path) {
 130                 if(vi_buf_read(nb, path) == -1) {
 131                         vi_free(nb);
 132                         return 0;
 133                 }
 134         }
 135
 136         if(vi->buflist) {
 137                 struct vi_buffer *last = vi->buflist->prev;
 138                 nb->prev = last;
 139                 nb->next = vi->buflist;
 140                 last->next = nb;
 141                 vi->buflist->prev = nb;
 142         } else {
 143                 nb->next = nb->prev = nb;
 144                 vi->buflist = nb;
 145         }
 146         return nb;
 147 }
 148
 149 static int remove_buf(struct visor *vi, struct vi_buffer *vb)
 150 {
 151         if(!vi->buflist) {
 152                 vi_error(vi, "failed to remove a buffer which doesn't exist\n");
 153                 return -1;
 154         }
 155
 156         if(vb->next == vb) {
 157                 if(vi->buflist != vb) {
 158                         vi_error(vi, "failed to remove buffer, buffer list inconsistency\n");
 159                         return -1;
 160                 }
 161                 vi->buflist = 0;
 162                 return 0;
 163         }
 164
 165         if(vi->buflist == vb) {
 166                 vi->buflist = vb->next;
 167         }
 168         vb->prev->next = vb->next;
 169         vb->next->prev = vb->prev;
 170         vb->next = vb->prev = vb;
 171         return 0;
 172 }
 173
 174 int vi_delete_buf(struct visor *vi, struct vi_buffer *vb)
 175 {
 176         if(remove_buf(vi, vb) == -1) {
 177                 return -1;
 178         }
 179
 180         vi_free(vb->path);
 181         vi_free(vb->orig);
 182         vi_free(vb->add);
 183         vi_free(vb->spans);
 184         return 0;
 185 }
 186
 187 int vi_num_buf(struct visor *vi)
 188 {
 189         int count;
 190         struct vi_buffer *vb;
 191
 192         if(!vi->buflist) return 0;
 193
 194         count = 1;
 195         vb = vi->buflist->next;
 196         while(vb != vi->buflist) {
 197                 count++;
 198                 vb = vb->next;
 199         }
 200         return count;
 201 }
 202
 203 struct vi_buffer *vi_getcur_buf(struct visor *vi)
 204 {
 205         return vi->buflist;
 206 }
 207
 208 void vi_setcur_buf(struct visor *vi, struct vi_buffer *vb)
 209 {
 210         vi->buflist = vb;
 211 }
 212
 213 struct vi_buffer *vi_next_buf(struct visor *vi)
 214 {
 215         return vi->buflist ? vi->buflist->next : 0;
 216 }
 217
 218 struct vi_buffer *vi_prev_buf(struct visor *vi)
 219 {
 220         return vi->buflist ? vi->buflist->prev : 0;
 221 }
 222
 223 /* split_span splits the span sp. if size > 0 it moves the second part to sp+2,
 224  * leaving an empty place at sp+1 for the new span. The start point of the
 225  * second part is adjusted by size.
 226  *
 227  * It can't fail, because it's always called with the span array having at
 228  * least two empty slots (see: add_span).
 229  */
 230 void split_span(struct vi_buffer *vb, struct vi_span *sp, vi_addr spoffs, unsigned long size)
 231 {
 232         int newseg = size > 0 ? 1 : 0;
 233         struct vi_span *tail = sp + newseg + 1;
 234         int num_move = vb->spans + vb->num_spans - sp - 1;
 235
 236         memmove(tail + 1, sp + 1, num_move * sizeof *sp);
 237         vb->num_spans += tail - sp;
 238
 239         *tail = *sp;
 240         sp->size = spoffs;
 241         tail->start += spoffs;
 242         tail->size -= spoffs;
 243
 244         sp = tail;
 245         for(;;) {
 246                 if(size <= tail->size) {
 247                         tail->size -= size;
 248                         break;
 249                 }
 250                 size -= tail->size;
 251                 tail->size = 0;
 252                 tail++;
 253         }
 254
 255         if(tail > sp) {
 256                 /* we produced one or more zero-sized spans, drop them */
 257                 num_move = vb->num_spans - (tail - sp);
 258                 memmove(sp, tail, num_move * sizeof *sp);
 259                 vb->num_spans -= num_move;
 260         }
 261 }
 262
 263 static int add_span(struct vi_buffer *vb, vi_addr at, int src, vi_addr start, unsigned long size)
 264 {
 265         struct visor *vi = vb->vi;
 266         struct vi_span *sp;
 267         vi_addr spoffs;
 268
 269         /* make sure we have space for at least two new spans (split + add) */
 270         if(vb->num_spans + 1 >= vb->max_spans) {
 271                 int newmax = vb->max_spans > 0 ? (vb->max_spans << 1) : 16;
 272                 struct vi_span *tmp = vi_realloc(vb->spans, newmax * sizeof *tmp);
 273                 if(!tmp) return -1;
 274                 vb->spans = tmp;
 275                 vb->max_spans = newmax;
 276         }
 277
 278         if((sp = vi_buf_find_span(vb, at, &spoffs))) {
 279                 if(spoffs > 0) {
 280                         split_span(vb, sp++, spoffs, 1);
 281                 } else {
 282                         split_span(vb, sp++, 0, 0);
 283                 }
 284         } else {
 285                 sp = vb->spans + vb->num_spans;
 286         }
 287
 288         sp->src = src;
 289         sp->start = start;
 290         sp->size = size;
 291         vb->num_spans++;
 292         return 0;
 293 }
 294
 295 void vi_buf_reset(struct vi_buffer *vb)
 296 {
 297         struct visor *vi = vb->vi;
 298         struct vi_buffer *prev, *next;
 299
 300         vi_free(vb->path);
 301
 302         if(vb->fp) {
 303                 if(vb->file_mapped) vi_unmap(vb->fp);
 304                 vi_close(vb->fp);
 305         }
 306         vi_free(vb->orig);
 307         vi_free(vb->add);
 308         vi_free(vb->spans);
 309
 310         prev = vb->prev;
 311         next = vb->next;
 312         memset(vb, 0, sizeof *vb);
 313         vb->prev = prev;
 314         vb->next = next;
 315         vb->vi = vi;
 316 }
 317
 318 int vi_buf_read(struct vi_buffer *vb, const char *path)
 319 {
 320         struct visor *vi = vb->vi;
 321         vi_file *fp;
 322         unsigned long fsz;
 323         int plen;
 324
 325         vi_buf_reset(vb);
 326
 327         if(!(fp = vi_open(path, VI_RDONLY | VI_CREAT))) {
 328                 return -1;
 329         }
 330         plen = strlen(path);
 331         if(!(vb->path = vi_malloc(plen + 1))) {
 332                 vi_error(vi, "failed to allocate path name buffer\n");
 333                 vi_buf_reset(vb);
 334                 return -1;
 335         }
 336         memcpy(vb->path, path, plen + 1);
 337
 338         vb->num_spans = 0;
 339
 340         if((fsz = vi_size(fp))) {
 341                 /* existing file, map it into memory, or failing that read it */
 342                 if(!vi->fop.map || !(vb->orig = vi_map(fp))) {
 343                         if(!(vb->orig = vi_malloc(fsz))) {
 344                                 vi_buf_reset(vb);
 345                                 return -1;
 346                         }
 347                 } else {
 348                         vb->file_mapped = 1;
 349                 }
 350
 351                 if(add_span(vb, 0, SPAN_ORIG, 0, fsz) == -1) {
 352                         vi_error(vi, "failed to allocate span\n");
 353                         vi_buf_reset(vb);
 354                         return -1;
 355                 }
 356         }
 357         vb->orig_size = fsz;
 358         return 0;
 359 }
 360
 361 int vi_buf_write(struct vi_buffer *vb, const char *path)
 362 {
 363         int i, wbuf_count;
 364         struct visor *vi = vb->vi;
 365         vi_file *fp;
 366         static char wbuf[512];
 367
 368         if(!path) path = vb->path;
 369         if(!path) {
 370                 vi_error(vi, "failed to write buffer, unknown path\n");
 371                 return -1;
 372         }
 373
 374         if(!(fp = vi_open(path, VI_WRONLY | VI_CREAT))) {
 375                 vi_error(vi, "failed to open %s for writing\n", path);
 376                 return -1;
 377         }
 378
 379         wbuf_count = 0;
 380         for(i=0; i<vb->num_spans; i++) {
 381                 struct vi_span *sp = vb->spans + i;
 382                 const char *sptxt = vi_buf_span_text(vb, sp);
 383                 int n, count = 0;
 384                 while(count < sp->size) {
 385                         n = sp->size - count;
 386                         if(n > sizeof wbuf - wbuf_count) {
 387                                 n = sizeof wbuf - wbuf_count;
 388                         }
 389                         memcpy(wbuf + wbuf_count, sptxt + count, n);
 390                         count += n;
 391                         wbuf_count += n;
 392                 }
 393
 394                 if(wbuf_count >= sizeof wbuf) {
 395                         vi_write(fp, wbuf, wbuf_count);
 396                 }
 397         }
 398
 399         if(wbuf_count > 0) {
 400                 vi_write(fp, wbuf, wbuf_count);
 401         }
 402         vi_close(fp);
 403         return 0;
 404 }
 405
 406 long vi_buf_size(struct vi_buffer *vb)
 407 {
 408         int i;
 409         long sz = 0;
 410
 411         for(i=0; i<vb->num_spans; i++) {
 412                 sz += vb->spans[i].size;
 413         }
 414         return sz;
 415 }
 416
 417 struct vi_span *vi_buf_find_span(struct vi_buffer *vb, vi_addr at, vi_addr *soffs)
 418 {
 419         int i;
 420         long sz = 0, prev_sz;
 421
 422         for(i=0; i<vb->num_spans; i++) {
 423                 prev_sz = sz;
 424                 sz += vb->spans[i].size;
 425                 if(sz > at) {
 426                         if(soffs) *soffs = at - prev_sz;
 427                         return vb->spans + i;
 428                 }
 429         }
 430         return 0;
 431 }
 432
 433 const char *vi_buf_span_text(struct vi_buffer *vb, struct vi_span *sp)
 434 {
 435         const char *buf = sp->src == SPAN_ORIG ? vb->orig : vb->add;
 436         return buf + sp->start;
 437 }