1 files changed, 879 insertions, 14 deletions

diff --git a/toys/pending/vi.c b/toys/pending/vi.c
index bf8db841..db2f42c9 100644
--- a/toys/pending/vi.c
+++ b/toys/pending/vi.c
@@ -1,17 +1,15 @@
 /* vi.c - You can't spell "evil" without "vi".
  *
  * Copyright 2015 Rob Landley <rob@landley.net>
+ * Copyright 2019 Jarno Mäkipää <jmakip87@gmail.com>
  *
  * See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/vi.html
-
 USE_VI(NEWTOY(vi, "<1>1", TOYFLAG_USR|TOYFLAG_BIN))
-
 config VI
   bool "vi"
   default n
   help
     usage: vi FILE
-
     Visual text editor. Predates the existence of standardized cursor keys,
     so the controls are weird and historical.
 */
@@ -20,29 +18,896 @@ config VI
 #include "toys.h"
 
 GLOBALS(
-  struct linestack *ls;
-  char *statline;
+    struct termios default_opts;
+    struct linestack *ls;
+    char *statline;
+    int cur_col;
+    int cur_row;
+    unsigned screen_height;
+    unsigned screen_width;
+    int vi_mode;
 )
 
+/*
+ *
+ * TODO:
+ * BUGS:  screen pos adjust does not cover "widelines"
+ *        utf8 problems with some files. perhaps use lib utf8 functions instead
+ *        append to EOL does not show input but works when ESC out
+ *        
+ *
+ * REFACTOR:  use dllist functions where possible.
+ *            draw_page dont draw full page at time if nothing changed...
+ *            ex callbacks
+ *            
+ * FEATURE:   ex: / ? %   //atleast easy cases
+ *            vi: x dw d$ d0 
+ *            vi: yw yy (y0 y$)
+ *            vi+ex: gg G //line movements
+ *            ex: r 
+ *            ex: !external programs
+ *            ex: w filename //only writes to same file now
+ *            big file support? 
+ */
+
+
 struct linestack_show {
   struct linestack_show *next;
   long top, left;
   int x, width, y, height;
 };
 
-// linestack, what to show, where to show it
-void linestack_show(struct linestack *ls, struct linestack_show *lss)
+static void draw_page();
+static void draw_char(char c, int x, int y, int highlight);
+//utf8 support
+static int utf8_dec(char key, char* utf8_scratch,int* sta_p) ;
+static int utf8_len(char* str);
+static int draw_rune(char* c,int x,int y, int highlight);
+
+
+static void cur_left();
+static void cur_right();
+static void cur_up();
+static void cur_down();
+static void check_cursor_bounds();
+static void adjust_screen_buffer();
+
+
+struct str_line {
+  int alloc_len;
+  int str_len; 
+  char* str_data;
+};
+
+//lib dllist uses next and prev kinda opposite what im used to so I just
+//renamed both ends to up and down
+struct linelist {
+  struct linelist *up;//next
+  struct linelist *down;//prev
+  struct str_line *line;
+};
+//inserted line not yet pushed to buffer
+struct str_line *il;
+struct linelist *text; //file loaded into buffer
+struct linelist *scr_r;//current screen coord 0 row
+struct linelist *c_r;//cursor position row 
+int modified;
+
+void dlist_insert_nomalloc(struct double_list **list, struct double_list *new)
 {
-  return;
+  if (*list) {
+    new->next = *list;
+    new->prev = (*list)->prev;
+    if((*list)->prev) (*list)->prev->next = new;
+    (*list)->prev = new;
+  } else *list = new->next = new->prev = new;
 }
 
-void vi_main(void)
+
+// Add an entry to the end of a doubly linked list
+struct double_list *dlist_insert(struct double_list **list, char *data)
 {
-  int i;
+  struct double_list *new = xmalloc(sizeof(struct double_list));
+  new->data = data;
+  dlist_insert_nomalloc(list, new);
 
-  if (!(TT.ls = linestack_load(*toys.optargs)))
-    TT.ls = xzalloc(sizeof(struct linestack));
+  return new;
+}
+void linelist_unload() 
+{
  
-  for (i=0; i<TT.ls->len; i++)
-    printf("%.*s\n", (int)TT.ls->idx[i].len, (char *)TT.ls->idx[i].ptr);  
+}
+
+void write_file(char* filename)
+{
+  struct linelist *lst = text;
+  FILE *fp = 0;
+  if (!filename)
+    filename = (char*)*toys.optargs;
+  fp = fopen(filename,"w");
+  if (!fp) return ;
+  while(lst) {
+    fprintf(fp,"%s\n",lst->line->str_data);
+    lst = lst->down;
+  }
+  fclose(fp);
+}
+
+int linelist_load(char* filename) 
+{
+  struct linelist *lst = c_r;//cursor position or 0
+  FILE* fp = 0;
+  if (!filename)
+    filename = (char*)*toys.optargs;
+
+  fp = fopen(filename, "r");
+  if (!fp) return 0;
+
+
+  for (;;) {
+    char* line = xzalloc(80);
+    ssize_t alc =80;
+    ssize_t len;
+    if ((len = getline(&line, (void *)&alc, fp))== -1) {
+      if (errno == EINVAL || errno == ENOMEM) {
+        printf("error %d\n",errno);
+      }
+      free(line);
+      break;
+    }
+    lst = (struct linelist*)dlist_add((struct double_list**)&lst,
+        xzalloc(sizeof(struct str_line)));
+    lst->line->alloc_len = alc;
+    lst->line->str_len = len;
+    lst->line->str_data = line;
+
+    if (lst->line->str_data[len-1]=='\n') {
+      lst->line->str_data[len-1]=0;
+      lst->line->str_len--;
+    }
+    if (text == 0) {
+      text = lst;
+    }
+
+  }
+  if (text) {
+    dlist_terminate(text->up);
+  }
+  fclose(fp);
+  return 1;
+
+}
+//TODO this is overly complicated refactor with lib dllist
+int ex_dd(int count) 
+{
+  struct linelist* lst = c_r;
+  if (c_r==text && text == scr_r) {
+    if (!text->down && !text->up && text->line) {
+      text->line->str_len=1;
+      sprintf(text->line->str_data," ");
+      goto success_exit;
+    } 
+    if (text->down) {
+      text =text->down;
+      text->up=0;
+      c_r=text;
+      scr_r=text;
+      free(lst->line->str_data);
+      free(lst->line);
+      free(lst);
+    }
+     goto recursion_exit;  
+  }
+  //TODO use lib dllist stuff
+  if (lst)
+  {
+    if (lst->down) {
+      lst->down->up = lst->up;
+    }
+    if (lst->up) {
+      lst->up->down = lst->down; 
+    }
+    if (scr_r == c_r) {
+      scr_r =c_r->down ? c_r->down : c_r->up; 
+    }
+    if (c_r->down)
+      c_r = c_r->down;
+    else {
+      c_r = c_r->up; 
+      count = 1;
+    }
+    free(lst->line->str_data);
+    free(lst->line);
+    free(lst);
+  }
+
+recursion_exit:
+  count--;
+  //make this recursive
+  if (count)
+    return ex_dd(count);
+success_exit:
+  check_cursor_bounds();
+  adjust_screen_buffer();
+  return 1;
+}
+
+int ex_dw(int count)
+{
+  return 1;
+}
+
+int ex_deol(int count) 
+{
+  return 1;
+}
+//does not work with utf8 yet
+int vi_x(int count)
+{
+  char* s;
+  int* l;
+  int* p;
+  if (!c_r)
+    return 0;
+  s = c_r->line->str_data;
+  l = &c_r->line->str_len;
+  p = &TT.cur_col;
+  if (!(*l)) return 0;
+  if ((*p) == (*l)-1) { 
+    s[*p]=0;
+    if (*p) (*p)--; 
+    (*l)--;
+  } else { 
+    memmove(s+(*p),s+(*p)+1,(*l)-(*p)); 
+    s[*l]=0; 
+    (*l)--; 
+  }
+  count--;
+  return (count) ? vi_x(count) : 1; 
+}
+
+//move commands does not behave correct way yet.
+//only jump to next space for now.
+int vi_movw(int count) 
+{
+  if (!c_r)
+    return 0;
+  //could we call moveend first
+  while(c_r->line->str_data[TT.cur_col] > ' ') 
+    TT.cur_col++;
+  while(c_r->line->str_data[TT.cur_col] <= ' ') {
+    TT.cur_col++;
+    if (!c_r->line->str_data[TT.cur_col]) {
+      //we could call j and g0
+      if (!c_r->down) return 0;
+      c_r = c_r->down;
+      TT.cur_col=0;
+    }
+  } 
+  count--;
+  if (count>1)
+    return vi_movw(count);
+
+      check_cursor_bounds();
+      adjust_screen_buffer();
+  return 1;
+}
+
+int vi_movb(int count) 
+{
+  if (!c_r)
+    return 0;
+  if (!TT.cur_col) {
+      if (!c_r->up) return 0;
+      c_r = c_r->up;
+      TT.cur_col=(c_r->line->str_len) ? c_r->line->str_len-1 : 0;
+      goto exit_function;
+  }
+  if (TT.cur_col)
+      TT.cur_col--;
+  while(c_r->line->str_data[TT.cur_col] <= ' ') {
+    if (TT.cur_col) TT.cur_col--;
+    else goto exit_function;
+  } 
+  while(c_r->line->str_data[TT.cur_col] > ' ') {
+    if (TT.cur_col)TT.cur_col--;
+    else goto exit_function;
+  }
+  TT.cur_col++;
+exit_function:
+  count--;
+  if (count>1)
+    return vi_movb(count);
+      check_cursor_bounds();
+      adjust_screen_buffer();
+  return 1;
+}
+
+int vi_move(int count) 
+{
+  if (!c_r)
+    return 0;
+  if (TT.cur_col < c_r->line->str_len)
+    TT.cur_col++;
+  if (c_r->line->str_data[TT.cur_col] <= ' ' || count > 1)
+    vi_movw(count); //find next word; 
+  while(c_r->line->str_data[TT.cur_col] > ' ') 
+    TT.cur_col++;
+  if (TT.cur_col) TT.cur_col--;
+      check_cursor_bounds();
+      adjust_screen_buffer();
+  return 1;
+}
+
+void i_insert()
+{
+  char* t = xzalloc(c_r->line->alloc_len);
+  char* s = c_r->line->str_data;
+   int sel = c_r->line->str_len-TT.cur_col;
+  strncpy(t,&s[TT.cur_col],sel);
+  t[sel+1] = 0;
+  if (c_r->line->alloc_len< c_r->line->str_len+il->str_len+5) {
+    c_r->line->str_data = xrealloc(c_r->line->str_data,c_r->line->alloc_len*2+il->alloc_len*2);
+    c_r->line->alloc_len = c_r->line->alloc_len*2 + 2*il->alloc_len;
+    memset(&c_r->line->str_data[c_r->line->str_len],0,c_r->line->alloc_len-c_r->line->str_len);
+  s = c_r->line->str_data;
+  }
+  strcpy(&s[TT.cur_col],il->str_data);
+  strcpy(&s[TT.cur_col+il->str_len],t);
+  TT.cur_col += il->str_len;
+  if (TT.cur_col) TT.cur_col--;
+  c_r->line->str_len+=il->str_len;
+  free(t);
+
+}
+//new line at split pos;
+void i_split()
+{
+  struct str_line* l = xmalloc(sizeof(struct str_line));
+  int l_a = c_r->line->alloc_len;
+  int l_len = c_r->line->str_len-TT.cur_col;
+  l->str_data = xzalloc(l_a);
+  l->alloc_len=l_a;
+  l->str_len = l_len;
+  strncpy(l->str_data,&c_r->line->str_data[TT.cur_col],l_len);
+  l->str_data[l_len] = 0;
+  c_r->line->str_len-=l_len;
+  c_r->line->str_data[c_r->line->str_len] = 0;
+  c_r = (struct linelist*)dlist_insert((struct double_list**)&c_r,(char*)l);
+  c_r->line = l;
+  TT.cur_col=0;
+  check_cursor_bounds();
+  adjust_screen_buffer();
+}
+
+struct vi_cmd_param {
+  const char* cmd;
+  int (*vi_cmd_ptr)(int);
+};
+struct vi_cmd_param vi_cmds[7] =
+{
+  {"dd",&ex_dd},
+  {"dw",&ex_dw},
+  {"d$",&ex_deol},
+  {"w",&vi_movw},
+  {"b",&vi_movb},
+  {"e",&vi_move},
+  {"x",&vi_x},
+};
+int run_vi_cmd(char* cmd) 
+{
+  int val = 0;
+  char* cmd_e;
+  errno = 0;
+  val = strtol(cmd, &cmd_e, 10);
+  if (errno || val == 0) {
+    val = 1;
+  }
+  else {
+    cmd = cmd_e;
+  }
+  for(int i=0;i<7;i++) {
+    if (strstr(cmd,vi_cmds[i].cmd)) {
+      return vi_cmds[i].vi_cmd_ptr(val);
+    }
+  }
+  return 0;
+
+}
+
+int search_str(char* s)
+{
+  struct linelist* lst = c_r;
+  char *c = strstr(&c_r->line->str_data[TT.cur_col],s);
+  if (c) {
+    TT.cur_col = c_r->line->str_data-c;
+  TT.cur_col=c-c_r->line->str_data;
+  }
+  else for(;!c;) {
+    lst = lst->down;
+    if (!lst) return 1;
+    c = strstr(&lst->line->str_data[TT.cur_col],s);
+  }
+  c_r=lst;
+  TT.cur_col=c-c_r->line->str_data;
+  return 0;
+}
+ 
+int run_ex_cmd(char* cmd)
+{
+  if (cmd[0] == '/') {
+    //search pattern 
+    if (!search_str(&cmd[1]) ) {
+      check_cursor_bounds();
+      adjust_screen_buffer();
+    }
+  } else if (cmd[0] == '?') {
+
+  } else if (cmd[0] == ':') {
+    if (strstr(&cmd[1],"q!")) {
+      //exit_application;
+      return -1;
+    }
+    else if (strstr(&cmd[1],"wq")) {
+      write_file(0);
+      return -1;
+    }
+    else if (strstr(&cmd[1],"w")) {
+      write_file(0);
+      return 1;
+    }
+  }
+  return 0;
+
+}
+
+void vi_main(void)
+{
+  char keybuf[16];
+  char utf8_code[8];
+  int utf8_dec_p = 0;
+  int key = 0;
+  char vi_buf[16];
+  int vi_buf_pos=0;
+  il = xzalloc(sizeof(struct str_line));
+  il->str_data = xzalloc(80);
+  il->alloc_len = 80;
+  keybuf[0] = 0;
+  memset(vi_buf,0,16);
+  memset(utf8_code,0,8);
+  linelist_load(0);
+  scr_r = text;
+  c_r = text;
+  TT.cur_row = 0;
+  TT.cur_col = 0;
+  TT.screen_width = 80;
+  TT.screen_height = 24;
+  TT.vi_mode = 1;
+  terminal_size(&TT.screen_width, &TT.screen_height);
+  TT.screen_height -=2; //TODO this is hack fix visual alignment
+  set_terminal(0,1,0,0);
+  //writes stdout into different xterm buffer so when we exit
+  //we dont get scroll log full of junk
+  tty_esc("?1049h");
+  tty_esc("H");
+  xflush();
+  draw_page();
+  while(1) {
+    key = scan_key(keybuf,-1);
+    printf("key %d\n",key);
+    switch (key) {
+      case -1:
+      case 3:
+      case 4:
+        goto cleanup_vi;
+    }
+    if (TT.vi_mode == 1) { //NORMAL
+      switch (key) {
+        case 'h':
+          cur_left();
+          break;
+        case 'j':
+          cur_down();
+          break;
+        case 'k':
+          cur_up();
+          break;
+        case 'l':
+          cur_right();
+          break;
+        case '/':
+        case '?':
+        case ':':
+          TT.vi_mode = 0;
+          il->str_data[0]=key;
+          il->str_len++;
+          break;
+        case 'a':
+          TT.cur_col++;
+        case 'i':
+          TT.vi_mode = 2;
+          break;
+        case 27:
+          vi_buf[0] = 0;
+          vi_buf_pos = 0;
+          break;
+        default:
+          if (key > 0x20 && key < 0x7B) {
+            vi_buf[vi_buf_pos] = key;
+            vi_buf_pos++;
+            if (run_vi_cmd(vi_buf)) {
+              memset(vi_buf,0,16);
+              vi_buf_pos=0;
+            }
+            else if (vi_buf_pos==16) {
+              vi_buf_pos = 0;
+            }
+
+          } 
+
+          break;
+      }
+    } else if (TT.vi_mode == 0) { //EX MODE
+      switch (key) {
+        case 27:
+          TT.vi_mode=1;
+          il->str_len = 0;
+          memset(il->str_data,0,il->alloc_len);
+          break;
+        case 0x7F:
+        case 0x08:
+          if (il->str_len){
+            il->str_data[il->str_len] = 0;
+            if (il->str_len>1) il->str_len--;
+          }
+          break;
+        case 0x0D:
+            if (run_ex_cmd(il->str_data) == -1)
+              goto cleanup_vi;
+          TT.vi_mode=1;
+          il->str_len = 0;
+          memset(il->str_data,0,il->alloc_len);
+          break;
+        default: //add chars to ex command until ENTER
+          if (key >= 0x20 && key < 0x7F) { //might be utf?
+            if (il->str_len == il->alloc_len)
+            {
+              il->str_data = realloc(il->str_data,il->alloc_len*2);
+              il->alloc_len *=2;
+            }
+            il->str_data[il->str_len] = key;
+            il->str_len++;
+          }
+          break;
+      }
+    } else if (TT.vi_mode == 2) {//INSERT MODE
+      switch (key) {
+        case 27:
+          i_insert();
+          TT.vi_mode=1;
+          il->str_len = 0;
+          memset(il->str_data,0,il->alloc_len);
+          break;
+        case 0x7F:
+        case 0x08:
+          if (il->str_len)
+            il->str_data[il->str_len--] = 0;
+          break;
+        case 0x09:
+          //TODO implement real tabs
+          il->str_data[il->str_len++] = ' ';
+          il->str_data[il->str_len++] = ' ';
+          break;
+
+        case 0x0D:
+          //insert newline
+          //
+          i_insert();
+          il->str_len = 0;
+          memset(il->str_data,0,il->alloc_len);
+          i_split();
+          break;
+        default:
+          if (key >= 0x20 /*&& key < 0x7F) { 
+            if (il->str_len == il->alloc_len)
+            {
+              il->str_data = realloc(il->str_data,il->alloc_len*2);
+              il->alloc_len *=2;
+            }
+            il->str_data[il->str_len] = key;
+            il->str_len++;
+          } else if (key > 0x7F */&& utf8_dec(key, utf8_code, &utf8_dec_p)) {
+            if (il->str_len+utf8_dec_p+1 >= il->alloc_len)
+            {
+              il->str_data = realloc(il->str_data,il->alloc_len*2);
+              il->alloc_len *=2;
+            }
+            strcpy(il->str_data+il->str_len,utf8_code);
+            il->str_len +=utf8_dec_p;
+            utf8_dec_p=0;
+            *utf8_code=0;
+
+          }
+          break;
+      }
+    }
+
+    draw_page();
+
+  }
+cleanup_vi:
+ tty_reset();
+  tty_esc("?1049l");
+}
+
+static void draw_page()
+{
+  unsigned y = 0;
+  int cy_scr =0;
+  int cx_scr =0;
+  struct linelist* scr_buf= scr_r;
+  //clear screen
+  tty_esc("2J");
+  tty_esc("H");
+
+
+  tty_jump(0,0);
+  for(; y < TT.screen_height; ) {
+    if (scr_buf && scr_buf->line->str_data && scr_buf->line->str_len) {
+      for(int p = 0; p < scr_buf->line->str_len;y++) {
+        unsigned x = 0;
+        for(;x<TT.screen_width;x++) {
+          if (p < scr_buf->line->str_len) {
+            int hi = 0;
+            if (scr_buf == c_r && p == TT.cur_col) {
+              if (TT.vi_mode == 2) {
+                tty_jump(x,y);
+                
+                tty_esc("1m"); //bold
+                printf("%s",il->str_data);
+                x+=il->str_len;
+                tty_esc("0m"); 
+              } 
+              cy_scr = y;
+              cx_scr = x;
+            }
+            int l = draw_rune(&scr_buf->line->str_data[p],x,y,hi);
+            if (!l)
+              break;
+            p+=l;
+            if (l>2) x++;//traditional chinese is somehow 2 width in tty???
+          }
+          else {
+            if (scr_buf == c_r && p == TT.cur_col) {
+              if (TT.vi_mode == 2) {
+                tty_jump(x,y);
+                
+                tty_esc("1m"); //bold
+                printf("%s",il->str_data);
+                x+=il->str_len;
+                tty_esc("0m"); 
+              } 
+              cy_scr = y;
+              cx_scr = x;
+            }
+            break; 
+          }
+        }
+        printf("\r\n"); 
+      }
+    }
+    else {
+      if (scr_buf == c_r){
+              cy_scr = y;
+              cx_scr = 0;
+              if (TT.vi_mode == 2) {
+                tty_jump(0,y);
+                tty_esc("1m"); //bold
+                printf("%s",il->str_data);
+                cx_scr +=il->str_len;
+                tty_esc("0m"); 
+              } else draw_char(' ',0,y,1);
+      }
+     y++; 
+    }
+    printf("\n");
+    if (scr_buf->down)
+      scr_buf=scr_buf->down;
+    else break;
+  }
+  for(;y < TT.screen_height;y++) {
+              printf("\n");
+  }
+
+  tty_jump(0, TT.screen_height);
+  switch (TT.vi_mode) {
+    case 0:
+    tty_esc("30;44m"); 
+    printf("COMMAND|");
+    break;
+    case 1:
+    tty_esc("30;42m"); 
+    printf("NORMAL|");
+    break;
+    case 2:
+    tty_esc("30;41m"); 
+    printf("INSERT|");
+    break;
+
+  }
+  //DEBUG
+  tty_esc("47m"); 
+  tty_esc("30m"); 
+  int i = utf8_len(&c_r->line->str_data[TT.cur_col]);
+  if (i) {
+    char t[5] = {0,0,0,0,0};
+    strncpy(t,&c_r->line->str_data[TT.cur_col],i);
+    printf("utf: %d %s",i,t);
+  }
+  printf("| %d, %d\n",cx_scr,cy_scr); //screen coord
+  
+  tty_jump(TT.screen_width-12, TT.screen_height);
+  printf("| %d, %d\n",TT.cur_row,TT.cur_col);
+  tty_esc("37m"); 
+  tty_esc("40m");
+  if (!TT.vi_mode) {
+    tty_esc("1m");
+    tty_jump(0,TT.screen_height+1);
+    printf("%s",il->str_data);
+  } else tty_jump(cx_scr,cy_scr);
+  xflush();
+
+}
+static void draw_char(char c, int x, int y, int highlight) 
+{
+  tty_jump(x,y);
+  if (highlight) {
+    tty_esc("30m"); //foreground black
+    tty_esc("47m"); //background white 
+  }
+  printf("%c",c);
+}
+//utf rune draw
+//printf and useless copy could be replaced by direct write() to stdout
+static int draw_rune(char* c,int x,int y, int highlight)
+{
+  int l = utf8_len(c);
+  char t[5] = {0,0,0,0,0};
+  if (!l) return 0;
+  tty_jump(x,y);
+  tty_esc("0m");
+  if (highlight) {
+    tty_esc("30m"); //foreground black
+    tty_esc("47m"); //background white 
+  }
+  strncpy(t,c,5);
+ printf("%s",t);
+  tty_esc("0m");
+  return l;
+}
+
+static void check_cursor_bounds()
+{
+  if (c_r->line->str_len-1 < TT.cur_col) {
+    if (c_r->line->str_len == 0)
+      TT.cur_col = 0;
+    else
+      TT.cur_col = c_r->line->str_len-1;
+  }
+}
+
+static void adjust_screen_buffer() 
+{
+  //search cursor and screen TODO move this perhaps
+  struct linelist* t = text;
+  int c = -1;
+  int s = -1;
+  int i = 0;
+  for(;;) {
+    i++;
+    if (t == c_r)
+      c = i;
+    if (t == scr_r)
+      s = i;
+    t = t->down;
+    if ( ((c != -1) && (s != -1)) || t == 0)
+      break;
+  }
+  if (c <= s) {
+    scr_r = c_r;
+  }
+  else if ( c > s ) {
+    //should count multiline long strings!
+    int distance = c - s +1;
+    //TODO instead iterate scr_r up and check strlen%screen_width 
+    //for each iteration
+    if (distance >= (int)TT.screen_height) {
+      int adj = distance - TT.screen_height;
+      while(adj--) {
+        scr_r = scr_r->down;
+      }
+    }
+  }
+  TT.cur_row = c;
+
+}
+
+//return 0 if not ASCII nor UTF-8
+//this is not fully tested
+//naive implementation with branches
+//there is better branchless lookup table versions out there
+//1 0xxxxxxx
+//2 110xxxxx  10xxxxxx 
+//3 1110xxxx	10xxxxxx	10xxxxxx
+//4	11110xxx	10xxxxxx	10xxxxxx	10xxxxxx
+static int utf8_len(char* str)
+{
+  int len=0;
+  uint8_t *c = (uint8_t*)str; 
+  if (!c || !(*c)) return 0; 
+  if (*c < 0x7F) return 1; 
+  if ((*c & 0xE0) == 0xc0) len = 2;
+  else if ((*c & 0xF0) == 0xE0 ) len = 3;
+  else if ((*c & 0xF8) == 0xF0 ) len = 4;
+  else return 0;
+  c++;
+  for(int i = len-1;i>0;i--) {
+    if ((*c++ & 0xc0)!=0x80) return 0;
+  }
+  return len;
+}
+
+static int utf8_dec(char key, char* utf8_scratch,int* sta_p) 
+{
+  int len = 0;
+  char* c = utf8_scratch;
+  c[*sta_p] = key;
+  if (!(*sta_p))  *c = key;
+  if (*c < 0x7F) { *sta_p = 1; return 1; }
+  if ((*c & 0xE0) == 0xc0) len = 2;
+  else if ((*c & 0xF0) == 0xE0 ) len = 3;
+  else if ((*c & 0xF8) == 0xF0 ) len = 4;
+  else {*sta_p = 0; return 0; }
+  
+  (*sta_p)++;
+
+  if (*sta_p == 1) return 0;
+  if ((c[*sta_p-1] & 0xc0)!=0x80) {*sta_p = 0; return 0; }
+
+  if (*sta_p == len) { c[(*sta_p)] = 0; return 1; }
+  
+  return 0;
+}
+
+static void cur_left()
+{
+  if (!TT.cur_col) return;
+  TT.cur_col--;
+
+  if (!utf8_len(&c_r->line->str_data[TT.cur_col])) cur_left();
+}
+
+static void cur_right()
+{
+  if (TT.cur_col == c_r->line->str_len-1) return;
+  TT.cur_col++;
+  if (!utf8_len(&c_r->line->str_data[TT.cur_col])) cur_right();
+}
+
+static void cur_up()
+{
+  if (c_r->up != 0)
+    c_r = c_r->up;
+  if (!utf8_len(&c_r->line->str_data[TT.cur_col])) cur_left();
+  check_cursor_bounds();
+  adjust_screen_buffer();
+}
+
+static void cur_down()
+{
+  if (c_r->down != 0)
+    c_r = c_r->down;
+  if (!utf8_len(&c_r->line->str_data[TT.cur_col])) cur_left();
+  check_cursor_bounds();
+  adjust_screen_buffer();
 }