X-Git-Url: https://git.danieliu.xyz/?p=taskasaur.git;a=blobdiff_plain;f=parser.c;h=9300bca91cb8ce81d4af3034625e549606022444;hp=3c283498a26e1ba946fea3018d8b8ee93b8e929c;hb=HEAD;hpb=8d3a5e5f51153c38f4c5b20a309af2b6e5bf686d

diff --git a/parser.c b/parser.c
index 3c28349..9300bca 100644
--- a/parser.c
+++ b/parser.c
@@ -1,17 +1,27 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <md4c.h>
-
-typedef struct TodoItem {
-    char* name;
-    char* description;
-    char* due;
-    char** items;
-} TodoItem;
+
+#include "headers/parser.h"
+
+typedef struct State {
+    Board* board;
+    TodoList* cur_todolist;
+    TodoItem* cur_todoitem;
+    /* for use during processing */
+    char* last_block_text;
+} State;
 
 char* read_file(char* file_name, long* size);
 
+/* processing */
+void enter_todolist(State* state, char* list_name);
+void exit_todolist(State* state);
+
+void enter_todoitem(State* state, char* item_name);
+void exit_todoitem(State* state);
+
+void set_description(State* state, char* description);
+void set_due(State* state, char* due); // make an acc date struct later
+void add_subtask(State* state, char* subtask_name, SubTaskState subtask_state);
+
 /* callbacks to parser */
 int enter_block(MD_BLOCKTYPE type, void* detail, void* userdata);
 int leave_block(MD_BLOCKTYPE type, void* detail, void* userdata);
@@ -23,7 +33,7 @@ void syntax(void);
 
 const MD_PARSER parser = {
     0,
-    MD_DIALECT_COMMONMARK,
+    MD_FLAG_TASKLISTS,
     &enter_block,
     &leave_block,
     &enter_span,
@@ -33,17 +43,36 @@ const MD_PARSER parser = {
     &syntax
 };
 
-int
-main(int argc, char** argv)
+
+/* reading */
+Board*
+begin_parse(char* board_path)
 {
-    char* input_buffer;
+    const char* input_buffer;
     long input_size;
+    State state;
+    Board* new_board;
+
+    /* read entire file */
+    input_buffer = read_file(board_path, &input_size);
 
-    input_buffer = read_file("test_board.md", &input_size);
+    /* setup state */
+    state.cur_todolist = NULL;
+    state.cur_todoitem = NULL;
 
-    md_parse(input_buffer, input_size, &parser, NULL);
+    new_board = malloc(sizeof(Board));
+    new_board->todolist_list = malloc(0);
+    new_board->todolist_count = 0;
+    state.board = new_board;
 
-    return 0;    
+    md_parse(input_buffer, input_size, &parser, &state);
+
+    /* finish calls */
+    exit_todolist(&state);
+
+    free((char*)input_buffer);
+
+    return state.board;
 }
 
 char*
@@ -55,7 +84,7 @@ read_file(char* file_name, long* size)
 
     file = fopen(file_name, "r");
     if (file == NULL) {
-        printf("Something went wrong opening file\n");
+        perror("read_file > fopen");
         return NULL;
     }
 
@@ -81,6 +110,102 @@ read_file(char* file_name, long* size)
     return output;
 }
 
+void
+enter_todolist(State* state, char* list_name)
+{
+    TodoList* new_todolist;
+    
+    new_todolist = malloc(sizeof(TodoList));
+    new_todolist->list_name = list_name;
+    new_todolist->item_list = malloc(0);
+    new_todolist->item_count = 0;
+
+    state->cur_todolist = new_todolist;
+}
+
+void
+exit_todolist(State* state)
+{
+    #define sb state->board
+
+    if (state->cur_todolist == NULL) return; 
+
+    exit_todoitem(state);
+
+    sb->todolist_count += 1;
+    sb->todolist_list = realloc(sb->todolist_list, sb->todolist_count*sizeof(TodoList*));
+    sb->todolist_list[sb->todolist_count-1] = state->cur_todolist;
+    state->cur_todolist = NULL;
+
+    #undef sb
+}
+
+void
+enter_todoitem(State* state, char* item_name)
+{
+    TodoItem* new_todoitem;
+
+    new_todoitem = malloc(sizeof(TodoItem));
+    new_todoitem->item_name = item_name;
+    new_todoitem->description = strdup("");
+    new_todoitem->due = strdup("");
+    new_todoitem->subtask_list = malloc(0);
+    new_todoitem->subtask_count = 0;
+
+    state->cur_todoitem = new_todoitem;
+    
+}
+
+void
+exit_todoitem(State* state)
+{
+    #define st state->cur_todolist
+
+    if (state->cur_todoitem == NULL) return; 
+    
+    /* append current item to todo list */
+    st->item_count += 1;
+    st->item_list = realloc(st->item_list, st->item_count*sizeof(TodoItem*));
+    st->item_list[st->item_count-1] = state->cur_todoitem;
+    state->cur_todoitem = NULL;
+
+    #undef st
+}
+
+void
+set_description(State* state, char* description)
+{
+    state->cur_todoitem->description = description;
+}
+
+void
+set_due(State* state, char* due)
+{
+    state->cur_todoitem->due = due;
+}
+
+void
+add_subtask(State* state, char* subtask_name, SubTaskState subtask_state)
+{
+    SubTask* new_subtask;
+    SubTask** subtask_list;
+    
+    /* create new subtask */
+    new_subtask = malloc(sizeof(SubTask));
+    new_subtask->subtask_name = subtask_name;
+    new_subtask->done = subtask_state;
+
+    /* add it */
+    subtask_list = state->cur_todoitem->subtask_list;
+
+    state->cur_todoitem->subtask_count += 1;
+    subtask_list = realloc(subtask_list, state->cur_todoitem->subtask_count*sizeof(SubTask*));
+    subtask_list[state->cur_todoitem->subtask_count-1] = new_subtask;
+
+    state->cur_todoitem->subtask_list = subtask_list;
+
+}
+
 int
 enter_block(MD_BLOCKTYPE type, void* detail, void* userdata)
 {
@@ -90,29 +215,100 @@ enter_block(MD_BLOCKTYPE type, void* detail, void* userdata)
 int
 leave_block(MD_BLOCKTYPE type, void* detail, void* userdata)
 {
+    State* state;
+    state = (State*)userdata;
+
+    switch (type) {
+
+        case MD_BLOCK_H:;
+
+            MD_BLOCK_H_DETAIL* h_detail;
+            h_detail = ((MD_BLOCK_H_DETAIL*)detail);
+
+            switch(h_detail->level) {
+
+                case 1:
+                    break;
+
+                case 2:
+                    exit_todolist(state);
+                    enter_todolist(state, state->last_block_text);
+                    break;
+
+                case 3:
+                    exit_todoitem(state);
+                    enter_todoitem(state, state->last_block_text);
+                    break;
+            }
+
+            break;
+
+        case MD_BLOCK_QUOTE:
+            set_description(state, state->last_block_text);
+            break;
+
+        case MD_BLOCK_LI:;
+            MD_BLOCK_LI_DETAIL* li_detail;
+            SubTaskState done;
+
+            li_detail = ((MD_BLOCK_LI_DETAIL*)detail);
+
+            assert(li_detail->is_task != 0); // all lists should be task lists
+
+            done = li_detail->task_mark == ' ' ? SubTaskState_todo : SubTaskState_done;
+
+            add_subtask(state, state->last_block_text, done);
+            break;
+
+        // no need for default case for now :>
+    }
     return 0;
 }
 
 int
 enter_span(MD_SPANTYPE type, void* detail, void* userdata)
 {
+
+
     return 0;
 }
 
 int
 leave_span(MD_SPANTYPE type, void* detail, void* userdata)
 {
+    State* state;
+    state = (State*)userdata;
+    
+    switch (type) {
+        case MD_SPAN_STRONG:
+            set_due(state, state->last_block_text);
+            break;
+    }
     return 0;
 }
 
 int
 text(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata){
+
+    State* state;
+    char* content;
+
+    state = (State*)userdata;
+
+    content = malloc(size*sizeof(char)+1);
+    memcpy(content, text, size);
+    content[size] = 0;
+
+    /* printf("%s\n", content); */
+    state->last_block_text = content;
+    
     return 0;
 }
 
 void
 debug_log(const char* msg, void* userdata)
 {
+    printf(msg);
     return;
 }
 
@@ -121,3 +317,118 @@ syntax(void)
 {
     return;
 }
+
+/* writing */
+int
+begin_write(char* board_path, Board* board)
+{ // TODO, make a backup file of board before write in case it crashes
+
+    FILE* file;
+
+    file = fopen(board_path, "w+");
+    if (file == NULL) {
+        perror("begin_write > fopen");
+        return -1;
+    }
+
+    for (int i = 0; i < board->todolist_count; i++) {
+        TodoList* cur_todolist = board->todolist_list[i];
+
+        fprintf(file, "## %s\n", cur_todolist->list_name);
+
+        for (int j = 0; j < cur_todolist->item_count; j++) {
+            TodoItem* cur_todoitem = cur_todolist->item_list[j];
+
+            fprintf(file, "### %s\n", cur_todoitem->item_name);
+            
+            /* bug rn, for some reason date is being written as description too */
+            if (strlen(cur_todoitem->description) > 0) {
+                fprintf(file, "> %s\n", cur_todoitem->description);
+            }
+            if (strlen(cur_todoitem->due) > 0) {
+                fprintf(file, "**%s**\n", cur_todoitem->due);
+            }
+
+            for (int k = 0; k < cur_todoitem->subtask_count; k++) {
+                SubTask* cursubtask = cur_todoitem->subtask_list[k];
+
+                char done_char = (cursubtask->done == SubTaskState_done) ? 'X' : ' ';
+                fprintf(file, "- [%c] %s\n", done_char, cursubtask->subtask_name);
+
+            }
+
+        }
+
+    }
+
+    fclose(file);
+
+    return 0;
+}
+
+/* others */
+void
+log_todo(Board* board)
+{
+    for (int i = 0; i < board->todolist_count; i++) {
+        TodoList* todolist;
+        printf("List =-=-=-=-=-==-=-=-=-=-=-\n");
+        todolist = board->todolist_list[i];
+        printf("List name: %s\n", todolist->list_name);
+        printf("Num of items: %d\n", todolist->item_count);
+
+        for (int j = 0; j < todolist->item_count; j++) {
+            TodoItem* todoitem;
+            printf("Item =-=-=-=-=-\n");
+            todoitem = todolist->item_list[j];
+            printf("Item name: %s\n", todoitem->item_name);
+            printf("Description: %s\n", todoitem->description);
+            printf("Num of subtasks: %d\n", todoitem->subtask_count);
+
+            for (int k = 0; k < todoitem->subtask_count; k++) {
+                SubTask* subtask;
+                int done;
+
+                subtask = todoitem->subtask_list[k];
+                printf("Subtask: %s, %d\n", subtask->subtask_name, subtask->done);
+            }
+        }
+    }
+}
+
+int
+free_board(Board* board)
+{ // all the fields are being leaked rn
+
+    for (int i = 0; i < board->todolist_count; i++) {
+        TodoList* cur_todolist = board->todolist_list[i];
+
+        /* free(cur_todolist->list_name); */
+
+        for (int j = 0; j < cur_todolist->item_count; j++) {
+            TodoItem* cur_todoitem = cur_todolist->item_list[j];
+
+            /* free(cur_todoitem->item_name); */
+            /* free(cur_todoitem->description); */
+            /* free(cur_todoitem->due); */
+
+            /* free subtask later too */
+            for (int k = 0; k < cur_todoitem->subtask_count; k++) {
+                SubTask* cur_subtask = cur_todoitem->subtask_list[k];
+
+                /* free(cur_subtask->subtask_name); */
+                free(cur_subtask);
+                
+            }
+
+            free(cur_todoitem);
+        }
+
+        free(cur_todolist);
+    }
+
+    /* free(board->board_name); */
+    free(board);
+
+    return 0;
+}