Adding splitting screen and buffer switching

assets/beluga.txt

@@ -9,12 +9,12 @@
     #----------------------------------------------------------##                   
    #=--------------------------------------------------------------##                
   +--------------------------+@#-%*-----------------------------------#*         
-  +--------------------------%@@@@#-------------------------------------**                              BELUGA - VERSION 1.1
+  +--------------------------%@@@@#-------------------------------------**                              BELUGA - VERSION 2.3
   *-=-------------------------#@@*---------------------------------------=%
   %*#==--------------------------------------------------------------------+#                           ----- KEY-BINDS -----
-  *%%=-=--------------------------------------------------------------------=#                          CTRL-q         leave
-  %=--------------------------------------------------------------------------#*                        CTRL-s          save
- %-----------------------------------------------------------------------------**                       CTRL-o     open-file
+  *%%=-=--------------------------------------------------------------------=#                          CTRL-x CTRL-c  leave
+  %=--------------------------------------------------------------------------#*                        CTRL-x CTRL-s   save
+ %-----------------------------------------------------------------------------**                       CTRL-x f   open-file
 *+--=---===----=---------------=*-----------------------------------------------** 
  #--=##      *#%#*+==----==+**+----------------------=  ***=---------------------% 
  *%**=-----------====    ==---------------------------------=+#+-----------------=#                                 

config/init.lisp

@@ -2,6 +2,7 @@
 
 (define TAB-LENGTH 4)
 (define QUIT-TIMES 1)
+(define THEME "dark")
 
 ;; PACKAGES
 
@@ -80,5 +81,9 @@
 (map-key "f" editor-open-file "user")
 (map-key "TAB" editor-insert-tab "no-prefix")
 (map-key "CTRL-k" editor-del-row "no-prefix")
-(map-key "CTRL-s" editor-find "no-prefix")
+(map-key "CTRL-s" buffer-find "no-prefix")
 (map-key "CTRL-r" editor-move-to-end-of-word "no-prefix")
+(map-key "\"" editor-split-screen-vertical "user")
+(map-key "o" editor-switch-next-pane "user")
+(map-key "*" editor-unify-panes "user")
+

include/buffer.h

@@ -0,0 +1,58 @@
+/**
+ * @file buffer.h
+ * @brief Buffer management for handling multiple open files
+ */
+
+#ifndef BUFFER_H_
+#define BUFFER_H_
+
+#include "data.h"
+
+/**
+ * @brief Creates a new buffer for a file
+ * @param filename Path to the file
+ * @return Buffer ID on success, -1 on failure
+ */
+int bufferCreate(const char *filename);
+
+/**
+ * @brief Switches to a specific buffer by ID
+ * @param buffer_id The buffer ID to switch to
+ * @return 0 on success, -1 on failure
+ */
+int bufferSwitch(int buffer_id);
+
+struct buffer_t *bufferFindById(int buffer_id);
+
+/**
+ * @brief Closes a buffer by ID
+ * @param buffer_id The buffer ID to close
+ * @return 0 on success, -1 on failure
+ */
+int bufferClose(int buffer_id);
+
+/**
+ * @brief Gets the current active buffer
+ * @return Pointer to current buffer_t, NULL if none
+ */
+struct buffer_t *bufferGetCurrent(void);
+
+/**
+ * @brief Lists all open buffers
+ * @return Number of open buffers
+ */
+int bufferListAll(void);
+
+/**
+ * @brief Saves current buffer to disk
+ * @return 0 on success, -1 on failure
+ */
+int bufferSave(void);
+
+/**
+ * @brief Saves all buffers to disk
+ * @return 0 on success, -1 on failure
+ */
+int bufferSaveAll(void);
+
+#endif

include/builtins.h

@@ -3,45 +3,53 @@
 
 #include "lisp.h"
 
+// Mouvement
+
 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 l_editorInserTab(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);
+// Text editing
 
+Lisp l_editorInsertNewLine(Lisp args, LispError* e, LispContext ctx);
+Lisp l_editorInserTab(Lisp args, LispError *e, LispContext ctx);
+Lisp deletePreviousChar(Lisp args, LispError *e, LispContext ctx);
 Lisp editorPrintC(Lisp args, LispError *e, LispContext ctx);
-
-Lisp addPackage(Lisp args, LispError *e, LispContext ctx);
-
 Lisp editorDelRow_L(Lisp args, LispError *e, LispContext ctx);
-
-Lisp editorFind_L(Lisp args, LispError *e, LispContext ctx);
-
 Lisp editorReadChar_L(Lisp args, LispError *e, LispContext ctx);
 
-Lisp editorSetPrefix(Lisp args, LispError *e, LispContext ctx);
+// Editor
 
+Lisp editorQuit(Lisp args, LispError *e, LispContext ctx);
+Lisp l_editorSave(Lisp args, LispError *e, LispContext ctx);
+Lisp editorSetPrefix(Lisp args, LispError *e, LispContext ctx);
 Lisp editorPrefix(Lisp args, LispError *e, LispContext ctx);
+Lisp mapKey(Lisp args, LispError *e, LispContext ctx);
+void registerBuiltin(char * key_sequence, LispCFunc f);
+Lisp editorOpenFile(Lisp args, LispError *e, LispContext ctx);
+Lisp addPackage(Lisp args, LispError *e, LispContext ctx);
+
+
+// Buffer
+
+Lisp editorSwitchNextBuffer(Lisp args, LispError *e, LispContext ctx);
+Lisp bufferFind_L(Lisp args, LispError *e, LispContext ctx);
+
+
+// Pane
+
+Lisp l_editorSplitScreenVertical(Lisp args, LispError *e, LispContext ctx);
+Lisp editorSwitchNextPane(Lisp args, LispError *e, LispContext ctx);
+Lisp editorUnifiedPanes(Lisp args, LispError *e, LispContext ctx);
+
+
+
+
+
+
+// Other
 
 void free_structs(void);
 

include/color.h

@@ -0,0 +1,123 @@
+#ifndef COLOR_H_
+#define COLOR_H_
+
+
+// ============================================================================
+// TEXT STYLES / ATTRIBUTES
+// ============================================================================
+#define ANSI_RESET          "\x1b[0m"      // Reset all attributes
+#define ANSI_BOLD           "\x1b[1m"      // Bold text
+#define ANSI_DIM            "\x1b[2m"      // Dim/faint text
+#define ANSI_ITALIC         "\x1b[3m"      // Italic text
+#define ANSI_UNDERLINE      "\x1b[4m"      // Underline text
+#define ANSI_BLINK          "\x1b[5m"      // Blinking text
+#define ANSI_REVERSE        "\x1b[7m"      // Reverse video (invert colors)
+#define ANSI_HIDDEN         "\x1b[8m"      // Hidden/invisible text
+#define ANSI_STRIKETHROUGH  "\x1b[9m"      // Strikethrough text
+
+// ============================================================================
+// FOREGROUND COLORS (30-37 standard, 90-97 bright)
+// ============================================================================
+#define ANSI_BLACK          "\x1b[30m"
+#define ANSI_RED            "\x1b[31m"
+#define ANSI_GREEN          "\x1b[32m"
+#define ANSI_YELLOW         "\x1b[33m"
+#define ANSI_BLUE           "\x1b[34m"
+#define ANSI_MAGENTA        "\x1b[35m"
+#define ANSI_CYAN           "\x1b[36m"
+#define ANSI_WHITE          "\x1b[37m"
+
+// Bright/Light foreground colors (90-97)
+#define ANSI_BRIGHT_BLACK   "\x1b[90m"
+#define ANSI_BRIGHT_RED     "\x1b[91m"
+#define ANSI_BRIGHT_GREEN   "\x1b[92m"
+#define ANSI_BRIGHT_YELLOW  "\x1b[93m"
+#define ANSI_BRIGHT_BLUE    "\x1b[94m"
+#define ANSI_BRIGHT_MAGENTA "\x1b[95m"
+#define ANSI_BRIGHT_CYAN    "\x1b[96m"
+#define ANSI_BRIGHT_WHITE   "\x1b[97m"
+
+// ============================================================================
+// BACKGROUND COLORS (40-47 standard, 100-107 bright)
+// ============================================================================
+#define ANSI_BG_BLACK       "\x1b[40m"
+#define ANSI_BG_RED         "\x1b[41m"
+#define ANSI_BG_GREEN       "\x1b[42m"
+#define ANSI_BG_YELLOW      "\x1b[43m"
+#define ANSI_BG_BLUE        "\x1b[44m"
+#define ANSI_BG_MAGENTA     "\x1b[45m"
+#define ANSI_BG_CYAN        "\x1b[46m"
+#define ANSI_BG_WHITE       "\x1b[47m"
+
+// Bright/Light background colors (100-107)
+#define ANSI_BG_BRIGHT_BLACK   "\x1b[100m"
+#define ANSI_BG_BRIGHT_RED     "\x1b[101m"
+#define ANSI_BG_BRIGHT_GREEN   "\x1b[102m"
+#define ANSI_BG_BRIGHT_YELLOW  "\x1b[103m"
+#define ANSI_BG_BRIGHT_BLUE    "\x1b[104m"
+#define ANSI_BG_BRIGHT_MAGENTA "\x1b[105m"
+#define ANSI_BG_BRIGHT_CYAN    "\x1b[106m"
+#define ANSI_BG_BRIGHT_WHITE   "\x1b[107m"
+
+// ============================================================================
+// 256-COLOR MODE (for more colors)
+// ============================================================================
+// Foreground: \x1b[38;5;Nm  where N is 0-255
+// Background: \x1b[48;5;Nm  where N is 0-255
+// Example macros:
+#define ANSI_FG_256(N)      "\x1b[38;5;" #N "m"
+#define ANSI_BG_256(N)      "\x1b[48;5;" #N "m"
+
+// ============================================================================
+// TRUE COLOR / 24-BIT COLOR (RGB)
+// ============================================================================
+// Foreground: \x1b[38;2;R;G;Bm
+// Background: \x1b[48;2;R;G;Bm
+// Example macros:
+#define ANSI_FG_RGB(R,G,B)  "\x1b[38;2;" #R ";" #G ";" #B "m"
+#define ANSI_BG_RGB(R,G,B)  "\x1b[48;2;" #R ";" #G ";" #B "m"
+
+// ============================================================================
+// CURSOR MOVEMENT
+// ============================================================================
+#define ANSI_CURSOR_UP(N)       "\x1b[" #N "A"    // Move up N lines
+#define ANSI_CURSOR_DOWN(N)     "\x1b[" #N "B"    // Move down N lines
+#define ANSI_CURSOR_RIGHT(N)    "\x1b[" #N "C"    // Move right N columns
+#define ANSI_CURSOR_LEFT(N)     "\x1b[" #N "D"    // Move left N columns
+#define ANSI_CURSOR_HOME        "\x1b[H"          // Move to home (0,0)
+#define ANSI_CURSOR_HIDE        "\x1b[?25l"       // Hide cursor
+#define ANSI_CURSOR_SHOW        "\x1b[?25h"       // Show cursor
+
+// ============================================================================
+// SCREEN CONTROL
+// ============================================================================
+#define ANSI_CLEAR_SCREEN   "\x1b[2J"      // Clear entire screen
+#define ANSI_CLEAR_LINE     "\x1b[K"       // Clear from cursor to end of line
+#define ANSI_CLEAR_UP       "\x1b[1J"      // Clear from cursor to start
+#define ANSI_CLEAR_DOWN     "\x1b[0J"      // Clear from cursor to end
+
+// ============================================================================
+// EXAMPLE USAGE
+// ============================================================================
+/*
+#include <stdio.h>
+
+int main(void) {
+    // Simple color example
+    printf("%sHello in Red%s\n", ANSI_RED, ANSI_RESET);
+    
+    // Bold and colored
+    printf("%s%sBold Green%s\n", ANSI_BOLD, ANSI_GREEN, ANSI_RESET);
+    
+    // Background color
+    printf("%s%sYellow on Blue%s\n", ANSI_YELLOW, ANSI_BG_BLUE, ANSI_RESET);
+    
+    // Combine multiple styles
+    printf("%s%s%sUnderlined Bold Cyan%s\n", 
+           ANSI_UNDERLINE, ANSI_BOLD, ANSI_CYAN, ANSI_RESET);
+    
+    return 0;
+}
+*/
+
+#endif

include/data.h

@@ -13,14 +13,63 @@
  * \param
  * */
 
-typedef struct erow {
+typedef struct frow {
   int size;     /**< Size of the line */
   int rsize;    /**< Size of the render line */
   char *chars;  /**< Characters of the line */
   char *render; /**< The actual line we will print */
-} erow;
+} frow;
 
-enum editorStatus_e {
+
+/**
+ * @brief Split modes for screen layout
+ */
+typedef enum {
+    SPLIT_NONE = 0,      // Single buffer fullscreen
+    SPLIT_VERTICAL,      // Left-right split
+    SPLIT_HORIZONTAL     // Top-bottom split
+} SplitMode;
+
+/**
+ * @brief Represents an editor viewport/pane
+ */
+typedef struct {
+    int buffer_id;        // Which buffer this pane displays
+    int start_row;        // Starting row on screen
+    int start_col;        // Starting column on screen
+    int height;           // Height of this pane
+    int width;            // Width of this pane
+    int cursor_x;         // Local cursor x in this pane
+    int cursor_y;         // Local cursor y in this pane
+  int rx, ry; 
+    int row_offset;       // Scroll offset for rows
+    int col_offset;       // Scroll offset for columns
+    int is_active;        // Is this pane currently active
+} EditorPane;
+
+/**
+ * @brief Screen layout manager
+ */
+typedef struct {
+    SplitMode mode;
+    EditorPane *panes;
+    int num_panes;
+    int active_pane;      // Index of active pane
+} ScreenLayout;
+
+
+typedef struct theme {
+  char *BACKGROUND_COLOR;
+  char *COLOR_KEYWORD;
+  char *COLOR_TYPE;
+  char *COLOR_STRING;
+  char *COLOR_COMMENT;
+  char *COLOR_NUMBER;
+  char *COLOR_DEFAULT;
+
+} theme_t;
+
+enum bufferStatus_e {
   IDLE,
   READ_ONLY,
   READ_AND_WRITE,
@@ -29,6 +78,7 @@ enum editorStatus_e {
 struct const_t {
   int TAB_LENGTH;
   int QUIT_TIMES;
+  char *THEME;
 };
 
 struct prefix_t {
@@ -40,7 +90,22 @@ struct keyBind_t {
   char *key_sequence;
   int prefix_id;
   Lisp command;
+};
 
+enum buffer_type { FILE_BUFF, TERMINAL_BUFF };
+
+struct buffer_t {
+  enum buffer_type type;
+  int buffer_id;
+  int width, height;
+  int x, y; /**< Position in the buffer (cursor) */
+  frow *row;
+  int numrows;
+  char *filename;
+  enum bufferStatus_e state;
+  int dirty;             /**< Has this buffer been modified since last save */
+  int row_offset;        /**< Scroll offset for rows in this buffer */
+  int col_offset;        /**< Scroll offset for columns in this buffer */
 };
 
 /**
@@ -48,17 +113,12 @@ struct keyBind_t {
  * \brief Containing our editor state.
  */
 struct editorConfig {
-  int cursor_x, cursor_y; /**< Cursor position */
-  int rx;                 /**< Position in the render*/
-  int row_offset;         /**< Position scroll of lines */
-  int col_offset;         /**< Position scroll of colomns*/
   int screenrows;         /**< Terminal height*/
   int screencols;         /**< Terminal width*/
-  int numrows;            /**< Number of rows contained */
-  erow *row;              /**< Store all the rows printed */
+
+  ScreenLayout layout;
+  
   int dirty;
-  char *filename;
-  enum editorStatus_e state;
   int prefix_state;
   char status_msg[80];
   time_t status_msg_time;
@@ -67,6 +127,7 @@ struct editorConfig {
   struct const_t constantes;
   int quit_times_buffer;
 
+  char *init_file_path;
   FILE *fd_init_file;
   Lisp env;
   LispContext ctx;     /** Lisp context */
@@ -79,6 +140,10 @@ struct editorConfig {
   struct prefix_t *prefix;
   int number_of_prefix;
 
+  struct buffer_t buffers[64];
+  int number_of_buffer;
+
+  theme_t theme;
 };
 
 /**
@@ -93,5 +158,4 @@ struct abuf {
 
 extern struct editorConfig E;
 
-
 #endif

include/editor_op.h

@@ -2,10 +2,12 @@
 #define EDITOR_OP_H_
 
 #include "data.h"
-void editorInsertChar(int c);
+void bufferInsertChar(int c);
 
-void editorInsertNewLine();
+void bufferInsertNewLine();
 
-void editorDelChar();
+void bufferDelChar();
+
+void editorSetStatusMessage(const char *fmt, ...);
 
 #endif // EDITOR_OP_H_

include/file_io.h

@@ -8,15 +8,15 @@
 #include <stdlib.h>
 #include <sys/types.h>
 
-char *editorRowsToString(int *buffer_len);
+char *bufferRowsToString(struct buffer_t *buf,int *buffer_len);
 
 
 void editorCloseFile(void);
 
-void editorOpen(char *filename);
+void editorOpen(struct buffer_t *buffer);
 
 void editorSave();
 
-void editorFind();
+void bufferFind(struct buffer_t *buf);
 
 #endif // FILE_IO_H_

include/lisp.h

@@ -2075,8 +2075,10 @@ static Lisp parse(Lexer* lex, LispError* out_error, LispContext ctx)
         result = lisp_cons(get_sym(SYM_BEGIN, ctx), lisp_list_reverse(result), ctx);
     }
 
-    if (out_error) *out_error = error;
+    if (out_error)
+      *out_error = error;
     return result;
+
 }
 
 Lisp lisp_read(const char *program, LispError* out_error, LispContext ctx)
@@ -2122,6 +2124,7 @@ void* fread_all_(FILE* file, size_t* out_size) {
                 return NULL;
             }
             data = new_data;
+            memset(data + *out_size, 0, cap - *out_size);
         }
 
         size_t read = fread(data + *out_size, 1, BLOCK_SIZE, file);

include/output.h

@@ -1,11 +1,7 @@
 #ifndef OUTPUT_H_
 #define OUTPUT_H_
 
-#include "append_buffer.h"
 #include "data.h"
-#include "define.h"
-#include "row_op.h"
-#include <stdio.h>
 #include <unistd.h>
 
 /**
@@ -23,6 +19,4 @@ void editorDrawStatusBar(struct abuf *ab);
 
 void editorDrawMessageBar(struct abuf *ab);
 
-void editorSetStatusMessage(const char *fmt, ...);
-
 #endif // OUTPUT_H_

include/row_op.h

@@ -8,22 +8,22 @@
 #include <time.h>
 #include <unistd.h>
 
-int editorRowCxToRx(erow *row, int cursor_x);
+int bufferRowCxToRx(frow *row, int cursor_x);
 
-int editorRowRxToCx(erow *row, int rx);
+int bufferRowRxToCx(frow *row, int rx);
 
-void editorUpdateRow(erow *row);
+void bufferUpdatfrow(frow *row);
 
-void editorInsertRow(int at, char *s, size_t len);
+void bufferInsertRow(struct buffer_t *buffer, int at, char *s, size_t len);
 
-void editorFreeRow(erow *row);
+void bufferFrefrow(frow *row);
 
-void editorDelRow(int at);
+void bufferDelRow(struct buffer_t *buffer, int at);
 
-void editorRowInsertChar(erow *row, int at, int c);
+void bufferRowInsertChar(struct buffer_t *buffer, frow *row, int at, int c);
 
-void editorRowAppendString(erow *row, char *s, size_t len);
+void bufferRowAppendString(struct buffer_t *buffer, frow *row, char *s, size_t len);
 
-void editorRowDelchar(erow *row, int at);
+void bufferRowDelchar(struct buffer_t *buffer, frow *row, int at);
 
 #endif // ROW_OP_H_

include/split_screen.h

@@ -0,0 +1,62 @@
+/**
+ * @file split_screen.h
+ * @brief Split screen management for displaying multiple buffers
+ */
+
+#ifndef SPLIT_SCREEN_H_
+#define SPLIT_SCREEN_H_
+
+#include "data.h"
+
+/**
+ * @brief Initializes split screen system
+ */
+void splitScreenInit(void);
+
+/**
+ * @brief Splits screen vertically (left-right)
+ * @param buffer_id_left Buffer ID for left pane
+ * @param buffer_id_right Buffer ID for right pane
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenVertical(int buffer_id_left, int buffer_id_right);
+
+/**
+ * @brief Splits screen horizontally (top-bottom)
+ * @param buffer_id_top Buffer ID for top pane
+ * @param buffer_id_bottom Buffer ID for bottom pane
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenHorizontal(int buffer_id_top, int buffer_id_bottom);
+
+/**
+ * @brief Returns to single buffer fullscreen
+ */
+void splitScreenUnify(void);
+
+/**
+ * @brief Switches active pane (focus moves between splits)
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenSwitchPane(void);
+
+/**
+ * @brief Updates the active pane's buffer
+ * @param buffer_id New buffer ID for active pane
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenSetPaneBuffer(int buffer_id);
+
+/**
+ * @brief Gets current screen layout
+ * @return Pointer to current ScreenLayout
+ */
+ScreenLayout *splitScreenGetLayout(void);
+
+/**
+ * @brief Gets active pane
+ * @return Pointer to active EditorPane
+ */
+EditorPane *splitScreenGetActivePane(void);
+
+#endif

include/syntax_highlighter.h

@@ -0,0 +1,23 @@
+#ifndef SYNTAX_HIGHLIGHTER_H_
+#define SYNTAX_HIGHLIGHTER_H_
+
+#include "color.h"
+
+// Color codes that only affect foreground, preserving your background color
+#define COLOR_RESET         "\x1b[39m"            // Reset all (4 bytes)
+
+// Token types
+typedef enum {
+  TOKEN_KEYWORD,
+  TOKEN_TYPE,
+  TOKEN_STRING,
+  TOKEN_COMMENT,
+  TOKEN_NUMBER,
+  TOKEN_OPERATOR,
+  TOKEN_DEFAULT
+} TokenType;
+
+char *highlight_line(const char * line, int *length);
+
+#endif
+

install.sh

@@ -16,8 +16,10 @@ fi
 
 echo "Create config files ..."
 mkdir -pv ~/.beluga/
-cp -rv ./assets/ ~/.beluga/
+mkdir -pv ~/.beluga/assets/
+cp -rv ./assets/beluga.txt ~/.beluga/assets/
 mkdir -pv ~/.beluga/packages/
+mkdir -pv ~/.beluga/config/
 
 read -p "Do you want to replace your config file or keep it (init.lisp.bak) / (init.lisp.new) ? (Y/n)" confirm
 if [[ "$confirm" =~ ^[Yy]$ ]]; then

main.c

@@ -5,6 +5,8 @@
  * interactions. \version 0.1 \date 21 septembre 2024
  */
 
+#include "include/buffer.h"
+#include "include/split_screen.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -18,7 +20,7 @@
 #include "include/file_io.h"
 #include "include/init.h"
 #include "include/input.h"
-#include "include/output.h"
+#include "include/editor_op.h"
 #include "include/terminal.h"
 
 struct editorConfig E;
@@ -30,17 +32,18 @@ int main(int argc, char *argv[]) {
   enableRawMode();
   initEditor();
   if (argc >= 2) {
-    E.state = READ_AND_WRITE;
-    editorOpen(argv[1]);
+    EditorPane *active = splitScreenGetActivePane();
+    active->buffer_id = bufferCreate(argv[1]);
   } else {
     strcat(splash_screen, getenv("HOME"));
     strcat(splash_screen, "/.beluga/assets/beluga.txt");
     fprintf(stderr, "%s\n", splash_screen);
-    editorOpen(splash_screen);
+    EditorPane *active = splitScreenGetActivePane();
+    active->buffer_id = bufferCreate(splash_screen);
   }
-  free(splash_screen);
+  //free(splash_screen);
 
-  editorSetStatusMessage("HELP: Ctrl-S = save | Ctrl-Q = quit");
+  editorSetStatusMessage("HELP: Ctrl-x Ctrl-s = save | Ctrl-x Ctrl-c = quit");
 
 
   while (1) {

meson.build

@@ -1,5 +1,5 @@
 project('beluga', 'c',
-  version : '1.1',
+  version : '2.3',
   default_options : [
     'c_std=none',
   ]
@@ -13,6 +13,7 @@ src_files = files(
   'main.c',
   'src/append_buffer.c',
   'src/editor_op.c',
+  'src/syntax_highlighter.c',
   'src/file_io.c',
   'src/init.c',
   'src/input.c',
@@ -20,6 +21,8 @@ src_files = files(
   'src/row_op.c',
   'src/terminal.c',
   'src/builtins.c',
+  'src/buffer.c',
+  'src/split_screen.c'
 )
 
 # Executable

src/buffer.c

@@ -0,0 +1,236 @@
+/**
+ * @file buffer.c
+ * @brief Buffer management implementation for multiple open files
+ */
+
+#include "../include/buffer.h"
+#include "../include/file_io.h"
+#include "../include/editor_op.h"
+#include "../include/data.h"
+#include "include/split_screen.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern struct editorConfig E;
+
+/**
+ * @brief Finds a buffer by filename
+ * @param filename The filename to search for
+ * @return Buffer ID if found, -1 if not found
+ */
+static int bufferFindByFilename(const char *filename) {
+    for (int i = 0; i < E.number_of_buffer; i++) {
+        if (E.buffers[i].filename != NULL && 
+            strcmp(E.buffers[i].filename, filename) == 0) {
+            return E.buffers[i].buffer_id;
+        }
+    }
+    return -1;
+}
+
+/**
+ * @brief Finds a buffer by ID
+ * @param buffer_id The buffer ID to find
+ * @return Pointer to buffer, NULL if not found
+ */
+struct buffer_t *bufferFindById(int buffer_id) {
+    for (int i = 0; i < E.number_of_buffer; i++) {
+        if (E.buffers[i].buffer_id == buffer_id) {
+            return &E.buffers[i];
+        }
+    }
+    return NULL;
+}
+
+/**
+ * @brief Creates a new buffer for a file
+ * @details Allocates buffer slot, loads file content, saves buffer metadata.
+ * If file is already open, switches to existing buffer instead.
+ * @param filename Path to the file
+ * @return Buffer ID on success, -1 on failure
+ */
+int bufferCreate(const char *filename) {
+    // Check if file is already open
+    int existing_id = bufferFindByFilename(filename);
+    if (existing_id != -1) {
+        return bufferSwitch(existing_id);
+    }
+    
+    // Check if we have space for more buffers
+    if (E.number_of_buffer >= 64) {
+        editorSetStatusMessage("Error: maximum buffers reached (64)");
+        return -1;
+    }
+    
+    // Initialize new buffer
+    struct buffer_t *new_buf = &E.buffers[E.number_of_buffer];
+    new_buf->buffer_id = E.number_of_buffer;
+    new_buf->filename = strdup(filename);
+    new_buf->type = FILE_BUFF;
+    new_buf->state = READ_AND_WRITE;
+    new_buf->x = 0;
+    new_buf->y = 0;
+    new_buf->row_offset = 0;
+    new_buf->col_offset = 0;
+    new_buf->dirty = 0;  // New file starts clean
+    
+    // Load file content using existing editorOpen
+    editorOpen(new_buf);
+    
+    E.number_of_buffer++;
+    
+    editorSetStatusMessage("Opened: %s (buffer %d)", filename, new_buf->buffer_id);
+    return new_buf->buffer_id;
+}
+
+/**
+ * @brief Switches to a specific buffer by ID
+ * @details Saves current buffer state, loads target buffer content and state.
+ * @param buffer_id The buffer ID to switch to
+ * @return 0 on success, -1 on failure
+ */
+int bufferSwitch(int buffer_id) {
+    struct buffer_t *target = bufferFindById(buffer_id);
+    if (target == NULL) {
+      E.layout.panes[E.layout.active_pane].buffer_id = buffer_id;
+        editorSetStatusMessage("Error: buffer not found");
+        return -1;
+    }
+        
+    
+    editorSetStatusMessage("Switched to: %s (buffer %d)", 
+                          target->filename, buffer_id);
+    return 0;
+}
+
+/**
+ * @brief Closes a buffer by ID
+ * @details Frees buffer resources and removes from buffer list.
+ * Prompts to save unsaved changes. If closing current buffer,
+ * switches to next available buffer.
+ * @param buffer_id The buffer ID to close
+ * @return 0 on success, -1 on failure
+ */
+int bufferClose(int buffer_id) {
+    struct buffer_t *buf = bufferFindById(buffer_id);
+    if (buf == NULL) {
+        editorSetStatusMessage("Error: buffer not found");
+        return -1;
+    }
+
+    EditorPane * active = splitScreenGetActivePane();
+    
+    // If this is the current buffer, find next buffer to switch to
+    if (active->buffer_id == buffer_id) {
+        int next_id = -1;
+        
+        // Try to switch to next buffer
+        for (int i = 0; i < E.number_of_buffer; i++) {
+            if (E.buffers[i].buffer_id != buffer_id) {
+                next_id = E.buffers[i].buffer_id;
+                break;
+            }
+        }
+        
+        if (next_id != -1) {
+            bufferSwitch(next_id);
+        } else {
+            // No other buffers, clear editor
+            editorCloseFile();
+        }
+    }
+    
+    // Free buffer resources
+    free(buf->filename);
+    buf->filename = NULL;
+    buf->buffer_id = -1;
+    
+    // Remove from buffer list by shifting
+    for (int i = 0; i < E.number_of_buffer; i++) {
+        if (E.buffers[i].buffer_id == buffer_id) {
+            for (int j = i; j < E.number_of_buffer - 1; j++) {
+                E.buffers[j] = E.buffers[j + 1];
+            }
+            E.number_of_buffer--;
+            break;
+        }
+    }
+    
+    editorSetStatusMessage("Closed buffer %d", buffer_id);
+    return 0;
+}
+
+/**
+ * @brief Gets the current active buffer
+ * @return Pointer to current buffer_t, NULL if none
+ */
+struct buffer_t *bufferGetCurrent(void) {
+  EditorPane * active = splitScreenGetActivePane();
+    return bufferFindById(active->buffer_id);
+}
+
+/**
+ * @brief Lists all open buffers
+ * @details Prints buffer information to status message
+ * @return Number of open buffers
+ */
+int bufferListAll(void) {
+    if (E.number_of_buffer == 0) {
+        editorSetStatusMessage("No buffers open");
+        return 0;
+    }
+    
+    char buf[256] = "";
+    int offset = 0;
+    EditorPane * active = splitScreenGetActivePane();
+    
+    for (int i = 0; i < E.number_of_buffer; i++) {
+        struct buffer_t *b = &E.buffers[i];
+        char marker = (b->buffer_id == active->buffer_id) ? '*' : ' ';
+        offset += snprintf(&buf[offset], sizeof(buf) - offset,
+                          "%c%d:%s ", marker, b->buffer_id, 
+                          b->filename ? b->filename : "[No Name]");
+    }
+    
+    editorSetStatusMessage("Buffers: %s", buf);
+    return E.number_of_buffer;
+}
+
+/**
+ * @brief Saves current buffer to disk
+ * @return 0 on success, -1 on failure
+ */
+int bufferSave(void) {
+    EditorPane * active = splitScreenGetActivePane();
+    if (active->buffer_id == -1) {
+        editorSetStatusMessage("Error: no buffer active");
+        return -1;
+    }
+    
+    editorSave();
+    return 0;
+}
+
+/**
+ * @brief Saves all buffers to disk
+ * @details Iterates through all buffers, saves each one
+ * @return 0 on success, -1 on failure
+ */
+int bufferSaveAll(void) {
+    int saved = 0;
+    int failed = 0;
+    
+    for (int i = 0; i < E.number_of_buffer; i++) {
+        if (bufferSwitch(E.buffers[i].buffer_id) == 0) {
+            if (E.dirty && bufferSave() == 0) {
+                saved++;
+            }
+        } else {
+            failed++;
+        }
+    }
+    
+    editorSetStatusMessage("Saved %d buffers (%d failed)", saved, failed);
+    return (failed == 0) ? 0 : -1;
+}

src/builtins.c

@@ -1,3 +1,10 @@
+/**
+ * @file builtins.c
+ * @brief Built-in Lisp functions for editor operations
+ * @details Provides Lisp bindings for core editor functionality including
+ * cursor movement, file operations, keybinding management, and text manipulation
+ */
+
 #include "../include/builtins.h"
 #include "../include/data.h"
 #include "../include/define.h"
@@ -5,12 +12,21 @@
 #include "../include/file_io.h"
 #include "../include/input.h"
 #include "../include/row_op.h"
-#include "include/output.h"
+#include "../include/buffer.h"
+#include "../include/split_screen.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+/**
+ * @brief Finds a prefix configuration by name
+ * @details Searches the prefix array for a prefix matching the given name.
+ * Returns the first prefix (default) if no match is found.
+ * @param prefix_name Name of the prefix to search for (max 64 chars)
+ * @return Matching prefix_t structure, or E.prefix[0] if not found
+ * @note Updates global editor state E
+ */
 struct prefix_t find_prefix(const char prefix_name[64]) {
   int i = E.number_of_prefix + 1;
   while (i--) {
@@ -21,6 +37,19 @@ struct prefix_t find_prefix(const char prefix_name[64]) {
   return E.prefix[0];
 }
 
+/**
+ * @brief Lisp function to bind a command to a key sequence
+ * @details Registers a keybinding with an associated Lisp command and optional
+ * prefix modifier. Dynamically extends the keybind array.
+ * @param args Lisp list of 3 arguments: (key-sequence command prefix-name)
+ *        - key_sequence (string): The key or key combination to bind
+ *        - command (Lisp): The Lisp command/function to execute
+ *        - prefix_name (string): Prefix modifier name
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E (key_binds array)
+ */
 Lisp mapKey(Lisp args, LispError *e, LispContext ctx) {
   /*
    * 3 arguments keybind command prefix
@@ -49,6 +78,17 @@ Lisp mapKey(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to move cursor in a specified direction
+ * @details Moves the editor cursor up, down, left, or right based on direction string.
+ * @param args Lisp list with one argument: direction string
+ *        - "u": up, "d": down, "r": right, "l": left
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return Lisp boolean indicating whether movement was valid
+ * @note Updates global editor state E
+ * @see editorMoveCursor()
+ */
 Lisp moveCursor(Lisp args, LispError *e, LispContext ctx) {
   const char *direction = lisp_string(lisp_car(args));
   int is_in = 0;
@@ -70,20 +110,49 @@ Lisp moveCursor(Lisp args, LispError *e, LispContext ctx) {
   return lisp_make_bool(is_in);
 }
 
+/**
+ * @brief Frees all dynamically allocated editor structures
+ * @details Releases memory for prefix table, keybinds, filename, and all rows.
+ * Called during shutdown to prevent memory leaks.
+ * @note Updates global editor state E
+ */
 void free_structs(void) {
-  int i;
+  int i, j;
   free(E.prefix);
   for (i = 0; i < E.number_of_keybinds; ++i) {
     free(E.key_binds[i].key_sequence);
   }
   free(E.key_binds);
-  free(E.filename);
-  free(E.row->chars);
-  free(E.row->render);
-  free(E.row);
+  // free layout
+  free(E.layout.panes);
+
+  // Free buffers
+  for (i = 0; i < E.number_of_buffer; ++i) {
+    free(E.buffers[i].filename);
+    for (j = 0; j < E.buffers[i].numrows; ++j) {
+      free(E.buffers[i].row[j].render);
+      free(E.buffers[i].row[j].chars);
+    }
+    free(E.buffers[i].row);
+  }
+  
+  free(E.init_file_path);
+  fclose(E.fd_init_file);
   
 }
 
+/**
+ * @brief Lisp function to quit the editor
+ * @details Closes editor with unsaved changes protection. Prompts user to confirm
+ * quit after multiple attempts if file is dirty. Cleans up resources and restores terminal.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null() (never returns on successful exit)
+ * @note Calls exit(0) to terminate program
+ * @note Updates quit_times_buffer counter
+ * @see free_structs()
+ */
 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 "
@@ -101,6 +170,25 @@ Lisp editorQuit(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to save the current file
+ * @details Wrapper around editorSave() for use in Lisp keybindings.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @see editorSave()
+ */
+
+Lisp l_editorSplitScreenVertical(Lisp args, LispError *e, LispContext ctx) {
+  if (E.number_of_buffer >= 2) {
+        splitScreenVertical(E.buffers[0].buffer_id, E.buffers[1].buffer_id);
+    } else {
+        editorSetStatusMessage("Need at least 2 buffers open");
+    }
+  return lisp_null();
+}
+
 Lisp l_editorSave(Lisp args, LispError *e, LispContext ctx) {
 
   editorSave();
@@ -108,41 +196,99 @@ Lisp l_editorSave(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to insert a new line at cursor
+ * @details Wrapper around editorInsertNewLine() for use in Lisp keybindings.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @see editorInsertNewLine()
+ */
 Lisp l_editorInsertNewLine(Lisp args, LispError *e, LispContext ctx) {
 
-  editorInsertNewLine();
+  bufferInsertNewLine();
 
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to insert a tab (spaces) at cursor
+ * @details Inserts TAB_LENGTH spaces at the current cursor position.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Uses E.constantes.TAB_LENGTH for indentation width
+ */
 Lisp l_editorInserTab(Lisp args, LispError *e, LispContext ctx) {
 
   for (int i = 0; i<E.constantes.TAB_LENGTH; ++i) {
-    editorInsertChar(' ');
+    bufferInsertChar(' ');
   }
 
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to move cursor to beginning of line
+ * @details Moves cursor to column 0 of the current line.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E
+ */
 Lisp moveCursorBeginLine(Lisp args, LispError *e, LispContext ctx) {
-  E.cursor_x = 0;
+  E.layout.panes[E.layout.active_pane].cursor_x = 0;
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to move cursor to end of line
+ * @details Moves cursor to the end of the current line content.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E
+ */
 Lisp moveCursorEndLine(Lisp args, LispError *e, LispContext ctx) {
-  if (E.cursor_y < E.numrows) {
-    E.cursor_x = E.row[E.cursor_y].size;
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
+  if (active->cursor_y < buf->numrows) {
+    active->cursor_x = buf->row[active->cursor_y].size;
   }
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to delete character before cursor
+ * @details Wrapper around editorDelChar() for use in Lisp keybindings.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @see editorDelChar()
+ */
 Lisp deletePreviousChar(Lisp args, LispError *e, LispContext ctx) {
-  editorDelChar();
+  bufferDelChar();
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to move cursor up by one screen
+ * @details Scrolls up one full screen height, moving cursor to top of visible area.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E
+ * @see editorMoveCursor()
+ */
 Lisp editorMoveCursorPageUp(Lisp args, LispError *e, LispContext ctx) {
-  E.cursor_y = E.row_offset;
+  EditorPane *active = splitScreenGetActivePane();
+  active->cursor_y = active->row_offset;
   int times = E.screenrows;
   while (--times) {
     editorMoveCursor(ARROW_UP);
@@ -150,10 +296,22 @@ Lisp editorMoveCursorPageUp(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to move cursor down by one screen
+ * @details Scrolls down one full screen height, moving cursor to bottom of visible area.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E
+ * @see editorMoveCursor()
+ */
 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;
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buffer = bufferFindById(active->buffer_id);
+  active->cursor_y = active->row_offset + E.screenrows - 1;
+  if (active->cursor_y > buffer->numrows) {
+    active->cursor_y = buffer->numrows;
   }
   int times = E.screenrows;
   while (--times) {
@@ -163,10 +321,23 @@ Lisp editorMoveCursorPageDown(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to open a file
+ * @details Prompts user for filename and opens the file for editing.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E
+ * @see editorOpen()
+ * @see editorPrompt()
+ */
 Lisp editorOpenFile(Lisp args, LispError *e, LispContext ctx) {
   char *filename = editorPrompt("Open : %s", getenv("PWD"), 1);
   if (filename){
-    editorOpen(filename);
+    //    editorOpen(filename);
+    EditorPane *active = splitScreenGetActivePane();
+    active->buffer_id = bufferCreate(filename);
   }
   free(filename);
   
@@ -174,12 +345,32 @@ Lisp editorOpenFile(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to insert a character
+ * @details Extracts a character from Lisp string argument and inserts it at cursor.
+ * @param args Lisp list with one string argument
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Uses first character of the string argument
+ */
 Lisp editorPrintC(Lisp args, LispError *e, LispContext ctx) {
   char c = lisp_string(lisp_car(args))[0];
-  editorInsertChar(c);
+  bufferInsertChar(c);
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to load and execute a package
+ * @details Loads a Lisp package from the user's packages directory
+ * (~/.beluga/packages/<package_name>/init.lisp) and evaluates it.
+ * @param args Lisp list with one argument: package name (string)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Package files must be valid Lisp code
+ * @note Package directory defaults to ~/.beluga/packages/
+ */
 Lisp addPackage(Lisp args, LispError *e, LispContext ctx) {
   const char *package_name = lisp_string(lisp_car(args));
   fprintf(stderr, "%s\n", package_name);
@@ -199,27 +390,96 @@ Lisp addPackage(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to delete the current row
+ * @details Removes the line at the current cursor position.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E
+ * @see editorDelRow()
+ */
 Lisp editorDelRow_L(Lisp args, LispError *e, LispContext ctx) {
-  editorDelRow(E.cursor_y);
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buffer = bufferFindById(active->buffer_id);
+  bufferDelRow(buffer, active->cursor_y);
   return lisp_null();
 }
 
-Lisp editorFind_L(Lisp args, LispError *e, LispContext ctx) {
-  editorFind();
+Lisp editorSwitchNextBuffer(Lisp args, LispError *e, LispContext ctx) {
+  fprintf(stderr, "switch buffer\n");
+  if (E.number_of_buffer > 0) {
+    EditorPane *active = splitScreenGetActivePane();
+    int next_idx = (active->buffer_id + 1) % E.number_of_buffer;
+    active->buffer_id = next_idx;
+    }
+
   return lisp_null();
 }
 
+Lisp editorSwitchNextPane(Lisp args, LispError *e, LispContext ctx) {
+  splitScreenSwitchPane();
+  return lisp_null();
+}
+
+Lisp editorUnifiedPanes(Lisp args, LispError *e, LispContext ctx) {
+  if (E.layout.num_panes - 1) {
+    splitScreenUnify();
+  }
+  return lisp_null();
+}
+
+/**
+ * @brief Lisp function to search for text
+ * @details Wrapper around editorFind() for use in Lisp keybindings.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @see editorFind()
+ */
+Lisp bufferFind_L(Lisp args, LispError *e, LispContext ctx) {
+  fprintf(stderr, "LispFind\n");
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buffer = bufferFindById(active->buffer_id);
+  bufferFind(buffer);
+  return lisp_null();
+}
+
+/**
+ * @brief Lisp function to read character at cursor
+ * @details Returns the character at the current cursor position as a Lisp character.
+ * Returns 'a' if at end of line.
+ * @param args Lisp arguments (unused)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return Lisp character object representing the character at cursor
+ */
 Lisp editorReadChar_L(Lisp args, LispError *e, LispContext ctx) {
   Lisp returned_char;
-  if (E.row[E.cursor_y].render[E.cursor_x] == 0) {
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buffer = bufferFindById(active->buffer_id);
+  if (buffer->row[active->cursor_y].render[active->cursor_x] == 0) {
     returned_char = lisp_make_char('a');
   } else {
     
-     returned_char = lisp_make_char(E.row[E.cursor_y].render[E.cursor_x]); 
+     returned_char = lisp_make_char(buffer->row[active->cursor_y].render[active->cursor_x]); 
   }
   return returned_char;
 }
 
+/**
+ * @brief Lisp function to set the current prefix mode
+ * @details Changes the editor's prefix state to a named prefix, affecting which
+ * keybindings are active. Updates status message to show active prefix.
+ * @param args Lisp list with one argument: prefix name (string)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E (prefix_state)
+ * @see find_prefix()
+ */
 Lisp editorSetPrefix(Lisp args, LispError *e, LispContext ctx) {
   /*
    * Set the prefix state of editor to the prefix in argument
@@ -233,6 +493,16 @@ Lisp editorSetPrefix(Lisp args, LispError *e, LispContext ctx) {
   return lisp_null();
 }
 
+/**
+ * @brief Lisp function to define a new prefix modifier
+ * @details Registers a named prefix modifier that can be used with keybindings
+ * to create context-aware command sequences (e.g., Ctrl-X as a prefix).
+ * @param args Lisp list with one argument: prefix name (string, max 64 chars)
+ * @param e Error pointer for Lisp error handling
+ * @param ctx Lisp context
+ * @return lisp_null()
+ * @note Updates global editor state E (prefix array)
+ */
 Lisp editorPrefix(Lisp args, LispError *e, LispContext ctx) {
   E.prefix = (struct prefix_t *)realloc(E.prefix, (++(E.number_of_prefix) + 1) *
                                                       sizeof(struct prefix_t));

src/editor_op.c

@@ -1,52 +1,82 @@
+#include <stdarg.h>
+
 #include "../include/editor_op.h"
 #include "../include/row_op.h"
+#include "include/buffer.h"
+#include "include/data.h"
+#include "include/split_screen.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++;
+
+/**
+ * @brief Sets a temporary status message for display
+ * @details Formats and stores a message that will be displayed in the message
+ * bar for 5 seconds. Uses printf-style variable argument formatting.
+ * @param fmt Printf-style format string
+ * @param ... Variable arguments for format string
+ * @note Updates global editor state E (status_msg, status_msg_time)
+ * @see editorDrawMessageBar()
+ */
+void editorSetStatusMessage(const char *fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  vsnprintf(E.status_msg, sizeof(E.status_msg), fmt, ap);
+  va_end(ap);
+  E.status_msg_time = time(NULL);
 }
 
-void editorInsertNewLine() {
+
+void bufferInsertChar(int c) {
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
+    if (active->cursor_y == buf->numrows) {
+      bufferInsertRow(buf, buf->numrows, "", 0);
+    }
+    bufferRowInsertChar(buf, &buf->row[active->cursor_y], active->cursor_x, c);
+    active->cursor_x++;
+}
+
+void bufferInsertNewLine() {
   /*
    * Add new line and place the cursor at the beginning of it
    */
   fprintf(stderr, "Inserting new line\n");
-  erow *row;
-  if (!E.cursor_x) {
-    editorInsertRow(E.cursor_y, "", 0);
+    EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
+  frow *row;
+  if (!active->cursor_x) {
+    bufferInsertRow(buf, active->cursor_y, "", 0);
   } else {
-    row = &E.row[E.cursor_y];
-    editorInsertRow(E.cursor_y + 1, &row->chars[E.cursor_x],
-                    row->size - E.cursor_x);
-    row = &E.row[E.cursor_y];
-    row->size = E.cursor_x;
+    row = &buf->row[active->cursor_y];
+    bufferInsertRow(buf, active->cursor_y + 1, &row->chars[active->cursor_x],
+                    row->size - active->cursor_x);
+    row = &buf->row[active->cursor_y];
+    row->size = active->cursor_x;
     row->chars[row->size] = '\0';
-    editorUpdateRow(row);
+    bufferUpdatfrow(row);
   }
-  ++E.cursor_y;
-  E.cursor_x = 0;
+  ++active->cursor_y;
+  active->cursor_x = 0;
   fprintf(stderr, "Insert new line done\n");
 }
 
-void editorDelChar() {
-  erow *row;
-  if (E.cursor_y == E.numrows || !(E.cursor_x || E.cursor_y)) {
+void bufferDelChar() {
+  frow *row;
+    EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
+  if (active->cursor_y == buf->numrows || !(active->cursor_x || active->cursor_y)) {
     return;
   }
-  row = &E.row[E.cursor_y];
-  if (E.cursor_x > 0) {
-    editorRowDelchar(row, E.cursor_x - 1);
-    --E.cursor_x;
+  row = &buf->row[active->cursor_y];
+  if (active->cursor_x > 0) {
+    bufferRowDelchar(buf, row, active->cursor_x - 1);
+    --active->cursor_x;
   } else {
-    E.cursor_x = E.row[E.cursor_y - 1].size;
-    editorRowAppendString(&E.row[E.cursor_y - 1], row->chars, row->size);
-    editorDelRow(E.cursor_y);
-    --E.cursor_y;
+    active->cursor_x = buf->row[active->cursor_y - 1].size;
+    bufferRowAppendString(buf, &buf->row[active->cursor_y - 1], row->chars, row->size);
+    bufferDelRow(buf, active->cursor_y);
+    --active->cursor_y;
   }
 }

src/file_io.c

@@ -1,6 +1,17 @@
+/**
+ * @file file_io.c
+ * @brief File I/O operations module for the Beluga text editor
+ * @details Handles file loading, saving, searching, and buffer management.
+ * Provides functionality for opening/closing files, persisting changes to disk,
+ * and searching for text patterns within the document.
+ */
+
 #include "../include/file_io.h"
+#include "../include/editor_op.h"
 #include "../include/input.h"
-#include "../include/output.h"
+#include "include/buffer.h"
+#include "include/data.h"
+#include "include/split_screen.h"
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,55 +25,80 @@ extern ssize_t getline(char **restrict lineptr, size_t *restrict n,
 extern int ftruncate(int fd, off_t length);
 extern struct editorConfig E;
 
-char *editorRowsToString(int *buffer_len) {
+/**
+ * @brief Converts all editor rows to a single string buffer
+ * @details Concatenates all row content into a single allocated buffer with
+ * newlines between rows. Useful for file saving and buffer operations.
+ * @param buffer_len Pointer to integer where total buffer length will be stored
+ * @return Pointer to dynamically allocated buffer containing all row data.
+ *         Rows are separated by newline characters.
+ * @note Caller is responsible for freeing the returned buffer
+ */
+char *bufferRowsToString(struct buffer_t *buf, int *buffer_len) {
   int tot_len = 0;
   int j;
-    char *buf;
+  char *buffer;
   char *p;
 
-    for (j = 0; j < E.numrows; ++j) {
-        tot_len += E.row[j].size + 1;
+  for (j = 0; j < buf->numrows; ++j) {
+    tot_len += buf->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;
+  buffer = malloc(tot_len);
+  p = buffer;
+  for (j = 0; j < buf->numrows; ++j) {
+    memcpy(p, buf->row[j].chars, buf->row[j].size);
+    p += buf->row[j].size;
     *p = '\n';
     p++;
   }
 
-    return buf;
+  return buffer;
 }
 
+/**
+ * @brief Closes the current file and resets editor state
+ * @details Clears all rows, resets cursor position, scroll offsets, and file
+ * metadata. Does not prompt to save unsaved changes.
+ * @note Updates global editor state E
+ */
 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;
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
+  active->cursor_x = 0;
+  active->cursor_y = 0;
+  active->rx = 0;
+  active->row_offset = 0;
+  active->col_offset = 0;
+  for (int i = 0; i < buf->numrows; ++i) {
+    free(buf->row[i].chars);
+    free(buf->row[i].render);
+  }
+  buf->numrows = 0;
+  free(buf->row);
+  buf->row = NULL;
+  buf->dirty = 0;
+  free(buf->filename);
+  buf->filename = NULL;
   E.status_msg[0] = '\0';
   E.status_msg_time = 0;
 }
 
-void editorOpen(char *filename) {
+/**
+ * @brief Opens a file for editing
+ * @details Loads file content into editor rows, one line per row. If another
+ * file is already open, it is closed first (without saving). File is opened in
+ * a+ (read/append) mode to allow both reading and modification.
+ * @param filename Path to the file to open (relative or absolute)
+ * @note Updates global editor state E
+ * @note Calls die() on file open failure
+ * @note Newline characters are stripped from loaded lines
+ * @see editorInsertRow()
+ */
+void editorOpen(struct buffer_t* buffer) {
   FILE *fp;
 
-    // Test if a file is already open
-    if (E.filename != NULL) {
-        editorCloseFile();
-        E.state = READ_AND_WRITE;
-    }
-
-    free(E.filename);
-    E.filename = strdup(filename);
-
-    fp = fopen(filename, "a+");
+  fp = fopen(buffer->filename, "a+");
   if (!fp)
     die("fopen");
 
@@ -75,26 +111,40 @@ void editorOpen(char *filename) {
            (line[line_len - 1] == '\n' || line[line_len - 1] == '\r')) {
       --line_len;
     }
-        editorInsertRow(E.numrows, line, line_len);
+    bufferInsertRow(buffer, buffer->numrows, line, line_len);
+    free(line);
+    line = NULL;
   }
   free(line);
   fclose(fp);
   E.dirty = 0;
 }
 
+/**
+ * @brief Saves the current file to disk
+ * @details Prompts for filename if not set, converts all rows to a buffer,
+ * writes to disk using open/ftruncate/write, and updates dirty flag.
+ * Displays status messages on success or failure.
+ * @note Updates global editor state E (dirty flag)
+ * @note If no filename is set, prompts user via editorPrompt()
+ * @note Uses O_RDWR | O_CREAT with mode 0644
+ * @see editorRowsToString()
+ */
 void editorSave() {
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buffer = bufferFindById(active->buffer_id);
   int len;
   char *buf;
   int fd;
-    if (E.filename == NULL) {
-        E.filename = editorPrompt("Save as: %s (ESC to cancel)", "", 1);
-        if (E.filename == NULL) {
+  if (buffer->filename == NULL) {
+    buffer->filename = editorPrompt("Save as: %s (ESC to cancel)", "", 1);
+    if (buffer->filename == NULL) {
       editorSetStatusMessage("Save aborted");
       return;
     }
   }
-    buf = editorRowsToString(&len);
-    fd = open(E.filename, O_RDWR | O_CREAT, 0644);
+  buf = bufferRowsToString(buffer, &len);
+  fd = open(buffer->filename, O_RDWR | O_CREAT, 0644);
   if (fd != -1) {
     if (ftruncate(fd, len) != -1) {
       if (write(fd, buf, len) == len) {
@@ -111,20 +161,33 @@ void editorSave() {
   editorSetStatusMessage("Can't save! I/O error: %s", strerror(errno));
 }
 
-void editorFind() {
+/**
+ * @brief Searches for a string in the document
+ * @details Prompts user for a search query, then searches forward from current
+ * cursor position. Updates cursor position to the first match found.
+ * @note Updates global editor state E (cursor position, row_offset)
+ * @note Search is case-sensitive and operates on rendered line content
+ * @note Searches begin from the line after current cursor position
+ * @see editorPrompt()
+ * @see editorRowRxToCx()
+ */
+void bufferFind(struct buffer_t *buf) {
+  fprintf(stderr, "searching\n");
   char *query = editorPrompt("Search: %s (ESC to cancel)", "", 0);
-  if (query == NULL) return;
+  EditorPane *active = splitScreenGetActivePane();
+
+  if (query == NULL)
+    return;
   int i;
-  for (i = E.cursor_y + 1; i < E.numrows; i++) {
-    erow *row = &E.row[i];
+  for (i = active->cursor_y + 1; i < buf->numrows; i++) {
+    frow *row = &buf->row[i];
     char *match = strstr(row->render, query);
     if (match) {
-      E.cursor_y = i;
-      E.cursor_x = editorRowRxToCx(row, match - row->render);
-      E.row_offset = E.numrows;
+      active->cursor_y = i;
+      active->cursor_x = bufferRowRxToCx(row, match - row->render);
+      buf->row_offset = buf->numrows;
       break;
     }
   }
   free(query);
 }
-

src/init.c

@@ -1,15 +1,18 @@
 #include "../include/init.h"
 #include "../include/builtins.h"
+#include "../include/color.h"
 #include "../include/data.h"
 #include "../include/terminal.h"
+#include "include/split_screen.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #define LISP_IMPLEMENTATION
 #include "../include/lisp.h"
 #include "../include/lisp_lib.h"
 
-extern struct editorConfig;
+struct editorConfig;
 
 void registerBuiltin(char *key_sequence, LispCFunc f) {
   lisp_env_define(E.ctx.p->env, lisp_make_symbol(key_sequence, E.ctx),
@@ -17,7 +20,7 @@ void registerBuiltin(char *key_sequence, LispCFunc f) {
 }
 
 void initBuiltins() {
-  // move cursor
+  // Registering C functions as lisp macro
   registerBuiltin("move-cursor", moveCursor);
   registerBuiltin("map-key", mapKey);
   registerBuiltin("editor-quit", editorQuit);
@@ -32,45 +35,19 @@ void initBuiltins() {
   registerBuiltin("editor-insert-char", editorPrintC);
   registerBuiltin("add-package", addPackage);
   registerBuiltin("editor-del-row", editorDelRow_L);
-  registerBuiltin("editor-find", editorFind_L);
+  registerBuiltin("buffer-find", bufferFind_L);
   registerBuiltin("editor-read-char", editorReadChar_L);
   registerBuiltin("add-prefix", editorPrefix);
   registerBuiltin("editor-set-prefix", editorSetPrefix);
   registerBuiltin("editor-insert-tab", l_editorInserTab);
+  registerBuiltin("editor-switch-next-buffer", editorSwitchNextBuffer);
+  registerBuiltin("editor-split-screen-vertical", l_editorSplitScreenVertical);
+  registerBuiltin("editor-switch-next-pane", editorSwitchNextPane);
+  registerBuiltin("editor-unify-panes", editorUnifiedPanes);
 }
 
-void initEditor() {
-  char *init_file_path = (char *)calloc(256, sizeof(char));
-  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.state = READ_ONLY;
-  E.status_msg[0] = '\0';
-  E.status_msg_time = 0;
-  if (getWindowSize(&E.screenrows, &E.screencols) == -1) {
-    die("getWindowSize");
-  }
-  E.screenrows -= 2;
+void initConfig() {
 
-  E.number_of_keybinds = 0;
-  E.number_of_prefix = 0;
-  // General prefix is 0 (no prefix)
-  E.prefix = (struct prefix_t *)malloc(sizeof(struct prefix_t));
-  E.prefix[0].prefix_id = 0;
-  strncpy(E.prefix[0].prefix_name, "no-prefix", 64);
-  
-  E.prefix_state = 0;
-
-  strcat(init_file_path, getenv("HOME"));
-  strcat(init_file_path, "/.beluga/config/init.lisp");
-  printf("%s\n", init_file_path);
-  E.fd_init_file = fopen(init_file_path, "r");
   E.ctx = lisp_init();
   E.env = lisp_env(E.ctx);
   lisp_lib_load(E.ctx);
@@ -79,11 +56,71 @@ void initEditor() {
 
   // Read config file
   E.ctx_data = lisp_read_file(E.fd_init_file, &E.ctx_error, E.ctx);
-  free(init_file_path);
   if (E.ctx_error != LISP_ERROR_NONE) {
     die("init failed");
   }
   lisp_eval(E.ctx_data, &E.ctx_error, E.ctx);
+}
+
+void init_theme() {
+  E.constantes.THEME = (char *)lisp_string(
+      lisp_eval(lisp_read("THEME", &E.ctx_error, E.ctx), &E.ctx_error, E.ctx));
+  if (strcmp(E.constantes.THEME, "dark") == 0) {
+    E.theme.BACKGROUND_COLOR = ANSI_BG_RGB(40, 44, 52);
+    E.theme.COLOR_KEYWORD = ANSI_FG_RGB(198, 120, 221);
+    E.theme.COLOR_TYPE = ANSI_FG_RGB(97, 175, 239);
+    E.theme.COLOR_STRING = ANSI_FG_RGB(152, 195, 121);
+    E.theme.COLOR_COMMENT = ANSI_FG_RGB(92, 99, 112);
+    E.theme.COLOR_NUMBER = ANSI_FG_RGB(209, 154, 102);
+    E.theme.COLOR_DEFAULT = ANSI_FG_RGB(171, 178, 191);
+  } else {
+    E.theme.BACKGROUND_COLOR = ANSI_BG_RGB(250, 251, 252);
+    E.theme.COLOR_KEYWORD = ANSI_FG_RGB(166, 38, 164);
+    E.theme.COLOR_TYPE = ANSI_FG_RGB(4, 90, 180);
+    E.theme.COLOR_STRING = ANSI_FG_RGB(80, 161, 79);
+    E.theme.COLOR_COMMENT = ANSI_FG_RGB(152, 152, 152);
+    E.theme.COLOR_NUMBER = ANSI_FG_RGB(206, 102, 54);
+    E.theme.COLOR_DEFAULT = ANSI_FG_RGB(86, 89, 90);
+  }
+}
+
+void initEditor() {
+
+  if (getWindowSize(&E.screenrows, &E.screencols) == -1) {
+    die("getWindowSize");
+  }
+  E.screenrows -= 2;
+
+  
+  // Init graphics variables
+  splitScreenInit();
+  EditorPane *active = splitScreenGetActivePane();
+  active->cursor_x = 0;
+  active->cursor_y = 0;
+  active->rx = 0;
+  active->row_offset = 0;
+  active->col_offset = 0;
+  E.init_file_path = (char *)calloc(256, sizeof(char));
+  strcat(E.init_file_path, getenv("HOME"));
+  strcat(E.init_file_path, "/.beluga/config/init.lisp");
+  E.fd_init_file = fopen(E.init_file_path, "r");
+
+  // Status bar
+  E.status_msg[0] = '\0';
+  E.status_msg_time = 0;
+
+  // Key binds
+  E.number_of_keybinds = 0;
+  E.number_of_prefix = 0;
+  // General prefix is 0 (no prefix)
+  E.prefix = (struct prefix_t *)malloc(sizeof(struct prefix_t));
+  E.prefix[0].prefix_id = 0;
+  strncpy(E.prefix[0].prefix_name, "no-prefix", 64);
+  E.prefix_state = 0;
+
+  initConfig();
+
+  init_theme();
 
   // To modify
 

src/input.c

@@ -2,6 +2,9 @@
 #include "../include/define.h"
 #include "../include/editor_op.h"
 #include "../include/output.h"
+#include "include/buffer.h"
+#include "include/data.h"
+#include "include/split_screen.h"
 #include <ctype.h>
 #include <dirent.h>
 #include <stdint.h>
@@ -9,48 +12,72 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <unistd.h>
 
 extern struct editorConfig E;
 
-char *file_completion(const char *path) {
+/**
+ * @file input.c
+ * @brief Input handling module for the Beluga text editor
+ * @details Manages user input processing, key bindings, cursor movement, and file path completion
+ */
+
+/**
+ * @brief Returns the first file completion match for the given path
+ * @details Searches the directory containing the given path prefix and returns
+ * the first file or directory entry that matches the filename prefix.
+ * Appends a trailing slash for directory entries.
+ * @param path The file path to complete (can be relative or absolute)
+ * @return Pointer to the completed file path (dynamically allocated), or NULL if:
+ *         - path ends with '/' (already a directory)
+ *         - no matching entries found
+ *         - directory cannot be opened
+ * @note Caller is responsible for freeing the returned string
+ * @note Uses static buffer internally; may return stale pointers across calls
+ */
+const char *file_completion(const char *path) {
   DIR *dir;
   struct dirent *entry;
   char directory[128];
   char predict[128];
+  const char *last_slash;
   int predict_len = 0;
+  size_t dir_len;
 
+  // path is a directory
   if (path[strlen(path) - 1] == '/') {
-    return path;
+    fprintf(stderr, "[FILE COMP] is dir\n");
+    strncpy(directory, path, 128);
   }
 
   // Find dir name
-  char *last_slash = strrchr(path, '/');
+  last_slash = strrchr(path, '/');
   if (last_slash) {
-    size_t dir_len = last_slash - path + 1; // length of dir_path
+    dir_len = last_slash - path + 1; // length of dir_path
     strncpy(directory, path, dir_len);
-    predict_len = strlen(path) - dir_len - 1;
+    predict_len = strlen(path) - dir_len;
     strncpy(predict, last_slash + 1, predict_len);
     directory[dir_len] = '\0';
     predict[predict_len] = '\0';
     fprintf(stderr, "%s %s\n", directory, predict);
   } else {
-    return NULL;
+    fprintf(stderr, "[FILE COMP] dir not found\n");
+    return strdup(path);
   }
 
   dir = opendir(directory);
   if (!dir)
-    return NULL;
+    return strdup(path);
 
   while ((entry = readdir(dir)) != NULL) {
     if (strncmp(entry->d_name, predict, predict_len) == 0) {
-      static char full_path[128];
+      static char full_path[512];
       snprintf(full_path, sizeof(full_path), "%s%s", directory, entry->d_name);
 
       struct stat st;
       if (stat(full_path, &st) == 0 && S_ISDIR(st.st_mode)) {
         strcat(full_path, "/"); // add slash for directories
       }
+      closedir(dir);
       
       return strdup(full_path);
     }
@@ -59,13 +86,25 @@ char *file_completion(const char *path) {
   // Cleanup when no more entries
   closedir(dir);
   dir = NULL;
-  return NULL;
+  free(entry);
+  fprintf(stderr, "[FILE COMP] no entries\n");
+  return strdup(path);
 }
 
 /**
- * \fn char * editorPrompt(struct editorConfig *E, char *prompt, char bPathMode)
- * \brief Return user input in a prompt when enter is hit. */
-
+ * @brief Displays an interactive prompt and returns user input
+ * @details Allows the user to enter text in a prompt with optional path completion
+ * via Tab key. Supports backspace, delete, and escape key handling. Dynamically
+ * allocates memory for the input buffer.
+ * @param prompt The prompt message format string (printf-style)
+ * @param placeHolder Initial text to display in the input buffer
+ * @param bPathMode If non-zero, enables Tab key file path completion
+ * @return Pointer to the user-entered text (dynamically allocated), or NULL if:
+ *         - User pressed ESC to cancel
+ *         - Input buffer is empty when Enter is pressed
+ * @note Caller is responsible for freeing the returned string
+ * @note Uses editorReadKey() for input and editorRefreshScreen() for display
+ */
 char *editorPrompt(char *prompt, char *placeHolder, char bPathMode) {
   size_t buf_size = 128;
   char *buf = malloc(buf_size);
@@ -106,7 +145,9 @@ char *editorPrompt(char *prompt, char *placeHolder, char bPathMode) {
       }
       memset(buf, 0, 128);
       buf_len = 0;
-      strcpy(buf, file_completion(path));
+      char * buf_complete = (char *) file_completion(path);
+      strcpy(buf, buf_complete);
+      free(buf_complete);
       buf_len = strlen(buf);
       buf[buf_len] = '\0';
 
@@ -121,6 +162,17 @@ char *editorPrompt(char *prompt, char *placeHolder, char bPathMode) {
   }
 }
 
+/**
+ * @brief Converts a key code to its string representation
+ * @details Translates raw key codes (including special keys, control keys,
+ * and regular characters) into human-readable string formats suitable for
+ * display and keybinding configuration.
+ * @param key The key code to convert
+ * @return Pointer to static buffer containing the string representation.
+ *         Examples: "ENTER", "ARROW-UP", "CTRL-a", "TAB", "DELETE", etc.
+ * @note Returns pointer to static buffer; string is overwritten on next call
+ * @note Non-printable characters are formatted as "KEY-<number>"
+ */
 char *key_to_string(int key) {
   static char key_str[32];
 
@@ -187,47 +239,66 @@ char *key_to_string(int key) {
   return key_str;
 }
 
+/**
+ * @brief Moves the cursor based on arrow key input
+ * @details Updates cursor position (E.cursor_x, E.cursor_y) based on the given
+ * key direction. Handles line wrapping and boundary conditions. Prevents cursor
+ * from exceeding line lengths.
+ * @param key The arrow key code (ARROW_UP, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT)
+ * @return 1 if cursor movement was valid, 0 if cursor was constrained to line boundary
+ * @note Updates global editor state E
+ */
 int editorMoveCursor(int key) {
-  erow *row = (E.cursor_y >= E.numrows) ? NULL : &E.row[E.cursor_y];
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
+  frow *row = (active->cursor_y + active->row_offset >= buf->numrows) ? NULL : &buf->row[active->cursor_y + active->row_offset];
   int row_len;
+  int x = active->cursor_x + active->col_offset;
+  int y = active->cursor_y + active->row_offset;
   switch (key) {
   case ARROW_RIGHT:
-    if (row && E.cursor_x < row->size) {
-      ++E.cursor_x;
-    } else if (row && E.cursor_x == row->size) {
-      E.cursor_y++;
-      E.cursor_x = 0;
+    if (row && x < row->size) {
+        active->cursor_x++;
+
+    } else if (row && y == row->size) {
+      active->cursor_y++;
+      active->cursor_x = 0;
     }
     break;
   case ARROW_DOWN:
-    if (E.cursor_y < E.numrows) {
-      ++E.cursor_y;
+    if (y < buf->numrows) {
+
+      active->cursor_y++;
     }
     break;
   case ARROW_UP:
-    if (E.cursor_y != 0) {
-      --E.cursor_y;
+    if (y != 0) {
+      --active->cursor_y;
     }
     break;
   case ARROW_LEFT:
-    if (E.cursor_x != 0) {
-      --E.cursor_x;
-    } else if (E.cursor_y > 0) {
-      --E.cursor_y;
-      E.cursor_x = E.row[E.cursor_y].size;
+    if (x != 0) {
+      --active->cursor_x;
+    } else if (y > 0) {
+      --active->cursor_y;
+      active->cursor_x = buf->row[y].size;
     }
     break;
   }
     
-  row = (E.cursor_y >= E.numrows) ? NULL : &E.row[E.cursor_y];
-  row_len = row ? row->size : 0;
-  if (E.cursor_x > row_len) {
-    E.cursor_x = row_len;
-    return 0;
-  }
+    
   return 1;
 }
 
+/**
+ * @brief Executes the command bound to a key sequence
+ * @details Searches the keybinding table for a matching key sequence and
+ * prefix state, then evaluates the associated Lisp command.
+ * @param key_sequence The string representation of the key sequence
+ * @return 1 if a matching keybinding was found and executed, 0 otherwise
+ * @note Updates global editor state E (prefix_state)
+ * @note Uses Lisp interpreter to evaluate bound commands
+ */
 int executeKeyBind(char *key_sequence) {
   int i;
   int previous_state = 0;
@@ -235,7 +306,7 @@ int executeKeyBind(char *key_sequence) {
   for (i = 0; i < E.number_of_keybinds; ++i) {
     if (!strcmp(key_sequence, E.key_binds[i].key_sequence)) {
       if (E.prefix_state != E.key_binds[i].prefix_id) {
-        return 0;
+        continue;
       }
       previous_state = E.prefix_state;
       // It's a symbol, create a function call
@@ -249,12 +320,20 @@ int executeKeyBind(char *key_sequence) {
   return 0;
 }
 
+/**
+ * @brief Processes a single keypress from the user
+ * @details Reads a key, checks if it matches any registered keybinding,
+ * and either executes the bound command or inserts the character. Resets
+ * the quit buffer counter on successful key processing.
+ * @note Updates global editor state E
+ * @note Calls editorReadKey() to get input and editorInsertChar() for unbound keys
+ */
 void editorProcessKeypress() {
   int c = editorReadKey();
 
   if (executeKeyBind(key_to_string(c))) {
     return;
   }
-  editorInsertChar(c);
+  bufferInsertChar(c);
   E.quit_times_buffer = E.constantes.QUIT_TIMES;
 }

src/output.c

@@ -1,86 +1,233 @@
+/**
+ * @file output.c
+ * @brief Screen rendering and output module for the Beluga text editor
+ * @details Handles all screen updates, cursor positioning, status bar
+ * rendering, and display synchronization using ANSI escape sequences
+ */
+
 #include "../include/output.h"
-#include <stdarg.h>
+#include "../include/append_buffer.h"
+#include "../include/buffer.h"
+#include "../include/data.h"
+#include "../include/define.h"
+#include "../include/row_op.h"
+#include "../include/split_screen.h"
+#include "../include/syntax_highlighter.h"
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 extern struct editorConfig E;
 
-void editorDrawRows(struct abuf *ab) {
-  int y;
+/**
+ * @brief Renders a single pane with its buffer content
+ */
+static void editorDrawPane(struct abuf *ab, EditorPane *pane) {
+  if (pane == NULL || pane->buffer_id < 0)
+    return;
+
+  struct buffer_t *buf = bufferFindById(pane->buffer_id);
+  if (buf == NULL)
+    return;
+
+  // Draw content for this pane
+  for (int y = 0; y < pane->height; y++) {
+    int file_row = y + pane->row_offset;
+
+    // Position cursor at start of pane row
+    char pos_buf[32];
+    int pos_len = snprintf(pos_buf, sizeof(pos_buf), "\x1b[%d;%dH",
+                           pane->start_row + y + 1, pane->start_col + 1);
+    abAppend(ab, pos_buf, pos_len);
+
+    // Apply background color (6 bytes for RGB format)
+    abAppend(ab, E.theme.BACKGROUND_COLOR, strlen(E.theme.BACKGROUND_COLOR));
+
+    int chars_printed = 0;
+
+    if (file_row >= buf->numrows) {
+      // Empty line - show tilde
+      if (buf->numrows == 0 && y == pane->height / 3) {
         char welcome[80];
-  int welcome_len;
-  int padding;
-  int len;
-  int file_row;
-  for (y = 0; y < E.screenrows; ++y) {
-    file_row = y + E.row_offset;
-    if (file_row >= E.numrows) {
-      if (E.numrows == 0 && y == E.screenrows / 3) {
-        welcome_len =
-            snprintf(welcome, sizeof(welcome),
-                     "Beluga text editor -- version %s", BELUGA_VERSION);
-        if (welcome_len > E.screencols) {
-          welcome_len = E.screencols;
-        }
-        padding = (E.screencols - welcome_len) / 2;
+        int welcome_len =
+            snprintf(welcome, sizeof(welcome), "Buffer %d", pane->buffer_id);
+        if (welcome_len > pane->width)
+          welcome_len = pane->width;
+
+        int padding = (pane->width - welcome_len) / 2;
         if (padding) {
           abAppend(ab, "~", 1);
-          --padding;
+          chars_printed++;
+          padding--;
         }
-        while (padding--) {
+        while (padding-- && chars_printed < pane->width) {
           abAppend(ab, " ", 1);
+          chars_printed++;
         }
         abAppend(ab, welcome, welcome_len);
+        chars_printed += welcome_len;
       } else {
         abAppend(ab, "~", 1);
+        chars_printed++;
       }
     } else {
-      len = E.row[file_row].rsize - E.col_offset;
-      if (len < 0)
-        len = 0;
-      if (len > E.screencols)
-        len = E.screencols;
-      abAppend(ab, &E.row[file_row].render[E.col_offset], len);
+      // Render line with syntax highlighting, constrain to pane width
+      int start_offset = pane->col_offset;
+      int visible_len = buf->row[file_row].rsize - start_offset;
+      if (visible_len < 0)
+        visible_len = 0;
+      if (visible_len > pane->width)
+        visible_len = pane->width;
+
+      if (buf->filename[strlen(buf->filename) - 1] == 'c') {
+        int byte_len_to_print;
+
+        char *highlighted = highlight_line(
+            &buf->row[file_row].render[start_offset], &byte_len_to_print);
+
+        // Print only up to pane width
+
+        abAppend(ab, highlighted, byte_len_to_print);
+        free(highlighted);
+      } else {
+        abAppend(ab, &buf->row[file_row].render[start_offset], buf->row[file_row].rsize);
       }
-    abAppend(ab, ERASE_END_LINE, 3);
-    abAppend(ab, "\r\n", 2);
+
+      chars_printed = visible_len;
+    }
+
+    // Fill remaining space with background color to pane width
+    abAppend(ab, E.theme.BACKGROUND_COLOR, strlen(E.theme.BACKGROUND_COLOR));
+    while (chars_printed < pane->width) {
+      abAppend(ab, " ", 1);
+      chars_printed++;
+    }
+
+    // Restore background color at end of line
   }
 }
 
+/**
+ * @brief Renders all panes based on current split configuration
+ */
+static void editorDrawAllPanes(struct abuf *ab) {
+  ScreenLayout *layout = splitScreenGetLayout();
+
+  if (layout->num_panes == 1) {
+    // Single pane fullscreen
+    editorDrawPane(ab, &layout->panes[0]);
+  } else if (layout->num_panes == 2) {
+    // Draw both panes
+    for (int i = 0; i < 2; i++) {
+      editorDrawPane(ab, &layout->panes[i]);
+
+      // Draw pane border/divider if not the last pane
+      if (layout->mode == SPLIT_VERTICAL && i == 0) {
+        // Draw vertical divider
+        int divider_col = layout->panes[0].width;
+        for (int y = 0; y < layout->panes[0].height; y++) {
+          char pos_buf[32];
+          snprintf(pos_buf, sizeof(pos_buf), "\x1b[%d;%dH", y + 1, divider_col);
+          abAppend(ab, pos_buf, strlen(pos_buf));
+          abAppend(ab, "\x1b[1m|\x1b[0m", 9); // Bold pipe divider
+        }
+      } else if (layout->mode == SPLIT_HORIZONTAL && i == 0) {
+        // Draw horizontal divider
+        int divider_row = layout->panes[0].height;
+        char pos_buf[32];
+        snprintf(pos_buf, sizeof(pos_buf), "\x1b[%d;%dH", divider_row + 1, 1);
+        abAppend(ab, pos_buf, strlen(pos_buf));
+        for (int x = 0; x < E.screencols; x++) {
+          abAppend(ab, "\x1b[1m-\x1b[0m", 9); // Bold dash divider
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @brief Updates scroll offsets to keep cursor visible on screen
+ * @details Adjusts E.row_offset and E.col_offset to ensure the cursor remains
+ * within the visible viewport. Also updates E.rx (rendered x-coordinate).
+ * @note Updates global editor state E
+ * @see editorRowCxToRx()
+ */
 void editorScroll() {
-  E.rx = E.cursor_x;
-  if (E.cursor_y < E.numrows) {
-    E.rx = editorRowCxToRx(&E.row[E.cursor_y], E.cursor_x);
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
+  active->rx = active->cursor_x;
+
+  fprintf(stderr, "%d %d / %d %d\n", active->cursor_x, active->col_offset,
+          active->cursor_y, active->row_offset);
+
+  if (active->cursor_x < 0) {
+    active->cursor_x = 0;
+    active->col_offset = active->col_offset == 0 ? 0 : --active->col_offset;
   }
 
-  if (E.cursor_y < E.row_offset) {
-    E.row_offset = E.cursor_y;
+  if (active->cursor_y < 0) {
+    active->cursor_y = 0;
+    active->row_offset = active->row_offset == 0 ? 0 : --active->row_offset;
   }
-  if (E.cursor_y >= E.row_offset + E.screenrows) {
-    E.row_offset = E.cursor_y - E.screenrows + 1;
+
+  if (active->cursor_x == active->width) {
+
+    active->cursor_x--;
+    active->col_offset++;
   }
-  if (E.rx < E.col_offset) {
-    E.col_offset = E.rx;
-  }
-  if (E.rx >= E.col_offset + E.screencols) {
-    E.col_offset = E.rx - E.screencols + 1;
+
+  if (active->cursor_y == active->height) {
+
+    active->cursor_y--;
+    active->row_offset++;
   }
 }
 
+/**
+ * @brief Renders the status bar at the bottom of the screen
+ * @details Displays filename, line count, dirty flag, and current cursor
+ * position in an inverted color bar. Right-aligns the cursor position
+ * indicator.
+ * @param ab Pointer to append buffer structure for accumulating output
+ * @note Uses ANSI escape codes for color inversion
+ */
 void editorDrawStatusBar(struct abuf *ab) {
   int len, render_len;
   char status[80], render_status[80];
+  EditorPane *active = splitScreenGetActivePane();
+  struct buffer_t *buf = bufferFindById(active->buffer_id);
 
   abAppend(ab, "\x1b[7m", 4); // inverting colors
-  len = snprintf(status, sizeof(status), "%.20s - %d lines%s",
-                 E.filename ? E.filename : "[No Name]", E.numrows,
-                 E.dirty ? "*" : "");
+
+  const char *mode_str = "";
+  ScreenLayout *layout = splitScreenGetLayout();
+  if (layout->mode == SPLIT_VERTICAL)
+    mode_str = " [V-SPLIT]";
+  else if (layout->mode == SPLIT_HORIZONTAL)
+    mode_str = " [H-SPLIT]";
+
+  // Build buffer status showing all buffers with dirty indicators
+  char buf_status[200] = "";
+  int offset = 0;
+  for (int i = 0; i < E.number_of_buffer; i++) {
+    struct buffer_t *b = &E.buffers[i];
+    char marker = (b->buffer_id == active->buffer_id) ? '>' : ' ';
+    char dirty_marker = b->dirty ? '*' : ' ';
+    offset += snprintf(&buf_status[offset], sizeof(buf_status) - offset,
+                       "%c%d:%s%c ", marker, b->buffer_id,
+                       b->filename ? b->filename : "[No Name]", dirty_marker);
+  }
+
+  len = snprintf(status, sizeof(status), "%s%s", buf_status, mode_str);
+
   render_len = snprintf(render_status, sizeof(render_status), "%d/%d",
-                        E.cursor_y + 1, E.numrows);
+                        active->cursor_y + 1, buf->numrows);
+
   if (len > E.screencols) {
     len = E.screencols;
   }
+
   abAppend(ab, status, len);
   while (len < E.screencols) {
     if (E.screencols - len == render_len) {
@@ -91,10 +238,18 @@ void editorDrawStatusBar(struct abuf *ab) {
       ++len;
     }
   }
+
   abAppend(ab, "\x1b[m", 3); // normal text mode
   abAppend(ab, "\r\n", 2);
 }
 
+/**
+ * @brief Renders the message bar below the status bar
+ * @details Displays temporary status messages for a limited time (5 seconds).
+ * Only displays message if within time window and within screen width.
+ * @param ab Pointer to append buffer structure for accumulating output
+ * @note Messages are set by editorSetStatusMessage()
+ */
 void editorDrawMessageBar(struct abuf *ab) {
   int msg_len = strlen(E.status_msg);
   abAppend(ab, ERASE_END_LINE, 3);
@@ -106,32 +261,44 @@ void editorDrawMessageBar(struct abuf *ab) {
   }
 }
 
+/**
+ * @brief Performs complete screen refresh and buffer synchronization
+ * @details Clears screen, redraws all visible content (rows, status bar,
+ * message bar), positions cursor, and writes accumulated buffer to stdout. This
+ * is the main rendering function called each frame.
+ * @note Updates global editor state E (via editorScroll())
+ * @see editorDrawRows()
+ * @see editorDrawStatusBar()
+ * @see editorDrawMessageBar()
+ */
+
 void editorRefreshScreen() {
-  editorScroll();
   struct abuf ab = ABUF_INIT;
   char buf[32];
 
   abAppend(&ab, HIDE_CURSOR, 6);
   abAppend(&ab, CURSOR_TOP_LEFT, 3);
+  abAppend(&ab, E.theme.BACKGROUND_COLOR,
+           strlen(E.theme.BACKGROUND_COLOR)); // RGB background is 12 bytes
 
-  editorDrawRows(&ab);
+  // Draw all panes
+  editorScroll();
+  editorDrawAllPanes(&ab);
+
+  // Draw status bar and message bar
   editorDrawStatusBar(&ab);
   editorDrawMessageBar(&ab);
 
-  snprintf(buf, sizeof(buf), "\x1b[%d;%dH", (E.cursor_y - E.row_offset) + 1,
-           (E.rx - E.col_offset) + 1);
+  // Position cursor in active pane
+  EditorPane *active = splitScreenGetActivePane();
+  if (active != NULL) {
+    snprintf(buf, sizeof(buf), "\x1b[%d;%dH",
+             active->cursor_y + active->start_row + 1,
+             active->cursor_x + active->start_col + 1);
     abAppend(&ab, buf, strlen(buf));
+  }
 
   abAppend(&ab, SHOW_CURSOR, 6);
-
   write(STDOUT_FILENO, ab.b, ab.len);
   abFree(&ab);
 }
-
-void editorSetStatusMessage(const char *fmt, ...) {
-  va_list ap;
-  va_start(ap, fmt);
-  vsnprintf(E.status_msg, sizeof(E.status_msg), fmt, ap);
-  va_end(ap);
-  E.status_msg_time = time(NULL);
-}

src/row_op.c

@@ -6,7 +6,7 @@
 
 extern struct editorConfig E;
 
-int editorRowCxToRx(erow *row, int cursor_x) {
+int bufferRowCxToRx(frow *row, int cursor_x) {
   int render_x = 0;
   int i;
   for (i = 0; i < cursor_x; ++i) {
@@ -18,7 +18,7 @@ int editorRowCxToRx(erow *row, int cursor_x) {
   return render_x;
 }
 
-int editorRowRxToCx(erow *row, int rx) {
+int bufferRowRxToCx(frow *row, int rx) {
   int cur_rx = 0;
   int cx;
   for (cx = 0; cx < row->size; cx++) {
@@ -31,11 +31,11 @@ int editorRowRxToCx(erow *row, int rx) {
 }
 
 /**
- * \fn editorUpdateRow(erow *row)
+ * \fn bufferUpdatfrow(frow *row)
  * \brief Copy content of \p row in \p row->render.
  *  */
 
-void editorUpdateRow(erow *row) {
+void bufferUpdatfrow(frow *row) {
   int i, i_render;
   int tabs = 0;
 
@@ -68,52 +68,53 @@ void editorUpdateRow(erow *row) {
   row->rsize = i_render;
 }
 
-void editorInsertRow(int at, char *s, size_t len) {
-  if (at < 0 || at > E.numrows) {
+void bufferInsertRow(struct buffer_t *buffer, int at, char *s, size_t len) {
+  
+  if (at < 0 || at > buffer->numrows) {
     
     return;
   }
-  erow *tmp = (erow *)realloc(E.row, sizeof(erow) * (E.numrows + 1));
+  frow *tmp = (frow *)realloc(buffer->row, sizeof(frow) * (buffer->numrows + 1));
   if (!tmp) {
     return;
   }
-  E.row = tmp;
-  memmove(&E.row[at + 1], &E.row[at], sizeof(erow) * (E.numrows - at));
+  buffer->row = tmp;
+  memmove(&buffer->row[at + 1], &buffer->row[at], sizeof(frow) * (buffer->numrows - at));
 
-  E.row[at].size = len;
-  E.row[at].chars = malloc(len + 1);
-  memcpy(E.row[at].chars, s, len);
-  E.row[at].chars[len] = '\0';
+  buffer->row[at].size = len;
+  buffer->row[at].chars = malloc(len + 1);
+  memcpy(buffer->row[at].chars, s, len);
+  buffer->row[at].chars[len] = '\0';
 
-  E.row[at].rsize = 0;
-  E.row[at].render = NULL;
-  editorUpdateRow(&E.row[at]);
+  buffer->row[at].rsize = 0;
+  buffer->row[at].render = NULL;
+  bufferUpdatfrow(&buffer->row[at]);
 
-  ++E.numrows;
-  ++E.dirty;
+  ++buffer->numrows;
+  ++buffer->dirty;
 }
 
-void editorFreeRow(erow *row) {
+void bufferFrefrow(frow *row) {
   free(row->render);
   free(row->chars);
 }
 
-void editorDelRow(int at) {
-  if (at < 0 || at >= E.numrows) {
+void bufferDelRow(struct buffer_t *buffer, int at) {
+  if (at < 0 || at >= buffer->numrows) {
     return;
   }
-  editorFreeRow(&E.row[at]);
-  memmove(&E.row[at], &E.row[at + 1], sizeof(erow) * (E.numrows - at - 1));
-  --E.numrows;
-  ++E.dirty;
+  bufferFrefrow(&buffer->row[at]);
+  memmove(&buffer->row[at], &buffer->row[at + 1], sizeof(frow) * (buffer->numrows - at - 1));
+  --buffer->numrows;
+  ++buffer->dirty;
 }
 
 /**
- * \fn editorRowInsertChar(erow *row, int at, int c)
+ * \fn bufferRowInsertChar(frow *row, int at, int c)
  * \param at Index of where we want to insert the char */
 
-void editorRowInsertChar(erow *row, int at, int c) {
-  if (E.state == READ_ONLY)
+void bufferRowInsertChar(struct buffer_t *buffer, frow *row, int at, int c) {
+  if (buffer->state == READ_ONLY)
     return;
   if (at < 0 || at > row->size) {
     at = row->size;
@@ -122,30 +123,30 @@ void editorRowInsertChar(erow *row, int at, int c) {
   memmove(&row->chars[at + 1], &row->chars[at], row->size - at + 1);
   ++row->size;
   row->chars[at] = c;
-  editorUpdateRow(row);
-  ++E.dirty;
+  bufferUpdatfrow(row);
+  ++buffer->dirty;
 }
 
-void editorRowAppendString(erow *row, char *s, size_t len) {
+void bufferRowAppendString(struct buffer_t *buffer, frow *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;
+  bufferUpdatfrow(row);
+  ++buffer->dirty;
 }
 
 /**
- * \fn editorRowDelChar(struct editorConfig *E, erow *erow, int at)
+ * \fn bufferRowDelChar(struct bufferConfig *E, frow *frow, int at)
  * \brief Delete the a char at the chosen position on the given row
  * \param at Index of the char to delete
  * \param row Row on operation is made */
-void editorRowDelchar(erow *row, int at) {
+void bufferRowDelchar(struct buffer_t *buffer, frow *row, int at) {
   if (at < 0 || at >= row->size) {
     return;
   }
   memmove(&row->chars[at], &row->chars[at + 1], row->size - at);
   --row->size;
-  editorUpdateRow(row);
-  ++E.dirty;
+  bufferUpdatfrow(row);
+  ++buffer->dirty;
 }

src/split_screen.c

@@ -0,0 +1,218 @@
+/**
+ * @file split_screen.c
+ * @brief Split screen implementation
+ */
+
+#include "../include/split_screen.h"
+#include "../include/buffer.h"
+#include "../include/editor_op.h"
+#include <stdlib.h>
+#include <string.h>
+
+extern struct editorConfig E;
+
+/**
+ * @brief Initializes split screen system with single fullscreen pane
+ */
+void splitScreenInit(void) {
+    E.layout.mode = SPLIT_NONE;
+    E.layout.num_panes = 1;
+    E.layout.active_pane = 0;
+    
+    E.layout.panes = malloc(sizeof(EditorPane) * 2);
+    
+    // Initialize single fullscreen pane
+    E.layout.panes[0].buffer_id = -1; // No buffer for now
+    E.layout.panes[0].start_row = 0;
+    E.layout.panes[0].start_col = 0;
+    E.layout.panes[0].height = E.screenrows - 2;  // Leave room for status bar
+    E.layout.panes[0].width = E.screencols;
+    E.layout.panes[0].cursor_x = 0;
+    E.layout.panes[0].cursor_y = 0;
+    E.layout.panes[0].row_offset = 0;
+    E.layout.panes[0].col_offset = 0;
+    E.layout.panes[0].is_active = 1;
+}
+
+/**
+ * @brief Splits screen vertically (left-right)
+ * @param buffer_id_left Buffer ID for left pane
+ * @param buffer_id_right Buffer ID for right pane
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenVertical(int buffer_id_left, int buffer_id_right) {
+    // Verify both buffers exist
+    if (bufferFindById(buffer_id_left) == NULL ||
+        bufferFindById(buffer_id_right) == NULL) {
+        editorSetStatusMessage("Error: invalid buffer IDs");
+        return -1;
+    }
+    
+    // Reallocate panes array
+    E.layout.panes = realloc(E.layout.panes, sizeof(EditorPane) * 2);
+    E.layout.mode = SPLIT_VERTICAL;
+    E.layout.num_panes = 2;
+    E.layout.active_pane = 0;
+    
+    int half_width = E.screencols / 2;
+    int pane_height = E.screenrows - 2;  // Leave room for status bar
+    
+    // Left pane
+    E.layout.panes[0].buffer_id = buffer_id_left;
+    E.layout.panes[0].start_row = 0;
+    E.layout.panes[0].start_col = 0;
+    E.layout.panes[0].height = pane_height;
+    E.layout.panes[0].width = half_width;
+    E.layout.panes[0].cursor_x = 0;
+    E.layout.panes[0].cursor_y = 0;
+    E.layout.panes[0].row_offset = 0;
+    E.layout.panes[0].col_offset = 0;
+    E.layout.panes[0].is_active = 1;
+    
+    // Right pane
+    E.layout.panes[1].buffer_id = buffer_id_right;
+    E.layout.panes[1].start_row = 0;
+    E.layout.panes[1].start_col = half_width;
+    E.layout.panes[1].height = pane_height;
+    E.layout.panes[1].width = E.screencols - half_width;
+    E.layout.panes[1].cursor_x = 0;
+    E.layout.panes[1].cursor_y = 0;
+    E.layout.panes[1].row_offset = 0;
+    E.layout.panes[1].col_offset = 0;
+    E.layout.panes[1].is_active = 0;
+    
+    editorSetStatusMessage("Vertical split: %d | %d", buffer_id_left, buffer_id_right);
+    return 0;
+}
+
+/**
+ * @brief Splits screen horizontally (top-bottom)
+ * @param buffer_id_top Buffer ID for top pane
+ * @param buffer_id_bottom Buffer ID for bottom pane
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenHorizontal(int buffer_id_top, int buffer_id_bottom) {
+    // Verify both buffers exist
+    if (bufferFindById(buffer_id_top) == NULL ||
+        bufferFindById(buffer_id_bottom) == NULL) {
+        editorSetStatusMessage("Error: invalid buffer IDs");
+        return -1;
+    }
+    
+    // Reallocate panes array
+    E.layout.panes = realloc(E.layout.panes, sizeof(EditorPane) * 2);
+    E.layout.mode = SPLIT_HORIZONTAL;
+    E.layout.num_panes = 2;
+    E.layout.active_pane = 0;
+    
+    int half_height = (E.screenrows - 2) / 2;  // Account for status bar
+    
+    // Top pane
+    E.layout.panes[0].buffer_id = buffer_id_top;
+    E.layout.panes[0].start_row = 0;
+    E.layout.panes[0].start_col = 0;
+    E.layout.panes[0].height = half_height;
+    E.layout.panes[0].width = E.screencols;
+    E.layout.panes[0].cursor_x = 0;
+    E.layout.panes[0].cursor_y = 0;
+    E.layout.panes[0].row_offset = 0;
+    E.layout.panes[0].col_offset = 0;
+    E.layout.panes[0].is_active = 1;
+    
+    // Bottom pane
+    E.layout.panes[1].buffer_id = buffer_id_bottom;
+    E.layout.panes[1].start_row = half_height;
+    E.layout.panes[1].start_col = 0;
+    E.layout.panes[1].height = E.screenrows - 2 - half_height;
+    E.layout.panes[1].width = E.screencols;
+    E.layout.panes[1].cursor_x = 0;
+    E.layout.panes[1].cursor_y = 0;
+    E.layout.panes[1].row_offset = 0;
+    E.layout.panes[1].col_offset = 0;
+    E.layout.panes[1].is_active = 0;
+    
+    editorSetStatusMessage("Horizontal split: %d / %d", buffer_id_top, buffer_id_bottom);
+    return 0;
+}
+
+/**
+ * @brief Returns to single buffer fullscreen
+ */
+void splitScreenUnify(void) {
+    E.layout.mode = SPLIT_NONE;
+    E.layout.num_panes = 1;
+    E.layout.active_pane = 0;
+    
+    E.layout.panes[0].start_row = 0;
+    E.layout.panes[0].start_col = 0;
+    E.layout.panes[0].height = E.screenrows - 2;
+    E.layout.panes[0].width = E.screencols;
+    E.layout.panes[0].is_active = 1;
+    
+    editorSetStatusMessage("Unified view");
+}
+
+/**
+ * @brief Switches active pane (focus moves between splits)
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenSwitchPane(void) {
+    if (E.layout.num_panes < 2) {
+        editorSetStatusMessage("No split to switch");
+        return -1;
+    }
+    
+    // Deactivate current pane
+    E.layout.panes[E.layout.active_pane].is_active = 0;
+    
+    // Move to next pane
+    E.layout.active_pane = (E.layout.active_pane + 1) % E.layout.num_panes;
+    
+    // Activate new pane
+    E.layout.panes[E.layout.active_pane].is_active = 1;
+    
+    editorSetStatusMessage("Switched to pane %d (buffer %d)", 
+                          E.layout.active_pane,
+                          E.layout.panes[E.layout.active_pane].buffer_id);
+    return 0;
+}
+
+/**
+ * @brief Updates the active pane's buffer
+ * @param buffer_id New buffer ID for active pane
+ * @return 0 on success, -1 on failure
+ */
+int splitScreenSetPaneBuffer(int buffer_id) {
+    if (bufferFindById(buffer_id) == NULL) {
+        editorSetStatusMessage("Error: invalid buffer ID");
+        return -1;
+    }
+    
+    EditorPane *active = &E.layout.panes[E.layout.active_pane];
+    active->buffer_id = buffer_id;
+    active->cursor_x = 0;
+    active->cursor_y = 0;
+    active->row_offset = 0;
+    active->col_offset = 0;
+    
+    editorSetStatusMessage("Pane %d now showing buffer %d", 
+                          E.layout.active_pane, buffer_id);
+    return 0;
+}
+
+/**
+ * @brief Gets current screen layout
+ * @return Pointer to current ScreenLayout
+ */
+ScreenLayout *splitScreenGetLayout(void) {
+    return &E.layout;
+}
+
+/**
+ * @brief Gets active pane
+ * @return Pointer to active EditorPane
+ */
+EditorPane *splitScreenGetActivePane(void) {
+    if (E.layout.num_panes == 0) return NULL;
+    return &E.layout.panes[E.layout.active_pane];
+}

src/syntax_highlighter.c

@@ -0,0 +1,197 @@
+#include "../include/syntax_highlighter.h"
+#include "../include/data.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern struct editorConfig E;
+
+const char *c_keywords[] = {
+    "if",     "else",     "while",    "for",     "do",       "switch",
+    "case",   "break",    "#include", "#define", "continue", "return",
+    "goto",   "struct",   "union",    "enum",    "typedef",  "static",
+    "extern", "const",    "volatile", "sizeof",  "auto",     "register",
+    "inline", "restrict", NULL};
+
+// C types
+const char *c_types[] = {"int",    "char", "float", "double",
+                         "void",   "long", "short", "unsigned",
+                         "signed", "bool", NULL};
+
+// Check if character is alphanumeric or underscore
+int is_word_char(char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+         (c >= '0' && c <= '9') || c == '_' || c == '#';
+}
+
+// Check if string is a keyword
+int is_keyword(const char *word) {
+  for (int i = 0; c_keywords[i] != NULL; i++) {
+    if (strcmp(word, c_keywords[i]) == 0)
+      return 1;
+  }
+  return 0;
+}
+
+// Check if string is a type
+int is_type(const char *word) {
+  for (int i = 0; c_types[i] != NULL; i++) {
+    if (strcmp(word, c_types[i]) == 0)
+      return 1;
+  }
+  return 0;
+}
+
+// Get color code for token type
+const char *get_color(TokenType type) {
+  switch (type) {
+  case TOKEN_KEYWORD:
+    return E.theme.COLOR_KEYWORD;
+  case TOKEN_TYPE:
+    return E.theme.COLOR_TYPE;
+  case TOKEN_STRING:
+    return E.theme.COLOR_STRING;
+  case TOKEN_COMMENT:
+    return E.theme.COLOR_COMMENT;
+  case TOKEN_NUMBER:
+    return E.theme.COLOR_NUMBER;
+  default:
+    return E.theme.COLOR_DEFAULT;
+  }
+}
+
+int comment_section = 0;
+
+// Highlight a line of C code and return the highlighted string
+// Returns a newly allocated string that must be freed by the caller
+char *highlight_line(const char *line, int *length) {
+  char *result = malloc(1024); // Allocate space for result
+  int result_pos = 0;
+  int i = 0;
+
+  while (line[i] != '\0' && line[i] != '\n') {
+    // Skip whitespace
+    if (line[i] == ' ' || line[i] == '\t') {
+      result[result_pos++] = line[i++];
+      continue;
+    }
+    
+    if (comment_section) {
+      result_pos += sprintf(&result[result_pos], "%s", E.theme.COLOR_COMMENT);
+      while (line[i] != '\0' && line[i] != '\n') {
+        
+    if (line[i] == '*' && line[i + 1] == '/') {
+      comment_section = 0;
+    }
+
+        result[result_pos++] = line[i++];
+      }
+      result_pos += sprintf(&result[result_pos], "%s", COLOR_RESET);
+      continue;
+    }
+
+    // Handle line comments
+    if (line[i] == '/' && line[i + 1] == '/') {
+      result_pos += sprintf(&result[result_pos], "%s", E.theme.COLOR_COMMENT);
+      while (line[i] != '\0' && line[i] != '\n') {
+        result[result_pos++] = line[i++];
+      }
+      result_pos += sprintf(&result[result_pos], "%s", COLOR_RESET);
+      continue;
+    }
+
+    // Handle block comments
+    if ((line[i] == '/' && line[i + 1] == '*')) {
+      comment_section = 1;
+      result_pos += sprintf(&result[result_pos], "%s", E.theme.COLOR_COMMENT);
+      result[result_pos++] = line[i++];
+      result[result_pos++] = line[i++];
+      while (line[i] != '\0') {
+        if (line[i] == '*' && line[i + 1] == '/') {
+          result[result_pos++] = line[i++];
+          result[result_pos++] = line[i++];
+          break;
+        }
+        result[result_pos++] = line[i++];
+      }
+      result_pos += sprintf(&result[result_pos], "%s", COLOR_RESET);
+      continue;
+    }
+
+    // Handle strings
+    if (line[i] == '"') {
+      result_pos += sprintf(&result[result_pos], "%s\"", E.theme.COLOR_STRING);
+      i++;
+      while (line[i] != '\0' && line[i] != '"') {
+        if (line[i] == '\\') {
+          result[result_pos++] = line[i++];
+          result[result_pos++] = line[i++];
+        } else {
+          result[result_pos++] = line[i++];
+        }
+      }
+      if (line[i] == '"')
+        result[result_pos++] = line[i++];
+      result_pos += sprintf(&result[result_pos], "%s", COLOR_RESET);
+      continue;
+    }
+
+    // Handle character literals
+    if (line[i] == '\'') {
+      result_pos += sprintf(&result[result_pos], "%s'", E.theme.COLOR_STRING);
+      i++;
+      while (line[i] != '\0' && line[i] != '\'') {
+        if (line[i] == '\\') {
+          result[result_pos++] = line[i++];
+          result[result_pos++] = line[i++];
+        } else {
+          result[result_pos++] = line[i++];
+        }
+      }
+      if (line[i] == '\'')
+        result[result_pos++] = line[i++];
+      result_pos += sprintf(&result[result_pos], "%s", COLOR_RESET);
+      continue;
+    }
+
+    // Handle numbers
+    if (line[i] >= '0' && line[i] <= '9') {
+      result_pos += sprintf(&result[result_pos], "%s", E.theme.COLOR_NUMBER);
+      while (is_word_char(line[i]) || line[i] == '.') {
+        result[result_pos++] = line[i++];
+      }
+      result_pos += sprintf(&result[result_pos], "%s", COLOR_RESET);
+      continue;
+    }
+
+    // Handle identifiers and keywords
+    if (is_word_char(line[i])) {
+      int start = i;
+      while (is_word_char(line[i]))
+        i++;
+
+      char word[256];
+      strncpy(word, &line[start], i - start);
+      word[i - start] = '\0';
+
+      TokenType type = TOKEN_DEFAULT;
+      if (is_keyword(word))
+        type = TOKEN_KEYWORD;
+      else if (is_type(word))
+        type = TOKEN_TYPE;
+
+      result_pos += sprintf(&result[result_pos], "%s%s%s", get_color(type),
+                            word, COLOR_RESET);
+      continue;
+    }
+
+    // Handle operators and other characters
+    result_pos += sprintf(&result[result_pos], "%s", E.theme.COLOR_DEFAULT);
+    result[result_pos++] = line[i++];
+    result_pos += sprintf(&result[result_pos], "%s", COLOR_RESET);
+  }
+
+  result[result_pos] = '\0';
+  *length = result_pos + 1;
+  return result;
+}