permission files

.gitea/workflows/build.yml

@@ -1,9 +1,8 @@
-name: Meson Build and Deploy
+name: Build and Deploy Docs
 
 on:
   push:
-    branches: ["lisp"]
-  pull_request:
+    branches: ["lisp"] 
 
 jobs:
   build:
@@ -28,22 +27,3 @@ jobs:
 
       - name: Run tests
         run: meson test -C build --print-errorlogs || true
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: beluga
-          path: build/
-
-      - name: Install Doxygen
-        run: sudo apt-get update && sudo apt-get install -y doxygen graphviz
-
-      - name: Build Doxygen Docs
-        run: doxygen Doxyfile
-
-      - name: Deploy to Pages
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          publish_dir: ./docs/html
-          publish_branch: pages
-          github_token: ${{ secrets.GITEA_TOKEN }}

.gitignore

@@ -1,3 +1,3 @@
-tmp/*
-bin/*
+build/*
 doc/*
+beluga.wiki/*

README.md

@@ -4,17 +4,17 @@ Beluga is a project of CLI text editor that will fit perfectly with your azerty
 
 ## Requirements
 
-You will only need **make** or **gcc** to compile the editor.
+You will only need **cmake** and **clang** to compile the editor.
 
 ## Installation
 
-Here is the installation line :
+Here is the installation line for development version:
 
-```git clone --branch V1.0 --single-branch https://github.com/le-cocotier/beluga.git ~/.beluga && cd ~/.beluga && make build```
+```git clone --recurse-submodules https://github.com/le-cocotier/beluga.git ~/.beluga && cd ~/.beluga && mkdir build && cd build && cmake ../ && make beluga```
 
 The executable file will be in `bin/beluga`. Feel free to add it to your path.
 
-You can either run `make all` if you're interested by the doxygen documentation.
+You can either run `make all` or `make doc_doxygen` if you're interested by the doxygen documentation.
 
 ## Getting start
 

assets/beluga.txt

@@ -0,0 +1,43 @@
+                      **#%#*****###%**
+                *##+--------------------=##*  
+             #*=----------------------------=*#*                                 
+          #*------------------------------------*#                               
+        %+----------------------------------------=#*                            
+       #+---------------------------------------------##                            
+     *#-------------------------------------------------=##                         
+    *#----------------------------------------------------:-##
+    #----------------------------------------------------------##                   
+   #=--------------------------------------------------------------##                
+  +--------------------------+@#-%*-----------------------------------#*         
+  +--------------------------%@@@@#-------------------------------------**                              BELUGA - VERSION 1.1
+  *-=-------------------------#@@*---------------------------------------=%
+  %*#==--------------------------------------------------------------------+#                           ----- KEY-BINDS -----
+  *%%=-=--------------------------------------------------------------------=#                          CTRL-q         leave
+  %=--------------------------------------------------------------------------#*                        CTRL-s          save
+ %-----------------------------------------------------------------------------**                       CTRL-o     open-file
+*+--=---===----=---------------=*-----------------------------------------------** 
+ #--=##      *#%#*+==----==+**+----------------------=  ***=---------------------% 
+ *%**=-----------====    ==---------------------------------=+#+-----------------=#                                 
+   *%=----------------------------------------------------------=#*---------------#                                 
+     ##=----------------------------------=------------------------+%=------------+#                                
+       #%+---------------------------------=*------------------------+%------------#                                
+         *#%*=-------------=-----------------#-------------------------#+----------#                                
+             **#%#*******+=======-------------#=------------------------#----------#                                
+                #===#*=======------------------#*----=-----------=--=##*-----------#                                
+                 -====##=------------------------*%+------------=*#+=====----------#                                
+                 --=====+#*=----------------------=-=+*#####***+=======-----------=*                                
+                %------=====*%*=-------------------------========-----------------+*                                
+                 *-=--------====%%###+=--------------------------=-----------------#                                
+                  #-----------=%        +*##%%%%%%@@%%%%####*==---------------------**                              
+                    %=-------#*                                  #%*=-----------------+#                              
+                     *%+--=##                                       ##=-----------------=#*                           
+                        **                                       #+----=-------------------#*                       
+                                                               %+----------------------------#*                     
+                                                             *%-------------==----------------+#                    
+                                                            ##--------------==------------------#                     
+                                                           *#--------------===%-----------------=%                  
+                                                          ##---------------=-##*-----------------+#                 
+                                                        *#---------------==#+=#%-----------------%                 
+                                                       *%---------------+#      %*---------------#*                  
+                                                      *#------------=+#*          #%*=-----------#*                  
+                                                       #****##******                 *#%%##+=----%                 

config/init.lisp

@@ -0,0 +1,34 @@
+;; MACROS
+
+(define TAB-LENGTH 4)
+(define QUIT-TIMES 1)
+
+;; FUNCTIONS
+
+(define editor-delete-next-char (lambda () (
+                                            (move-cursor "right")
+                                            (editor-delete-previous-char)
+                                            )
+                                  )
+  )
+
+
+;; KEY MAPPING
+
+(map-key "CTRL-q" editor-quit)
+(map-key "CTRL-s" editor-save)
+(map-key "ARROW-UP" '(move-cursor "up"))
+(map-key "ARROW-DOWN" '(move-cursor "down"))
+(map-key "ARROW-RIGHT" '(move-cursor "right"))
+(map-key "ARROW-LEFT" '(move-cursor "left"))
+(map-key "ENTER" editor-insert-new-line)
+(map-key "CTRL-a" move-cursor-beg-line)
+(map-key "CTRL-e" move-cursor-end-line)
+(map-key "BACKSPACE" editor-delete-previous-char)
+(map-key "DEL" editor-delete-next-char)
+(map-key "PAGE-UP" move-cursor-page-up)
+(map-key "PAGE-DOWN" move-cursor-page-down)
+(map-key "CTRL-o" editor-open-file)
+
+
+

include/builtins.h

@@ -0,0 +1,32 @@
+#ifndef BUILTINS_H_
+#define BUILTINS_H_
+
+#include "../lisp-interpreter/dist/lisp.h"
+
+Lisp moveCursor(Lisp args, LispError *e, LispContext ctx);
+
+Lisp mapKey(Lisp args, LispError *e, LispContext ctx);
+
+void registerBuiltin(char * key_sequence, LispCFunc f);
+
+Lisp editorQuit(Lisp args, LispError *e, LispContext ctx);
+
+Lisp l_editorSave(Lisp args, LispError *e, LispContext ctx);
+
+Lisp l_editorInsertNewLine(Lisp args, LispError* e, LispContext ctx);
+
+Lisp moveCursorBeginLine(Lisp args, LispError *e, LispContext ctx);
+
+Lisp moveCursorEndLine(Lisp args, LispError *e, LispContext ctx);
+
+Lisp deletePreviousChar(Lisp args, LispError *e, LispContext ctx);
+
+Lisp editorMoveCursorPageUp(Lisp args, LispError* e, LispContext ctx);
+
+Lisp editorMoveCursorPageDown(Lisp args, LispError *e, LispContext ctx);
+
+Lisp editorOpenFile(Lisp args, LispError *e, LispContext ctx);
+
+Lisp editorPrintC(Lisp args, LispError *e, LispContext ctx);
+
+#endif

include/data.h

@@ -1,10 +1,12 @@
 #ifndef DATA_H_
 #define DATA_H_
 
-#include "../lisp-interpreter/dist/lisp.h"
+#include <stdio.h>
 #include <termios.h>
 #include <time.h>
 
+#include "../lisp-interpreter/dist/lisp.h"
+
 /**
  * \struct erow
  * \brief Store one editor row
@@ -18,6 +20,23 @@ typedef struct erow {
   char *render; /**< The actual line we will print */
 } erow;
 
+enum editorStatus_e {
+  IDLE,
+  READ_ONLY,
+  READ_AND_WRITE, 
+};
+
+struct const_t {
+  int TAB_LENGTH;
+  int QUIT_TIMES;
+};
+
+struct keyBind_t {
+  char *key_sequence;
+  Lisp command;
+  
+};
+
 /**
  * \struct editorConfig
  * \brief Containing our editor state.
@@ -33,12 +52,23 @@ struct editorConfig {
   erow *row;              /**< Store all the rows printed */
   int dirty;
   char *filename;
+  enum editorStatus_e state;
   char status_msg[80];
   time_t status_msg_time;
   struct termios orig_termios; /**< Terminal communication interface */
-  LispContext ctx;             /** Lisp context */
-  Lisp ctx_data;               /** Lisp data context */
-  LispError ctx_error;         /** Lisp ctx error */
+
+  struct const_t constantes;
+  int quit_times_buffer;
+
+  FILE *fd_init_file;
+  Lisp env;
+  LispContext ctx;     /** Lisp context */
+  Lisp ctx_data;       /** Lisp data context */
+  LispError ctx_error; /** Lisp ctx error */
+
+  struct keyBind_t* key_binds;
+  int number_of_keybinds;
+
 };
 
 /**
@@ -53,4 +83,5 @@ struct abuf {
 
 extern struct editorConfig E;
 
+
 #endif

include/define.h

@@ -24,8 +24,6 @@ enum editorKey {
 
 #define ABUF_INIT {NULL, 0}
 
-#define BELUGA_VERSION "1.0"
-#define TAB_LENGTH 4
-#define QUIT_TIMES 1
+#define BELUGA_VERSION "1.1"
 
 #endif // DEFINE_H_

include/file_io.h

@@ -10,6 +10,9 @@
 
 char *editorRowsToString(int *buffer_len);
 
+
+void editorCloseFile(void);
+
 void editorOpen(char *filename);
 
 void editorSave();

include/init.h

@@ -1,6 +1,7 @@
 #ifndef INIT_H_
 #define INIT_H_
 
+#include "builtins.h"
 #include "data.h"
 #include "terminal.h"
 #include <stdio.h>
@@ -10,6 +11,8 @@
  * \brief Job's function is to initialize all the fields of editorConfig.
  * */
 
+void initBuiltins();
+
 void initEditor();
 
 #endif // INIT_H_

include/input.h

@@ -5,6 +5,7 @@
 #include "define.h"
 #include "output.h"
 #include "terminal.h"
+#include "builtins.h"
 #include <unistd.h>
 
 // KEYS keycode
@@ -21,8 +22,12 @@
 
 char *editorPrompt(char *prompt);
 
+char *key_to_string(int key);
+
 void editorMoveCursor(int key);
 
+int executeKeyBind(char *key_sequence);
+
 /**
  * \fn void editorProcessKeypress()
  * \brief Get the last key input and do the proper action.

main.c

@@ -5,6 +5,8 @@
  * interactions. \version 0.1 \date 21 septembre 2024
  */
 
+#include <unistd.h>
+
 #define _DEFAULT_SOURCE
 #define _BSD_SOURCE
 #define _GNU_SOURCE
@@ -23,11 +25,15 @@ int main(int argc, char *argv[]) {
   enableRawMode();
   initEditor();
   if (argc >= 2) {
+    E.state = READ_AND_WRITE;
     editorOpen(argv[1]);
+  } else {
+    editorOpen("assets/beluga.txt");
   }
 
   editorSetStatusMessage("HELP: Ctrl-S = save | Ctrl-Q = quit");
 
+
   while (1) {
     editorRefreshScreen();
     editorProcessKeypress();

meson.build

@@ -1,5 +1,5 @@
 project('beluga', 'c',
-  version : '1.0.0',
+  version : '1.1',
   default_options : [
     'c_std=none',
   ]
@@ -22,6 +22,7 @@ src_files = files(
   'src/output.c',
   'src/row_op.c',
   'src/terminal.c',
+  'src/builtins.c',
 )
 
 # Executable

src/builtins.c

@@ -0,0 +1,141 @@
+#include "../include/builtins.h"
+#include "../include/define.h"
+#include "../include/input.h"
+#include "../include/file_io.h"
+#include "../include/editor_op.h"
+#include "../include/data.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+Lisp mapKey(Lisp args, LispError *e, LispContext ctx) {
+  const char *key_sequence = lisp_string(lisp_car(args));
+  args = lisp_cdr(args);
+  // second argument
+  Lisp func = lisp_car(args);
+
+  E.key_binds =
+      (struct keyBind_t *)realloc(E.key_binds, ++E.number_of_keybinds * sizeof(struct keyBind_t));
+  E.key_binds[E.number_of_keybinds - 1].key_sequence = (char *) malloc(50 * sizeof(char));
+
+  strncpy(E.key_binds[E.number_of_keybinds - 1].key_sequence, key_sequence, 50);
+
+  E.key_binds[E.number_of_keybinds - 1].command = func;
+
+  return lisp_null();
+}
+
+Lisp moveCursor(Lisp args, LispError *e, LispContext ctx) {
+  fprintf(stderr, "Cursor is moving\n");
+  const char *direction = lisp_string(lisp_car(args));
+  switch (direction[0]) {
+  case 'u':
+    editorMoveCursor(ARROW_UP);
+    break;
+  case 'd':
+    editorMoveCursor(ARROW_DOWN);
+    break;
+  case 'r':
+    editorMoveCursor(ARROW_RIGHT);
+    break;
+  case 'l':
+    editorMoveCursor(ARROW_LEFT);
+    break;
+  }
+
+
+  return lisp_null();
+}
+
+Lisp editorQuit(Lisp args, LispError* e, LispContext ctx) {
+  if (E.dirty && E.quit_times_buffer > 0) {
+    editorSetStatusMessage("WARNING! Changes hasn't been saved. Press Ctrl-Q "
+                           "another time to quit.");
+    --E.quit_times_buffer;
+    return lisp_null();
+  }
+  write(STDOUT_FILENO, "\x1b[2J", 4);
+  write(STDOUT_FILENO, CURSOR_TOP_LEFT, 3);
+  disableRawMode();
+  exit(0);
+
+  return lisp_null();
+
+  
+}
+
+
+Lisp l_editorSave(Lisp args, LispError* e, LispContext ctx) {
+
+  editorSave();
+  
+  return lisp_null();
+
+  
+}
+
+Lisp l_editorInsertNewLine(Lisp args, LispError* e, LispContext ctx) {
+
+  editorInsertNewLine();
+  
+  return lisp_null();
+
+  
+}
+
+Lisp moveCursorBeginLine(Lisp args, LispError *e, LispContext ctx) {
+  E.cursor_x = 0;
+  return lisp_null();
+}
+
+Lisp moveCursorEndLine(Lisp args, LispError* e, LispContext ctx) {
+  if (E.cursor_y < E.numrows) {
+    E.cursor_x = E.row[E.cursor_y].size;
+  }
+  return lisp_null();
+}
+
+
+Lisp deletePreviousChar(Lisp args, LispError* e, LispContext ctx) {
+  editorDelChar();
+  return lisp_null();
+}
+
+Lisp editorMoveCursorPageUp(Lisp args, LispError* e, LispContext ctx) {
+  E.cursor_y = E.row_offset;
+  int times = E.screenrows;
+  while (--times) {
+    editorMoveCursor(ARROW_UP);
+  }
+  return lisp_null();
+}
+
+Lisp editorMoveCursorPageDown(Lisp args, LispError* e, LispContext ctx) {
+  E.cursor_y = E.row_offset + E.screenrows - 1;
+  if (E.cursor_y > E.numrows) {
+    E.cursor_y = E.numrows;
+  }
+  int times = E.screenrows;
+  while (--times) {
+    editorMoveCursor(ARROW_DOWN);
+  }
+
+  return lisp_null();
+}
+
+Lisp editorOpenFile(Lisp args, LispError *e, LispContext ctx) {
+  char *filename = editorPrompt("Path : %s");
+  if (filename)
+    editorOpen(filename);
+
+  return lisp_null();
+}
+
+
+Lisp editorPrintC(Lisp args, LispError *e, LispContext ctx) {
+  char c = lisp_char(lisp_car(args));
+  editorInsertChar(c);
+  return lisp_null();
+}
+

src/editor_op.c

@@ -1,14 +1,16 @@
 #include "../include/editor_op.h"
 #include "../include/row_op.h"
+#include "data.h"
+
 
 extern struct editorConfig E;
 
 void editorInsertChar(int c) {
-  if (E.cursor_y == E.numrows) {
-    editorInsertRow(E.numrows, "", 0);
-  }
-  editorRowInsertChar(&E.row[E.cursor_y], E.cursor_x, c);
-  E.cursor_x++;
+    if (E.cursor_y == E.numrows) {
+      editorInsertRow(E.numrows, "", 0);
+    }
+    editorRowInsertChar(&E.row[E.cursor_y], E.cursor_x, c);
+    E.cursor_x++;
 }
 
 void editorInsertNewLine() {

src/file_io.c

@@ -1,6 +1,7 @@
 #include "../include/file_io.h"
 #include "../include/input.h"
 #include "../include/output.h"
+#include "data.h"
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -15,78 +16,98 @@ extern int ftruncate(int fd, off_t length);
 extern struct editorConfig E;
 
 char *editorRowsToString(int *buffer_len) {
-  int tot_len = 0;
-  int j;
-  char *buf;
-  char *p;
+    int tot_len = 0;
+    int j;
+    char *buf;
+    char *p;
 
-  for (j = 0; j < E.numrows; ++j) {
-    tot_len += E.row[j].size + 1;
-  }
-  *buffer_len = tot_len;
-  buf = malloc(tot_len);
-  p = buf;
-  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++;
-  }
+    for (j = 0; j < E.numrows; ++j) {
+        tot_len += E.row[j].size + 1;
+    }
+    *buffer_len = tot_len;
+    buf = malloc(tot_len);
+    p = buf;
+    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++;
+    }
 
-  return buf;
+    return buf;
+}
+
+void editorCloseFile(void) {
+    E.cursor_x = 0;
+    E.cursor_y = 0;
+    E.rx = 0;
+    E.row_offset = 0;
+    E.col_offset = 0;
+    E.numrows = 0;
+    E.row = NULL;
+    E.dirty = 0;
+    E.filename = NULL;
+    E.status_msg[0] = '\0';
+    E.status_msg_time = 0;
 }
 
 void editorOpen(char *filename) {
-  FILE *fp;
+    FILE *fp;
 
-  free(E.filename);
-  E.filename = strdup(filename);
-
-  fp = fopen(filename, "r");
-  if (!fp)
-    die("fopen");
-
-  char *line = NULL;
-  size_t line_cap = 0;
-  ssize_t line_len;
-
-  while ((line_len = getline(&line, &line_cap, fp)) != -1) {
-    while (line_len > 0 &&
-           (line[line_len - 1] == '\n' || line[line_len - 1] == '\r')) {
-      --line_len;
+    // Test if a file is already open
+    if (E.filename != NULL) {
+        editorCloseFile();
+        E.state = READ_AND_WRITE;
     }
-    editorInsertRow(E.numrows, line, line_len);
-  }
-  free(line);
-  fclose(fp);
-  E.dirty = 0;
+
+    free(E.filename);
+    E.filename = strdup(filename);
+
+    fp = fopen(filename, "a+");
+    if (!fp)
+        die("fopen");
+
+    char *line = NULL;
+    size_t line_cap = 0;
+    ssize_t line_len;
+
+    while ((line_len = getline(&line, &line_cap, fp)) != -1) {
+        while (line_len > 0 &&
+               (line[line_len - 1] == '\n' || line[line_len - 1] == '\r')) {
+            --line_len;
+        }
+        editorInsertRow(E.numrows, line, line_len);
+    }
+    free(line);
+    fclose(fp);
+    E.dirty = 0;
 }
 
 void editorSave() {
-  int len;
-  char *buf;
-  int fd;
-  if (E.filename == NULL) {
-    E.filename = editorPrompt("Save as: %s (ESC to cancel)");
+    int len;
+    char *buf;
+    int fd;
     if (E.filename == NULL) {
-      editorSetStatusMessage("Save aborted");
-      return;
+        E.filename = editorPrompt("Save as: %s (ESC to cancel)");
+        if (E.filename == NULL) {
+            editorSetStatusMessage("Save aborted");
+            return;
+        }
     }
-  }
-  buf = editorRowsToString(&len);
-  fd = open(E.filename, O_RDWR | O_CREAT, 0644);
-  if (fd != -1) {
-    if (ftruncate(fd, len) != -1) {
-      if (write(fd, buf, len) == len) {
+    buf = editorRowsToString(&len);
+    fd = open(E.filename, O_RDWR | O_CREAT, 0644);
+    if (fd != -1) {
+        if (ftruncate(fd, len) != -1) {
+            if (write(fd, buf, len) == len) {
+                close(fd);
+                free(buf);
+                E.dirty = 0;
+                editorSetStatusMessage("%d bytes written to disk", len);
+                return;
+            }
+        }
         close(fd);
-        free(buf);
-        E.dirty = 0;
-        editorSetStatusMessage("%d bytes written to disk", len);
-        return;
-      }
     }
-    close(fd);
-  }
-  free(buf);
-  editorSetStatusMessage("Can't save! I/O error: %s", strerror(errno));
+    free(buf);
+    editorSetStatusMessage("Can't save! I/O error: %s", strerror(errno));
 }

src/init.c

@@ -1,9 +1,38 @@
 #include "../include/init.h"
 #include "../include/data.h"
+#include "../include/terminal.h"
+#include "../include/builtins.h"
 #include <stdio.h>
 
+#define LISP_IMPLEMENTATION
+#include "../lisp-interpreter/dist/lisp.h"
+#include "../lisp-interpreter/dist/lisp_lib.h"
+
 extern struct editorConfig;
 
+
+void registerBuiltin(char *key_sequence, LispCFunc f) {
+  lisp_env_define(E.ctx.p->env, lisp_make_symbol(key_sequence, E.ctx),
+                  lisp_make_func(f), E.ctx);
+  
+}
+
+void initBuiltins() {
+  // move cursor
+  registerBuiltin("MOVE-CURSOR", moveCursor);
+  registerBuiltin("MAP-KEY", mapKey);
+  registerBuiltin("EDITOR-QUIT", editorQuit);
+  registerBuiltin("EDITOR-SAVE", l_editorSave);
+  registerBuiltin("EDITOR-INSERT-NEW-LINE", l_editorInsertNewLine);
+  registerBuiltin("MOVE-CURSOR-BEG-LINE", moveCursorBeginLine);
+  registerBuiltin("MOVE-CURSOR-END-LINE", moveCursorEndLine);
+  registerBuiltin("EDITOR-DELETE-PREVIOUS-CHAR", deletePreviousChar);
+  registerBuiltin("MOVE-CURSOR-PAGE-UP", editorMoveCursorPageUp);
+  registerBuiltin("MOVE-CURSOR-PAGE-DOWN", editorMoveCursorPageDown);
+  registerBuiltin("EDITOR-OPEN-FILE", editorOpenFile);
+  registerBuiltin("EDITOR-INSERT-CHAR", editorPrintC);
+}
+
 void initEditor() {
   E.cursor_x = 0;
   E.cursor_y = 0;
@@ -14,6 +43,7 @@ void initEditor() {
   E.row = NULL;
   E.dirty = 0;
   E.filename = NULL;
+  E.state = READ_ONLY;
   E.status_msg[0] = '\0';
   E.status_msg_time = 0;
   if (getWindowSize(&E.screenrows, &E.screencols) == -1) {
@@ -21,9 +51,33 @@ void initEditor() {
   }
   E.screenrows -= 2;
 
-  // E.fd_init_file = fopen("../config/init.el", "r");
+  E.number_of_keybinds = 0;
 
-  // E.ctx = lisp_init();
-  // E.ctx_data = lisp_read_file(E.fd_init_file, &E.ctx_error, E.ctx);
-  // lisp_printf(stderr, E.ctx_data);
+  
+  E.fd_init_file = fopen("config/init.lisp", "r");
+  E.ctx = lisp_init();
+  E.env = lisp_env(E.ctx);
+  lisp_lib_load(E.ctx);
+  // Init builtins lisp functions
+  initBuiltins();
+
+  // Read config file
+  E.ctx_data = lisp_read_file(E.fd_init_file, &E.ctx_error, E.ctx);
+  if (E.ctx_error != LISP_ERROR_NONE) {
+    die("init failed");
+  }
+  lisp_eval(E.ctx_data, &E.ctx_error, E.ctx);
+  
+  // To modify
+
+  E.constantes.TAB_LENGTH =
+      (int)lisp_eval(lisp_read("TAB-LENGTH", &E.ctx_error, E.ctx), &E.ctx_error,
+                     E.ctx)
+          .val.int_val;
+  E.constantes.QUIT_TIMES =
+      (int)lisp_eval(lisp_read("QUIT-TIMES", &E.ctx_error, E.ctx), &E.ctx_error,
+                     E.ctx)
+          .val.int_val;
+
+  E.quit_times_buffer = E.constantes.QUIT_TIMES;
 }

src/input.c

@@ -1,11 +1,12 @@
 #include "../include/input.h"
 #include "../include/editor_op.h"
-#include "../include/file_io.h"
 #include "../include/output.h"
+#include "../include/define.h"
 #include <ctype.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
 extern struct editorConfig E;
@@ -30,7 +31,6 @@ char *editorPrompt(char *prompt) {
         buf[--buf_len] = '\0';
       }
     } else if (c == ESCAPE) {
-      fprintf(stderr, "escape");
       editorSetStatusMessage("");
       free(buf);
       return NULL;
@@ -50,6 +50,73 @@ char *editorPrompt(char *prompt) {
   }
 }
 
+char *key_to_string(int key) {
+  static char key_str[32];
+
+  char tmp[10];
+  sprintf(tmp, "%d", key);
+
+
+  // First test enter key
+
+  if (key == '\r') {
+    strcpy(key_str, "ENTER");
+  } else if (key >= 1 && key <= 26) { // CTRL keys
+    snprintf(key_str, sizeof(key_str), "CTRL-%c", 'a' + key - 1);
+  } else {
+    switch (key) {
+    case ARROW_UP:
+      strcpy(key_str, "ARROW-UP");
+      break;
+    case ARROW_DOWN:
+      strcpy(key_str, "ARROW-DOWN");
+      break;
+    case ARROW_LEFT:
+      strcpy(key_str, "ARROW-LEFT");
+      break;
+    case ARROW_RIGHT:
+      strcpy(key_str, "ARROW-RIGHT");
+      break;
+    case PAGE_UP:
+      strcpy(key_str, "PAGE-UP");
+      fprintf(stderr, "pagr up\n");
+      break;
+    case PAGE_DOWN:
+      strcpy(key_str, "PAGE-DOWN");
+      break;
+    case DEL_KEY:
+      fprintf(stderr, "delete key\n");
+      strcpy(key_str, "DEL");
+      
+      break;
+    case BACKSPACE:
+      strcpy(key_str, "BACKSPACE");
+      break;
+    case '\r':
+      strcpy(key_str, "ENTER");
+      break;
+    case '\x1b':
+      strcpy(key_str, "ESCAPE");
+      break;
+    case BEG_LINE:
+      strcpy(key_str, "HOME");
+      break;
+    case END_LINE:
+      strcpy(key_str, "END");
+      break;
+    default:
+      // For regular characters
+      if (isprint(key)) {
+        snprintf(key_str, sizeof(key_str), "%c", key);
+      } else {
+        snprintf(key_str, sizeof(key_str), "KEY-%d", key);
+      }
+    }
+  }
+  return key_str;
+}
+
+
 void editorMoveCursor(int key) {
   erow *row = (E.cursor_y >= E.numrows) ? NULL : &E.row[E.cursor_y];
   int row_len;
@@ -89,81 +156,28 @@ void editorMoveCursor(int key) {
   }
 }
 
-void editorProcessKeypress() {
-  static int quit_times = QUIT_TIMES;
-  int c = editorReadKey();
-  int times;
-
-  switch (c) {
-
-  case '\r':
-    editorInsertNewLine();
-    break;
-  case CTRL_KEY('q'):
-    if (E.dirty && quit_times > 0) {
-      editorSetStatusMessage("WARNING! Changes hasn't been saved. Press Ctrl-Q "
-                             "another time to quit.");
-      --quit_times;
-      return;
+int executeKeyBind(char *key_sequence) {
+  int i;
+  for (i = 0; i < E.number_of_keybinds; ++i) {
+    if (!strcmp(key_sequence, E.key_binds[i].key_sequence)) {
+  
+        fprintf(stderr, "lisp function %s\n", key_sequence);
+        // It's a symbol, create a function call
+        lisp_eval(lisp_cons(E.key_binds[i].command, lisp_null(), E.ctx),
+                  &E.ctx_error, E.ctx);
+        return 1;
     }
-    write(STDOUT_FILENO, "\x1b[2J", 4);
-    write(STDOUT_FILENO, CURSOR_TOP_LEFT, 3);
-    disableRawMode();
-    exit(0);
-    break;
-
-  case CTRL_KEY('s'):
-    editorSave();
-    break;
-
-  case BEG_LINE:
-    E.cursor_x = 0;
-    break;
-
-  case END_LINE:
-    if (E.cursor_y < E.numrows) {
-      E.cursor_x = E.row[E.cursor_y].size;
-    }
-    break;
-
-  case BACKSPACE:
-  case CTRL_KEY('h'):
-  case DEL_KEY:
-    if (c == DEL_KEY) {
-      editorMoveCursor(ARROW_RIGHT);
-    }
-    editorDelChar();
-    break;
-
-  case PAGE_UP:
-  case PAGE_DOWN: {
-    if (c == PAGE_UP) {
-      E.cursor_y = E.row_offset;
-    } else if (c == PAGE_DOWN) {
-      E.cursor_y = E.row_offset + E.screenrows - 1;
-      if (E.cursor_y > E.numrows) {
-        E.cursor_y = E.numrows;
-      }
-    }
-    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_KEY('l'):
-  case '\x1b':
-    break;
-  default:
-    editorInsertChar(c);
-    break;
   }
-  quit_times = QUIT_TIMES;
+  return 0;
+}
+
+void editorProcessKeypress() {
+  int c = editorReadKey();
+
+  if (executeKeyBind(key_to_string(c))) {
+    return;
+  }
+  editorInsertChar(c);
+  E.quit_times_buffer = E.constantes.QUIT_TIMES;
+
 }

src/row_op.c

@@ -1,4 +1,6 @@
 #include "../include/row_op.h"
+#include "data.h"
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -10,7 +12,7 @@ int editorRowCxToRx(erow *row, int cursor_x) {
   int i;
   for (i = 0; i < cursor_x; ++i) {
     if (row->chars[i] == '\t') {
-      render_x += (TAB_LENGTH - 1) - (render_x % TAB_LENGTH);
+      render_x += (E.constantes.TAB_LENGTH - 1) - (render_x % E.constantes.TAB_LENGTH);
     }
     render_x++;
   }
@@ -34,8 +36,8 @@ void editorUpdateRow(erow *row) {
   }
 
   free(row->render);
-  row->render = malloc(row->size + tabs * (TAB_LENGTH - 1) +
-                       1); /**< Tabs needs TAB_LENGTH chars so TAB_LENGTH - 1
+  row->render = malloc(row->size + tabs * (E.constantes.TAB_LENGTH - 1) +
+                       1); /**< Tabs needs E.constantes.TAB_LENGTH chars so E.constantes.TAB_LENGTH - 1
                               more than the first already counted. */
 
   // end of counting
@@ -43,7 +45,7 @@ void editorUpdateRow(erow *row) {
   for (i = 0; i < row->size; ++i) {
     if (row->chars[i] == '\t') {
       row->render[i_render++] = ' ';
-      while (i_render % TAB_LENGTH) {
+      while (i_render % E.constantes.TAB_LENGTH) {
         row->render[i_render++] =
             ' '; /**< Addind the right amount of spaces for tabs */
       }
@@ -57,10 +59,14 @@ void editorUpdateRow(erow *row) {
 
 void editorInsertRow(int at, char *s, size_t len) {
   if (at < 0 || at > E.numrows) {
+    
     return;
   }
-
-  E.row = realloc(E.row, sizeof(erow) * (E.numrows + 1));
+  erow *tmp = (erow *)realloc(E.row, sizeof(erow) * (E.numrows + 1));
+  if (!tmp) {
+    return;
+  }
+  E.row = tmp;
   memmove(&E.row[at + 1], &E.row[at], sizeof(erow) * (E.numrows - at));
 
   E.row[at].size = len;
@@ -96,6 +102,8 @@ void editorDelRow(int at) {
  * \param at Index of where we want to insert the char */
 
 void editorRowInsertChar(erow *row, int at, int c) {
+  if (E.state == READ_ONLY)
+    return;
   if (at < 0 || at > row->size) {
     at = row->size;
   }

src/terminal.c

@@ -4,145 +4,146 @@
 #include <stdio.h>
 
 void die(const char *s) {
-    write(STDOUT_FILENO, "\x1b[2J", 4);
-    write(STDOUT_FILENO, CURSOR_TOP_LEFT, 3);
-    perror(s);
-    exit(1);
+  write(STDOUT_FILENO, "\x1b[2J", 4);
+  write(STDOUT_FILENO, CURSOR_TOP_LEFT, 3);
+  lisp_shutdown(E.ctx);
+  perror(s);
+  exit(1);
 }
 
 void disableRawMode() {
-    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &E.orig_termios) == -1) {
-        die("tcsetattr");
-    }
+  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &E.orig_termios) == -1) {
+    die("tcsetattr");
+  }
 }
 
 void enableRawMode() {
-    if (tcgetattr(STDIN_FILENO, &E.orig_termios) == -1) {
-        die("tcgetattr");
-    }
+  if (tcgetattr(STDIN_FILENO, &E.orig_termios) == -1) {
+    die("tcgetattr");
+  }
 
-    struct termios raw = E.orig_termios;
-    raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
-    raw.c_oflag &= ~(OPOST);
-    raw.c_cflag |= (CS8);
-    raw.c_lflag &= ~(ECHO | ICANON | ISIG | IEXTEN);
-    raw.c_cc[VMIN] = 0;
-    raw.c_cc[VTIME] = 1;
+  struct termios raw = E.orig_termios;
+  raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+  raw.c_oflag &= ~(OPOST);
+  raw.c_cflag |= (CS8);
+  raw.c_lflag &= ~(ECHO | ICANON | ISIG | IEXTEN);
+  raw.c_cc[VMIN] = 0;
+  raw.c_cc[VTIME] = 1;
 
-    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) == -1) {
-        die("tcgetattr");
-    }
+  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) == -1) {
+    die("tcgetattr");
+  }
 }
 
 int editorReadKey() {
-    int nread;
-    char c;
-    char seq[3];
-    while ((nread = read(STDIN_FILENO, &c, 1)) != 1) {
-        if (nread == -1 && errno != EAGAIN) {
-            die("read");
-        }
+  int nread;
+  char c;
+  char seq[3];
+  while ((nread = read(STDIN_FILENO, &c, 1)) != 1) {
+    if (nread == -1 && errno != EAGAIN) {
+      die("read");
     }
+  }
 
-    if (c == '\x1b') {
-        if (read(STDIN_FILENO, &seq[0], 1) != 1 ||
-            read(STDIN_FILENO, &seq[1], 1) != 1) {
-            return '\x1b';
-        }
-        if (seq[0] == '[') {
-            if (seq[1] >= '0' && seq[1] <= '9') {
-                if (read(STDIN_FILENO, &seq[2], 1) != 1) {
-                    return '\x1b';
-                }
-                if (seq[2] == '~') {
-                    switch (seq[1]) {
-                    case '1':
-                        return BEG_LINE;
-                    case '3':
-                        return DEL_KEY;
-                    case '4':
-                        return END_LINE;
-                    case '5':
-                        return PAGE_UP;
-                    case '6':
-                        return PAGE_DOWN;
-                    case '7':
-                        return BEG_LINE;
-                    case '8':
-                        return END_LINE;
-                    }
-                }
-            } 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 BEG_LINE;
-                case 'F':
-                    return END_LINE;
-                }
-            }
-        } else if (seq[0] == 'O') {
-            switch (seq[1]) {
-            case 'H':
-                return BEG_LINE;
-            case 'F':
-                return END_LINE;
-            }
-        }
-        return '\x1b';
-    } else {
-        return c;
+  if (c == '\x1b') {
+    if (read(STDIN_FILENO, &seq[0], 1) != 1 ||
+        read(STDIN_FILENO, &seq[1], 1) != 1) {
+      return '\x1b';
     }
+    if (seq[0] == '[') {
+      if (seq[1] >= '0' && seq[1] <= '9') {
+        if (read(STDIN_FILENO, &seq[2], 1) != 1) {
+          return '\x1b';
+        }
+        if (seq[2] == '~') {
+          switch (seq[1]) {
+          case '1':
+            return BEG_LINE;
+          case '3':
+            return DEL_KEY;
+          case '4':
+            return END_LINE;
+          case '5':
+            return PAGE_UP;
+          case '6':
+            return PAGE_DOWN;
+          case '7':
+            return BEG_LINE;
+          case '8':
+            return END_LINE;
+          }
+        }
+      } 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 BEG_LINE;
+        case 'F':
+          return END_LINE;
+        }
+      }
+    } else if (seq[0] == 'O') {
+      switch (seq[1]) {
+      case 'H':
+        return BEG_LINE;
+      case 'F':
+        return END_LINE;
+      }
+    }
+    return '\x1b';
+  } else {
+    return c;
+  }
 }
 
 int getCursorPosition(int *rows, int *cols) {
-    char buf[32];
-    unsigned int i = 0;
+  char buf[32];
+  unsigned int i = 0;
 
-    if (write(STDOUT_FILENO, "\x1b[6n", 4) != 4) {
-        return -1;
-    }
+  if (write(STDOUT_FILENO, "\x1b[6n", 4) != 4) {
+    return -1;
+  }
 
-    while (i < sizeof(buf) - 1) {
-        if (read(STDIN_FILENO, &buf[i], 1) != 1) {
-            break;
-        }
-        if (buf[i] == 'R') {
-            break;
-        }
-        ++i;
+  while (i < sizeof(buf) - 1) {
+    if (read(STDIN_FILENO, &buf[i], 1) != 1) {
+      break;
     }
-    buf[i] = '\0';
+    if (buf[i] == 'R') {
+      break;
+    }
+    ++i;
+  }
+  buf[i] = '\0';
 
-    if (buf[0] != '\x1b' || buf[1] != '[') {
-        return -1;
-    }
-    if (sscanf(&buf[2], "%d;%d", rows, cols) != 2) {
-        return -1;
-    }
+  if (buf[0] != '\x1b' || buf[1] != '[') {
+    return -1;
+  }
+  if (sscanf(&buf[2], "%d;%d", rows, cols) != 2) {
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 int getWindowSize(int *rows, int *cols) {
-    struct winsize ws;
+  struct winsize ws;
 
-    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
-        if (write(STDOUT_FILENO, "\x1b[999C\x1b[999B", 12) != 12) {
-            return -1;
-        }
-        return getCursorPosition(rows, cols);
-    } else {
-        *cols = ws.ws_col;
-        *rows = ws.ws_row;
-        return 0;
+  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
+    if (write(STDOUT_FILENO, "\x1b[999C\x1b[999B", 12) != 12) {
+      return -1;
     }
+    return getCursorPosition(rows, cols);
+  } else {
+    *cols = ws.ws_col;
+    *rows = ws.ws_row;
+    return 0;
+  }
 }