parser.c

   1
   2 #include "headers/parser.h"
   3
   4 typedef struct State {
   5     Board* board;
   6     TodoList* cur_todolist;
   7     TodoItem* cur_todoitem;
   8     /* for use during processing */
   9     char* last_block_text;
  10 } State;
  11
  12 char* read_file(char* file_name, long* size);
  13
  14 /* processing */
  15 void enter_todolist(State* state, char* list_name);
  16 void exit_todolist(State* state);
  17
  18 void enter_todoitem(State* state, char* item_name);
  19 void exit_todoitem(State* state);
  20
  21 void set_description(State* state, char* description);
  22 void set_due(State* state, char* due); // make an acc date struct later
  23 void add_subtask(State* state, char* subtask_name, SubTaskState subtask_state);
  24
  25 /* callbacks to parser */
  26 int enter_block(MD_BLOCKTYPE type, void* detail, void* userdata);
  27 int leave_block(MD_BLOCKTYPE type, void* detail, void* userdata);
  28 int enter_span(MD_SPANTYPE type, void* detail, void* userdata);
  29 int leave_span(MD_SPANTYPE type, void* detail, void* userdata);
  30 int text(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata);
  31 void debug_log(const char* msg, void* userdata);
  32 void syntax(void);
  33
  34 const MD_PARSER parser = {
  35     0,
  36     MD_FLAG_TASKLISTS,
  37     &enter_block,
  38     &leave_block,
  39     &enter_span,
  40     &leave_span,
  41     &text,
  42     &debug_log,
  43     &syntax
  44 };
  45
  46
  47 /* reading */
  48 Board*
  49 begin_parse(char* board_path)
  50 {
  51     const char* input_buffer;
  52     long input_size;
  53     State state;
  54     Board* new_board;
  55
  56     /* read entire file */
  57     input_buffer = read_file(board_path, &input_size);
  58
  59     /* setup state */
  60     state.cur_todolist = NULL;
  61     state.cur_todoitem = NULL;
  62
  63     new_board = malloc(sizeof(Board));
  64     new_board->todolist_list = malloc(0);
  65     new_board->todolist_count = 0;
  66     state.board = new_board;
  67
  68     md_parse(input_buffer, input_size, &parser, &state);
  69
  70     /* finish calls */
  71     exit_todolist(&state);
  72
  73     free((char*)input_buffer);
  74
  75     return state.board;
  76 }
  77
  78 char*
  79 read_file(char* file_name, long* size)
  80 { // apparently using seek isnt the greatest, may change to chunk reading later
  81     FILE* file;
  82     char* output;
  83     long fsize;
  84
  85     file = fopen(file_name, "r");
  86     if (file == NULL) {
  87         perror("read_file > fopen");
  88         return NULL;
  89     }
  90
  91     fseek(file, 0, SEEK_END);
  92     fsize = ftell(file);
  93     fseek(file, 0, SEEK_SET);
  94
  95     output = malloc(fsize+1); // maybe error check malloc
  96     fread(output, 1, fsize, file);
  97     if (ferror(file)) {
  98         printf("Something went wrong reading file\n");
  99         fclose(file);
 100         free(output);
 101         return NULL;
 102     }
 103     output[fsize] = 0; // add null terminator
 104
 105     /* clean up */
 106     fclose(file);
 107
 108     /* return */
 109     *size = fsize;
 110     return output;
 111 }
 112
 113 void
 114 enter_todolist(State* state, char* list_name)
 115 {
 116     TodoList* new_todolist;
 117
 118     new_todolist = malloc(sizeof(TodoList));
 119     new_todolist->list_name = list_name;
 120     new_todolist->item_list = malloc(0);
 121     new_todolist->item_count = 0;
 122
 123     state->cur_todolist = new_todolist;
 124 }
 125
 126 void
 127 exit_todolist(State* state)
 128 {
 129     #define sb state->board
 130
 131     if (state->cur_todolist == NULL) return;
 132
 133     exit_todoitem(state);
 134
 135     sb->todolist_count += 1;
 136     sb->todolist_list = realloc(sb->todolist_list, sb->todolist_count*sizeof(TodoList*));
 137     sb->todolist_list[sb->todolist_count-1] = state->cur_todolist;
 138     state->cur_todolist = NULL;
 139
 140     #undef sb
 141 }
 142
 143 void
 144 enter_todoitem(State* state, char* item_name)
 145 {
 146     TodoItem* new_todoitem;
 147
 148     new_todoitem = malloc(sizeof(TodoItem));
 149     new_todoitem->item_name = item_name;
 150     new_todoitem->description = strdup("");
 151     new_todoitem->due = strdup("");
 152     new_todoitem->subtask_list = malloc(0);
 153     new_todoitem->subtask_count = 0;
 154
 155     state->cur_todoitem = new_todoitem;
 156
 157 }
 158
 159 void
 160 exit_todoitem(State* state)
 161 {
 162     #define st state->cur_todolist
 163
 164     if (state->cur_todoitem == NULL) return;
 165
 166     /* append current item to todo list */
 167     st->item_count += 1;
 168     st->item_list = realloc(st->item_list, st->item_count*sizeof(TodoItem*));
 169     st->item_list[st->item_count-1] = state->cur_todoitem;
 170     state->cur_todoitem = NULL;
 171
 172     #undef st
 173 }
 174
 175 void
 176 set_description(State* state, char* description)
 177 {
 178     state->cur_todoitem->description = description;
 179 }
 180
 181 void
 182 set_due(State* state, char* due)
 183 {
 184     state->cur_todoitem->due = due;
 185 }
 186
 187 void
 188 add_subtask(State* state, char* subtask_name, SubTaskState subtask_state)
 189 {
 190     SubTask* new_subtask;
 191     SubTask** subtask_list;
 192
 193     /* create new subtask */
 194     new_subtask = malloc(sizeof(SubTask));
 195     new_subtask->subtask_name = subtask_name;
 196     new_subtask->done = subtask_state;
 197
 198     /* add it */
 199     subtask_list = state->cur_todoitem->subtask_list;
 200
 201     state->cur_todoitem->subtask_count += 1;
 202     subtask_list = realloc(subtask_list, state->cur_todoitem->subtask_count*sizeof(SubTask*));
 203     subtask_list[state->cur_todoitem->subtask_count-1] = new_subtask;
 204
 205     state->cur_todoitem->subtask_list = subtask_list;
 206
 207 }
 208
 209 int
 210 enter_block(MD_BLOCKTYPE type, void* detail, void* userdata)
 211 {
 212     return 0;
 213 }
 214
 215 int
 216 leave_block(MD_BLOCKTYPE type, void* detail, void* userdata)
 217 {
 218     State* state;
 219     state = (State*)userdata;
 220
 221     switch (type) {
 222
 223         case MD_BLOCK_H:;
 224
 225             MD_BLOCK_H_DETAIL* h_detail;
 226             h_detail = ((MD_BLOCK_H_DETAIL*)detail);
 227
 228             switch(h_detail->level) {
 229
 230                 case 1:
 231                     break;
 232
 233                 case 2:
 234                     exit_todolist(state);
 235                     enter_todolist(state, state->last_block_text);
 236                     break;
 237
 238                 case 3:
 239                     exit_todoitem(state);
 240                     enter_todoitem(state, state->last_block_text);
 241                     break;
 242             }
 243
 244             break;
 245
 246         case MD_BLOCK_QUOTE:
 247             set_description(state, state->last_block_text);
 248             break;
 249
 250         case MD_BLOCK_LI:;
 251             MD_BLOCK_LI_DETAIL* li_detail;
 252             SubTaskState done;
 253
 254             li_detail = ((MD_BLOCK_LI_DETAIL*)detail);
 255
 256             assert(li_detail->is_task != 0); // all lists should be task lists
 257
 258             done = li_detail->task_mark == ' ' ? SubTaskState_todo : SubTaskState_done;
 259
 260             add_subtask(state, state->last_block_text, done);
 261             break;
 262
 263         // no need for default case for now :>
 264     }
 265     return 0;
 266 }
 267
 268 int
 269 enter_span(MD_SPANTYPE type, void* detail, void* userdata)
 270 {
 271
 272
 273     return 0;
 274 }
 275
 276 int
 277 leave_span(MD_SPANTYPE type, void* detail, void* userdata)
 278 {
 279     State* state;
 280     state = (State*)userdata;
 281
 282     switch (type) {
 283         case MD_SPAN_STRONG:
 284             set_due(state, state->last_block_text);
 285             break;
 286     }
 287     return 0;
 288 }
 289
 290 int
 291 text(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata){
 292
 293     State* state;
 294     char* content;
 295
 296     state = (State*)userdata;
 297
 298     content = malloc(size*sizeof(char)+1);
 299     memcpy(content, text, size);
 300     content[size] = 0;
 301
 302     /* printf("%s\n", content); */
 303     state->last_block_text = content;
 304
 305     return 0;
 306 }
 307
 308 void
 309 debug_log(const char* msg, void* userdata)
 310 {
 311     printf(msg);
 312     return;
 313 }
 314
 315 void
 316 syntax(void)
 317 {
 318     return;
 319 }
 320
 321 /* writing */
 322 int
 323 begin_write(char* board_path, Board* board)
 324 { // TODO, make a backup file of board before write in case it crashes
 325
 326     FILE* file;
 327
 328     file = fopen(board_path, "w+");
 329     if (file == NULL) {
 330         perror("begin_write > fopen");
 331         return -1;
 332     }
 333
 334     for (int i = 0; i < board->todolist_count; i++) {
 335         TodoList* cur_todolist = board->todolist_list[i];
 336
 337         fprintf(file, "## %s\n", cur_todolist->list_name);
 338
 339         for (int j = 0; j < cur_todolist->item_count; j++) {
 340             TodoItem* cur_todoitem = cur_todolist->item_list[j];
 341
 342             fprintf(file, "### %s\n", cur_todoitem->item_name);
 343
 344             /* bug rn, for some reason date is being written as description too */
 345             if (strlen(cur_todoitem->description) > 0) {
 346                 fprintf(file, "> %s\n", cur_todoitem->description);
 347             }
 348             if (strlen(cur_todoitem->due) > 0) {
 349                 fprintf(file, "**%s**\n", cur_todoitem->due);
 350             }
 351
 352             for (int k = 0; k < cur_todoitem->subtask_count; k++) {
 353                 SubTask* cursubtask = cur_todoitem->subtask_list[k];
 354
 355                 char done_char = (cursubtask->done == SubTaskState_done) ? 'X' : ' ';
 356                 fprintf(file, "- [%c] %s\n", done_char, cursubtask->subtask_name);
 357
 358             }
 359
 360         }
 361
 362     }
 363
 364     fclose(file);
 365
 366     return 0;
 367 }
 368
 369 /* others */
 370 void
 371 log_todo(Board* board)
 372 {
 373     for (int i = 0; i < board->todolist_count; i++) {
 374         TodoList* todolist;
 375         printf("List =-=-=-=-=-==-=-=-=-=-=-\n");
 376         todolist = board->todolist_list[i];
 377         printf("List name: %s\n", todolist->list_name);
 378         printf("Num of items: %d\n", todolist->item_count);
 379
 380         for (int j = 0; j < todolist->item_count; j++) {
 381             TodoItem* todoitem;
 382             printf("Item =-=-=-=-=-\n");
 383             todoitem = todolist->item_list[j];
 384             printf("Item name: %s\n", todoitem->item_name);
 385             printf("Description: %s\n", todoitem->description);
 386             printf("Num of subtasks: %d\n", todoitem->subtask_count);
 387
 388             for (int k = 0; k < todoitem->subtask_count; k++) {
 389                 SubTask* subtask;
 390                 int done;
 391
 392                 subtask = todoitem->subtask_list[k];
 393                 printf("Subtask: %s, %d\n", subtask->subtask_name, subtask->done);
 394             }
 395         }
 396     }
 397 }
 398
 399 int
 400 free_board(Board* board)
 401 { // all the fields are being leaked rn
 402
 403     for (int i = 0; i < board->todolist_count; i++) {
 404         TodoList* cur_todolist = board->todolist_list[i];
 405
 406         /* free(cur_todolist->list_name); */
 407
 408         for (int j = 0; j < cur_todolist->item_count; j++) {
 409             TodoItem* cur_todoitem = cur_todolist->item_list[j];
 410
 411             /* free(cur_todoitem->item_name); */
 412             /* free(cur_todoitem->description); */
 413             /* free(cur_todoitem->due); */
 414
 415             /* free subtask later too */
 416             for (int k = 0; k < cur_todoitem->subtask_count; k++) {
 417                 SubTask* cur_subtask = cur_todoitem->subtask_list[k];
 418
 419                 /* free(cur_subtask->subtask_name); */
 420                 free(cur_subtask);
 421
 422             }
 423
 424             free(cur_todoitem);
 425         }
 426
 427         free(cur_todolist);
 428     }
 429
 430     /* free(board->board_name); */
 431     free(board);
 432
 433     return 0;
 434 }