Subversion Repositories SvarDOS

/* Sved, the SvarDOS editor

 *

 * Copyright (C) 2023-2024 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 <i86.h> /* MK_FP() */

#include "mdr\bios.h"

#include "mdr\cout.h"

#include "mdr\dos.h"

#include "svarlang\svarlang.h"

#define PVER "2024.0"

#define PDATE "2023-2024"

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

 * 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 char buff[512]; /* short lived buffer for whatever needed */

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;

  unsigned short curline_prev;

  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 slotid; /* 0..9 */

  char fname[128];

};

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

 * assembly pragma "functions"                                               *

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

unsigned short dos_alloc(unsigned short siz);

#pragma aux dos_alloc = \

"mov ah, 0x48" \

"int 0x21" \

"jnc done" \

"xor ax, ax" \

"done:" \

parm [bx] \

value [ax];

unsigned short dos_free(unsigned short segn);

#pragma aux dos_free = \

"mov ah, 0x49" \

"int 0x21" \

"jc done" \

"xor ax, ax" \

"done:" \

parm [es] \

value [ax];

unsigned short dos_fclose(unsigned short handle);

#pragma aux dos_fclose = \

"mov ah,0x3e" \

"int 0x21" \

"jc done" \

"xor ax, ax" \

"done:" \

parm [bx] \

value [ax];

unsigned short dos_fread(unsigned short handle, void *buf, unsigned short count, unsigned short *bytes);

#pragma aux dos_fread = \

"mov ah, 0x3f" \

"int 0x21" \

"jc done" \

"mov [di], ax" \

"xor ax, ax" \

"done:" \

parm [bx] [dx] [cx] [di] \

value [ax]

unsigned short dos_resizeblock(unsigned short siz, unsigned short segn);

#pragma aux dos_resizeblock = \

"mov ah, 0x4a" \

"int 0x21" \

"jc done" \

"xor ax, ax" \

"done:" \

parm [bx] [es] \

value [ax]

unsigned short dos_fwrite(unsigned short handle, unsigned short count, unsigned short *bytes, const void far *buf);

/* NOTE: last parameter (far pointer buf) is passed on the stack */

#pragma aux dos_fwrite = \

"push ds"   /* save DS into AX */ \

"pop ax" \

"pop dx" \

"pop ds" \

"push ax"   /* save DS into stack for later restoration */ \

"mov ah, 0x40" \

"int 0x21" \

"pop ds" \

"jc done" \

"mov [di], ax" \

"xor ax, ax" \

"done:" \

parm [bx] [cx] [di] \

value [ax]

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

 * functions                                                                 *

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

static size_t strlen(const char *s) {

  const char *ptr = s;

  while (*ptr != 0) ptr++;

  return(ptr - s);

}

static void bzero(void *ptr, size_t len) {

  char *p = ptr;

  while (len > 0) {

    *p = 0;

    p++;

    len--;

  }

}

static void fmemmove(void far *dst, const void far *src, size_t len) {

  short delta = 1;

  /* detect possible overlap in the forward direction */

  if (dst >= src) {

    dst = (char far *)dst + len - 1;

    src = (char far *)src + len - 1;

    delta = -1;

  }

  while (len-- > 0) {

    *(char far *)dst = *(char far *)src;

    dst = (char far *)dst + delta;

    src = (char far *)src + delta;

  }

}

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

  struct line far *res;

  unsigned short seg;

  seg = dos_alloc((sizeof(struct line) + siz + 15) / 16);

  if (seg == 0) return(NULL);

  res = MK_FP(seg, 0);

  res->len = 0;

  res->next = NULL;

  res->prev = NULL;

  return(res);

}

static void line_free(struct line far *ptr) {

  dos_free(FP_SEG(ptr));

}

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

  struct line far *newptr;

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

  if (dos_resizeblock((sizeof(struct line) + newsiz + 15) / 16, FP_SEG(db->cursor)) == 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 x;

  int k;

  if (maxlen == 0) return;

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

  /* print query string */

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

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

  for (;;) {

    mdr_cout_locate(screenlastrow, 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(screenlastrow, x + len, ' ', SCHEME_STBAR3);

        }

        break;

      default:

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

          mdr_cout_char(screenlastrow, 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 *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;

}

/* saves db file, resets db->modflag on success and overwrites the filename

 * field if saveas is not NULL */

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

  int fd = 0;

  const struct line far *l;

  unsigned short bytes;

  unsigned char eollen = 2;

  const unsigned char *eolbuf = "\r\n";

  int errflag = 0;

  /* if filename not overloaded then use the fname in db */

  if (saveas == NULL) saveas = db->fname;

  _asm {

    push cx

    push dx

    mov ah, 0x3C    /* create or truncate file */

    xor cx, cx      /* file attributes */

    mov dx, saveas  /* works only in SMALL/TINY mode */

    int 0x21

    jnc DONE

    mov errflag, ax

    DONE:

    mov fd, ax

    pop dx

    pop cx

  }

  if (errflag != 0) return(-1);

  l = db->cursor;

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

  /* preset line terminators */

  if (db->lfonly) {

    eolbuf++;

    eollen--;

  }

  while (l) {

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

    if (l->len != 0) {

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

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

      break;

    }

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

    l = l->next;

  }

  errflag |= dos_fclose(fd);

  /* did it all work? */

  if (errflag == 0) {

    db->modflag = 0;

    if (saveas != db->fname) mdr_dos_truename(db->fname, saveas);

  }

  return(errflag);

}

static void ui_statusbar(const struct file *db) {

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

  unsigned short helpcol = screenw - strlen(s);

  unsigned short col;

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

  {

    char slot[4] = "#00";

    if (db->slotid == 9) {

      slot[1] = '1';

    } else {

      slot[2] += db->slotid + 1;

    }

    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);

  /* eol type */

  {

    const char *eoltype = "CRLF";

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

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

  }

  /* line numbers */

  {

    unsigned short x;

    unsigned char count = 0;

    col = helpcol - 7;

    x = db->totlines;

    AGAIN:

    do {

      mdr_cout_char(screenlastrow, col--, '0' + (x % 10), SCHEME_STBAR1);

      x /= 10;

    } while (x);

    /* redo same exercise, but printing the current line now */

    if (count == 0) {

      count = 1;

      mdr_cout_char(screenlastrow, col--, '/', SCHEME_STBAR1);

      x = 1 + db->curline;

      goto AGAIN;

    }

  }

  /* filename and modflag */

  {

    const char *fn;

    unsigned short x;

    unsigned short maxfnlen = col - 6;

    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);

  }

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

}

static void ui_msg(unsigned short msgid1, unsigned short msgid2, unsigned short msgid3, unsigned char attr) {

  unsigned short x, y, maxmsglen, i;

  unsigned short msgcount = 1;

  const char *msg[3];

  msg[0] = svarlang_strid(msgid1);

  if (msgid2 != 0) {

    msgcount = 2;

    msg[1] = svarlang_strid(msgid2);

  }

  if (msgid3 != 0) {

    msgcount = 3;

    msg[2] = svarlang_strid(msgid3);

  }

  /* find longest msg */

  maxmsglen = 0;

  for (i = 0; i < msgcount; i++) {

    y = strlen(msg[i]);

    if (y > maxmsglen) maxmsglen = y;

  }

  y = (screenh - 6) >> 1;

  x = (screenw - maxmsglen - 3) >> 1;

  for (i = y+1+msgcount; i >= y; i--) mdr_cout_char_rep(i, x, ' ', attr, maxmsglen + 2);

  x++;

  for (i = 0; i < msgcount; i++) {

    mdr_cout_str(y+1+i, x, msg[i], attr, maxmsglen);

  }

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

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

}

/* returns 0 if operation may proceed, non-zero to cancel */

static unsigned char ui_confirm_if_unsaved(struct file *db) {

  int k;

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

  mdr_cout_cursor_hide();

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

   * ENTER        : agree to data loss

   * SPACE        : SAVE file before quit (only if valid filename present)

   * anything else: ABORT */

  ui_msg(4, 5, (db->fname[0])?9:8, SCHEME_MSG);

  k = mdr_dos_getkey2();

  mdr_cout_cursor_show();

  /* ENTER = agree to loose unsaved data */

  if (k == '\r') return(0);

  /* SPACE = save file and continue */

  if ((k == ' ') && (db->fname[0] != 0) && (savefile(db, NULL) == 0)) return(0);

  /* any other key = cancel operation */

  return(1);

}

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_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 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 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);

}

#define LOADFILE_FILENOTFOUND 2

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

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

  char *buffptr;

  unsigned short len, llen;

  unsigned short fd;

  unsigned char eolfound;

  unsigned char err = 0;

  /* 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 (take care to preserve the id of the slot, though) */

  {

    unsigned char slotid = db->slotid;

    bzero(db, sizeof(struct file));

    db->slotid = slotid;

  }

  /* start by adding an empty line */

  if (line_add(db, NULL, 0) != 0) return(2);

  if (fname == NULL) goto SKIPLOADING;

  /* make the filename canonical (DOS 3+ only, on earlier versions it just copies the filename) */

  mdr_dos_truename(db->fname, fname);

  /* fopen file */

  fd = 0;

  _asm {

    push cx

    push dx

    mov ax, 0x3d00

    mov dx, fname   // works only in SMALL memory model!

    xor cl, cl

    int 0x21

    mov fd, ax