X-Git-Url: https://git.danieliu.xyz/?a=blobdiff_plain;f=src%2Fparser.c;h=b4006109bd847194052b70cabb3cf9111e9da64a;hb=7b546f2a11460bed09b61116c8be38f8decf0440;hp=478da5b3c22bf868a9feda245500f33b99c104f2;hpb=a64de8af30f7a0465333e65f365dfa02ad2862b6;p=smdp.git

diff --git a/src/parser.c b/src/parser.c
index 478da5b..b400610 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -22,8 +22,10 @@
  */
 
 #include <ctype.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "parser.h"
 
@@ -31,27 +33,32 @@ deck_t *markdown_load(FILE *input) {
 
     int c = 0;    // char
     int i = 0;    // increment
-    int l = 0;    // line length
     int hc = 0;   // header count
     int lc = 0;   // line count
-    int sc = 0;   // slide count
+    int sc = 1;   // slide count
     int bits = 0; // markdown bits
+    int prev = 0; // markdown bits of previous line
 
     deck_t *deck = new_deck();
-    slide_t *slide = new_slide();
+    slide_t *slide = deck->slide;
     line_t *line = NULL;
     line_t *tmp = NULL;
     cstring_t *text = cstring_init();
 
-    // assign first slide to deck
-    deck->slide = slide;
-    sc++;
+    // initialize bits as empty line
+    SET_BIT(bits, IS_EMPTY);
 
     while ((c = fgetc(input)) != EOF) {
+        if (ferror(input)) {
+            fprintf(stderr, "markdown_load() failed to read input: %s\n", strerror(errno));
+            exit(EXIT_FAILURE);
+        }
+
         if(c == '\n') {
 
             // markdown analyse
-            bits = markdown_analyse(text);
+            prev = bits;
+            bits = markdown_analyse(text, prev);
 
             // if first line in file is markdown hr
             if(!line && CHECK_BIT(bits, IS_HR)) {
@@ -67,7 +74,6 @@ deck_t *markdown_load(FILE *input) {
 
                 // clear text
                 (text->reset)(text);
-                l = 0;
 
                 // create next slide
                 slide = next_slide(slide);
@@ -97,15 +103,15 @@ deck_t *markdown_load(FILE *input) {
                 // add bits to line
                 line->bits = bits;
 
-                // add length to line
-                line->length = l;
-
                 // calc offset
                 line->offset = next_nonblank(text, 0);
 
+                // adjust line length dynamicaly - excluding markup
+                if(line->text->text)
+                    adjust_line_length(line);
+
                 // new text
                 text = cstring_init();
-                l = 0;
             }
 
         } else if(c == '\t') {
@@ -113,14 +119,12 @@ deck_t *markdown_load(FILE *input) {
             // expand tab to spaces
             for (i = 0;  i < EXPAND_TABS;  i++) {
                 (text->expand)(text, ' ');
-                l++;
             }
 
         } else if(c == '\\') {
 
             // add char to line
             (text->expand)(text, c);
-            l++;
 
             // if !IS_CODE add next char to line
             // and do not increase line count
@@ -144,7 +148,6 @@ deck_t *markdown_load(FILE *input) {
 
             // add char to line
             (text->expand)(text, c);
-            l++;
 
         } else if(is_utf8(c)) {
 
@@ -156,10 +159,9 @@ deck_t *markdown_load(FILE *input) {
                 c = fgetc(input);
                 (text->expand)(text, c);
             }
-
-            l++;
         }
     }
+    (text->delete)(text);
 
     slide->lines = lc;
     deck->slides = sc;
@@ -172,34 +174,43 @@ deck_t *markdown_load(FILE *input) {
         deck->header = line;
 
         // find first non-header line
-        while(line->text->size > 0 && line->text->text[0] == '%') {
+        while(line && line->text->size > 0 && line->text->text[0] == '%') {
             hc++;
             line = line->next;
         }
 
-        // split linked list
-        line->prev->next = (void*)0;
-        line->prev = (void*)0;
+        // only split header if any non-header line is found
+        if(line) {
 
-        // remove header lines from slide
-        deck->slide->line = line;
+            // split linked list
+            line->prev->next = NULL;
+            line->prev = NULL;
+
+            // remove header lines from slide
+            deck->slide->line = line;
+
+            // adjust counts
+            deck->headers += hc;
+            deck->slide->lines -= hc;
+        } else {
 
-        // adjust counts
-        deck->headers += hc;
-        deck->slide->lines -= hc;
+            // remove header from deck
+            deck->header = NULL;
+        }
     }
 
-    // combine underlined H1/H2 in single line
     slide = deck->slide;
     while(slide) {
         line = slide->line;
         while(line) {
+            // combine underlined H1/H2 in single line
             if((CHECK_BIT(line->bits, IS_H1) ||
                 CHECK_BIT(line->bits, IS_H2)) &&
                CHECK_BIT(line->bits, IS_EMPTY) &&
                line->prev &&
                !CHECK_BIT(line->prev->bits, IS_EMPTY)) {
 
+
                 // remove line from linked list
                 line->prev->next = line->next;
                 if(line->next)
@@ -222,7 +233,65 @@ deck_t *markdown_load(FILE *input) {
                 // delete line
                 (tmp->text->delete)(tmp->text);
                 free(tmp);
+
+            // pass enclosing flag IS_UNORDERED_LIST_3
+            // to nested levels for unordered lists
+            } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_3)) {
+                tmp = line->next;
+                line_t *list_last_level_3 = line;
+
+                while(tmp &&
+                      CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3)) {
+                    if(CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3)) {
+                        list_last_level_3 = tmp;
+                    }
+                    tmp = tmp->next;
+                }
+
+                for(tmp = line; tmp != list_last_level_3; tmp = tmp->next) {
+                    SET_BIT(tmp->bits, IS_UNORDERED_LIST_3);
+                }
+
+            // pass enclosing flag IS_UNORDERED_LIST_2
+            // to nested levels for unordered lists
+            } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_2)) {
+                tmp = line->next;
+                line_t *list_last_level_2 = line;
+
+                while(tmp &&
+                      (CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_2) ||
+                       CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3))) {
+                    if(CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_2)) {
+                        list_last_level_2 = tmp;
+                    }
+                    tmp = tmp->next;
+                }
+
+                for(tmp = line; tmp != list_last_level_2; tmp = tmp->next) {
+                    SET_BIT(tmp->bits, IS_UNORDERED_LIST_2);
+                }
+
+            // pass enclosing flag IS_UNORDERED_LIST_1
+            // to nested levels for unordered lists
+            } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)) {
+                tmp = line->next;
+                line_t *list_last_level_1 = line;
+
+                while(tmp &&
+                      (CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_1) ||
+                       CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_2) ||
+                       CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3))) {
+                    if(CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_1)) {
+                        list_last_level_1 = tmp;
+                    }
+                    tmp = tmp->next;
+                }
+
+                for(tmp = line; tmp != list_last_level_1; tmp = tmp->next) {
+                    SET_BIT(tmp->bits, IS_UNORDERED_LIST_1);
+                }
             }
+
             line = line->next;
         }
         slide = slide->next;
@@ -231,7 +300,12 @@ deck_t *markdown_load(FILE *input) {
     return deck;
 }
 
-int markdown_analyse(cstring_t *text) {
+int markdown_analyse(cstring_t *text, int prev) {
+
+    // static variables can not be redeclaired, but changed outside of a declaration
+    // the program remembers their value on every function calls
+    static int unordered_list_level = 0;
+    static int unordered_list_level_offset[] = {-1, -1, -1, -1};
 
     int i = 0;      // increment
     int bits = 0;   // markdown bits
@@ -242,77 +316,177 @@ int markdown_analyse(cstring_t *text) {
         stars  = 0, minus  = 0,
         spaces = 0, other  = 0; // special character counts
 
+    const int unordered_list_offset = unordered_list_level_offset[unordered_list_level];
+
+    // return IS_EMPTY on null pointers
+    if(!text || !text->text) {
+        SET_BIT(bits, IS_EMPTY);
+        return bits;
+    }
+
     // count leading spaces
     offset = next_nonblank(text, 0);
 
     // strip trailing spaces
     for(eol = text->size; eol > offset && isspace((unsigned char) text->text[eol - 1]); eol--);
 
-    // IS_CODE
-    if(offset >= CODE_INDENT) {
-        SET_BIT(bits, IS_CODE);
-    }
+    // IS_UNORDERED_LIST_#
+    if(text->size >= offset + 2 &&
+       (text->text[offset] == '*' || text->text[offset] == '-') &&
+       text->text[offset + 1] == ' ') {
 
-    for(i = offset; i < eol; i++) {
+        // if different from last lines offset
+        if(offset != unordered_list_offset) {
 
-        if(text->text[i] == ' ') {
-            spaces++;
+            // test if offset matches a lower indent level
+            for(i = unordered_list_level; i >= 0; i--) {
+                if(unordered_list_level_offset[i] == offset) {
+                    unordered_list_level = i;
+                    break;
+                }
+            }
+            // if offset doesn't match any previously stored indent level
+            if(i != unordered_list_level) {
+                unordered_list_level = MIN(unordered_list_level + 1, UNORDERED_LIST_MAX_LEVEL);
+                // memorize the offset as next bigger indent level
+                unordered_list_level_offset[unordered_list_level] = offset;
+            }
+        }
 
-        } else if(CHECK_BIT(bits, IS_CODE)) {
-            other++;
+        // if no previous indent level matches, this must be the first line of the list
+        if(unordered_list_level == 0) {
+            unordered_list_level = 1;
+            unordered_list_level_offset[1] = offset;
+        }
 
-        } else {
-            switch(text->text[i]) {
-                case '=': equals++;  break;
-                case '#': hashes++;  break;
-                case '*': stars++;   break;
-                case '-': minus++;   break;
-                case '\\': other++; i++; break;
-                default:  other++;   break;
-            }
+        switch(unordered_list_level) {
+            case 1: SET_BIT(bits, IS_UNORDERED_LIST_1); break;
+            case 2: SET_BIT(bits, IS_UNORDERED_LIST_2); break;
+            case 3: SET_BIT(bits, IS_UNORDERED_LIST_3); break;
+            default: break;
         }
     }
 
-    // IS_H1
-    if((equals > 0 &&
-        hashes + stars + minus + spaces + other == 0) ||
-       (text &&
-        text->text &&
-        text->text[offset] == '#' &&
-        text->text[offset+1] != '#')) {
+    if(!CHECK_BIT(bits, IS_UNORDERED_LIST_1) &&
+       !CHECK_BIT(bits, IS_UNORDERED_LIST_2) &&
+       !CHECK_BIT(bits, IS_UNORDERED_LIST_3)) {
+
+        // continue list if indent level is still the same as in previous line
+        if ((CHECK_BIT(prev, IS_UNORDERED_LIST_1) ||
+             CHECK_BIT(prev, IS_UNORDERED_LIST_2) ||
+             CHECK_BIT(prev, IS_UNORDERED_LIST_3)) &&
+            offset >= unordered_list_offset) {
+
+            switch(unordered_list_level) {
+                case 1: SET_BIT(bits, IS_UNORDERED_LIST_1); break;
+                case 2: SET_BIT(bits, IS_UNORDERED_LIST_2); break;
+                case 3: SET_BIT(bits, IS_UNORDERED_LIST_3); break;
+                default: break;
+            }
+
+            // this line extends the previous list item
+            SET_BIT(bits, IS_UNORDERED_LIST_EXT);
 
-        SET_BIT(bits, IS_H1);
+        // or reset indent level
+        } else {
+            unordered_list_level = 0;
+        }
     }
 
-    // IS_H2
-    if((minus > 0 &&
-        equals + hashes + stars + spaces + other == 0) ||
-       (text &&
-        text->text &&
-        text->text[offset] == '#' &&
-        text->text[offset+1] == '#')) {
+    if(!CHECK_BIT(bits, IS_UNORDERED_LIST_1) &&
+       !CHECK_BIT(bits, IS_UNORDERED_LIST_2) &&
+       !CHECK_BIT(bits, IS_UNORDERED_LIST_3)) {
 
-        SET_BIT(bits, IS_H2);
-    }
+        // IS_CODE
+        if(offset >= CODE_INDENT &&
+           (CHECK_BIT(prev, IS_EMPTY) ||
+            CHECK_BIT(prev, IS_CODE))) {
+            SET_BIT(bits, IS_CODE);
 
-    // IS_QUOTE
-    if(text &&
-       text->text &&
-       text->text[offset] == '>') {
+        } else {
 
-        SET_BIT(bits, IS_QUOTE);
-    }
+            // IS_QUOTE
+            if(text->text[offset] == '>') {
+                SET_BIT(bits, IS_QUOTE);
+            }
 
-    // IS_HR
-    if((minus >= 3 && equals + hashes + stars + other == 0) ||
-       (stars >= 3 && equals + hashes + minus + other == 0)) {
+            // IS_CENTER
+            if(text->size >= offset + 3 &&
+               text->text[offset] == '-' &&
+               text->text[offset + 1] == '>' &&
+               text->text[offset + 2] == ' ') {
+                SET_BIT(bits, IS_CENTER);
 
-        SET_BIT(bits, IS_HR);
-    }
+                // remove start tag
+                (text->strip)(text, offset, 3);
+                eol -= 3;
 
-    // IS_EMPTY
-    if(other == 0) {
-        SET_BIT(bits, IS_EMPTY);
+                if(text->size >= offset + 3 &&
+                   text->text[eol - 1] == '-' &&
+                   text->text[eol - 2] == '<' &&
+                   text->text[eol - 3] == ' ') {
+
+                    // remove end tags
+                    (text->strip)(text, eol - 3, 3);
+
+                    // adjust end of line
+                    for(eol = text->size; eol > offset && isspace((unsigned char) text->text[eol - 1]); eol--);
+
+                }
+            }
+
+            for(i = offset; i < eol; i++) {
+
+                if(text->text[i] == ' ') {
+                    spaces++;
+
+                } else {
+                    switch(text->text[i]) {
+                        case '=': equals++;  break;
+                        case '#': hashes++;  break;
+                        case '*': stars++;   break;
+                        case '-': minus++;   break;
+                        case '\\': other++; i++; break;
+                        default:  other++;   break;
+                    }
+                }
+            }
+
+            // IS_H1
+            if(equals > 0 &&
+                hashes + stars + minus + spaces + other == 0) {
+                SET_BIT(bits, IS_H1);
+            }
+            if(text->text[offset] == '#' &&
+                text->text[offset+1] == ' ') {
+                SET_BIT(bits, IS_H1);
+                SET_BIT(bits, IS_H1_ATX);
+            }
+
+            // IS_H2
+            if(minus > 0 &&
+                equals + hashes + stars + spaces + other == 0) {
+                SET_BIT(bits, IS_H2);
+            }
+            if(text->text[offset] == '#' &&
+                text->text[offset+1] == '#' &&
+                text->text[offset+2] == ' ') {
+                SET_BIT(bits, IS_H2);
+                SET_BIT(bits, IS_H2_ATX);
+            }
+
+            // IS_HR
+            if((minus >= 3 && equals + hashes + stars + other == 0) ||
+               (stars >= 3 && equals + hashes + minus + other == 0)) {
+
+                SET_BIT(bits, IS_HR);
+            }
+
+            // IS_EMPTY
+            if(other == 0) {
+                SET_BIT(bits, IS_EMPTY);
+            }
+        }
     }
 
     return bits;
@@ -374,8 +548,52 @@ void markdown_debug(deck_t *deck, int debug) {
     }
 }
 
-int is_utf8(char ch) {
-    return (ch & 0x80);
+void adjust_line_length(line_t *line) {
+    int l = 0;
+    const static char *special = "\\*_`"; // list of interpreted chars
+    const char *c = &line->text->text[line->offset];
+    cstack_t *stack = cstack_init();
+
+    // for each char in line
+    for(; *c; c++) {
+        // if char is in special char list
+        if(strchr(special, *c)) {
+
+            // closing special char (or second backslash)
+            if((stack->top)(stack, *c)) {
+                if(*c == '\\') l++;
+                (stack->pop)(stack);
+
+            // treat special as regular char
+            } else if((stack->top)(stack, '\\')) {
+                l++;
+                (stack->pop)(stack);
+
+            // opening special char
+            } else {
+                (stack->push)(stack, *c);
+            }
+
+        } else {
+            // remove backslash from stack
+            if((stack->top)(stack, '\\'))
+                (stack->pop)(stack);
+            l++;
+        }
+    }
+
+    if(CHECK_BIT(line->bits, IS_H1_ATX))
+        l -= 2;
+    if(CHECK_BIT(line->bits, IS_H2_ATX))
+        l -= 3;
+
+    line->length = l;
+
+    (stack->delete)(stack);
+}
+
+bool is_utf8(char ch) {
+    return (ch & 0x80) != 0x00;
 }
 
 int length_utf8(char ch) {
@@ -397,6 +615,13 @@ int next_nonblank(cstring_t *text, int i) {
     return i;
 }
 
+int prev_blank(cstring_t *text, int i) {
+    while ((i > 0) && !isspace((unsigned char) (text->text)[i]))
+        i--;
+
+    return i;
+}
+
 int next_blank(cstring_t *text, int i) {
     while ((i < text->size) && !isspace((unsigned char) (text->text)[i]))
         i++;
@@ -407,4 +632,3 @@ int next_blank(cstring_t *text, int i) {
 int next_word(cstring_t *text, int i) {
     return next_nonblank(text, next_blank(text, i));
 }
-