nne

nne.c (34332B)

---

 /* nne: no-nonsense editor
  * A complete text editor in a single ANSI C89 file under 1000 SLOC
  * Usage: nne [file]
  * Build with:
  * cc -std=c89 -Os -O2 -s nne.c -o nne [-DNNE_IOBUFSZ=n] [-DNNE_TABWIDTH=m]
  * See README.md for features, controls and other details
  * Created by Luxferre in 2023, released into public domain */
 
 #define _POSIX_SOURCE
 #define _POSIX_C_SOURCE 1
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdio.h> /* we only use s(n)printf, never printf itself */
 #include <string.h>
 #include <stdarg.h> /* for message formatter */
 #include <errno.h>
 #include <termios.h>
 #include <signal.h>
 
 /* classic redefinitions */
 #define uint unsigned int
 #define ushort unsigned short
 #define uchar unsigned char
 #define NNE_CSZ sizeof(uint) /* single text character internal size */
 /* max amount of chars to be input/output on prompts/statuses */
 #ifndef NNE_IOBUFSZ
 #define NNE_IOBUFSZ 2000 
 #endif
 #ifndef NNE_TABWIDTH
 #define NNE_TABWIDTH 2
 #endif
 #define NNE_PAGESIZE 2048 /* memory page size in bytes for main text buffer */
 /* non-POSIX fallbacks for some flags */
 #ifndef SIGWINCH 
 #define SIGWINCH 28
 #endif
 
 /* terminal control macros (constants) */
 #define ERESET "\033[0m"      /* reset the styling */
 #define CLS "\033[2J"         /* clear the entire screen */
 #define LINECLR "\033[2K"     /* clear the current line */
 #define CURRESET "\033[0;0H"  /* reset the visual cursor */
 #ifdef NNE_NO_ALTBUF          /* can be defined for legacy terminals */
 #define CURSHOW ""
 #define CURHIDE ""
 #define ALTBUFON ""
 #define ALTBUFOFF CLS         /* if no altbuf, then clear the screen */
 #else
 #define CURSHOW "\033[?25h"   /* show the cursor */
 #define CURHIDE "\033[?25l"   /* hide the cursor */
 #define ALTBUFON "\033[?47h\033%G"  /* turn on alternate screen + UTF-8 */
 #define ALTBUFOFF "\033[?47l" /* turn off alternate screen */
 #endif
 
 /* terminal control macros (sprintf templates) */
 #define CURSET "\033[%03u;%03uH"  /* set the cursor position (line;col) */
 
 /* some enums */
 enum nne_modes { NNE_NORMAL = 1, NNE_CMD }; /* operation modes */
 enum nne_keys { /* special keys */
   K_ESC = 27, K_BACKSPACE = 127,
   /* negative PC keys so that we don't conflict with any UTF-8 codepoint */
   K_UP = 0xFFFFFF00, K_DOWN, K_RIGHT, K_LEFT, /* arrow keys */
   K_INS, K_DEL, K_HOME, K_END, K_PGUP, K_PGDN, /* IBM PC specific keys */
   K_MODCMD /* modstring pseudo-key */
 };
 
 /* some terminal I/O helpers */
 struct termios tty_opts_backup, tty_opts_raw;
 
 /* editor status variables and buffers */
 static ushort nne_termw = 80, nne_termh = 25; /* current terminal size */
 static ushort nne_scrx, nne_scry; /* current on-screen cursor position */
 static ushort nne_mode;  /* current modes: NNE_NORMAL, NNE_CMD */
 static ushort nne_status_override = 0; /* statusbar override */
 static ushort nne_file_loaded = 0; /* set to 1 if a file is loaded */
 static ushort nne_file_saved = 0; /* set to 1 if the file is just saved */
 static char nne_fname[NNE_IOBUFSZ * NNE_CSZ]; /* pointer to the file name */
 static char *nne_scrbuf; /* reallocatable screen buffer */
 static uint nne_scrpos;  /* absolute screen buffer position */
 static uint nne_scrsize; /* byte length of the visual screen buffer */
 static uint *nne_textbuf; /* (UTF-8) reallocatable main text buffer */
 static char nne_msgbuf[NNE_IOBUFSZ] = {0}; /* output buffer */
 static uint nne_cmdbuf[NNE_IOBUFSZ] = {0}; /* (UTF-8) prompt buffer */
 static uint nne_searchbuf[NNE_IOBUFSZ] = {0}; /* (UTF-8) search buffer */
 static uint nne_searchlen = 0; /* actual search buffer length */
 static int  nne_searchidx = -1; /* running search index */
 static uint *nne_clipbuf; /* (UTF-8) reallocatable clipboard buffer */
 static uint nne_cliplen = 0; /* actual clipboard buffer length */
 static uint nne_len; /* current physical length of nne_textbuf */
 static uint nne_real_len; /* current trackable length of nne_textbuf */
 static int  nne_pos; /* current in-document absolute position */
 static uint nne_row, nne_col; /* current in-document cursor position */
 static uint nne_scr_row; /* current wrapped cursor vertical position */
 static uint nne_buflines; /* amount of lines loaded into the buffer */
 static int  nne_line_offset = 0; /* offset from the start to the screen */
 
 /* help screen */
 
 static char* nne_help_screen = "\033[s\
 ---------------------------- nne shortcut help ---------------------------\
 \033[1B\033[74D\
 |                                                                        |\
 \033[1B\033[74D\
 |Save       Esc Esc s, Esc Esc w     Line jump    Esc Esc l [num] Return |\
 \033[1B\033[74D\
 |Quit       Esc Esc q                Brace match  Esc Esc 5              |\
 \033[1B\033[74D\
 |Tab char   Esc Esc Tab              Find text    Esc Esc / [text] Return|\
 \033[1B\033[74D\
 |Delete     Del,  Esc Esc Bksp       Copy line    Esc Esc y              |\
 \033[1B\033[74D\
 |Page Up    PgUp, Esc Esc Up         Copy lines   Esc Esc Y [num] Return |\
 \033[1B\033[74D\
 |Page Down  PgDn, Esc Esc Down       Cut line     Esc Esc d              |\
 \033[1B\033[74D\
 |Home       Home, Esc Esc 0          Cut lines    Esc Esc D [num] Return |\
 \033[1B\033[74D\
 |End        End,  Esc Esc 4          Paste        Esc Esc p, Esc Esc v   |\
 \033[1B\033[74D\
 |Next word  Esc Esc Right            Discard/undo Esc Esc u              |\
 \033[1B\033[74D\
 |Prev word  Esc Esc Left             Run shell    Esc Esc e [cmd] Return |\
 \033[1B\033[74D\
 |File start Esc Esc 8                This help    Esc Esc h              |\
 \033[1B\033[74D\
 |File end   Esc Esc 9                                                    |\
 \033[1B\033[74D\
 |                                                                        |\
 \033[1B\033[74D\
 |                      Created by Luxferre in 2023                       |\
 \033[1B\033[74D\
 |                      Released into public domain                       |\
 \033[1B\033[74D\
 |                                                                        |\
 \033[1B\033[74D\
 |                    Press Return to exit this screen                    |\
 \033[1B\033[74D\
 --------------------------------------------------------------------------\033[u";
 
 /* elementary routines */ 
 
 /* generic routines to output string constants */
 void nnputs(char *str) {write(1, str, strlen(str));}
 char* nnmsg(int desc, char *format, ...) {
   va_list aptr;
   int r;
   memset(nne_msgbuf, 0, NNE_IOBUFSZ); /* zero out the message buffer */
   va_start(aptr, format);
   r = vsnprintf(nne_msgbuf, NNE_IOBUFSZ - 1, format, aptr);
   va_end(aptr);
   if(r > 0 && desc > 0) write(desc, nne_msgbuf, r);
   return nne_msgbuf;
 }
 /* write a widechar (internal) to stdout */
 void nnwritew(int w) {uchar c;while((c=(w&255))>0){write(1,&c,1);w>>=8;}}
 
 void cleanup() { /* screen and other resources cleanup routine */
   int ecode = errno; /* save the error code */
   signal(SIGWINCH, SIG_DFL); /* reset signal handler */
   tcsetattr(0, TCSANOW, &tty_opts_backup); /* restore terminal options */
   nnputs(ERESET ALTBUFOFF); /* return to the default screen buffer */
   if(ecode) perror("Error"); /* print exit reason if errored out */
 }
 
 uchar readc() { /* read a single raw byte from stdin */
   uchar c = 0;
   int nread;
   while((nread = read(0, &c, 1)) != 1)
     if(nread == -1 && errno != EAGAIN && errno != EINTR)
       exit(errno);
   return c;
 }
 
 /* Reallocate a buffer based upon the page size, return the new bufptr */
 void* page_realloc(void *buf, uint curlen, uint targetlen, uint *reslen, uint pagesize) {
   if(targetlen < 1) targetlen = 1; /* safeguard */
   if(pagesize < 1) pagesize = 1;   /* safeguard */
   uint alloclen = targetlen, r = targetlen % pagesize;
   if(r > 0) alloclen = targetlen - r + pagesize; /* the next page multiple */
   if(curlen != alloclen) {
     buf = realloc(buf, alloclen);
     if(buf == NULL) exit(errno);
   }
   *reslen = alloclen; 
   return buf;
 }
 
 /* insert n bytes from src into dest of length destlen at position pos */
 /* dest is also reallocated automatically with page_realloc */
 /* returns the new bufptr */
 void* meminsert(void *dest, uint destlen, uint pos, void *src, uint n, uint *reslen, uint pagesize) {
   dest = page_realloc(dest, destlen, destlen + n, reslen, pagesize);
   char *dd = (char *) dest;
   /* i like to move it, move it */
   memmove(dd + pos + n, dd + pos, destlen - pos);
   memmove(dd + pos, src, n); /* fill the space from src */
   return dest;
 }
 
 /* erase n bytes in dest of length destlen at position pos */
 /* dest is also reallocated automatically with page_realloc */
 /* returns the new bufptr */
 void* memerase(void *dest, uint destlen, uint pos, uint n, uint *reslen, uint pagesize) {
   char *dd = (char *) dest;
   /* i like to move it, move it */
   memmove((dd + pos), (dd + pos + n), destlen - pos - n);
   return page_realloc(dest, destlen, destlen - n, reslen, pagesize);
 }
 
 /* editor core operations */
 
 /* find the beginning of a particular line number (1-based) */
 int nne_findline(int lineno) {
   int pos, rc = 1; 
   if(lineno < 1) lineno = 1; /* safeguard */
   for(pos=0;pos<nne_real_len-1;pos++) {
     if(rc == lineno) break;
     if(nne_textbuf[pos] == '\n') rc++; /* increment row */
   }
   return pos;
 }
 
 /* find the physical (with wraps) line number by position */
 int nne_findscrlineno(int pos) {
   uint i, rc = 0, cc = 0, wcf = 0; /* row, column and line wrap counters */
   if(pos < 0) pos = 0; /* safeguard */
   if(pos > nne_real_len - 2) pos = nne_real_len - 2; /* safeguard */
   for(i=0;i<pos;i++) {
     if(nne_textbuf[i] == '\n') { /* newline encountered */
       rc++; /* increment row */
       cc = 0; /* reset column */
     } else { /* increment column */
       cc += (nne_textbuf[i] == '\t') ? NNE_TABWIDTH : 1;
       if(((cc - 1) % nne_termw) >= (nne_termw - 1)) wcf++;
     }
   }
   return rc + wcf + 1; /* newlines + wraps + 1 */
 }
 
 /* update screen coordinates with regards to scrolling parameters */
 void nne_update_scrxy() {
   /* find current virtual row and column */
   nne_scr_row = nne_findscrlineno(nne_pos);
   nne_scrx = 1 + ((nne_col - 1) % nne_termw);
   /* calculate scroll-aware update */
   nne_scry = nne_scr_row - nne_line_offset;
 }
 
 /* update (1-based) row and column by the current nne_pos (0-based) */
 void nne_update_coords() {
   uint i, rc = 0, cc = 0; /* row, column and line wrap counters */
   nne_buflines = 1; /* total line counter */
   if(nne_pos >= nne_real_len) nne_pos = nne_real_len - 1; /* safeguard */
   for(i=0;i<nne_real_len-1;i++) {
     if(i < nne_pos) { /* count all stats until nne_pos */
       if(nne_textbuf[i] == '\n') { /* newline encountered */
         nne_buflines++; /* update total line count */
         rc++; /* increment row */
         cc = 0; /* reset column */
       }
       else cc += (nne_textbuf[i]=='\t') ? NNE_TABWIDTH : 1; /* incr. col */
     } /* only count total lines otherwise */
     else if(nne_textbuf[i] == '\n') nne_buflines++;
   }
   nne_row = rc + 1;
   nne_col = cc + 1;
   nne_update_scrxy();
 }
 
 /* insert a character into nne_textbuf at current row and column */
 /* also update row and col accordingly */
 void nne_inschar(int c) { 
   nne_textbuf = meminsert(nne_textbuf, nne_real_len*NNE_CSZ, nne_pos*NNE_CSZ, &c, NNE_CSZ, &nne_len, NNE_PAGESIZE);
   nne_pos++;
   nne_update_coords();
   nne_real_len++; /* only update the length after updating the coordinates */
   nne_file_saved = 0; /* reset the save flag */
 }
 
 /* delete a character */
 void nne_delchar() { 
   nne_textbuf = memerase(nne_textbuf, nne_real_len*NNE_CSZ, nne_pos*NNE_CSZ, NNE_CSZ, &nne_len, NNE_PAGESIZE);
   nne_update_coords();
   nne_real_len--; /* only update the length after updating the coordinates */
   nne_file_saved = 0; /* reset the save flag */
 }
 
 /* load a file into nne_textbuf */
 void nne_loadfile(char *fname) {
   FILE *f = fopen(fname, "r");
   if(f == NULL) {nne_file_loaded = 1; return;}
   int c, c1, c2, c3, wc, flen, i;
   fseek(f, 0, SEEK_END); /* seek to the end of the file */
   flen = ftell(f);  /* get the current file pointer */
   fseek(f, 0, SEEK_SET); /* seek to the start of the file */
   if(flen) { /* don't do anything if the file is empty */
     uchar *pbuf = calloc(flen, 1); /* primary loading buffer */
     if(fread(pbuf, flen, 1, f) < 0) exit(errno); /* populate pbuf */
     fclose(f);
     nne_real_len = flen + 2; /* reserve for the last char */
     nne_textbuf = realloc(nne_textbuf, NNE_CSZ * nne_real_len);
     memset(nne_textbuf, 0, NNE_CSZ * nne_real_len);
     nne_pos = 0; /* reset the buffer position */
     for(i=0;i<flen;) {
       c = pbuf[i++];
       if(c > 128) { /* assuming UTF-8 input: just store as little-endian */
         wc = c1 = c2 = c3 = 0;
         if((c & 0xf0) == 0xf0) { /* read 3 extra bytes (rare situation) */
           if(i>=flen) break; c1 = pbuf[i++];
           if(i>=flen) break; c2 = pbuf[i++];
           if(i>=flen) break; c3 = pbuf[i++]; 
           wc = c | (c1 << 8) | (c2 << 16) | (c3 << 24);
         }
         else if((c & 0xe0) == 0xe0) { /* read 2 extra bytes */
           if(i>=flen) break; c1 = pbuf[i++];
           if(i>=flen) break; c2 = pbuf[i++];
           wc = c | (c1 << 8) | (c2 << 16);
         }
         else if((c & 0xc0) == 0xc0) { /* read 1 extra byte */
           if(i>=flen) break; c1 = pbuf[i++];
           wc = c | (c1 << 8);
         }
         nne_textbuf[nne_pos++] = wc;
       }
       else if(c>0) { /* low-ASCII character */
         if(c == '\r') c = '\n'; /* convert CR to LF */
         nne_textbuf[nne_pos++] = c;
       }
     }
     free(pbuf); /* we no longer need the primary buffer */
   }
   nne_pos = 0; /* reset the buffer position again */
   nne_file_loaded = 1; /* mark the file load fact */
   nne_file_saved = 1; /* by default, no changes are made */
   nne_update_coords();
 }
 
 /* save nne_textbuf into a file */
 void nne_savefile(char *fname) {
   FILE *f = fopen(fname, "w"); /* fully overwriting, be careful */
   if(f == NULL) return;
   int i, v, c;
   for(i=0;i<nne_real_len-2;i++) {
     v = nne_textbuf[i]; /* copy the currently written value */
     while((c = v&255) > 0) { /* extract the byte */
       if(fputc(c, f) < 1) exit(errno);
       v >>= 8; /* shift to the next byte */
     }
   }
   fclose(f);
   nne_file_saved = 1; /* mark the file save fact */
 }
 
 /* UI operations */
 
 uint inkey() { /* input a single key (logical) */
   uchar c = readc(), c1, c2, c3;
   if(c == K_ESC) { /* escape sequence start */
     if(!(c1 = readc())) return K_ESC;
     if(c1 == K_ESC) return K_MODCMD; /* modstring is ESC ESC */
     if(!(c2 = readc())) return K_ESC;
     else if(c1 == '[') {
       if(c2 >= '0' && c2 <= '9') {
         if(!(c3 = readc())) return K_ESC;
         if(c3 == '~') {
           switch(c2) {
             case '1': return K_HOME;
             case '2': return K_INS;
             case '3': return K_DEL;
             case '4': return K_END;
             case '5': return K_PGUP;
             case '6': return K_PGDN;
             case '7': return K_HOME;
             case '8': return K_END;
           }
         }
       } else {
         switch(c2) {
           case 'A': return K_UP;
           case 'B': return K_DOWN;
           case 'C': return K_RIGHT;
           case 'D': return K_LEFT;
           case 'H': return K_HOME;
           case 'F': return K_END;
         }
       }
     } else if(c1 == 'O') {
       switch(c2) {
         case 'H': return K_HOME;
         case 'F': return K_END;
       }
     }
     return K_ESC;
   }
   else if(c > 128) { /* assuming UTF-8 input: just store as little-endian */
     int wc = 0;
     if((c & 0xf0) == 0xf0) { /* read 3 extra bytes (rare situation) */
       c1 = readc(); c2 = readc(); c3 = readc();
       wc = c | (c1 << 8) | (c2 << 16) | (c3 << 24);
     }
     else if((c & 0xe0) == 0xe0) { /* read 2 extra bytes */
       c1 = readc(); c2 = readc();
       wc = c | (c1 << 8) | (c2 << 16);
     }
     else if((c & 0xc0) == 0xc0) { /* read 1 extra byte */
       c1 = readc();
       wc = c | (c1 << 8);
     }
     return wc;
   }
   else return c; /* low-ASCII character */
 }
 
 /* input a string into nne_cmdbuf (NNE_IOBUFSZ uints long) */
 /* stops on NNE_IOBUFSZ-1 chars or Return press */
 /* Esc (or double Esc) aborts */
 /* returns the resulting amount of input characters */
 uint nne_prompt(char *prompt) {
   nnmsg(1, CURSET LINECLR, nne_termh, 1); /* clear the status bar line */
   uint c, rd = 0, endinput = 0, l = strlen(prompt);
   /* print the prompt message and move the cursor after it */
   if(l > 0) nnmsg(1, "%s ", prompt);
   memset(nne_cmdbuf, 0, NNE_IOBUFSZ * NNE_CSZ); /* zero out the input buffer */
   while(rd < NNE_IOBUFSZ) {
     c = inkey();
     switch(c) {
       case K_BACKSPACE:
         if(rd > 0) { /* don't backspace if nothing entered */
           c = nne_cmdbuf[rd-1]; /* store the character */
           nne_cmdbuf[rd-1] = 0; /* zero out the character */
           rd--; /* decrement the read counter */
           /* move cursor back and erase until the end of the line */
           nnmsg(1, "\033[%uD\033[0K", c == '\t' ? NNE_TABWIDTH : 1);
         }
         break;
       case K_ESC: case K_MODCMD: endinput = 1; rd = 0; break; /* abort */
       case '\r': case '\n': endinput = 1; break; /* confirm */
       default:
         if((c == '\t') || (c > 31 && c < K_UP)) {
           nne_cmdbuf[rd++] = c;
           nnwritew(c); /* print the new character */
         }
     }
     if(endinput) break; /* end operation on abort or confirm */
   }
   return rd;
 }
 
 /* input a non-negative integer value (uses nne_prompt and nne_cmdbuf) */
 uint nne_digit_prompt(char *prompt) {
   uint i=0, j, c, r = nne_prompt(prompt);
   for(j=0;j<r;j++) { /* decimal digit parsing loop */
     if(nne_cmdbuf[j] > '9') break;
     c = nne_cmdbuf[j] - '0'; /* valid digit range */
     if(c >= 0 && c < 10) i = i*10 + c;
     else break;
   }
   return i;
 }
 
 uint scrbuf_appendw(int wc) { /* append a widechar to the screen buffer */
   uchar c;
   while((c = (wc & 255))) { /* this is why we store UTF-8 as little-endian */
     nne_scrbuf[nne_scrpos++] = c;
     wc >>= 8;
   }
   return nne_scrpos;
 }
 
 uint scrbuf_append(char *str) { /* append a string to the screen buffer */
   uint l = strlen(str), i;
   for(i=0;i<l;i++) nne_scrbuf[nne_scrpos++] = str[i];
   return nne_scrpos;
 }
 
 void render() { /* main screen rendering function */
   uint i, k, cc = 0, rc = 0, wcf = 0;
   memset(nne_scrbuf, 0, nne_scrsize); /* prefill with zeroes */
   nne_scrpos = 0; /* reset the position */
   /* clear the screen, hide the cursor and reset its position */
   scrbuf_append(CLS CURHIDE CURRESET);
   /* render the active screen part */
   nne_update_scrxy();
   if((nne_scr_row - 1) < nne_line_offset) {
     nne_line_offset = nne_scr_row - 1;
     nne_update_scrxy();
   }
   if(nne_scry >= nne_termh) {
     nne_line_offset = nne_scr_row - nne_termh + 1;
     nne_update_scrxy();
   }
   /* find the offset line into i, use j as real newline counter */
   /* also complete with wraps */
   for(i=0,rc=0,wcf=0;i<nne_real_len - 1;i++) {
     if((rc + wcf) == nne_line_offset) break;
     if(nne_textbuf[i] == '\n') { /* newline encountered */
       rc++; /* increment row */
       cc = 0; /* reset column */
     } else {
       cc++; /* increment column */
       if((cc % nne_termw) == (nne_termw - 1)) wcf++;
     }
   }
   /* now count the newlines and wraps in rc */
   for(rc=0,cc=0;rc<nne_termh-1;i++) {
     if(i >= nne_real_len) break;
     if(nne_textbuf[i] == '\n') {
       scrbuf_append("\r\n");
       rc++; /* increment row */
       cc = 0; /* reset column */
     }
     else {
       cc++; /* increment column */
       if((cc % nne_termw) == (nne_termw - 1)) rc++;
       if(nne_textbuf[i] == '\t') {/* retab */
         for(k=0;k<NNE_TABWIDTH;k++) scrbuf_appendw(' ');
       }
       /* visual \n autoconversion */
       else if(nne_textbuf[i] == '\r') {} /* ignore */
       else scrbuf_appendw(nne_textbuf[i]); /* add the character as is */
     }
   }
   /* render the status bar */
   /* put cursor to the current on-screen position and display it */
   if(nne_status_override) {
     scrbuf_append(nne_msgbuf);
     nne_status_override = 0;
   }
   else scrbuf_append(nnmsg(0, CURSET "%c %u,%u %02u%% %ux%u | %s | %s", nne_termh, 1,
     (nne_mode == NNE_CMD) ? 'C' : '-', nne_row, nne_col,
     (100*nne_pos/(nne_real_len <= 2 ? 2 : nne_real_len - 2)),
     nne_termw, nne_termh, nne_fname, "Press Esc Esc h to get help"));
   scrbuf_append(nnmsg(0, CURSET CURSHOW "\0", nne_scry, nne_scrx));
   /* actually draw the screen buffer until the first zero byte */
   nnputs(nne_scrbuf);
 }
 
 /* platform-independent terminal size detection */
 static void nne_termsize() {
   if(write(1, "\033[s\033[999C\033[999B", 15) != 15) return;
   if(write(1, "\033[6n", 4) != 4) return;
   char buf[32], i;
   for(i=0;i<31;i++) {
     if(read(0, &buf[i], 1) != 1) break;
     if(buf[i] == 'R') break;
   }
   if(write(1, "\033[u", 3) != 3) return; /* restore the cursor position */
   buf[i] = 0;
   if(buf[0] != '\033' || buf[1] != '[') return;
   if(sscanf(&buf[2], "%hu;%hu", &nne_termh, &nne_termw) != 2) return;
   nne_scrsize = (nne_termw * nne_termh) << 2; /* update the byte size */
   nne_scrbuf = realloc(nne_scrbuf, nne_scrsize); /* reallocate accordingly */
   if(nne_scrbuf == NULL) exit(errno); /* exit on memory error */
 }
 
 static void resizehandler(int sig) {
   if(SIGWINCH == sig) {
     nne_termsize();
     signal(SIGWINCH, resizehandler); /* resetup the signal handler */
   }
 }
 
 /* motion helper methods */
 
 /* get line start by given position in nne_textbuf */
 uint nne_linestart(uint pos) {
   int st = pos - 1;
   for(;st>=0;st--) if(nne_textbuf[st] == '\n') break;
   return st + 1;
 }
 
 /* get line end by given position in nne_textbuf */
 uint nne_lineend(uint pos) {
   uint ed = pos;
   for(;ed<nne_real_len-2;ed++) if(nne_textbuf[ed] == '\n') break;
   return ed;
 }
 
 /* jump to a column (or to the end of the line if we don't fit) */
 void nne_jumpcol(uint col) {
   uint ls = nne_linestart(nne_pos); /* get current line start */
   uint le = nne_lineend(nne_pos); /* get current line end */
   col--; /* the column is 1-based, so decrement */
   if(col > (le - ls)) nne_pos = le;
   else nne_pos = ls + col;
 }
 
 /* jump to the matching character (if found) */
 void nne_jumpmatch(uchar c1, uchar c2, int dir) {
   int balance = 0, xpos = nne_pos;
   for(;xpos >=0 && xpos <= nne_real_len - 2;xpos += dir) {
     if(nne_textbuf[xpos] == c1) balance++;
     if(nne_textbuf[xpos] == c2) balance--;
     if(!balance) break;
   }
   if(xpos >= 0 && xpos <= nne_real_len - 2) nne_pos = xpos;
 }
 
 /* copy a text region into the clipboard buffer (return the copied length) */
 uint nne_copyregion(uint start, uint end) {
   uint l = end - start, i;
   nne_clipbuf = realloc(nne_clipbuf, l * NNE_CSZ);
   memset(nne_clipbuf, 0, l * NNE_CSZ);
   for(i=0;i<l;i++) {
     if(start + i < nne_real_len - 2)
       nne_clipbuf[i] = nne_textbuf[start + i];
     else {l = i; break;}
   }
   nne_cliplen = l;
   return l;
 }
 
 uchar nne_iswhitespace(uint c) { /* check if we encounter a whitespace */
   return ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r')) ? 1 : 0;
 }
 
 /* some motions duplicated on keyboard and modkeys */
 
 void motion_del() { /* delete current character */
   if(nne_pos < nne_real_len - 2) nne_delchar();
   if(nne_pos == nne_real_len - 1) nne_pos--;
   if(nne_pos < 0) nne_pos = 0;
 }
 void motion_home() {nne_pos = nne_linestart(nne_pos);}
 void motion_end() {nne_pos = nne_lineend(nne_pos);}
 void motion_left() {nne_pos--; if(nne_pos<0) nne_pos=0;}
 void motion_right() {nne_pos++; if(nne_pos>=nne_real_len-1) nne_pos--;}
 void motion_up() {motion_home(); motion_left(); motion_home(); nne_jumpcol(nne_col);}
 void motion_down() {motion_end(); motion_right(); nne_jumpcol(nne_col);}
 void motion_pgup() {ushort pg=nne_termh>>1,i;for(i=0;i<pg;i++)motion_up();}
 void motion_pgdn() {ushort pg=nne_termh>>1,i;for(i=0;i<pg;i++)motion_down();}
 int motion_save() { /* save the buffer into file */
   int i, j, r; uchar c;
   if(!nne_file_loaded) { /* we have a new file */
     r = nne_prompt("New file name:");
     if(r) { /* we entered something */
       memset(nne_fname, 0, NNE_IOBUFSZ * NNE_CSZ);
       for(i=0,j=0;i<r;i++)
         while((c = (nne_cmdbuf[i]&255)) > 0) {
           nne_fname[j++] = c;
           nne_cmdbuf[i] >>= 8;
         }
     } else { /* no new name entered */
       nnmsg(0, CURSET "No file saved", nne_termh, 1);
       nne_status_override = 1;
       return 0;
     }
   }
   nne_savefile(nne_fname);
   nne_file_loaded = 1; /* update the file load fact */
   return 1;
 }
 
 /* main key-driven action handler, returns 1 on success */
 int nne_action(int key) {
   int i, j, r; uchar c;
   if(nne_mode == NNE_CMD) { /* modcommand mode */
     switch(key) {
       case 's': case 'w':
         if(motion_save()) {
           nnmsg(0, CURSET "Saved %s, %u chars, %u lines",
             nne_termh, 1, nne_fname, nne_real_len - 2, nne_buflines);
           nne_status_override = 1;
         }
         break;
       case 'y': /* copy current line */
         r = nne_copyregion(nne_linestart(nne_pos), nne_lineend(nne_pos) + 1);
         nnmsg(0, CURSET "Copied %u chars", nne_termh, 1, r);
         nne_status_override = 1;
         break;
       case 'Y': /* copy multiple lines starting from the current one */
         r = nne_digit_prompt("Copy lines:");
         if(r < 1 || r > nne_buflines - nne_row) r = 1;
         i = nne_lineend(nne_findline(nne_row + r - 1));
         r = nne_copyregion(nne_linestart(nne_pos), i + 1);
         nnmsg(0, CURSET "Copied %u chars", nne_termh, 1, r);
         nne_status_override = 1;
         break;
       case 'd': /* cut current line */
         r = nne_copyregion(i = nne_linestart(nne_pos), nne_lineend(nne_pos) + 1);
         nne_pos = i; /* go to the current line start */
         for(i=0;i<r;i++) motion_del();
         nnmsg(0, CURSET "Cut %u chars", nne_termh, 1, r);
         nne_status_override = 1;
         break;
       case 'D': /* cut multiple lines starting from the current one */
         r = nne_digit_prompt("Cut lines:");
         if(r < 1 || r > nne_buflines - nne_row) r = 1;
         j = nne_lineend(nne_findline(nne_row + r - 1));
         r = nne_copyregion(i = nne_linestart(nne_pos), j + 1);
         nne_pos = i; /* go to the current line start */
         for(i=0;i<r;i++) motion_del();
         nnmsg(0, CURSET "Cut %u chars", nne_termh, 1, r);
         nne_status_override = 1;
         break;
       case 'v': case 'p': /* paste */
         for(i=0;i<nne_cliplen;i++) nne_inschar(nne_clipbuf[i]);
         nnmsg(0, CURSET "Pasted %u chars", nne_termh, 1, nne_cliplen);
         nne_status_override = 1;
         break;
       case 'l':
         i = nne_digit_prompt("Jump to line #:");
         if(i < 1) i = 1;
         if(i > nne_buflines) i = nne_buflines;
         nne_pos = nne_findline(i);
         break;
       case '/': /* search */
         r = nne_prompt("Find:");
         if(r) { /* init search buffer */
           memset(nne_searchbuf, 0, NNE_IOBUFSZ * NNE_CSZ);
           for(i=0;i<r;i++) nne_searchbuf[i] = nne_cmdbuf[i];
           nne_searchlen = r;
           nne_searchidx = -1; /* reset running search index */
         }
         if(nne_searchlen > 0) { /* perform the search */
           for(i=nne_searchidx+1;i<nne_real_len-1;i++) {
             r = 1; /* intermediate search result */
             for(j=0;j<NNE_IOBUFSZ;j++) {
               if(nne_searchbuf[j] == 0) break;
               if(nne_searchbuf[j] != nne_textbuf[i+j]) {r = 0; break;}
             }
             if(r) {nne_pos = nne_searchidx = i; break;}
             if(i == nne_real_len - 2) {
               nne_searchidx = -1;
               nnmsg(0, CURSET "End of search results", nne_termh, 1);
               nne_status_override = 1;
               break;
             }
           }
         }
         break;
       case 'u': /* discard unsaved data */
         if(nne_file_loaded && !nne_file_saved) {
           if(nne_prompt("Discard unsaved data? [y/n]")) {
             c = nne_cmdbuf[0]&255;
             if(c == 'y' || c == 'Y') {nne_loadfile(nne_fname);}
           } 
         }
         break;
       case 'e': /* external shell command runner */
         if((r = nne_prompt("Shell command:")) > 0) {
           char *rcmd = calloc(r*NNE_CSZ + 1, 1); /* allocate command buffer */
           for(i=0,j=0;i<r;i++) /* retrieve raw bytes into command */
             while((c = (nne_cmdbuf[i]&255)) > 0) {
               rcmd[j++] = c;
               nne_cmdbuf[i] >>= 8;
             }
           motion_save(); /* save file */
           r = system(rcmd); /* run the shell command */
           free(rcmd); /* free command buffer */
           nne_loadfile(nne_fname); /* reload file */
           nnmsg(0, CURSET "Command exit code: %d", nne_termh, 1, r);
           nne_status_override = 1;
         }
         break;
       case 'q': /* quit */
         if(nne_file_loaded && !nne_file_saved) {
           if(nne_prompt("Save? [y/n]")) {
             c = nne_cmdbuf[0]&255;
             if(c == 'y' || c == 'Y') {if(motion_save()) return 0;}
             else if(c == 'n' || c == 'N') return 0;
             else break;
           }
         } else return 0;
         break;
       case '0': motion_home(); break;
       case '4': motion_end(); break;
       case '5': /* bracket matcher */
         switch(nne_textbuf[nne_pos]) {
           case '(': nne_jumpmatch('(', ')', 1); break;
           case ')': nne_jumpmatch(')', '(', -1); break;
           case '[': nne_jumpmatch('[', ']', 1); break;
           case ']': nne_jumpmatch(']', '[', -1); break;
           case '{': nne_jumpmatch('{', '}', 1); break;
           case '}': nne_jumpmatch('}', '{', -1); break;
           case '<': nne_jumpmatch('<', '>', 1); break;
           case '>': nne_jumpmatch('>', '<', -1); break;
         }
         break;
       case '8': nne_pos = 0; break; /* jump to file start */
       case '9': /* jump to file end */
         nne_pos = nne_real_len - 2;
         if(nne_pos < 0) nne_pos = 0;
         break;
       case K_LEFT: /* find previous word */
         while((nne_pos > 0) && !nne_iswhitespace(nne_textbuf[nne_pos]))
           motion_left(); /* go to the first whitespace before this word */
         while((nne_pos > 0) && nne_iswhitespace(nne_textbuf[nne_pos]))
           motion_left(); /* go to the end of the previous word */
         while((nne_pos > 0) && !nne_iswhitespace(nne_textbuf[nne_pos]))
           motion_left(); /* go to the first whitespace before the previous word */
         while(nne_iswhitespace(nne_textbuf[nne_pos]))
           motion_right(); /* go to the beginning of the previous word */
         break;
       case K_RIGHT: /* find next word */
         while((nne_pos < nne_real_len - 2) && !nne_iswhitespace(nne_textbuf[nne_pos]))
           motion_right(); /* go to the first whitespace after this word */
         while((nne_pos < nne_real_len - 2) && nne_iswhitespace(nne_textbuf[nne_pos]))
           motion_right(); /* go to the beginning of the next word */
         break;
       case K_UP: motion_pgup(); break;
       case K_DOWN: motion_pgdn(); break;
       case K_BACKSPACE: motion_del(); break;
       case '\t': nne_inschar('\t'); break; /* insert literal tab */
       case 'h': /* help screen */
         nnmsg(1, CURSET "%s", (nne_termh >> 1) - 10, (nne_termw >> 1) - 37,
           nne_help_screen);
         r = nne_prompt(""); /* pause editing, wait for Return key */
         break;
     }
     nne_mode = NNE_NORMAL; /* exit the modcommand mode afterwards */
   }
   else { /* assume NNE_NORMAL, normal mode */
     switch(key) {
       case K_MODCMD: nne_mode = NNE_CMD; break;
       case K_LEFT: motion_left(); break;
       case K_RIGHT: motion_right(); break;
       case K_UP: motion_up(); break;
       case K_DOWN: motion_down(); break;
       case K_HOME: motion_home(); break;
       case K_END: motion_end(); break;
       case K_PGUP: motion_pgup(); break;
       case K_PGDN: motion_pgdn(); break;
       case K_DEL: motion_del(); break;
       case K_BACKSPACE: /* delete previous character */
         nne_pos--;
         if(nne_pos < 0) nne_pos = 0; else nne_delchar();
         break;
       case '\t': /* tabstop */
         for(i=0;i<NNE_TABWIDTH;i++) nne_inschar(' ');
         break;
       case '\r': case '\n': /* newline, autoindent */
         if(key == '\r') key = '\n'; /* convert CR to LF */
         r = nne_linestart(nne_pos); /* get this line start */
         j = nne_pos; /* cache current position as line end */
         nne_inschar(key); /* output this newline */
         if(nne_row > 1) /* no autoindent on the first row */
           for(;((i = nne_textbuf[r]) == ' ' || i == '\t') && r < j;r++)
             nne_inschar(i); /* copy previous whitespace characters */
         break;
       default: /* normal insertion for supported characters */
         if(key > 31 && key < K_UP) nne_inschar(key);
     }
   }
   /* update all wraps and cursor position */
   nne_update_coords();
   return 1;
 }
 
 int main(int argc, char* argv[]) { /* editor entry point */
   /* use the alternative screen buffer and enable UTF-8 */
   nnputs(ALTBUFON CLS "\033[?7h");
   /* prepare screen */
   tcgetattr(0, &tty_opts_backup);
   atexit(&cleanup);
   /* cfmakeraw is non-POSIX, so emulating it */
   tty_opts_raw.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP |
     INLCR | IGNCR | ICRNL | IXON);
   tty_opts_raw.c_oflag &= ~OPOST;
   tty_opts_raw.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
   tty_opts_raw.c_cflag &= ~(CSIZE | PARENB);
   tty_opts_raw.c_cflag |= CS8;
   tty_opts_raw.c_cc[VMIN] = 0;
   tty_opts_raw.c_cc[VTIME] = 1;
   tty_opts_raw.c_iflag |= 0x4000; /* IUTF8 */
   tcsetattr(0, TCSANOW, &tty_opts_raw);
   nne_scrbuf = malloc(0); /* allocate the minimum for screen */
   resizehandler(SIGWINCH); /* populate the dimensions now */
   /* end prepare screen */
   /* prepare editor parameters */
   nne_scrx = nne_scry = nne_row = nne_col = 1;
   nne_buflines = 0;
   nne_mode = NNE_NORMAL;
   nne_pos = 0;
   nne_len = nne_real_len = 1;
   nne_textbuf = malloc(0); /* allocate the minimum for text */
   nne_clipbuf = malloc(0); /* allocate the minimum for clipboard */
   nne_inschar(' '); /* initialize the last character in the buffer */
   if(argc > 1) { /* file name exists */
     memmove(nne_fname, argv[1], NNE_IOBUFSZ);
     nne_loadfile(nne_fname);
   } else memmove(nne_fname, "(new)", 6);
   /* end prepare editor parameters */
   render();
   while(nne_action(inkey())) render(); /* main loop */
   cleanup();
   if(nne_textbuf) free(nne_textbuf); /* free main text */
   if(nne_scrbuf) free(nne_scrbuf);   /* free screen */
   if(nne_clipbuf) free(nne_clipbuf); /* free clipboard */
   return 0;
 }