diff options
| -rw-r--r-- | toys/pending/vi.c | 893 |
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(); } |