Subversion Repositories SvarDOS

/* Sved, the SvarDOS editor

 *

 * Copyright (C) 2023 Mateusz Viste

 *

 * Sved is released under the terms of the MIT license.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

#include <dos.h>      /* _dos_open(), _dos_read(), _dos_close(), ... */

#include <fcntl.h>    /* O_RDONLY, O_WRONLY */

#include <string.h>

#include "mdr\bios.h"

#include "mdr\cout.h"

#include "mdr\dos.h"

#include "svarlang\svarlang.h"

#define PVER "2023.0"

#define PDATE "2023"

/*****************************************************************************

 * global variables and definitions                                          *

 *****************************************************************************/

/* preload the mono scheme (to be overloaded at runtime if color adapter present) */

static unsigned char SCHEME_TEXT   = 0x07,

                     SCHEME_MENU   = 0x70,

                     SCHEME_MENU_CUR= 0x0f,

                     SCHEME_MENU_SEL= 0x00,

                     SCHEME_STBAR1 = 0x70,

                     SCHEME_STBAR2 = 0x70, /* greyed out information */

                     SCHEME_STBAR3 = 0x70, /* query */

                     SCHEME_SCROLL = 0x70,

                     SCHEME_MSG    = 0x70,

                     SCHEME_ERR    = 0x70;

static unsigned char screenw, screenh, screenlastrow, screenlastcol;

static unsigned char glob_monomode, glob_tablessmode;

static struct {

    unsigned char from;

    unsigned char to;

    unsigned char statusbar;

} uidirty = {0, 0xff, 1}; /* make sure to redraw entire UI at first run */

#define SCROLL_CURSOR 0xB1

struct line {

  unsigned short len;

  struct line far *next;

  struct line far *prev;

  char payload[1];

};

struct file {

  struct line far *cursor;

  unsigned short xoffset;

  unsigned short cursorposx;

  unsigned short cursorposy;

  unsigned short totlines;

  unsigned short curline;

  char lfonly;   /* set if line endings are LF (CR/LF otherwise) */

  char modflag;  /* non-zero if file has been modified since last save */

  char modflagprev;

  char fname[128];

};

/*****************************************************************************

 * functions                                                                 *

 *****************************************************************************/

static struct line far *line_calloc(unsigned short siz) {

  struct line far *res;

  unsigned int seg;

  if (_dos_allocmem((sizeof(struct line) + siz + 15) / 16, &seg) != 0) return(NULL);

  res = MK_FP(seg, 0);

  _fmemset(res, 0, sizeof(struct line) + siz);

  return(MK_FP(seg, 0));

}

static void line_free(struct line far *ptr) {

  _dos_freemem(FP_SEG(ptr));

}

static int curline_resize(struct file far *db, unsigned short newsiz) {

  unsigned int maxavail;

  struct line far *newptr;

  /* try resizing the block (much faster) */

  if (_dos_setblock((sizeof(struct line) + newsiz + 15) / 16, FP_SEG(db->cursor), &maxavail) == 0) return(0);

  /* create a new block and copy data over */

  newptr = line_calloc(newsiz);

  if (newptr == NULL) return(-1);

  _fmemmove(newptr, db->cursor, sizeof(struct line) + db->cursor->len);

  /* rewire the linked list */

  db->cursor = newptr;

  if (newptr->next) newptr->next->prev = newptr;

  if (newptr->prev) newptr->prev->next = newptr;

  return(0);

}

/* adds a new line at cursor position into file linked list and advance cursor

 * returns non-zero on error */

static int line_add(struct file *db, const char far *line, unsigned short slen) {

  struct line far *l;

  l = line_calloc(slen);

  if (l == NULL) return(-1);

  l->prev = db->cursor;

  if (db->cursor) {

    l->next = db->cursor->next;

    db->cursor->next = l;

    l->next->prev = l;

  }

  db->cursor = l;

  if (slen > 0) {

    _fmemmove(l->payload, line, slen);

    l->len = slen;

  }

  db->totlines += 1;

  db->curline += 1;

  return(0);

}

static void ui_getstring(const char *query, char *s, unsigned short maxlen) {

  unsigned short len = 0;

  unsigned char y, x;

  int k;

  if (maxlen == 0) return;

  maxlen--; /* make room for the nul terminator */

  y = screenlastrow;

  /* print query string */

  x = mdr_cout_str(y, 0, query, SCHEME_STBAR3, 40);

  mdr_cout_char_rep(y, x++, ' ', SCHEME_STBAR3, screenw - x);

  for (;;) {

    mdr_cout_locate(y, x + len);

    k = mdr_dos_getkey2();

    switch (k) {

      case 0x1b: /* ESC */

        s[0] = 0;

        return;

      case '\r':

        s[len] = 0;

        return;

      case 0x08: /* BKSPC */

        if (len > 0) {

          len--;

          mdr_cout_char(y, x + len, ' ', SCHEME_STBAR3);

        }

        break;

      default:

        if ((k <= 0xff) && (k >= ' ') && (len < maxlen)) {

          mdr_cout_char(y, x + len, k, SCHEME_STBAR3);

          s[len++] = k;

        }

    }

  }

}

/* append a nul-terminated string to line at cursor position */

static int line_append(struct file *f, const char far *buf, unsigned short len) {

  if (sizeof(struct line) + f->cursor->len + len < len) goto ERR; /* overflow check */

  if (curline_resize(f, f->cursor->len + len) != 0) goto ERR;

  _fmemmove(f->cursor->payload + f->cursor->len, buf, len);

  f->cursor->len += len;

  return(0);

  ERR:

  return(-1);

}

static void db_rewind(struct file *db) {

  if (db->cursor == NULL) return;

  while (db->cursor->prev) db->cursor = db->cursor->prev;

  db->curline = 0;

}

static void ui_basic(const struct file *db, unsigned char slotnum) {

  const char *s = svarlang_strid(0); /* ESC=MENU */

  unsigned short helpcol = screenw - strlen(s);

  unsigned short maxfnlen = helpcol - 14;

  /* slot number (guaranteed to be 0-9) */

  {

    char slot[4] = "#00";

    if (slotnum == 9) {

      slot[1] = '1';

    } else {

      slotnum++;

      slot[2] += slotnum;

    }

    mdr_cout_str(screenlastrow, 0, slot, SCHEME_STBAR2, 3);

  }

  /* fill rest of status bar with background */

  mdr_cout_char_rep(screenlastrow, 3, ' ', SCHEME_STBAR1, helpcol - 3);

  /* filename and modflag */

  {

    const char *fn;

    unsigned short x;

    if (db->fname[0] == 0) {

      fn = svarlang_str(0, 1); /* "UNTITLED" */

    } else {

      /* display filename up to maxfnlen chars */

      fn = db->fname;

      x = strlen(fn);

      if (x > maxfnlen) fn += x - maxfnlen;

    }

    x = mdr_cout_str(screenlastrow, 4, fn, SCHEME_STBAR1, maxfnlen);

    if (db->modflag) mdr_cout_char(screenlastrow, 5 + x, '!', SCHEME_STBAR2);

  }

  /* eol type */

  {

    const char *eoltype = "CRLF";

    if (db->lfonly) eoltype += 2;

    mdr_cout_str(screenlastrow, helpcol - 6, eoltype, SCHEME_STBAR1, 5);

  }

  mdr_cout_str(screenlastrow, helpcol, s, SCHEME_STBAR2, 40);

}

static void ui_msg(const char *msg1, const char *msg2, unsigned char attr) {

  unsigned short x, y, msglen, i;

  unsigned short msg2flag = 0;

  msglen = strlen(msg1);

  if (msg2) {

    msg2flag = 1;

    i = strlen(msg2);

    if (i > msglen) msglen = i;

  }

  y = (screenh - 6) >> 1;

  x = (screenw - msglen - 4) >> 1;

  for (i = y+2+msg2flag; i >= y; i--) mdr_cout_char_rep(i, x, ' ', attr, msglen + 2);

  x++;

  mdr_cout_str(y+1, x, msg1, attr, msglen);

  if (msg2) mdr_cout_str(y+2, x, msg2, attr, msglen);

  if (uidirty.from > y) uidirty.from = y;

  if (uidirty.to < y+4) uidirty.to = y+4;

}

static unsigned char ui_confirm_if_unsaved(const struct file *db) {

  unsigned char r = 0;

  if (db->modflag == 0) return(0);

  mdr_cout_cursor_hide();

  /* if file has been modified then ask for confirmation */

  ui_msg(svarlang_str(0,4), svarlang_str(0,5), SCHEME_MSG);

  if (mdr_dos_getkey2() != '\r') r = 1;

  mdr_cout_cursor_show();

  return(r);

}

static void ui_refresh(const struct file *db) {

  unsigned char x;

  const struct line far *l;

  unsigned char y = db->cursorposy;

  /* quit early if nothing to refresh */

  if (uidirty.from == 0xff) return;

#ifdef DBG_REFRESH

  static char m = 'a';

  m++;

  if (m > 'z') m = 'a';

#endif

  /* rewind cursor line to first line that needs redrawing */

  for (l = db->cursor; y > uidirty.from; y--) l = l->prev;

  /* iterate over lines and redraw whatever needs to be redrawn */

  for (; l != NULL; l = l->next, y++) {

    /* skip lines that do not need to be refreshed */

    if (y < uidirty.from) continue;

    if (y > uidirty.to) break;

    x = 0;

    if (db->xoffset < l->len) {

      unsigned char i, limit;

      if (l->len - db->xoffset < screenw) {

        limit = l->len;

      } else {

        limit = db->xoffset + screenlastcol;

      }

      for (i = db->xoffset; i < limit; i++) mdr_cout_char(y, x++, l->payload[i], SCHEME_TEXT);

    }

    /* write empty spaces until end of line */

    if (x < screenlastcol) mdr_cout_char_rep(y, x, ' ', SCHEME_TEXT, screenlastcol - x);

#ifdef DBG_REFRESH

    mdr_cout_char(y, 0, m, SCHEME_STBAR1);

#endif

    if (y == screenh - 2) break;

  }

  /* fill all lines below if empty (and they need to be redrawn) */

  if (l == NULL) {

    while ((y < screenlastrow) && (y < uidirty.to)) {

      mdr_cout_char_rep(y++, 0, ' ', SCHEME_TEXT, screenlastcol);

    }

  }

  /* scroll bar */

  for (y = 0; y < screenlastrow; y++) {

    mdr_cout_char(y, screenlastcol, SCROLL_CURSOR, SCHEME_SCROLL);

  }

  /* scroll cursor */

  if (db->totlines >= screenh) {

    unsigned short topline = db->curline - db->cursorposy;

    unsigned short col;

    unsigned short totlines = db->totlines - screenh + 1;

    if (db->totlines - screenh > screenh) {

      col = topline / (totlines / screenlastrow);

    } else {

      col = topline * screenlastrow / totlines;

    }

    if (col >= screenlastrow) col = screenh - 2;

    mdr_cout_char(col, screenlastcol, ' ', SCHEME_SCROLL);

  }

  /* clear out the dirty flag */

  uidirty.from = 0xff;

}

static void check_cursor_not_after_eol(struct file *db) {

  if (db->xoffset + db->cursorposx <= db->cursor->len) return;

  if (db->cursor->len < db->xoffset) {

    db->cursorposx = 0;

    db->xoffset = db->cursor->len;

    uidirty.from = 0;

    uidirty.to = 0xff;

  } else {

    db->cursorposx = db->cursor->len - db->xoffset;

  }

}

static void cursor_up(struct file *db) {

  if (db->cursor->prev == NULL) return;

  db->curline -= 1;

  db->cursor = db->cursor->prev;

  if (db->cursorposy == 0) {

    uidirty.from = 0;

    uidirty.to = 0xff;

  } else {

    db->cursorposy -= 1;

  }

}

static void cursor_eol(struct file *db) {

  /* adjust xoffset to make sure eol is visible on screen */

  if (db->xoffset > db->cursor->len) {

    db->xoffset = db->cursor->len - 1;

    uidirty.from = 0;

    uidirty.to = 0xff;

  }

  if (db->xoffset + screenlastcol <= db->cursor->len) {

    db->xoffset = db->cursor->len - screenw + 2;

    uidirty.from = 0;

    uidirty.to = 0xff;

  }

  db->cursorposx = db->cursor->len - db->xoffset;

}

static void cursor_down(struct file *db) {

  if (db->cursor->next == NULL) return;

  db->curline += 1;

  db->cursor = db->cursor->next;

  if (db->cursorposy < screenh - 2) {

    db->cursorposy += 1;

  } else {

    uidirty.from = 0;

    uidirty.to = 0xff;

  }

}

static void cursor_left(struct file *db) {

  if (db->cursorposx > 0) {

    db->cursorposx -= 1;

  } else if (db->xoffset > 0) {

    db->xoffset -= 1;

    uidirty.from = 0;

    uidirty.to = 0xff;

  } else if (db->cursor->prev != NULL) { /* jump to end of line above */

    cursor_up(db);

    cursor_eol(db);

  }

}

static void cursor_home(struct file *db) {

  db->cursorposx = 0;

  if (db->xoffset != 0) {

    db->xoffset = 0;

    uidirty.from = 0;

    uidirty.to = 0xff;

  }

}

static void cursor_right(struct file *db) {

  if (db->cursor->len > db->xoffset + db->cursorposx) {

    if (db->cursorposx < screenw - 2) {

      db->cursorposx += 1;

    } else {

      db->xoffset += 1;

      uidirty.from = 0;

      uidirty.to = 0xff;

    }

  } else if (db->cursor->next != NULL) { /* jump to start of next line */

    cursor_down(db);

    cursor_home(db);

  }

}

static void del(struct file *db) {

  if (db->cursorposx + db->xoffset < db->cursor->len) {

    _fmemmove(db->cursor->payload + db->cursorposx + db->xoffset, db->cursor->payload + db->cursorposx + db->xoffset + 1, db->cursor->len - db->cursorposx - db->xoffset);

    db->cursor->len -= 1; /* do this AFTER memmove so the copy includes the nul terminator */

    uidirty.from = db->cursorposy;

    uidirty.to = db->cursorposy;

    db->modflag = 1;

  } else if (db->cursor->next != NULL) { /* cursor is at end of line: merge current line with next one (if there is a next one) */

    struct line far *nextline = db->cursor->next;

    if (db->cursor->next->len > 0) {

      if (curline_resize(db, db->cursor->len + db->cursor->next->len + 1) == 0) {

        _fmemmove(db->cursor->payload + db->cursor->len, db->cursor->next->payload, db->cursor->next->len + 1);

        db->cursor->len += db->cursor->next->len;

      }

    }

    db->cursor->next = db->cursor->next->next;

    db->cursor->next->prev = db->cursor;

    line_free(nextline);

    uidirty.from = db->cursorposy;

    uidirty.to = 0xff;

    db->totlines -= 1;

    db->modflag = 1;

  }

}

static void bkspc(struct file *db) {

  /* backspace is basically "left + del", not applicable only if cursor is on 1st byte of the file */

  if ((db->cursorposx + db->xoffset == 0) && (db->cursor->prev == NULL)) return;

  cursor_left(db);

  del(db);

}

/* returns 0 on success, 1 on file not found, 2 on other error */

static int loadfile(struct file *db, const char *fname) {

  char buff[512]; /* read one entire sector at a time (faster) */

  char *buffptr;

  unsigned int len, llen;

  int fd;

  unsigned char eolfound;

  /* free the entire linked list of lines */

  db_rewind(db);

  while (db->cursor) {

    struct line far *victim;

    victim = db->cursor;

    db->cursor = db->cursor->next;

    line_free(victim);

  }

  /* zero out the struct */

  bzero(db, sizeof(struct file));

  if (fname == NULL) goto SKIPLOADING;

  memcpy(db->fname, fname, strlen(fname));

  if (_dos_open(fname, O_RDONLY, &fd) != 0) {

    return(1);

  }

  db->lfonly = 1;

  /* start by adding an empty line */

  if (line_add(db, NULL, 0) != 0) {

    /* TODO ERROR HANDLING */

  }

  for (eolfound = 0;;) {

    unsigned short consumedbytes;

    if ((_dos_read(fd, buff, sizeof(buff), &len) != 0) || (len == 0)) break;

    buffptr = buff;

    FINDLINE:

    /* look for nearest \n (also expand tabs) */

    for (consumedbytes = 0;; consumedbytes++) {

      if (buffptr[consumedbytes] == '\t') {

        llen = consumedbytes;

        break;

      }

      if (consumedbytes == len) {

        llen = consumedbytes;

        break;

      }

      if (buffptr[consumedbytes] == '\r') {

        llen = consumedbytes;

        consumedbytes++;

        db->lfonly = 0;

        break;

      }

      if (buffptr[consumedbytes] == '\n') {

        eolfound = 1;

        llen = consumedbytes;

        consumedbytes++;

        break;

      }

    }

    /* consumedbytes is the amount of bytes processed from buffptr,

     * llen is the length of line's payload (without its line terminator) */

    /* append content, if line is non-empty */

    if ((llen > 0) && (line_append(db, buffptr, llen) != 0)) {

      goto IOERR;

    }

    /* allocate the next line if current line ended */

    if (eolfound) {

      if (line_add(db, NULL, 0) != 0) {

        goto IOERR;

      }

      eolfound = 0;

    }

    /* append 8 spaces if tab char found */

    if ((consumedbytes < len) && (buffptr[consumedbytes] == '\t') && (glob_tablessmode == 0)) {

      consumedbytes++;

      if (line_append(db, "        ", 8) != 0) {

        goto IOERR;

      }

    }

    /* anything left? process the buffer leftover again */

    if (consumedbytes < len) {

      len -= consumedbytes;

      buffptr += consumedbytes;

      goto FINDLINE;

    }

  }

  _dos_close(fd);

  SKIPLOADING:

  /* add an empty line at end if not present already, also rewind cursor to top of file */

  if ((db->cursor == NULL) || (db->cursor->len != 0)) line_add(db, NULL, 0);

  db_rewind(db);

  return(0);

  IOERR:

  _dos_close(fd);

  return(2);

}

/* a custom argv-parsing routine that looks directly inside the PSP, avoids the need

 * of argc and argv, saves some 330 bytes of binary size

 * returns non-zero on error */

static int parseargv(struct file *dbarr) {

  char *tail = (void *)0x81; /* THIS WORKS ONLY IN SMALL MEMORY MODEL */

  unsigned short count = 0;

  char *arg;

  unsigned short lastarg = 0;

  int err;

  while (!lastarg) {

    /* jump to nearest arg */

    while (*tail == ' ') {

      *tail = 0;

      tail++;

    }

    if (*tail == '\r') {

      *tail = 0;

      break;

    }

    arg = tail;

    /* jump to next delimiter */

    while ((*tail != ' ') && (*tail != '\r')) tail++;

    /* if \r then remember this is the last arg */

    if (*tail == '\r') lastarg = 1;

    *tail = 0;

    tail++;

    /* look at the arg now */

    if (*arg == '/') {

      if (arg[1] == 't') { /* /t = do not expand tabs */

        glob_tablessmode = 1;

      } else if (arg[1] == 'm') { /* /m = force mono mode */

        glob_monomode = 1;

      } else {  /* help screen */

        mdr_coutraw_str(svarlang_str(1,3)); /* Sved, the SvarDOS editor */

        mdr_coutraw_str(" [");

        mdr_coutraw_str(svarlang_str(1,4)); /* ver */

        mdr_coutraw_puts(" " PVER "]");

        mdr_coutraw_puts("Copyright (C) " PDATE " Mateusz Viste");

        mdr_coutraw_crlf();

        mdr_coutraw_str("sved [/m] [/t] ");

        mdr_coutraw_puts(svarlang_str(1,1)); /* args syntax */

        mdr_coutraw_crlf();

        mdr_coutraw_puts(svarlang_str(1,10)); /* /m */

        mdr_coutraw_puts(svarlang_str(1,11)); /* /t */

        return(-1);

      }

      continue;

    }

    /* looks to be a filename */

    if (count == 10) {

      mdr_coutraw_puts(svarlang_str(0,12)); /* too many files */

      return(-1);

    }

    /* try loading it */

    mdr_coutraw_str(svarlang_str(1,2));

    mdr_coutraw_char(' ');

    mdr_coutraw_puts(arg);

    err = loadfile(&(dbarr[count]), arg);

    if (err) {

      if (err == 1) { /* file not found */

        if ((count == 0) && (lastarg != 0)) { /* a 'file not found' is fine if only one file was given */

          memcpy(dbarr[count].fname, arg, strlen(arg) + 1);

          err = 0;

        } else {

          err = 11;

        }

      } else { /* general error */

        err = 10;

      }

      if (err) {

        mdr_coutraw_puts(svarlang_str(0,err));

        return(-1);

      }

    }

    count++;

  }

  return(0);

}

static int savefile(const struct file *db, const char *newfname) {

  int fd;

  const struct line far *l;

  unsigned int bytes;

  unsigned char eollen;

  unsigned char eolbuf[2];

  int errflag = 0;

  /* either create a new file if newfname provided, or... */

  if (newfname) {

    if (_dos_creatnew(newfname, _A_NORMAL, &fd) != 0) return(-1);

  } else { /* ...open db->fname */

    if (_dos_open(db->fname, O_WRONLY, &fd) != 0) return(-1);

  }

  l = db->cursor;

  while (l->prev) l = l->prev;

  /* preset line terminators */

  if (db->lfonly) {

    eolbuf[0] = '\n';

    eollen = 1;

  } else {

    eolbuf[0] = '\r';

    eolbuf[1] = '\n';

    eollen = 2;

  }

  while (l) {

    /* do not write the last empty line, it is only useful for edition */

    if (l->len != 0) {

      errflag |= _dos_write(fd, l->payload, l->len, &bytes);

    } else if (l->next == NULL) {

      break;

    }

    errflag |= _dos_write(fd, eolbuf, eollen, &bytes);

    l = l->next;

  }

  errflag |= _dos_close(fd);

  return(errflag);

}

static void insert_in_line(struct file *db, const char *databuf, unsigned short len) {

  if (curline_resize(db, db->cursor->len + len) == 0) {

    unsigned short off = db->xoffset + db->cursorposx;

    db->modflag = 1;

    _fmemmove(db->cursor->payload + off + len, db->cursor->payload + off, db->cursor->len - off + 1);

    db->cursor->len += len;

    uidirty.from = db->cursorposy;

    uidirty.to = db->cursorposy;

    while (len--) {

      db->cursor->payload[off++] = *databuf;

      databuf++;

      cursor_right(db);

    }

  }

}

/* recompute db->curline by counting nodes in linked list */

static void recompute_curline(struct file *db) {

  const struct line far *l = db->cursor;

  db->curline = 0;

  while (l->prev != NULL) {

    db->curline += 1;

    l = l->prev;

  }

}

enum MENU_ACTION {

  MENU_NONE   = 0,