| /* Kilo -- A very simple editor in less than 1-kilo lines of code (as counted |
| * by "cloc"). Does not depend on libcurses, directly emits VT100 |
| * escapes on the terminal. |
| * |
| * ----------------------------------------------------------------------- |
| * |
| * Copyright (C) 2016 Salvatore Sanfilippo <antirez at gmail dot com> |
| * |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #define KILO_VERSION "0.0.1" |
| |
| #ifndef _BSD_SOURCE |
| #define _BSD_SOURCE |
| #endif |
| #define _GNU_SOURCE |
| |
| #include <termios.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <ctype.h> |
| #include <sys/types.h> |
| #include <sys/ioctl.h> |
| #include <sys/time.h> |
| #include <unistd.h> |
| #include <stdarg.h> |
| #include <fcntl.h> |
| |
| #ifdef __Fuchsia__ |
| #include <zircon/device/console.h> |
| |
| static time_t time(void* arg) { |
| return 0; |
| } |
| |
| static int getConsoleSize(int *rows, int *cols) { |
| ioctl_console_dimensions_t dims; |
| ssize_t r = ioctl_console_get_dimensions(0, &dims); |
| if (r != sizeof(dims)) { |
| return -1; |
| } |
| *rows = dims.height; |
| *cols = dims.width; |
| return 0; |
| } |
| |
| #endif |
| |
| /* Syntax highlight types */ |
| #define HL_NORMAL 0 |
| #define HL_NONPRINT 1 |
| #define HL_COMMENT 2 /* Single line comment. */ |
| #define HL_MLCOMMENT 3 /* Multi-line comment. */ |
| #define HL_KEYWORD1 4 |
| #define HL_KEYWORD2 5 |
| #define HL_STRING 6 |
| #define HL_NUMBER 7 |
| #define HL_MATCH 8 /* Search match. */ |
| |
| #define HL_HIGHLIGHT_STRINGS (1<<0) |
| #define HL_HIGHLIGHT_NUMBERS (1<<1) |
| |
| struct editorSyntax { |
| char **filematch; |
| char **keywords; |
| char singleline_comment_start[2]; |
| char multiline_comment_start[3]; |
| char multiline_comment_end[3]; |
| int flags; |
| }; |
| |
| /* This structure represents a single line of the file we are editing. */ |
| typedef struct erow { |
| int idx; /* Row index in the file, zero-based. */ |
| int size; /* Size of the row, excluding the null term. */ |
| int rsize; /* Size of the rendered row. */ |
| char *chars; /* Row content. */ |
| char *render; /* Row content "rendered" for screen (for TABs). */ |
| unsigned char *hl; /* Syntax highlight type for each character in render.*/ |
| int hl_oc; /* Row had open comment at end in last syntax highlight |
| check. */ |
| } erow; |
| |
| typedef struct hlcolor { |
| int r,g,b; |
| } hlcolor; |
| |
| struct editorConfig { |
| int cx,cy; /* Cursor x and y position in characters */ |
| int rowoff; /* Offset of row displayed. */ |
| int coloff; /* Offset of column displayed. */ |
| int screenrows; /* Number of rows that we can show */ |
| int screencols; /* Number of cols that we can show */ |
| int numrows; /* Number of rows */ |
| int rawmode; /* Is terminal raw mode enabled? */ |
| erow *row; /* Rows */ |
| int dirty; /* File modified but not saved. */ |
| char *filename; /* Currently open filename */ |
| char statusmsg[80]; |
| time_t statusmsg_time; |
| struct editorSyntax *syntax; /* Current syntax highlight, or NULL. */ |
| }; |
| |
| static struct editorConfig E; |
| |
| enum KEY_ACTION{ |
| KEY_NULL = 0, /* NULL */ |
| CTRL_C = 3, /* Ctrl-c */ |
| CTRL_D = 4, /* Ctrl-d */ |
| CTRL_F = 6, /* Ctrl-f */ |
| CTRL_H = 8, /* Ctrl-h */ |
| TAB = 9, /* Tab */ |
| CTRL_L = 12, /* Ctrl+l */ |
| NEWLINE = 10, /* Newline */ |
| ENTER = 13, /* Enter */ |
| CTRL_Q = 17, /* Ctrl-q */ |
| CTRL_S = 19, /* Ctrl-s */ |
| CTRL_U = 21, /* Ctrl-u */ |
| ESC = 27, /* Escape */ |
| BACKSPACE = 127, /* Backspace */ |
| /* The following are just soft codes, not really reported by the |
| * terminal directly. */ |
| ARROW_LEFT = 1000, |
| ARROW_RIGHT, |
| ARROW_UP, |
| ARROW_DOWN, |
| DEL_KEY, |
| HOME_KEY, |
| END_KEY, |
| PAGE_UP, |
| PAGE_DOWN |
| }; |
| |
| void editorSetStatusMessage(const char *fmt, ...); |
| |
| /* =========================== Syntax highlights DB ========================= |
| * |
| * In order to add a new syntax, define two arrays with a list of file name |
| * matches and keywords. The file name matches are used in order to match |
| * a given syntax with a given file name: if a match pattern starts with a |
| * dot, it is matched as the last past of the filename, for example ".c". |
| * Otherwise the pattern is just searched inside the filenme, like "Makefile"). |
| * |
| * The list of keywords to highlight is just a list of words, however if they |
| * a trailing '|' character is added at the end, they are highlighted in |
| * a different color, so that you can have two different sets of keywords. |
| * |
| * Finally add a stanza in the HLDB global variable with two two arrays |
| * of strings, and a set of flags in order to enable highlighting of |
| * comments and numbers. |
| * |
| * The characters for single and multi line comments must be exactly two |
| * and must be provided as well (see the C language example). |
| * |
| * There is no support to highlight patterns currently. */ |
| |
| /* C / C++ */ |
| char *C_HL_extensions[] = {".c",".cpp",NULL}; |
| char *C_HL_keywords[] = { |
| /* A few C / C++ keywords */ |
| "switch","if","while","for","break","continue","return","else", |
| "struct","union","typedef","static","enum","class", |
| /* C types */ |
| "int|","long|","double|","float|","char|","unsigned|","signed|", |
| "void|",NULL |
| }; |
| |
| /* Here we define an array of syntax highlights by extensions, keywords, |
| * comments delimiters and flags. */ |
| struct editorSyntax HLDB[] = { |
| { |
| /* C / C++ */ |
| C_HL_extensions, |
| C_HL_keywords, |
| "//","/*","*/", |
| HL_HIGHLIGHT_STRINGS | HL_HIGHLIGHT_NUMBERS |
| } |
| }; |
| |
| #define HLDB_ENTRIES (sizeof(HLDB)/sizeof(HLDB[0])) |
| |
| /* ======================= Low level terminal handling ====================== */ |
| |
| static struct termios orig_termios; /* In order to restore at exit.*/ |
| |
| void disableRawMode(int fd) { |
| /* Don't even check the return value as it's too late. */ |
| if (E.rawmode) { |
| tcsetattr(fd,TCSAFLUSH,&orig_termios); |
| E.rawmode = 0; |
| } |
| } |
| |
| /* Called at exit to avoid remaining in raw mode. */ |
| void editorAtExit(void) { |
| disableRawMode(STDIN_FILENO); |
| } |
| |
| /* Raw mode: 1960 magic shit. */ |
| int enableRawMode(int fd) { |
| #ifdef __Fuchsia__ |
| return 0; |
| #else |
| struct termios raw; |
| |
| if (E.rawmode) return 0; /* Already enabled. */ |
| if (!isatty(STDIN_FILENO)) goto fatal; |
| atexit(editorAtExit); |
| if (tcgetattr(fd,&orig_termios) == -1) goto fatal; |
| |
| raw = orig_termios; /* modify the original mode */ |
| /* input modes: no break, no CR to NL, no parity check, no strip char, |
| * no start/stop output control. */ |
| raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); |
| /* output modes - disable post processing */ |
| raw.c_oflag &= ~(OPOST); |
| /* control modes - set 8 bit chars */ |
| raw.c_cflag |= (CS8); |
| /* local modes - choing off, canonical off, no extended functions, |
| * no signal chars (^Z,^C) */ |
| raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); |
| /* control chars - set return condition: min number of bytes and timer. */ |
| raw.c_cc[VMIN] = 0; /* Return each byte, or zero for timeout. */ |
| raw.c_cc[VTIME] = 1; /* 100 ms timeout (unit is tens of second). */ |
| |
| /* put terminal in raw mode after flushing */ |
| if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal; |
| E.rawmode = 1; |
| return 0; |
| |
| fatal: |
| errno = ENOTTY; |
| return -1; |
| #endif |
| } |
| |
| /* Read a key from the terminal put in raw mode, trying to handle |
| * escape sequences. */ |
| int editorReadKey(int fd) { |
| int nread; |
| char c, seq[3]; |
| while ((nread = read(fd,&c,1)) == 0); |
| if (nread == -1) exit(1); |
| |
| while(1) { |
| switch(c) { |
| case NEWLINE: |
| return ENTER; |
| case ESC: /* escape sequence */ |
| /* If this is just an ESC, we'll timeout here. */ |
| if (read(fd,seq,1) == 0) return ESC; |
| if (read(fd,seq+1,1) == 0) return ESC; |
| |
| /* ESC [ sequences. */ |
| if (seq[0] == '[') { |
| if (seq[1] >= '0' && seq[1] <= '9') { |
| /* Extended escape, read additional byte. */ |
| if (read(fd,seq+2,1) == 0) return ESC; |
| if (seq[2] == '~') { |
| switch(seq[1]) { |
| case '3': return DEL_KEY; |
| case '5': return PAGE_UP; |
| case '6': return PAGE_DOWN; |
| } |
| } |
| } else { |
| switch(seq[1]) { |
| case 'A': return ARROW_UP; |
| case 'B': return ARROW_DOWN; |
| case 'C': return ARROW_RIGHT; |
| case 'D': return ARROW_LEFT; |
| case 'H': return HOME_KEY; |
| case 'F': return END_KEY; |
| } |
| } |
| } |
| |
| /* ESC O sequences. */ |
| else if (seq[0] == 'O') { |
| switch(seq[1]) { |
| case 'H': return HOME_KEY; |
| case 'F': return END_KEY; |
| } |
| } |
| break; |
| default: |
| return c; |
| } |
| } |
| } |
| |
| /* Use the ESC [6n escape sequence to query the horizontal cursor position |
| * and return it. On error -1 is returned, on success the position of the |
| * cursor is stored at *rows and *cols and 0 is returned. */ |
| int getCursorPosition(int ifd, int ofd, int *rows, int *cols) { |
| char buf[32]; |
| unsigned int i = 0; |
| |
| /* Report cursor location */ |
| if (write(ofd, "\x1b[6n", 4) != 4) return -1; |
| |
| /* Read the response: ESC [ rows ; cols R */ |
| while (i < sizeof(buf)-1) { |
| if (read(ifd,buf+i,1) != 1) break; |
| if (buf[i] == 'R') break; |
| i++; |
| } |
| buf[i] = '\0'; |
| |
| /* Parse it. */ |
| if (buf[0] != ESC || buf[1] != '[') return -1; |
| if (sscanf(buf+2,"%d;%d",rows,cols) != 2) return -1; |
| return 0; |
| } |
| |
| /* Try to get the number of columns in the current terminal. If the ioctl() |
| * call fails the function will try to query the terminal itself. |
| * Returns 0 on success, -1 on error. */ |
| int getWindowSize(int ifd, int ofd, int *rows, int *cols) { |
| #ifdef __Fuchsia__ |
| if (getConsoleSize(rows, cols) == 0) { |
| return 0; |
| } else { |
| #else |
| struct winsize ws; |
| if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) { |
| #endif |
| /* ioctl() failed. Try to query the terminal itself. */ |
| int orig_row, orig_col, retval; |
| |
| /* Get the initial position so we can restore it later. */ |
| retval = getCursorPosition(ifd,ofd,&orig_row,&orig_col); |
| if (retval == -1) goto failed; |
| |
| /* Go to right/bottom margin and get position. */ |
| if (write(ofd,"\x1b[999C\x1b[999B",12) != 12) goto failed; |
| retval = getCursorPosition(ifd,ofd,rows,cols); |
| if (retval == -1) goto failed; |
| |
| /* Restore position. */ |
| char seq[32]; |
| snprintf(seq,32,"\x1b[%d;%dH",orig_row,orig_col); |
| if (write(ofd,seq,strlen(seq)) == -1) { |
| /* Can't recover... */ |
| } |
| return 0; |
| #ifndef __Fuchsia__ |
| } else { |
| *cols = ws.ws_col; |
| *rows = ws.ws_row; |
| return 0; |
| #endif |
| } |
| |
| failed: |
| return -1; |
| } |
| |
| /* ====================== Syntax highlight color scheme ==================== */ |
| |
| int is_separator(int c) { |
| return c == '\0' || isspace(c) || strchr(",.()+-/*=~%[];",c) != NULL; |
| } |
| |
| /* Return true if the specified row last char is part of a multi line comment |
| * that starts at this row or at one before, and does not end at the end |
| * of the row but spawns to the next row. */ |
| int editorRowHasOpenComment(erow *row) { |
| if (row->hl && row->rsize && row->hl[row->rsize-1] == HL_MLCOMMENT && |
| (row->rsize < 2 || (row->render[row->rsize-2] != '*' || |
| row->render[row->rsize-1] != '/'))) return 1; |
| return 0; |
| } |
| |
| /* Set every byte of row->hl (that corresponds to every character in the line) |
| * to the right syntax highlight type (HL_* defines). */ |
| void editorUpdateSyntax(erow *row) { |
| row->hl = realloc(row->hl,row->rsize); |
| memset(row->hl,HL_NORMAL,row->rsize); |
| |
| if (E.syntax == NULL) return; /* No syntax, everything is HL_NORMAL. */ |
| |
| int i, prev_sep, in_string, in_comment; |
| char *p; |
| char **keywords = E.syntax->keywords; |
| char *scs = E.syntax->singleline_comment_start; |
| char *mcs = E.syntax->multiline_comment_start; |
| char *mce = E.syntax->multiline_comment_end; |
| |
| /* Point to the first non-space char. */ |
| p = row->render; |
| i = 0; /* Current char offset */ |
| while(*p && isspace(*p)) { |
| p++; |
| i++; |
| } |
| prev_sep = 1; /* Tell the parser if 'i' points to start of word. */ |
| in_string = 0; /* Are we inside "" or '' ? */ |
| in_comment = 0; /* Are we inside multi-line comment? */ |
| |
| /* If the previous line has an open comment, this line starts |
| * with an open comment state. */ |
| if (row->idx > 0 && editorRowHasOpenComment(&E.row[row->idx-1])) |
| in_comment = 1; |
| |
| while(*p) { |
| /* Handle // comments. */ |
| if (prev_sep && *p == scs[0] && *(p+1) == scs[1]) { |
| /* From here to end is a comment */ |
| memset(row->hl+i,HL_COMMENT,row->size-i); |
| return; |
| } |
| |
| /* Handle multi line comments. */ |
| if (in_comment) { |
| row->hl[i] = HL_MLCOMMENT; |
| if (*p == mce[0] && *(p+1) == mce[1]) { |
| row->hl[i+1] = HL_MLCOMMENT; |
| p += 2; i += 2; |
| in_comment = 0; |
| prev_sep = 1; |
| continue; |
| } else { |
| prev_sep = 0; |
| p++; i++; |
| continue; |
| } |
| } else if (*p == mcs[0] && *(p+1) == mcs[1]) { |
| row->hl[i] = HL_MLCOMMENT; |
| row->hl[i+1] = HL_MLCOMMENT; |
| p += 2; i += 2; |
| in_comment = 1; |
| prev_sep = 0; |
| continue; |
| } |
| |
| /* Handle "" and '' */ |
| if (in_string) { |
| row->hl[i] = HL_STRING; |
| if (*p == '\\') { |
| row->hl[i+1] = HL_STRING; |
| p += 2; i += 2; |
| prev_sep = 0; |
| continue; |
| } |
| if (*p == in_string) in_string = 0; |
| p++; i++; |
| continue; |
| } else { |
| if (*p == '"' || *p == '\'') { |
| in_string = *p; |
| row->hl[i] = HL_STRING; |
| p++; i++; |
| prev_sep = 0; |
| continue; |
| } |
| } |
| |
| /* Handle non printable chars. */ |
| if (!isprint(*p)) { |
| row->hl[i] = HL_NONPRINT; |
| p++; i++; |
| prev_sep = 0; |
| continue; |
| } |
| |
| /* Handle numbers */ |
| if ((isdigit(*p) && (prev_sep || row->hl[i-1] == HL_NUMBER)) || |
| (*p == '.' && i >0 && row->hl[i-1] == HL_NUMBER)) { |
| row->hl[i] = HL_NUMBER; |
| p++; i++; |
| prev_sep = 0; |
| continue; |
| } |
| |
| /* Handle keywords and lib calls */ |
| if (prev_sep) { |
| int j; |
| for (j = 0; keywords[j]; j++) { |
| int klen = strlen(keywords[j]); |
| int kw2 = keywords[j][klen-1] == '|'; |
| if (kw2) klen--; |
| |
| if (!memcmp(p,keywords[j],klen) && |
| is_separator(*(p+klen))) |
| { |
| /* Keyword */ |
| memset(row->hl+i,kw2 ? HL_KEYWORD2 : HL_KEYWORD1,klen); |
| p += klen; |
| i += klen; |
| break; |
| } |
| } |
| if (keywords[j] != NULL) { |
| prev_sep = 0; |
| continue; /* We had a keyword match */ |
| } |
| } |
| |
| /* Not special chars */ |
| prev_sep = is_separator(*p); |
| p++; i++; |
| } |
| |
| /* Propagate syntax change to the next row if the open commen |
| * state changed. This may recursively affect all the following rows |
| * in the file. */ |
| int oc = editorRowHasOpenComment(row); |
| if (row->hl_oc != oc && row->idx+1 < E.numrows) |
| editorUpdateSyntax(&E.row[row->idx+1]); |
| row->hl_oc = oc; |
| } |
| |
| /* Maps syntax highlight token types to terminal colors. */ |
| int editorSyntaxToColor(int hl) { |
| switch(hl) { |
| case HL_COMMENT: |
| case HL_MLCOMMENT: return 36; /* cyan */ |
| case HL_KEYWORD1: return 33; /* yellow */ |
| case HL_KEYWORD2: return 32; /* green */ |
| case HL_STRING: return 35; /* zircon */ |
| case HL_NUMBER: return 31; /* red */ |
| case HL_MATCH: return 34; /* blu */ |
| default: return 37; /* white */ |
| } |
| } |
| |
| /* Select the syntax highlight scheme depending on the filename, |
| * setting it in the global state E.syntax. */ |
| void editorSelectSyntaxHighlight(char *filename) { |
| for (unsigned int j = 0; j < HLDB_ENTRIES; j++) { |
| struct editorSyntax *s = HLDB+j; |
| unsigned int i = 0; |
| while(s->filematch[i]) { |
| char *p; |
| int patlen = strlen(s->filematch[i]); |
| if ((p = strstr(filename,s->filematch[i])) != NULL) { |
| if (s->filematch[i][0] != '.' || p[patlen] == '\0') { |
| E.syntax = s; |
| return; |
| } |
| } |
| i++; |
| } |
| } |
| } |
| |
| /* ======================= Editor rows implementation ======================= */ |
| |
| /* Update the rendered version and the syntax highlight of a row. */ |
| void editorUpdateRow(erow *row) { |
| int tabs = 0, nonprint = 0, j, idx; |
| |
| /* Create a version of the row we can directly print on the screen, |
| * respecting tabs, substituting non printable characters with '?'. */ |
| free(row->render); |
| for (j = 0; j < row->size; j++) |
| if (row->chars[j] == TAB) tabs++; |
| |
| row->render = malloc(row->size + tabs*8 + nonprint*9 + 1); |
| idx = 0; |
| for (j = 0; j < row->size; j++) { |
| if (row->chars[j] == TAB) { |
| row->render[idx++] = ' '; |
| while((idx+1) % 8 != 0) row->render[idx++] = ' '; |
| } else { |
| row->render[idx++] = row->chars[j]; |
| } |
| } |
| row->rsize = idx; |
| row->render[idx] = '\0'; |
| |
| /* Update the syntax highlighting attributes of the row. */ |
| editorUpdateSyntax(row); |
| } |
| |
| /* Insert a row at the specified position, shifting the other rows on the bottom |
| * if required. */ |
| void editorInsertRow(int at, char *s, size_t len) { |
| if (at > E.numrows) return; |
| E.row = realloc(E.row,sizeof(erow)*(E.numrows+1)); |
| if (at != E.numrows) { |
| memmove(E.row+at+1,E.row+at,sizeof(E.row[0])*(E.numrows-at)); |
| for (int j = at+1; j <= E.numrows; j++) E.row[j].idx++; |
| } |
| E.row[at].size = len; |
| E.row[at].chars = malloc(len+1); |
| memcpy(E.row[at].chars,s,len+1); |
| E.row[at].hl = NULL; |
| E.row[at].hl_oc = 0; |
| E.row[at].render = NULL; |
| E.row[at].rsize = 0; |
| E.row[at].idx = at; |
| editorUpdateRow(E.row+at); |
| E.numrows++; |
| E.dirty++; |
| } |
| |
| /* Free row's heap allocated stuff. */ |
| void editorFreeRow(erow *row) { |
| free(row->render); |
| free(row->chars); |
| free(row->hl); |
| } |
| |
| /* Remove the row at the specified position, shifting the remainign on the |
| * top. */ |
| void editorDelRow(int at) { |
| erow *row; |
| |
| if (at >= E.numrows) return; |
| row = E.row+at; |
| editorFreeRow(row); |
| memmove(E.row+at,E.row+at+1,sizeof(E.row[0])*(E.numrows-at-1)); |
| for (int j = at; j < E.numrows-1; j++) E.row[j].idx++; |
| E.numrows--; |
| E.dirty++; |
| } |
| |
| /* Turn the editor rows into a single heap-allocated string. |
| * Returns the pointer to the heap-allocated string and populate the |
| * integer pointed by 'buflen' with the size of the string, escluding |
| * the final nulterm. */ |
| char *editorRowsToString(int *buflen) { |
| char *buf = NULL, *p; |
| int totlen = 0; |
| int j; |
| |
| /* Compute count of bytes */ |
| for (j = 0; j < E.numrows; j++) |
| totlen += E.row[j].size+1; /* +1 is for "\n" at end of every row */ |
| *buflen = totlen; |
| totlen++; /* Also make space for nulterm */ |
| |
| p = buf = malloc(totlen); |
| for (j = 0; j < E.numrows; j++) { |
| memcpy(p,E.row[j].chars,E.row[j].size); |
| p += E.row[j].size; |
| *p = '\n'; |
| p++; |
| } |
| *p = '\0'; |
| return buf; |
| } |
| |
| /* Insert a character at the specified position in a row, moving the remaining |
| * chars on the right if needed. */ |
| void editorRowInsertChar(erow *row, int at, int c) { |
| if (at > row->size) { |
| /* Pad the string with spaces if the insert location is outside the |
| * current length by more than a single character. */ |
| int padlen = at-row->size; |
| /* In the next line +2 means: new char and null term. */ |
| row->chars = realloc(row->chars,row->size+padlen+2); |
| memset(row->chars+row->size,' ',padlen); |
| row->chars[row->size+padlen+1] = '\0'; |
| row->size += padlen+1; |
| } else { |
| /* If we are in the middle of the string just make space for 1 new |
| * char plus the (already existing) null term. */ |
| row->chars = realloc(row->chars,row->size+2); |
| memmove(row->chars+at+1,row->chars+at,row->size-at+1); |
| row->size++; |
| } |
| row->chars[at] = c; |
| editorUpdateRow(row); |
| E.dirty++; |
| } |
| |
| /* Append the string 's' at the end of a row */ |
| void editorRowAppendString(erow *row, char *s, size_t len) { |
| row->chars = realloc(row->chars,row->size+len+1); |
| memcpy(row->chars+row->size,s,len); |
| row->size += len; |
| row->chars[row->size] = '\0'; |
| editorUpdateRow(row); |
| E.dirty++; |
| } |
| |
| /* Delete the character at offset 'at' from the specified row. */ |
| void editorRowDelChar(erow *row, int at) { |
| if (row->size <= at) return; |
| memmove(row->chars+at,row->chars+at+1,row->size-at); |
| editorUpdateRow(row); |
| row->size--; |
| E.dirty++; |
| } |
| |
| /* Insert the specified char at the current prompt position. */ |
| void editorInsertChar(int c) { |
| int filerow = E.rowoff+E.cy; |
| int filecol = E.coloff+E.cx; |
| erow *row = (filerow >= E.numrows) ? NULL : &E.row[filerow]; |
| |
| /* If the row where the cursor is currently located does not exist in our |
| * logical representaion of the file, add enough empty rows as needed. */ |
| if (!row) { |
| while(E.numrows <= filerow) |
| editorInsertRow(E.numrows,"",0); |
| } |
| row = &E.row[filerow]; |
| editorRowInsertChar(row,filecol,c); |
| if (E.cx == E.screencols-1) |
| E.coloff++; |
| else |
| E.cx++; |
| E.dirty++; |
| } |
| |
| /* Inserting a newline is slightly complex as we have to handle inserting a |
| * newline in the middle of a line, splitting the line as needed. */ |
| void editorInsertNewline(void) { |
| int filerow = E.rowoff+E.cy; |
| int filecol = E.coloff+E.cx; |
| erow *row = (filerow >= E.numrows) ? NULL : &E.row[filerow]; |
| |
| if (!row) { |
| if (filerow == E.numrows) { |
| editorInsertRow(filerow,"",0); |
| goto fixcursor; |
| } |
| return; |
| } |
| /* If the cursor is over the current line size, we want to conceptually |
| * think it's just over the last character. */ |
| if (filecol >= row->size) filecol = row->size; |
| if (filecol == 0) { |
| editorInsertRow(filerow,"",0); |
| } else { |
| /* We are in the middle of a line. Split it between two rows. */ |
| editorInsertRow(filerow+1,row->chars+filecol,row->size-filecol); |
| row = &E.row[filerow]; |
| row->chars[filecol] = '\0'; |
| row->size = filecol; |
| editorUpdateRow(row); |
| } |
| fixcursor: |
| if (E.cy == E.screenrows-1) { |
| E.rowoff++; |
| } else { |
| E.cy++; |
| } |
| E.cx = 0; |
| E.coloff = 0; |
| } |
| |
| /* Delete the char at the current prompt position. */ |
| void editorDelChar(void) { |
| int filerow = E.rowoff+E.cy; |
| int filecol = E.coloff+E.cx; |
| erow *row = (filerow >= E.numrows) ? NULL : &E.row[filerow]; |
| |
| if (!row || (filecol == 0 && filerow == 0)) return; |
| if (filecol == 0) { |
| /* Handle the case of column 0, we need to move the current line |
| * on the right of the previous one. */ |
| filecol = E.row[filerow-1].size; |
| editorRowAppendString(&E.row[filerow-1],row->chars,row->size); |
| editorDelRow(filerow); |
| row = NULL; |
| if (E.cy == 0) |
| E.rowoff--; |
| else |
| E.cy--; |
| E.cx = filecol; |
| if (E.cx >= E.screencols) { |
| int shift = (E.screencols-E.cx)+1; |
| E.cx -= shift; |
| E.coloff += shift; |
| } |
| } else { |
| editorRowDelChar(row,filecol-1); |
| if (E.cx == 0 && E.coloff) |
| E.coloff--; |
| else |
| E.cx--; |
| } |
| if (row) editorUpdateRow(row); |
| E.dirty++; |
| } |
| |
| /* Load the specified program in the editor memory and returns 0 on success |
| * or 1 on error. */ |
| int editorOpen(char *filename) { |
| FILE *fp; |
| |
| E.dirty = 0; |
| free(E.filename); |
| E.filename = strdup(filename); |
| |
| fp = fopen(filename,"r"); |
| if (!fp) { |
| if (errno != ENOENT) { |
| perror("Opening file"); |
| exit(1); |
| } |
| return 1; |
| } |
| |
| char *line = NULL; |
| size_t linecap = 0; |
| ssize_t linelen; |
| while((linelen = getline(&line,&linecap,fp)) != -1) { |
| if (linelen && (line[linelen-1] == '\n' || line[linelen-1] == '\r')) |
| line[--linelen] = '\0'; |
| editorInsertRow(E.numrows,line,linelen); |
| } |
| free(line); |
| fclose(fp); |
| E.dirty = 0; |
| return 0; |
| } |
| |
| #define UNSAFE_SAVES 1 |
| |
| /* Save the current file on disk. Return 0 on success, 1 on error. */ |
| int editorSave(void) { |
| int len; |
| char *buf = editorRowsToString(&len); |
| #if UNSAFE_SAVES |
| unlink(E.filename); |
| #endif |
| int fd = open(E.filename,O_RDWR|O_CREAT,0644); |
| if (fd == -1) goto writeerr; |
| |
| #if !UNSAFE_SAVES |
| /* Use truncate + a single write(2) call in order to make saving |
| * a bit safer, under the limits of what we can do in a small editor. */ |
| if (ftruncate(fd,len) == -1) goto writeerr; |
| #endif |
| if (write(fd,buf,len) != len) goto writeerr; |
| |
| close(fd); |
| free(buf); |
| E.dirty = 0; |
| editorSetStatusMessage("%d bytes written on disk", len); |
| return 0; |
| |
| writeerr: |
| free(buf); |
| if (fd != -1) close(fd); |
| editorSetStatusMessage("Can't save! I/O error: %s",strerror(errno)); |
| return 1; |
| } |
| |
| /* ============================= Terminal update ============================ */ |
| |
| /* We define a very simple "append buffer" structure, that is an heap |
| * allocated string where we can append to. This is useful in order to |
| * write all the escape sequences in a buffer and flush them to the standard |
| * output in a single call, to avoid flickering effects. */ |
| struct abuf { |
| char *b; |
| int len; |
| }; |
| |
| #define ABUF_INIT {NULL,0} |
| |
| void abAppend(struct abuf *ab, const char *s, int len) { |
| char *new = realloc(ab->b,ab->len+len); |
| |
| if (new == NULL) return; |
| memcpy(new+ab->len,s,len); |
| ab->b = new; |
| ab->len += len; |
| } |
| |
| void abFree(struct abuf *ab) { |
| free(ab->b); |
| } |
| |
| /* This function writes the whole screen using VT100 escape characters |
| * starting from the logical state of the editor in the global state 'E'. */ |
| void editorRefreshScreen(void) { |
| int y; |
| erow *r; |
| char buf[32]; |
| struct abuf ab = ABUF_INIT; |
| |
| abAppend(&ab,"\x1b[?25l",6); /* Hide cursor. */ |
| abAppend(&ab,"\x1b[H",3); /* Go home. */ |
| for (y = 0; y < E.screenrows; y++) { |
| int filerow = E.rowoff+y; |
| |
| if (filerow >= E.numrows) { |
| if (E.numrows == 0 && y == E.screenrows/3) { |
| char welcome[80]; |
| int welcomelen = snprintf(welcome,sizeof(welcome), |
| "Kilo editor -- verison %s\x1b[0K\r\n", KILO_VERSION); |
| int padding = (E.screencols-welcomelen)/2; |
| if (padding) { |
| abAppend(&ab,"~",1); |
| padding--; |
| } |
| while(padding--) abAppend(&ab," ",1); |
| abAppend(&ab,welcome,welcomelen); |
| } else { |
| abAppend(&ab,"~\x1b[0K\r\n",7); |
| } |
| continue; |
| } |
| |
| r = &E.row[filerow]; |
| |
| int len = r->rsize - E.coloff; |
| int current_color = -1; |
| if (len > 0) { |
| if (len > E.screencols) len = E.screencols; |
| char *c = r->render+E.coloff; |
| unsigned char *hl = r->hl+E.coloff; |
| int j; |
| for (j = 0; j < len; j++) { |
| if (hl[j] == HL_NONPRINT) { |
| char sym; |
| abAppend(&ab,"\x1b[7m",4); |
| if (c[j] <= 26) |
| sym = '@'+c[j]; |
| else |
| sym = '?'; |
| abAppend(&ab,&sym,1); |
| abAppend(&ab,"\x1b[0m",4); |
| } else if (hl[j] == HL_NORMAL) { |
| if (current_color != -1) { |
| abAppend(&ab,"\x1b[39m",5); |
| current_color = -1; |
| } |
| abAppend(&ab,c+j,1); |
| } else { |
| int color = editorSyntaxToColor(hl[j]); |
| if (color != current_color) { |
| char buf[16]; |
| int clen = snprintf(buf,sizeof(buf),"\x1b[%dm",color); |
| current_color = color; |
| abAppend(&ab,buf,clen); |
| } |
| abAppend(&ab,c+j,1); |
| } |
| } |
| } |
| abAppend(&ab,"\x1b[39m",5); |
| abAppend(&ab,"\x1b[0K",4); |
| abAppend(&ab,"\r\n",2); |
| } |
| |
| /* Create a two rows status. First row: */ |
| abAppend(&ab,"\x1b[0K",4); |
| abAppend(&ab,"\x1b[7m",4); |
| char status[80], rstatus[80]; |
| int len = snprintf(status, sizeof(status), "%.20s - %d lines %s", |
| E.filename, E.numrows, E.dirty ? "(modified)" : ""); |
| int rlen = snprintf(rstatus, sizeof(rstatus), |
| "%d/%d",E.rowoff+E.cy+1,E.numrows); |
| if (len > E.screencols) len = E.screencols; |
| abAppend(&ab,status,len); |
| while(len < E.screencols) { |
| if (E.screencols - len == rlen) { |
| abAppend(&ab,rstatus,rlen); |
| break; |
| } else { |
| abAppend(&ab," ",1); |
| len++; |
| } |
| } |
| abAppend(&ab,"\x1b[0m\r\n",6); |
| |
| /* Second row depends on E.statusmsg and the status message update time. */ |
| abAppend(&ab,"\x1b[0K",4); |
| int msglen = strlen(E.statusmsg); |
| if (msglen && time(NULL)-E.statusmsg_time < 5) |
| abAppend(&ab,E.statusmsg,msglen <= E.screencols ? msglen : E.screencols); |
| |
| /* Put cursor at its current position. Note that the horizontal position |
| * at which the cursor is displayed may be different compared to 'E.cx' |
| * because of TABs. */ |
| int j; |
| int cx = 1; |
| int filerow = E.rowoff+E.cy; |
| erow *row = (filerow >= E.numrows) ? NULL : &E.row[filerow]; |
| if (row) { |
| for (j = E.coloff; j < (E.cx+E.coloff); j++) { |
| if (j < row->size && row->chars[j] == TAB) cx += 7-((cx)%8); |
| cx++; |
| } |
| } |
| snprintf(buf,sizeof(buf),"\x1b[%d;%dH",E.cy+1,cx); |
| abAppend(&ab,buf,strlen(buf)); |
| abAppend(&ab,"\x1b[?25h",6); /* Show cursor. */ |
| write(STDOUT_FILENO,ab.b,ab.len); |
| abFree(&ab); |
| } |
| |
| /* Set an editor status message for the second line of the status, at the |
| * end of the screen. */ |
| void editorSetStatusMessage(const char *fmt, ...) { |
| va_list ap; |
| va_start(ap,fmt); |
| vsnprintf(E.statusmsg,sizeof(E.statusmsg),fmt,ap); |
| va_end(ap); |
| E.statusmsg_time = time(NULL); |
| } |
| |
| /* =============================== Find mode ================================ */ |
| |
| #define KILO_QUERY_LEN 256 |
| |
| void editorFind(int fd) { |
| char query[KILO_QUERY_LEN+1] = {0}; |
| int qlen = 0; |
| int last_match = -1; /* Last line where a match was found. -1 for none. */ |
| int find_next = 0; /* if 1 search next, if -1 search prev. */ |
| int saved_hl_line = -1; /* No saved HL */ |
| char *saved_hl = NULL; |
| |
| #define FIND_RESTORE_HL do { \ |
| if (saved_hl) { \ |
| memcpy(E.row[saved_hl_line].hl,saved_hl, E.row[saved_hl_line].rsize); \ |
| saved_hl = NULL; \ |
| } \ |
| } while (0) |
| |
| /* Save the cursor position in order to restore it later. */ |
| int saved_cx = E.cx, saved_cy = E.cy; |
| int saved_coloff = E.coloff, saved_rowoff = E.rowoff; |
| |
| while(1) { |
| editorSetStatusMessage( |
| "Search: %s (Use ESC/Arrows/Enter)", query); |
| editorRefreshScreen(); |
| |
| int c = editorReadKey(fd); |
| if (c == DEL_KEY || c == CTRL_H || c == BACKSPACE) { |
| if (qlen != 0) query[--qlen] = '\0'; |
| last_match = -1; |
| } else if (c == ESC || c == ENTER) { |
| if (c == ESC) { |
| E.cx = saved_cx; E.cy = saved_cy; |
| E.coloff = saved_coloff; E.rowoff = saved_rowoff; |
| } |
| FIND_RESTORE_HL; |
| editorSetStatusMessage(""); |
| return; |
| } else if (c == ARROW_RIGHT || c == ARROW_DOWN) { |
| find_next = 1; |
| } else if (c == ARROW_LEFT || c == ARROW_UP) { |
| find_next = -1; |
| } else if (isprint(c)) { |
| if (qlen < KILO_QUERY_LEN) { |
| query[qlen++] = c; |
| query[qlen] = '\0'; |
| last_match = -1; |
| } |
| } |
| |
| /* Search occurrence. */ |
| if (last_match == -1) find_next = 1; |
| if (find_next) { |
| char *match = NULL; |
| int match_offset = 0; |
| int i, current = last_match; |
| |
| for (i = 0; i < E.numrows; i++) { |
| current += find_next; |
| if (current == -1) current = E.numrows-1; |
| else if (current == E.numrows) current = 0; |
| match = strstr(E.row[current].render,query); |
| if (match) { |
| match_offset = match-E.row[current].render; |
| break; |
| } |
| } |
| find_next = 0; |
| |
| /* Highlight */ |
| FIND_RESTORE_HL; |
| |
| if (match) { |
| erow *row = &E.row[current]; |
| last_match = current; |
| if (row->hl) { |
| saved_hl_line = current; |
| saved_hl = malloc(row->rsize); |
| memcpy(saved_hl,row->hl,row->rsize); |
| memset(row->hl+match_offset,HL_MATCH,qlen); |
| } |
| E.cy = 0; |
| E.cx = match_offset; |
| E.rowoff = current; |
| E.coloff = 0; |
| /* Scroll horizontally as needed. */ |
| if (E.cx > E.screencols) { |
| int diff = E.cx - E.screencols; |
| E.cx -= diff; |
| E.coloff += diff; |
| } |
| } |
| } |
| } |
| } |
| |
| /* ========================= Editor events handling ======================== */ |
| |
| /* Handle cursor position change because arrow keys were pressed. */ |
| void editorMoveCursor(int key) { |
| int filerow = E.rowoff+E.cy; |
| int filecol = E.coloff+E.cx; |
| int rowlen; |
| erow *row = (filerow >= E.numrows) ? NULL : &E.row[filerow]; |
| |
| switch(key) { |
| case ARROW_LEFT: |
| if (E.cx == 0) { |
| if (E.coloff) { |
| E.coloff--; |
| } else { |
| if (filerow > 0) { |
| E.cy--; |
| E.cx = E.row[filerow-1].size; |
| if (E.cx > E.screencols-1) { |
| E.coloff = E.cx-E.screencols+1; |
| E.cx = E.screencols-1; |
| } |
| } |
| } |
| } else { |
| E.cx -= 1; |
| } |
| break; |
| case ARROW_RIGHT: |
| if (row && filecol < row->size) { |
| if (E.cx == E.screencols-1) { |
| E.coloff++; |
| } else { |
| E.cx += 1; |
| } |
| } else if (row && filecol == row->size) { |
| E.cx = 0; |
| E.coloff = 0; |
| if (E.cy == E.screenrows-1) { |
| E.rowoff++; |
| } else { |
| E.cy += 1; |
| } |
| } |
| break; |
| case ARROW_UP: |
| if (E.cy == 0) { |
| if (E.rowoff) E.rowoff--; |
| } else { |
| E.cy -= 1; |
| } |
| break; |
| case ARROW_DOWN: |
| if (filerow < E.numrows) { |
| if (E.cy == E.screenrows-1) { |
| E.rowoff++; |
| } else { |
| E.cy += 1; |
| } |
| } |
| break; |
| } |
| /* Fix cx if the current line has not enough chars. */ |
| filerow = E.rowoff+E.cy; |
| filecol = E.coloff+E.cx; |
| row = (filerow >= E.numrows) ? NULL : &E.row[filerow]; |
| rowlen = row ? row->size : 0; |
| if (filecol > rowlen) { |
| E.cx -= filecol-rowlen; |
| if (E.cx < 0) { |
| E.coloff += E.cx; |
| E.cx = 0; |
| } |
| } |
| } |
| |
| /* Process events arriving from the standard input, which is, the user |
| * is typing stuff on the terminal. */ |
| #define KILO_QUIT_TIMES 3 |
| void editorProcessKeypress(int fd) { |
| /* When the file is modified, requires Ctrl-q to be pressed N times |
| * before actually quitting. */ |
| static int quit_times = KILO_QUIT_TIMES; |
| |
| int c = editorReadKey(fd); |
| switch(c) { |
| case ENTER: /* Enter */ |
| editorInsertNewline(); |
| break; |
| case CTRL_C: /* Ctrl-c */ |
| /* We ignore ctrl-c, it can't be so simple to lose the changes |
| * to the edited file. */ |
| break; |
| case CTRL_Q: /* Ctrl-q */ |
| /* Quit if the file was already saved. */ |
| if (E.dirty && quit_times) { |
| editorSetStatusMessage("WARNING!!! File has unsaved changes. " |
| "Press Ctrl-Q %d more times to quit.", quit_times); |
| quit_times--; |
| return; |
| } |
| exit(0); |
| break; |
| case CTRL_S: /* Ctrl-s */ |
| editorSave(); |
| break; |
| case CTRL_F: |
| editorFind(fd); |
| break; |
| case BACKSPACE: /* Backspace */ |
| case CTRL_H: /* Ctrl-h */ |
| case DEL_KEY: |
| editorDelChar(); |
| break; |
| case PAGE_UP: |
| case PAGE_DOWN: |
| if (c == PAGE_UP && E.cy != 0) |
| E.cy = 0; |
| else if (c == PAGE_DOWN && E.cy != E.screenrows-1) |
| E.cy = E.screenrows-1; |
| { |
| int times = E.screenrows; |
| while(times--) |
| editorMoveCursor(c == PAGE_UP ? ARROW_UP: |
| ARROW_DOWN); |
| } |
| break; |
| |
| case ARROW_UP: |
| case ARROW_DOWN: |
| case ARROW_LEFT: |
| case ARROW_RIGHT: |
| editorMoveCursor(c); |
| break; |
| case CTRL_L: /* ctrl+l, clear screen */ |
| /* Just refresht the line as side effect. */ |
| break; |
| case ESC: |
| /* Nothing to do for ESC in this mode. */ |
| break; |
| default: |
| editorInsertChar(c); |
| break; |
| } |
| |
| quit_times = KILO_QUIT_TIMES; /* Reset it to the original value. */ |
| } |
| |
| int editorFileWasModified(void) { |
| return E.dirty; |
| } |
| |
| void initEditor(void) { |
| E.cx = 0; |
| E.cy = 0; |
| E.rowoff = 0; |
| E.coloff = 0; |
| E.numrows = 0; |
| E.row = NULL; |
| E.dirty = 0; |
| E.filename = NULL; |
| E.syntax = NULL; |
| if (getWindowSize(STDIN_FILENO,STDOUT_FILENO, |
| &E.screenrows,&E.screencols) == -1) |
| { |
| perror("Unable to query the screen for size (columns / rows)"); |
| exit(1); |
| } |
| E.screenrows -= 2; /* Get room for status bar. */ |
| } |
| |
| int main(int argc, char **argv) { |
| if (argc != 2) { |
| fprintf(stderr,"Usage: kilo <filename>\n"); |
| exit(1); |
| } |
| |
| initEditor(); |
| editorSelectSyntaxHighlight(argv[1]); |
| editorOpen(argv[1]); |
| enableRawMode(STDIN_FILENO); |
| editorSetStatusMessage( |
| "HELP: Ctrl-S = save | Ctrl-Q = quit | Ctrl-F = find"); |
| while(1) { |
| editorRefreshScreen(); |
| editorProcessKeypress(STDIN_FILENO); |
| } |
| return 0; |
| } |
