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 void
  48 log_todo(Board* board)
  49 {
  50     for (int i = 0; i < board->todolist_count; i++) {
  51         TodoList* todolist;
  52         printf("List =-=-=-=-=-==-=-=-=-=-=-\n");
  53         todolist = board->todolist_list[i];
  54         printf("List name: %s\n", todolist->list_name);
  55         printf("Num of items: %d\n", todolist->item_count);
  56
  57         for (int j = 0; j < todolist->item_count; j++) {
  58             TodoItem* todoitem;
  59             printf("Item =-=-=-=-=-\n");
  60             todoitem = todolist->item_list[j];
  61             printf("Item name: %s\n", todoitem->item_name);
  62             printf("Description: %s\n", todoitem->description);
  63             printf("Num of subtasks: %d\n", todoitem->subtask_count);
  64
  65             for (int k = 0; k < todoitem->subtask_count; k++) {
  66                 SubTask* subtask;
  67                 int done;
  68
  69                 subtask = todoitem->subtask_list[k];
  70                 printf("Subtask: %s, %d\n", subtask->subtask_name, subtask->done);
  71             }
  72         }
  73     }
  74 }
  75
  76 Board*
  77 begin_parse(char* board_path)
  78 {
  79     const char* input_buffer;
  80     long input_size;
  81     State state;
  82     Board* new_board;
  83
  84     /* read entire file */
  85     input_buffer = read_file(board_path, &input_size);
  86
  87     /* setup state */
  88     state.cur_todolist = NULL;
  89     state.cur_todoitem = NULL;
  90
  91     new_board = malloc(sizeof(Board));
  92     new_board->todolist_list = malloc(0);
  93     new_board->todolist_count = 0;
  94     state.board = new_board;
  95
  96     md_parse(input_buffer, input_size, &parser, &state);
  97
  98     /* finish calls */
  99     exit_todolist(&state);
 100
 101     free((char*)input_buffer);
 102
 103     return state.board;
 104 }
 105
 106 char*
 107 read_file(char* file_name, long* size)
 108 { // apparently using seek isnt the greatest, may change to chunk reading later
 109     FILE* file;
 110     char* output;
 111     long fsize;
 112
 113     file = fopen(file_name, "r");
 114     if (file == NULL) {
 115         printf("Something went wrong opening file\n");
 116         return NULL;
 117     }
 118
 119     fseek(file, 0, SEEK_END);
 120     fsize = ftell(file);
 121     fseek(file, 0, SEEK_SET);
 122
 123     output = malloc(fsize+1); // maybe error check malloc
 124     fread(output, 1, fsize, file);
 125     if (ferror(file)) {
 126         printf("Something went wrong reading file\n");
 127         fclose(file);
 128         free(output);
 129         return NULL;
 130     }
 131     output[fsize] = 0; // add null terminator
 132
 133     /* clean up */
 134     fclose(file);
 135
 136     /* return */
 137     *size = fsize;
 138     return output;
 139 }
 140
 141 void
 142 enter_todolist(State* state, char* list_name)
 143 {
 144     TodoList* new_todolist;
 145
 146     new_todolist = malloc(sizeof(TodoList));
 147     new_todolist->list_name = list_name;
 148     new_todolist->item_list = malloc(0);
 149     new_todolist->item_count = 0;
 150
 151     state->cur_todolist = new_todolist;
 152 }
 153
 154 void
 155 exit_todolist(State* state)
 156 {
 157     #define sb state->board
 158
 159     if (state->cur_todolist == NULL) return;
 160
 161     exit_todoitem(state);
 162
 163     sb->todolist_count += 1;
 164     sb->todolist_list = realloc(sb->todolist_list, sb->todolist_count*sizeof(TodoList*));
 165     sb->todolist_list[sb->todolist_count-1] = state->cur_todolist;
 166     state->cur_todolist = NULL;
 167
 168     #undef sb
 169 }
 170
 171 void
 172 enter_todoitem(State* state, char* item_name)
 173 {
 174     TodoItem* new_todoitem;
 175
 176     new_todoitem = malloc(sizeof(TodoItem));
 177     new_todoitem->item_name = item_name;
 178     new_todoitem->description = NULL;
 179     new_todoitem->due = NULL;
 180     new_todoitem->subtask_list = malloc(0);
 181     new_todoitem->subtask_count = 0;
 182
 183     state->cur_todoitem = new_todoitem;
 184
 185 }
 186
 187 void
 188 exit_todoitem(State* state)
 189 {
 190     #define st state->cur_todolist
 191
 192     TodoList* todolist;
 193     TodoItem** item_list;
 194
 195     if (state->cur_todoitem == NULL) return;
 196
 197     /* append current item to todo list */
 198     todolist = state->cur_todolist;
 199     item_list = todolist->item_list;
 200
 201     st->item_count += 1;
 202     st->item_list = realloc(st->item_list, st->item_count*sizeof(TodoItem*));
 203     st->item_list[st->item_count-1] = state->cur_todoitem;
 204     state->cur_todoitem = NULL;
 205
 206 }
 207
 208 void
 209 set_description(State* state, char* description)
 210 {
 211     state->cur_todoitem->description = description;
 212 }
 213
 214 void
 215 set_due(State* state, char* due)
 216 {
 217
 218 }
 219
 220 void
 221 add_subtask(State* state, char* subtask_name, SubTaskState subtask_state)
 222 {
 223     SubTask* new_subtask;
 224     SubTask** subtask_list;
 225
 226     /* create new subtask */
 227     new_subtask = malloc(sizeof(SubTask));
 228     new_subtask->subtask_name = subtask_name;
 229     new_subtask->done = subtask_state;
 230
 231     /* add it */
 232     subtask_list = state->cur_todoitem->subtask_list;
 233
 234     state->cur_todoitem->subtask_count += 1;
 235     subtask_list = realloc(subtask_list, state->cur_todoitem->subtask_count*sizeof(SubTask*));
 236     subtask_list[state->cur_todoitem->subtask_count-1] = new_subtask;
 237
 238     state->cur_todoitem->subtask_list = subtask_list;
 239
 240 }
 241
 242 int
 243 enter_block(MD_BLOCKTYPE type, void* detail, void* userdata)
 244 {
 245     return 0;
 246 }
 247
 248 int
 249 leave_block(MD_BLOCKTYPE type, void* detail, void* userdata)
 250 {
 251     State* state;
 252     state = (State*)userdata;
 253
 254     switch (type) {
 255
 256         case MD_BLOCK_H:;
 257
 258             MD_BLOCK_H_DETAIL* h_detail;
 259             h_detail = ((MD_BLOCK_H_DETAIL*)detail);
 260
 261             switch(h_detail->level) {
 262
 263                 case 1:
 264                     break;
 265
 266                 case 2:
 267                     exit_todolist(state);
 268                     enter_todolist(state, state->last_block_text);
 269                     break;
 270
 271                 case 3:
 272                     exit_todoitem(state);
 273                     enter_todoitem(state, state->last_block_text);
 274                     break;
 275             }
 276
 277             break;
 278
 279         case MD_BLOCK_QUOTE:
 280             set_description(state, state->last_block_text);
 281             break;
 282
 283         case MD_BLOCK_LI:;
 284             MD_BLOCK_LI_DETAIL* li_detail;
 285             SubTaskState done;
 286
 287             li_detail = ((MD_BLOCK_LI_DETAIL*)detail);
 288
 289             assert(li_detail->is_task != 0); // all lists should be task lists
 290
 291             done = li_detail->task_mark == ' ' ? SubTaskState_todo : SubTaskState_done;
 292
 293             add_subtask(state, state->last_block_text, done);
 294             break;
 295
 296         // no need for default case for now :>
 297     }
 298     return 0;
 299 }
 300
 301 int
 302 enter_span(MD_SPANTYPE type, void* detail, void* userdata)
 303 {
 304
 305
 306     return 0;
 307 }
 308
 309 int
 310 leave_span(MD_SPANTYPE type, void* detail, void* userdata)
 311 {
 312     State* state;
 313     state = (State*)userdata;
 314
 315     switch (type) {
 316         case MD_SPAN_STRONG:
 317             printf("date, %s\n", state->last_block_text);
 318             break;
 319     }
 320     return 0;
 321 }
 322
 323 int
 324 text(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata){
 325
 326     State* state;
 327     char* content;
 328
 329     state = (State*)userdata;
 330
 331     content = malloc(size*sizeof(char)+1);
 332     memcpy(content, text, size);
 333     content[size] = 0;
 334
 335     /* printf("%s\n", content); */
 336     state->last_block_text = content;
 337
 338     return 0;
 339 }
 340
 341 void
 342 debug_log(const char* msg, void* userdata)
 343 {
 344     printf(msg);
 345     return;
 346 }
 347
 348 void
 349 syntax(void)
 350 {
 351     return;
 352 }