started C implementation, created custom library for handling strings

final/dynstr.c

@@ -0,0 +1,232 @@
+/// dynamic array class
+/// written by: Harry Irving
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+typedef struct {
+    int size;
+    int capacity;
+    char* data;
+} String;
+
+String str_with_capacity(int capacity) {
+    String s;
+
+    /// allocate memory for 'capacity' chars
+    s.data = (char*)calloc(capacity, sizeof(char));
+
+    s.size = 0;
+    s.capacity = capacity;
+
+    return s;
+}
+
+String str_from_chars(char* string) {
+    String s;
+
+    s.data = (char*)calloc(strlen(string), sizeof(char));
+    strcpy(s.data, string);
+    s.size = strlen(string);
+    s.capacity = strlen(string);
+    return s;
+}
+
+String str_from_slice(char* string, int len) {
+    String s;
+
+    s.data = (char*)calloc(len, sizeof(char));
+    strncpy(s.data, string, len);
+    s.size = len;
+    s.capacity = len;
+    return s;
+}
+
+
+String str_new() {
+    return str_with_capacity(1);
+}
+
+int str_dealloc(String* self) {
+    free(self->data);
+    return 0;
+}
+
+void str_push(String* self, char c) {
+    // check size < capacity
+    if (self->size < self->capacity) {
+        self->data[self->size] = c;
+        self->size++;
+        return;
+    }
+
+    // reallocate to add capacity for an extra char
+    int newcap = self->capacity + sizeof(char);
+    self->data = (char*)realloc(self->data, newcap);
+    self->data[self->size] = c;
+    self->size++;
+    self->capacity = newcap;
+    return;
+}
+
+char str_pop(String* self) {
+    if (self->size == 0) {
+        return '\0';
+    }
+    self->size--;
+    char c = self->data[self->size];
+    return c;
+}
+
+void str_insert(String* self, int index, char c) {
+    if (index > self->size) {
+        return;
+    }
+    self->size++;
+    for (int i = self->size - 1; i > index; i--) {
+        self->data[i] = self->data[i - 1];
+    }
+    self->data[index] = c;
+}
+
+void str_remove(String* self, int index) {
+    if (index >= self->size) {
+        return;
+    }
+    self->size--;
+    for (int i = index; i < self->size; i++) {
+        self->data[i] = self->data[i + 1];
+    }
+}
+
+String* str_lines(String* self, int* numlines) {
+
+    char* string = self->data;
+    String* lines = NULL;
+    
+    // find the number of lines in the file
+    *numlines = 0;
+    for (int i = 0; i < strlen(string); i++) {
+        if (string[i] == '\n') {
+            (*numlines)++;
+        }
+    }
+
+    // add one if the last char is not a newline
+    // in this case there is one more line than newline symbols
+    if (self->data[strlen(self->data) - 1] != '\n') {
+        (*numlines)++;
+    }
+
+    // allocate memory for an array of pointers to each line
+    lines = (String*)malloc((*numlines + 1) * sizeof(String));
+
+    int i = 0;
+    char* start = string;
+    char* end = string;
+
+    while (*end != '\0') {
+        if (*end == '\n') {
+            lines[i] = str_from_slice(start, end - start);
+
+            end++;
+            start = end;
+
+            i++;
+        } else {
+            end++;
+        }
+    }
+    // returns an array of String
+    return lines;
+}
+
+/// splits a string into an array of strings based on a delimiter
+String* str_split(String* self, int* res_len, char c) {
+
+    char* string = self->data;
+    String* elements = NULL;
+    
+    // find the number of lines in the file
+
+    bool flag = false;
+    *res_len = 0;
+    for (int i = 0; i < strlen(string); i++) {
+        if (string[i] == c) {
+            if (flag) {
+                (*res_len)++;
+                flag = false;
+            }
+        } else {
+            flag = true;
+        }
+    }
+    if (flag) {
+        (*res_len)++;
+    }
+
+    // allocate memory for an array of pointers to each line
+    elements = (String*)malloc((*res_len) * sizeof(String));
+
+    int i = 0;
+    flag = false;
+    char* start = string;
+    char* end = string;
+
+    while (*end != '\0') {
+        if (*end == c) {
+            if (flag) {
+                elements[i] = str_from_slice(start, end - start);
+                i++;
+            }
+            end++;
+            start = end;
+            flag = false;
+        } else {
+            end++;
+            flag = true;
+        }
+    } if (flag) {
+        elements[i] = str_from_slice(start, end - start);
+    }
+
+
+    // returns an array of String
+    return elements;
+}
+
+int str_len(String* s) {
+    return s->size;
+}
+
+char* to_chars(String* s) {
+    return s->data;
+}
+
+// int main() {
+//     String s = str_from_chars("hello\nworld\neeeee\notherline\n\0");
+
+//     int numlines = 0;
+//     String* lns = str_lines(&s, &numlines);
+//     str_dealloc(&s);
+
+//     for (int i = 0; i < numlines; i++) {
+//         printf("%s\n", lns[i].data);
+//         str_dealloc(&lns[i]);
+//     }
+
+//     String s2 = str_from_chars("$this$needs$to$be$split");
+
+//     int elements = 0;
+//     String* split = str_split(&s2, &elements, '$');
+//     str_dealloc(&s2);
+
+//     printf("%d elements\n", elements);
+//     for (int i = 0; i < elements; i++) {
+//         printf("%s\n", split[i].data);
+//         str_dealloc(&split[i]);
+//         printf("(dealloced)\n");
+//     }   
+// }

final/dynstr.h

@@ -0,0 +1,36 @@
+#ifndef DYNSTR_H
+#define DYNSTR_H
+
+typedef struct {
+    int size;
+    int capacity;
+    char* data;
+} String;
+
+String str_with_capacity(int capacity);
+
+String str_from_chars(char* string);
+
+String str_from_slice(char* string, int len);
+
+String str_new();
+
+String* str_lines(String* self, int* numlines);
+
+// String* str_split(String* self, int* res_len, char c);
+
+void str_push(String* s, char c);
+
+char str_pop(String* s);
+
+void str_insert(String* s, int index, char c);
+
+void str_remove(String* s, int index);
+
+int str_dealloc(String* s);
+
+char* to_chars(String* s);
+
+int str_len(String* s);
+
+#endif

final/editor.c

@@ -0,0 +1,82 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include "dynstr.h"
+#include <ncurses.h>
+
+typedef struct {
+    int lines;
+    int screen_line;
+    int screen_col;
+    bool editmode;
+    String* buffer;
+} Editor;
+
+Editor new_editor() {
+    Editor e;
+    e.lines = 0;
+    e.screen_line = 0;
+    e.screen_col = 0;
+    e.editmode = false;
+    e.buffer = NULL;
+    return e;
+}
+
+Editor editor_from(char* input_string) {
+    // TODO: fix this function
+    Editor e;
+    e.lines = 0;
+    e.screen_line = 0;
+    e.screen_col = 0;
+    e.editmode = false;
+    e.buffer = NULL;
+    return e;
+}
+
+void move_cursor(Editor* self, int x, int y) {
+    if (x != 0
+        && self->screen_line + y >= 0
+        && self->screen_line + y <= self->lines) 
+    {
+        self->screen_line += y;
+        int line_width = str_len(&self->buffer[self->screen_line]);
+        if (self->screen_col > line_width) {
+            self->screen_col = line_width;
+        }
+    } else if (self->screen_col + x < 0) {
+        if (self->screen_line - 1 >= 0) {
+            self->screen_col = str_len(&self->buffer[self->screen_line]);
+        }
+    } else if (self->screen_col + x > str_len(&self->buffer[self->screen_line])) {
+        if (self->screen_line + 1 <= self->lines) {
+            self->screen_col = 0;
+            self->screen_line += 1;
+        }
+    } else if (x != 0) {
+        self->screen_col += x;
+    }
+    
+    move(self->screen_line, self->screen_col);
+}
+
+void delchar(Editor* self) {
+    str_remove(&self->buffer[self->screen_line], self->screen_col);
+    delch();
+}
+
+void addchar(Editor* self, char c) {
+    insch(c);
+    // insert the character into the string at the given index
+    if (self->screen_line == self->lines) {
+        // reallocate self->buffer to be 1 larger
+        self->lines++;
+        self->buffer = realloc(self->buffer, sizeof(String) * (self->lines + 1));
+    }
+    str_insert(&self->buffer[self->screen_line], self->screen_col, c);
+    move_cursor(self, 1, 0);
+}
+
+String* to_string(Editor* self) {
+
+}
+

final/editor.h

@@ -0,0 +1,18 @@
+#include "dynstr.h"
+
+typedef struct {
+    int screen_line;
+    int screen_col;
+    bool editmode;
+    String* buffer;
+} Editor;
+
+Editor new_editor();
+
+Editor editor_from(char* input_string);
+
+void move_cursor(Editor* self, int x, int y);
+void delchar(Editor* self);
+void addchar(Editor* self, char c);
+
+String* to_string(Editor* self);

final/main.c

@@ -1,17 +1,7 @@
 #include <ncurses.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-typedef struct {
-    int file_line;
-    int file_col;
-    int buff_line;
-    int buff_col;
-    int editmode;
-} EditorData;
+#include "editor.h"
 
 void help() {
     printf("Usage:\n");
@@ -23,3 +13,56 @@ void help() {
     printf("    cmd len <path/to/file> // returns the length of the specified file\n");
     printf("    cmd log // prints a list of all changes made to the file\n");
 }
+
+int open_editor() {
+    initscr();
+    raw();
+    noecho();
+    keypad(stdscr, true);
+    int max_y, max_x;
+    getmaxyx(stdscr, max_y, max_x);
+
+    move(0, 0);
+
+    Editor editor = new_editor();
+
+    while (true) {
+        refresh();
+        int c = getch();
+        if (editor.editmode) {
+            switch (c) {
+                case 27:
+                    editor.editmode = false;
+                    break;
+                case KEY_BACKSPACE:
+                    delchar(&editor);
+                    break;
+                case KEY_ENTER:
+                    editor.editmode = false;
+                    break;
+                default:
+                    addchar(&editor, c);
+                    break;
+            }
+        } else {
+            switch (c) {
+                case 'q':
+                    return 0;
+                case 'i':
+                    editor.editmode = true;
+                    break;
+                case 'w':
+                    // TODO: write function to save the data to a file
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}
+
+int main() {
+    open_editor();
+    return 0;
+}
+