refactor

1 files changed, 920 insertions, 0 deletions

diff --git a/command/ed.c b/command/ed.c
new file mode 100644
index 0000000..472473f
--- /dev/null
+++ b/command/ed.c
@@ -0,0 +1,920 @@
+#include "command.h"
+#include "lslib.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#define INPUT_LEN 1024
+
+static char** lines = NULL;
+static unsigned long line_capacity;
+static unsigned long line_count;
+static unsigned long line_current;
+static bool pending_writes;
+static char* default_filename = NULL;
+static re_t last_regex = NULL;
+
+enum LineAddressType {
+    INDEX,
+    RANGE,
+    SET,
+    FREE
+};
+
+struct LineAddress {
+    enum LineAddressType type;
+    union {
+        struct {
+            long int i;
+        } index;
+        struct {
+            long int a;
+            long int b;
+        } range;
+        struct {
+            long int* b;
+            unsigned long c;
+            unsigned long s;
+        } set;
+    } data;
+    bool empty;
+};
+
+enum RegexDirection {
+    BEFORE,
+    AFTER,
+    ALL
+};
+
+static bool read_regex(char** end, re_t* regex, enum RegexDirection dir) {
+    char c;
+    char* index = *end;
+    char* regex_str = index;
+    while(true) {
+        c = *(index++);
+        if (c == '\0') {
+            error_s("missing regex after %c\n", dir == BEFORE ? '?' : '/');
+            return false;
+        }
+        if (c == (dir == BEFORE ? '?' : '/')) {
+            *(index - 1) = '\0';
+            break;
+        }
+    }
+    *regex = re_compile(regex_str);
+    last_regex = *regex;
+    *end = index;
+    return true;
+}
+
+static bool parse_regex(char** end, struct LineAddress* address, enum RegexDirection dir) {
+    re_t regex;
+    unsigned long cap, siz, i, until;
+    long int* buf;
+
+    if (!read_regex(end, &regex, dir)) return false;
+
+    cap = 8;
+    siz = 0;
+    buf = malloc(cap * sizeof(long int));
+
+    i = (dir == ALL ? 0 : line_current);
+    until = (dir == BEFORE ? 0 : line_count - 1);
+    for (; (dir == BEFORE ? i >= until : i < until); dir == BEFORE ? i-- : i++) {
+        int len;
+        if (re_matchp(regex, lines[i], &len) == -1) {
+            if (dir == BEFORE && i == 0) break;
+            continue;
+        }
+        if (cap == siz) {
+            cap *= 2;
+            buf = realloc(buf, cap * sizeof(long int));
+        }
+        buf[siz] = i;
+        siz++;
+        if (dir == BEFORE && i == 0) break;
+    }
+
+    address->empty = false;
+    address->type = SET;
+    address->data.set.s = siz;
+    address->data.set.c = cap;
+    address->data.set.b = buf;
+    return true;
+}
+
+static void free_address (struct LineAddress address) {
+    if (address.type != SET) return;
+    address.type = FREE;
+    free(address.data.set.b);
+}
+
+static void expand_buffer(long int** buf, unsigned long* cap, unsigned long* size) {
+    if (*cap == *size) {
+        *cap *= 2;
+        *buf = realloc(*buf, sizeof(long int) * *cap);
+    }
+}
+
+static bool parse_regex_lines(char** end, struct LineAddress* address) {
+    re_t regex;
+    unsigned long cap, siz;
+    long int* buf;
+    int len;
+    struct LineAddress addr;
+
+    if (!read_regex(end, &regex, ALL)) return false;
+
+    cap = 8;
+    siz = 0;
+    buf = malloc(cap * sizeof(long int));
+
+    addr = *address;
+    if (addr.type == INDEX) {
+        if (re_matchp(regex, lines[addr.data.index.i], &len) != -1) {
+            buf[0] = addr.data.index.i;
+            siz = 1;
+        }
+    } else if (addr.type == RANGE) {
+        long int i;
+        for (i = addr.data.range.a; i < addr.data.range.b; i++) {
+            if (re_matchp(regex, lines[i], &len) == -1) continue;
+            expand_buffer(&buf, &cap, &siz);
+            buf[siz] = i;
+            siz++;
+        }
+    } else if (addr.type == SET) {
+        unsigned long i;
+        for (i = 0; i < addr.data.set.s; i++) {
+            if (re_matchp(regex, lines[addr.data.set.b[i]], &len) == -1) continue;
+            expand_buffer(&buf, &cap, &siz);
+            buf[siz] = addr.data.set.b[i];
+            siz++;
+        }
+    }
+
+    free_address(*address);
+    address->empty = false;
+    address->type = SET;
+    address->data.set.s = siz;
+    address->data.set.c = cap;
+    address->data.set.b = buf;
+    return true;
+}
+
+static bool read_address(char** command, bool whitespace, struct LineAddress* a) {
+    char* index = *command;
+    struct LineAddress address;
+
+    char* end_pre;
+    long int n_pre;
+    char pre;
+
+    memset(&address, 0, sizeof(struct LineAddress));
+    
+    address.empty = false;
+    if (strlen(*command) < 1) {
+        address.type = INDEX;
+        address.data.index.i = line_current + 1;
+        if (line_current >= line_count) line_current = line_count - 1;
+        *a = address;
+        return true;
+    }
+
+    n_pre = strtol(index, &end_pre, 10) - 1;
+    if (end_pre == index) {
+        n_pre = -1;
+    } else {
+        if (n_pre < 0) {
+            error_s("input cannot be negative\n");
+            return false;
+        }
+        index = end_pre;
+    }
+    
+    pre = *(index++);
+    switch (pre) {
+        case '.':
+            address.type = INDEX;
+            address.data.index.i = line_current;
+            break;
+        case '$':
+            address.type = INDEX;
+            address.data.index.i = line_count - 1;
+            break;
+        case '-':
+        case '^': {
+            char* end;
+            long int n;
+
+            address.type = INDEX;
+            n = strtol(index, &end, 10) - 1;
+
+            if (n < 0) {
+                error_s("input cannot be negative\n");
+                return false;
+            }
+
+            if (index == end) {
+                address.data.index.i = line_current - 1;
+            } else {
+                address.data.index.i = line_current - n;
+            }
+
+            if (address.data.index.i < 0) {
+                error_s("line number %ld does not exist\n", address.data.index.i + 1);
+                return false;
+            }
+
+            break;
+        }
+        case '+': {
+            char* end;
+            long int n;
+
+            address.type = INDEX;
+            n = strtol(index, &end, 10) - 1;
+
+            if (n < 0) {
+                error_s("input cannot be negative\n");
+                return false;
+            }
+            if (index == end) {
+                address.data.index.i = line_current + 1;
+            } else {
+                address.data.index.i = line_current + n;
+            }
+            if (address.data.index.i >= (long int) line_count) {
+                error_s("line number %ld does not exist\n", address.data.index.i + 1);
+                return false;
+            }
+            break;
+        }
+        case '%':
+            address.type = RANGE;
+            address.data.range.a = 0;
+            address.data.range.b = line_count - 1;
+            break;
+        case ';':
+            address.type = RANGE;
+            address.data.range.a = line_current;
+            address.data.range.b = line_count - 1;
+            break;
+        case '/': 
+            if (!parse_regex(&index, &address, AFTER)) return false;
+            break;
+        case '?':
+            if (!parse_regex(&index, &address, BEFORE)) return false;
+            break;
+        default: {
+            index--;
+            if (n_pre == -1) {
+                address.type = INDEX;
+                address.data.index.i = line_current;
+                address.empty = true;
+                break;
+            } else if (whitespace) {
+                address.type = INDEX;
+                address.data.index.i = line_current + n_pre;
+            } else {
+                address.type = INDEX;
+                address.data.index.i = n_pre;
+            }
+            if (address.data.index.i < 0 || address.data.index.i >= (long int) line_count) {
+                error_s("line number %ld does not exist\n", address.data.index.i + 1);
+                return false;
+            }
+        }
+    }
+    *command = index;
+    *a = address;
+    return true;
+}
+
+static void free_data(bool all) {
+    if (lines != NULL) {
+        unsigned long i;
+        for (i = 0; i < line_count; i++) {
+            free(lines[i]);
+        }
+        free(lines);
+        lines = NULL;
+    }
+    if (all && default_filename != NULL) {
+        free(default_filename);
+        default_filename = NULL;
+    }
+}
+
+static void load_empty(void) {
+    free_data(false);
+
+    line_capacity = 8;
+    lines = malloc(sizeof(char*) * line_capacity);
+
+    line_count = 0;
+    line_current = 0;
+    pending_writes = false;
+}
+
+static void get_input(FILE* file, char*** buffer, unsigned long* capacity, unsigned long* size) {
+    unsigned long cap = 8;
+    unsigned long siz = 0;
+    char** buf = malloc(sizeof(char*) * cap);
+
+    char* line = NULL;
+    size_t offset = 0;
+    
+    clearerr(stdin);
+    while (getline(&line, &offset, file) != -1) {
+        if (cap == siz) {
+            cap *= 2;
+            buf = realloc(buf, sizeof(char*) * cap);
+        }
+        buf[siz] = line;
+        siz++;
+        line = NULL;
+    }
+
+    free(line);
+
+    *buffer = buf;
+    *capacity = cap;
+    *size = siz;
+}
+
+int ed_getline(char *buf, size_t size) {
+    size_t i = 0;
+    int ch;
+    clearerr(stdin);
+    while ((ch = getchar()) != EOF) {  /* Read until EOF ... */
+        if (i + 1 < size) {
+            buf[i++] = ch;
+        }
+        if (ch == '\n') {  /* ... or end of line */
+            break;  
+        }
+    } 
+    buf[i] = '\0';
+    if (i == 0) { 
+        return EOF;
+    }
+    return i;
+}
+
+static void load_file(FILE* file) {
+    free_data(false);
+    line_current = 0;
+    get_input(file, &lines, &line_capacity, &line_count);
+    if (file != stdin)
+        fclose(file);
+    
+}
+
+static bool check_if_sure(char* prompt) {
+    char buf[INPUT_LEN];
+
+    if (!pending_writes) {
+        return true;
+    }
+
+    printf("%s", prompt);
+    fflush(stdout);
+
+    if (ed_getline(buf, INPUT_LEN) == EOF) {
+        putchar('\n');
+        return false;
+    }
+
+    return prefix("y", buf);
+}
+
+static bool skip_whitespace(char** index) {
+    char c;
+    bool w = false;
+    while (c = **index, c == ' ' || c == '\t') { (*index)++; w = true; }
+    return w;
+}
+
+static void expand(unsigned long count) {
+    if (count < line_capacity) return;
+    line_capacity *= 2;
+    if (count > line_capacity) line_capacity = count;
+    lines = realloc(lines, line_capacity * sizeof(char*));
+}
+
+static void append_lines(unsigned long index, char** new, unsigned long new_len) {
+    if (new_len < 1) return;
+    pending_writes = true;
+    expand(line_count + new_len);
+    if (index + 1 <= line_count)
+        memmove(&lines[index+new_len], &lines[index], sizeof(char*) * (line_count - index));
+    memcpy(&lines[index], new, sizeof(char*) * new_len);
+    line_count += new_len;
+}
+
+static void delete_lines(unsigned long a, unsigned long b) {
+    unsigned long i;
+
+    if (b < a) return;
+    pending_writes = true;
+    
+    for (i = a; i <= b; i++) {
+        free(lines[i]);
+    }
+    if (b == line_count - 1) {
+        line_count = a;
+        return;
+    }
+    memmove(&lines[a], &lines[b+1], sizeof(char*) * (line_count - (b + 1)));
+    line_count -= (b - a) + 1;
+    line_current = a;
+    if (line_current >= line_count) line_current = line_count - 1;
+}
+
+static bool handle_append(struct LineAddress* address) {
+    char** buf;
+    unsigned long cap, size;
+
+    if (address->type != INDEX) {
+        error_s("append command requires index addressing\n");
+        return false;
+    }
+    
+    if (line_count == 0) {
+        address->data.index.i = -1;
+    }
+    
+    get_input(stdin, &buf, &cap, &size);
+    
+    if (size > 0) {
+        append_lines(address->data.index.i + 1, buf, size);
+        printf("ed: appened %lu lines\n", size);
+    }
+    
+    line_current += size;
+    free(buf);
+    return true;
+}
+
+static bool handle_delete(struct LineAddress* address) {
+    if (address->empty && address->data.index.i >= (long int) line_count) {
+        error_s("line number %ld does not exist\n", address->data.index.i + 1);
+        return false;
+    }
+
+    if (address->type == INDEX) {
+        delete_lines(address->data.index.i, address->data.index.i);
+        output("deleted line %ld\n", address->data.index.i+1);
+    } else if (address->type == RANGE) {
+        delete_lines(address->data.range.a, address->data.range.b);
+        output("deleted lines %ld-%ld\n", address->data.range.a+1, address->data.range.b+1);
+    } else if (address->type == SET) {
+        unsigned long i;
+        for (i = 0; i < address->data.set.s; i++) {
+            delete_lines(address->data.set.b[i], address->data.set.b[i]);
+        }
+        output("deleted %lu lines\n", address->data.set.s);
+    }
+    
+    return true;
+}
+
+static bool get_file_name(char** filename) {
+    size_t len = strlen(*filename);
+
+    if (len < 1 || (len == 1 && **filename == '\n')) {
+        if (default_filename == NULL) {
+            error_s("no default filename specified\n");
+            return false;
+        }
+        *filename = default_filename;
+    } else {
+        if ((*filename)[len - 1] == '\n') {
+            (*filename)[len - 1] = '\0';
+            len--;
+        }
+        if (default_filename != NULL) {
+            default_filename = realloc(default_filename, len + 1);
+        } else {
+            default_filename = malloc(len + 1);
+        }
+        memcpy(default_filename, *filename, len + 1);
+        *filename = default_filename;
+    }
+    return true;
+}
+
+static void write_file(char* filename, struct LineAddress* address, char* type) {
+    FILE* file;
+    int wrote;
+
+    if (line_count < 1) {
+        error_s("cannot write empty file\n");
+        return;
+    }
+    
+    if (!get_file_name(&filename)) return;
+    file = get_file_s(filename, type);
+    if (file == NULL) return;
+    
+    wrote = 0;
+    
+    if (address->empty) {
+        unsigned long i;
+        for (i = 0; i < line_count; i++) {
+            fprintf(file, "%s", lines[i]); 
+            wrote++;
+        }
+    } else if (address->type == INDEX) {
+        long int i = address->data.index.i;
+        fprintf(file, "%s", lines[i]); 
+        wrote++;
+    } else if (address->type == RANGE) {
+        long int i;
+        for (i = address->data.range.a; i < address->data.range.b; i++) {
+            fprintf(file, "%s", lines[i]); 
+            wrote++;
+        }
+    } else if (address->type == SET) {
+        unsigned long i;
+        for (i = 0; i < address->data.set.s; i++) {
+            fprintf(file, "%s", lines[address->data.set.b[i]]);
+            wrote++;
+        }
+    }
+
+    pending_writes = false;
+    fclose(file);
+    output("wrote %d lines from %s\n", wrote, filename);
+}
+
+static void read_file(char* filename) {
+    FILE* file;
+    char** buf;
+    long int line;
+    unsigned long capacity, size;
+
+    if (!get_file_name(&filename)) return;
+    file = get_file_s(filename, "r");
+    if (file == NULL) return;
+
+    capacity = 8;
+    size = 0;
+    buf = malloc(capacity * sizeof(char*));
+    get_input(file, &buf, &capacity, &size);
+
+    if (size < 1) {
+        free(buf);
+        error_s("attempted to read a empty file\n");
+        return;
+    }
+
+    line = -1;
+    if (line_count > 0) {
+        line = line_count - 1;
+    }
+
+    append_lines(line, buf, size);
+    free(buf);
+    output("read and appended %lu lines from %s\n", size, filename);
+}
+
+static void expand_string(char** buf, int* capacity, int* size, char* text, int len) {
+    if (*size + len >= *capacity) {
+        *capacity *= 2;
+        if (*capacity < *size + len) *capacity = *size + len;
+        *buf = realloc(*buf, *capacity);
+    }
+    memcpy(*buf + *size, text, len);
+    *size += len;
+}
+
+static int substute_string(long int index, long int matches, re_t regex, char* sub, int sub_len) {
+    int capacity = 8;
+    int size = 0;
+    char* buf = malloc(sizeof(char) * capacity);
+    long int left;
+
+    int offset = 0;
+    int matches_found = 0;
+    while(true) {
+        int distance, len;
+        
+        if (lines[index][offset] == '\0') break;
+        
+        if (matches_found >= matches && matches > 0) break;
+        
+        if ((distance = re_matchp(regex, &lines[index][offset], &len)) == -1) {
+            break;
+        }
+        
+        if (distance > 0) {
+            expand_string(&buf, &capacity, &size, &lines[index][offset], distance);
+        }
+
+        expand_string(&buf, &capacity, &size, sub, sub_len);
+        offset += len + distance;
+        matches_found++;
+    }
+
+    left = strlen(lines[index] + offset);
+    expand_string(&buf, &capacity, &size, &lines[index][offset], left + 1);
+
+    free(lines[index]);
+    lines[index] = buf;
+    return matches_found;
+}
+
+static void prompt(void) {
+    char buf[INPUT_LEN];
+    char* index;
+    char cmd;
+    bool whitespace, linenumbers;
+    struct LineAddress address;
+    
+    printf(": ");
+    fflush(stdout);
+
+    if (ed_getline(buf, INPUT_LEN) == EOF) { putchar('\n'); return; }
+    if (buf[0] == '\0') { putchar('\n'); return; }
+
+    index = &buf[0];
+    whitespace = skip_whitespace(&index);
+
+    if (!read_address(&index, whitespace, &address)) return;
+
+    cmd = *(index++);
+    
+    if (cmd == ',') {
+        struct LineAddress address2;
+        
+        if (address.type != INDEX) {
+            error_s("comma range addressing requires two index addresses\n");
+            free_address(address);
+            return;
+        }
+        
+        whitespace = skip_whitespace(&index);
+        
+        if (!read_address(&index, whitespace, &address2)) {
+            free_address(address);
+            return;
+        }
+        
+        if (address2.type != INDEX) {
+            error_s("comma range addressing requires two index addresses\n");
+            free_address(address);
+            free_address(address2);
+            return;
+        }
+        
+        address.type = RANGE;
+        address.data.range.a = address.data.index.i; /* cursed */
+        address.data.range.b = address2.data.index.i;
+
+        cmd = *(index++);
+    }
+
+    if (address.type == RANGE && address.data.range.a > address.data.range.b) {
+        error_s("range addressing must be in ascending order\n");
+        free_address(address);
+        return;
+    }
+
+    linenumbers = false;
+
+test:
+    switch (cmd) {
+        case '\0':
+        case '\n':
+            if (address.empty) {
+                if (line_current == line_count) {
+                    error_s("line number %ld does not exist\n", line_current + 1);
+                    break;
+                } else if (line_current + 1 == line_count) {
+                    error_s("line number %ld does not exist\n", line_current + 2);
+                    break;
+                } else {
+                    line_current++;
+                }
+                printf("%s", lines[line_current]);
+                break;
+            }
+            if (address.type == INDEX) {
+                line_current = address.data.index.i;
+            } else if (address.type == RANGE) {
+                line_current = address.data.range.b;
+            } else if (address.type == SET) {
+                error_s("unexpected range addressing\n");
+                break;
+            }
+            printf("%s", lines[line_current]);
+            break;
+        case 'a':
+            handle_append(&address);
+            break;
+        case 'd':
+            handle_delete(&address);
+            break;
+        case 'c':
+            if (!handle_delete(&address)) { break; }
+            address.type = INDEX;
+            address.data.index.i = line_current - 1;
+            handle_append(&address);
+            break;
+        case 'n':
+            linenumbers = true;
+            __attribute__((fallthrough));
+        case 'p':
+            if (address.empty && address.data.index.i >= (long int) line_count) {
+                error_s("line number %ld does not exist\n", address.data.index.i + 1);
+                break;
+            }
+            if (address.type == INDEX) {
+                if (linenumbers) printf("%ld\t", address.data.index.i + 1);
+                printf("%s", lines[address.data.index.i]);
+            } else if (address.type == RANGE) {
+                long int i;
+                for (i = address.data.range.a; i <= address.data.range.b; i++) {
+                    if (linenumbers) printf("%ld\t", i + 1);
+                    printf("%s", lines[i]);
+                }
+            } else if (address.type == SET) {
+                unsigned long i;
+                for (i = 0; i < address.data.set.s; i++) {
+                    if (linenumbers) printf("%ld\t", address.data.set.b[i] +1);
+                    printf("%s", lines[address.data.set.b[i]]);
+                }
+            }
+            break;
+        case 'q':
+            if (!check_if_sure("Quit for sure? ")) break;
+            __attribute__((fallthrough));
+        case 'Q':
+            free_address(address);
+            free_data(true);
+            exit(EXIT_SUCCESS);
+            break;
+        case 'g':
+            skip_whitespace(&index);
+            free_address(address);
+            if (*(index++) != '/') {
+                error_s("unexpected character at start of regex\n");
+                break;
+            }
+            if (!parse_regex(&index, &address, ALL)) { return; }
+            skip_whitespace(&index);
+            if (*index == '\n' || *index == '\0') {
+                cmd = 'p';
+            } else {
+                cmd = *(index++);
+            }
+            goto test;
+            break;
+        case 's': {
+            char* replace = index;
+            long int matches, sub_len, matches_found;
+            unsigned long i;
+            
+            skip_whitespace(&index);
+            if (*(index++) != '/') {
+                error_s("unexpected character at start of regex\n");
+                break;
+            }
+            if (!parse_regex_lines(&index, &address)) { return; }
+            while(*index != '\0' && *index != '/') index++;
+            if (*index != '/') {
+                error_s("/ missing after %c\n", *index);
+                break;
+            }
+            if (address.data.set.s < 1) {
+                error_s("no matches found\n");
+                break;
+            }
+            *(index++) = '\0';
+            if (*index == '\0' || *index == '\n') {
+                matches = 1;
+            } else if (*index == 'g') {
+                matches = -1;
+            } else {
+                char* end;
+                matches = strtol(index, &end, 10);
+                if (end == index) {
+                    error_s("invalid number: %s\n", index);
+                    break;
+                }
+                if (matches < 1) {
+                    error_s("matches cannot be less than 1\n");
+                    break;
+                }
+            }
+            sub_len = strlen(replace);
+            matches_found = 0;
+            
+            for (i = 0; i < address.data.set.s; i++) {
+                matches_found += substute_string(address.data.set.b[i], matches, last_regex, replace, sub_len);
+            }
+            output("replaced %ld matches over %ld lines\n", matches_found, address.data.set.s);
+            pending_writes = true;
+            break;
+        }
+        case 'w': {
+            bool quit = false;
+            if (*index == 'q') {
+                index++;
+                quit = true;
+            }
+            skip_whitespace(&index);
+            write_file(index, &address, "w");
+            if (quit) {
+                free_address(address);
+                free_data(true);
+                exit(EXIT_SUCCESS);
+            }
+            break;
+        }
+        case 'r': {
+            skip_whitespace(&index);
+            read_file(index);
+            break;
+        }
+        case 'e': 
+            if (!check_if_sure("Load new file for sure? ")) break;
+            __attribute__((fallthrough));
+        case 'E': {
+            char* filename;
+            FILE* file;
+
+            skip_whitespace(&index);
+            
+            filename = index;
+            if(!get_file_name(&filename)) break;
+            
+            file = get_file_s(filename, "r");
+            if (file == NULL) break;
+            
+            load_file(file);
+            break;
+        }
+        case 'W':
+            skip_whitespace(&index);
+            write_file(index, &address, "a");
+            break;
+        case '=':
+            printf("%ld\n", line_current + 1);
+            break;
+        default:
+            error_s("unimplemented command\n");
+            break;
+    }
+
+    free_address(address);
+
+}
+
+static void prompt_loop(void) {
+    while (true) {
+        prompt();
+    }
+}
+
+static void help(void) {
+    printf("Usage: ed [FILE]\n\n");
+    printf("Edit a given [FILE] or create a new text file\n\n");
+    printf("\t(.,.)\tnewline\t\tgo to address line and print\n");
+    printf("\t(.)\ta\t\tappend new data after given line\n");
+    printf("\t(.,.)\tc\t\treplace given lines with new data\n");
+    printf("\t(.,.)\td\t\tdelete given lines\n");
+    printf("\t\te file\t\tdelete current buffer and edit file\n");
+    printf("\t\tE file\t\tdelete current buffer and edit file unconditionally\n");
+    printf("\t\tg/re/command\tgrep all lines with regex and run command on matches\n");
+    printf("\t(.,.)\tn\t\tprint given lines along with their line numbers\n");
+    printf("\t(.,.)\tp\t\tprint given lines\n");
+    printf("\t\tq\t\tquit file\n");
+    printf("\t\tQ\t\tquit file unconditionally\n");
+    printf("\t($)\tr file\t\tread file and append to end of buffer\n");
+    printf("\t(.,.)\ts/re/replace/\treplace the first match on each matching line\n");
+    printf("\t(.,.)\ts/re/replace/g\treplace all matches on each matching line\n");
+    printf("\t(.,.)\ts/re/replace/n\treplace n matches on each matching line\n");
+    printf("\t(.,.)\tw file\t\twrite contents of lines to file\n");
+    printf("\t(.,.)\twq file\t\twrite contents of lines to file then quit\n");
+    printf("\t(.,.)\tW file\t\tappend contents of line to file\n");
+    printf("\t\t=\t\tprint current line number\n");
+}
+
+COMMAND(ed) {
+
+    parse_help(argc, argv, help);
+
+    if (argc < 1) {
+        load_empty();
+        prompt_loop();
+    } else {
+        FILE* file = get_file(argv[0], "r");
+        load_file(file);
+        get_file_name(&argv[0]);
+        prompt_loop();
+    }
+    return EXIT_SUCCESS;
+}