Added check of list string length.
[smdp.git] / src / parser.c
1 /*
2  * Functions necessary to parse a file and transform its content into
3  * a deck of slides containing lines. All based on markdown formating
4  * rules.
5  * Copyright (C) 2016 Michael Goehler
6  *
7  * This file is part of mdp.
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program. If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 #include <ctype.h>
25 #include <errno.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <wchar.h>
29 #include <wctype.h>
30 #include <string.h>
31
32 #include "parser.h"
33
34 deck_t *markdown_load(FILE *input) {
35
36     wchar_t c = L'\0';    // char
37     int i = 0;    // increment
38     int hc = 0;   // header count
39     int lc = 0;   // line count
40     int sc = 1;   // slide count
41     int bits = 0; // markdown bits
42     int prev = 0; // markdown bits of previous line
43
44     deck_t *deck = new_deck();
45     slide_t *slide = deck->slide;
46     line_t *line = NULL;
47     line_t *tmp = NULL;
48     cstring_t *text = cstring_init();
49
50     // initialize bits as empty line
51     SET_BIT(bits, IS_EMPTY);
52
53     while ((c = fgetwc(input)) != WEOF) {
54         if (ferror(input)) {
55             fprintf(stderr, "markdown_load() failed to read input: %s\n", strerror(errno));
56             exit(EXIT_FAILURE);
57         }
58
59         if(c == L'\n') {
60
61             // markdown analyse
62             prev = bits;
63             bits = markdown_analyse(text, prev);
64
65             // if first line in file is markdown hr
66             if(!line && CHECK_BIT(bits, IS_HR)) {
67
68                 // clear text
69                 (text->reset)(text);
70
71             } else if(line && CHECK_BIT(bits, IS_STOP)) {
72
73                 // set stop bit on last line
74                 SET_BIT(line->bits, IS_STOP);
75
76                 // clear text
77                 (text->reset)(text);
78
79             // if text is markdown hr
80             } else if(CHECK_BIT(bits, IS_HR) &&
81                       CHECK_BIT(line->bits, IS_EMPTY)) {
82
83                 slide->lines = lc;
84
85                 // clear text
86                 (text->reset)(text);
87
88                 // create next slide
89                 slide = next_slide(slide);
90                 sc++;
91
92             } else if(CHECK_BIT(bits, IS_TILDE_CODE) &&
93                       CHECK_BIT(bits, IS_EMPTY)) {
94                 // remove tilde code markers
95                 (text->reset)(text);
96
97             } else {
98
99                 // if slide ! has line
100                 if(!slide->line || !line) {
101
102                     // create new line
103                     line = new_line();
104                     slide->line = line;
105                     lc = 1;
106
107                 } else {
108
109                     // create next line
110                     line = next_line(line);
111                     lc++;
112
113                 }
114
115                 // add text to line
116                 line->text = text;
117
118                 // add bits to line
119                 line->bits = bits;
120
121                 // calc offset
122                 line->offset = next_nonblank(text, 0);
123
124                 // adjust line length dynamicaly - excluding markup
125                 if(line->text->value)
126                     adjust_line_length(line);
127
128                 // new text
129                 text = cstring_init();
130             }
131
132         } else if(c == L'\t') {
133
134             // expand tab to spaces
135             for (i = 0;  i < EXPAND_TABS;  i++) {
136                 (text->expand)(text, L' ');
137             }
138
139         } else if(c == L'\\') {
140
141             // add char to line
142             (text->expand)(text, c);
143
144             // if !IS_CODE add next char to line
145             // and do not increase line count
146             if(next_nonblank(text, 0) < CODE_INDENT) {
147
148                 c = fgetwc(input);
149                 (text->expand)(text, c);
150             }
151
152         } else if(iswprint(c) || iswspace(c)) {
153
154             // add char to line
155             (text->expand)(text, c);
156         }
157     }
158     (text->delete)(text);
159
160     slide->lines = lc;
161     deck->slides = sc;
162
163     // detect header
164     line = deck->slide->line;
165     if(line && line->text->size > 0 && line->text->value[0] == L'%') {
166
167         // assign header to deck
168         deck->header = line;
169
170         // find first non-header line
171         while(line && line->text->size > 0 && line->text->value[0] == L'%') {
172             hc++;
173             line = line->next;
174         }
175
176         // only split header if any non-header line is found
177         if(line) {
178
179             // split linked list
180             line->prev->next = NULL;
181             line->prev = NULL;
182
183             // remove header lines from slide
184             deck->slide->line = line;
185
186             // adjust counts
187             deck->headers += hc;
188             deck->slide->lines -= hc;
189         } else {
190
191             // remove header from deck
192             deck->header = NULL;
193         }
194     }
195
196     slide = deck->slide;
197     while(slide) {
198         line = slide->line;
199
200         // ignore mdpress format attributes
201         if(line &&
202            slide->lines > 1 &&
203            !CHECK_BIT(line->bits, IS_EMPTY) &&
204            line->text->value[line->offset] == L'=' &&
205            line->text->value[line->offset + 1] == L' ') {
206
207             // remove line from linked list
208             slide->line = line->next;
209             line->next->prev = NULL;
210
211             // maintain loop condition
212             tmp = line;
213             line = line->next;
214
215             // adjust line count
216             slide->lines -= 1;
217
218             // delete line
219             (tmp->text->delete)(tmp->text);
220             free(tmp);
221         }
222
223         while(line) {
224             // combine underlined H1/H2 in single line
225             if((CHECK_BIT(line->bits, IS_H1) ||
226                 CHECK_BIT(line->bits, IS_H2)) &&
227                CHECK_BIT(line->bits, IS_EMPTY) &&
228                line->prev &&
229                !CHECK_BIT(line->prev->bits, IS_EMPTY)) {
230
231
232                 // remove line from linked list
233                 line->prev->next = line->next;
234                 if(line->next)
235                     line->next->prev = line->prev;
236
237                 // set bits on previous line
238                 if(CHECK_BIT(line->bits, IS_H1)) {
239                     SET_BIT(line->prev->bits, IS_H1);
240                 } else {
241                     SET_BIT(line->prev->bits, IS_H2);
242                 }
243
244                 // adjust line count
245                 slide->lines -= 1;
246
247                 // maintain loop condition
248                 tmp = line;
249                 line = line->prev;
250
251                 // delete line
252                 (tmp->text->delete)(tmp->text);
253                 free(tmp);
254
255             // pass enclosing flag IS_UNORDERED_LIST_3
256             // to nested levels for unordered lists
257             } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_3)) {
258                 tmp = line->next;
259                 line_t *list_last_level_3 = line;
260
261                 while(tmp &&
262                       CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3)) {
263                     if(CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3)) {
264                         list_last_level_3 = tmp;
265                     }
266                     tmp = tmp->next;
267                 }
268
269                 for(tmp = line; tmp != list_last_level_3; tmp = tmp->next) {
270                     SET_BIT(tmp->bits, IS_UNORDERED_LIST_3);
271                 }
272
273             // pass enclosing flag IS_UNORDERED_LIST_2
274             // to nested levels for unordered lists
275             } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_2)) {
276                 tmp = line->next;
277                 line_t *list_last_level_2 = line;
278
279                 while(tmp &&
280                       (CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_2) ||
281                        CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3))) {
282                     if(CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_2)) {
283                         list_last_level_2 = tmp;
284                     }
285                     tmp = tmp->next;
286                 }
287
288                 for(tmp = line; tmp != list_last_level_2; tmp = tmp->next) {
289                     SET_BIT(tmp->bits, IS_UNORDERED_LIST_2);
290                 }
291
292             // pass enclosing flag IS_UNORDERED_LIST_1
293             // to nested levels for unordered lists
294             } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)) {
295                 tmp = line->next;
296                 line_t *list_last_level_1 = line;
297
298                 while(tmp &&
299                       (CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_1) ||
300                        CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_2) ||
301                        CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_3))) {
302                     if(CHECK_BIT(tmp->bits, IS_UNORDERED_LIST_1)) {
303                         list_last_level_1 = tmp;
304                     }
305                     tmp = tmp->next;
306                 }
307
308                 for(tmp = line; tmp != list_last_level_1; tmp = tmp->next) {
309                     SET_BIT(tmp->bits, IS_UNORDERED_LIST_1);
310                 }
311             }
312
313             line = line->next;
314         }
315         slide = slide->next;
316     }
317
318     return deck;
319 }
320
321 int markdown_analyse(cstring_t *text, int prev) {
322
323     // static variables can not be redeclaired, but changed outside of a declaration
324     // the program remembers their value on every function calls
325     static int unordered_list_level = 0;
326     static int unordered_list_level_offset[] = {-1, -1, -1, -1};
327     static int num_tilde_characters = 0;
328
329     int i = 0;      // increment
330     int bits = 0;   // markdown bits
331     int offset = 0; // text offset
332     int eol    = 0; // end of line
333
334     int equals = 0, hashes = 0,
335         stars  = 0, minus  = 0,
336         spaces = 0, other  = 0; // special character counts
337
338     const int unordered_list_offset = unordered_list_level_offset[unordered_list_level];
339
340     // return IS_EMPTY on null pointers
341     if(!text || !text->value) {
342         SET_BIT(bits, IS_EMPTY);
343
344         // continue fenced code blocks across empty lines
345         if(num_tilde_characters > 0)
346             SET_BIT(bits, IS_CODE);
347
348         return bits;
349     }
350
351     // count leading spaces
352     offset = next_nonblank(text, 0);
353
354     // IS_TILDE_CODE
355     if (wcsncmp(text->value, L"~~~", 3) == 0) {
356         int tildes_in_line = next_nontilde(text, 0);
357         if (tildes_in_line >= num_tilde_characters) {
358             if (num_tilde_characters > 0) {
359                 num_tilde_characters = 0;
360             } else {
361                 num_tilde_characters = tildes_in_line;
362             }
363             SET_BIT(bits, IS_EMPTY);
364             SET_BIT(bits, IS_TILDE_CODE);
365             return bits;
366         }
367     }
368
369     if (num_tilde_characters > 0) {
370         SET_BIT(bits, IS_CODE);
371         SET_BIT(bits, IS_TILDE_CODE);
372         return bits;
373     }
374
375     // IS_STOP
376     if((offset < CODE_INDENT || !CHECK_BIT(prev, IS_CODE)) &&
377        (!wcsncmp(&text->value[offset], L"<br>", 4) ||
378         !wcsncmp(&text->value[offset], L"<BR>", 4) ||
379         !wcsncmp(&text->value[offset], L"^", 1))) {
380         SET_BIT(bits, IS_STOP);
381         return bits;
382     }
383
384     // strip trailing spaces
385     for(eol = text->size; eol > offset && iswspace(text->value[eol - 1]); eol--);
386
387     // IS_UNORDERED_LIST_#
388     if(text->size >= offset + 2 &&
389        (text->value[offset] == L'*' || text->value[offset] == L'-') &&
390        iswspace(text->value[offset + 1])) {
391
392         // if different from last lines offset
393         if(offset != unordered_list_offset) {
394
395             // test if offset matches a lower indent level
396             for(i = unordered_list_level; i >= 0; i--) {
397                 if(unordered_list_level_offset[i] == offset) {
398                     unordered_list_level = i;
399                     break;
400                 }
401             }
402             // if offset doesn't match any previously stored indent level
403             if(i != unordered_list_level) {
404                 unordered_list_level = MIN(unordered_list_level + 1, UNORDERED_LIST_MAX_LEVEL);
405                 // memorize the offset as next bigger indent level
406                 unordered_list_level_offset[unordered_list_level] = offset;
407             }
408         }
409
410         // if no previous indent level matches, this must be the first line of the list
411         if(unordered_list_level == 0) {
412             unordered_list_level = 1;
413             unordered_list_level_offset[1] = offset;
414         }
415
416         switch(unordered_list_level) {
417             case 1: SET_BIT(bits, IS_UNORDERED_LIST_1); break;
418             case 2: SET_BIT(bits, IS_UNORDERED_LIST_2); break;
419             case 3: SET_BIT(bits, IS_UNORDERED_LIST_3); break;
420             default: break;
421         }
422     }
423
424     if(!CHECK_BIT(bits, IS_UNORDERED_LIST_1) &&
425        !CHECK_BIT(bits, IS_UNORDERED_LIST_2) &&
426        !CHECK_BIT(bits, IS_UNORDERED_LIST_3)) {
427
428         // continue list if indent level is still the same as in previous line
429         if ((CHECK_BIT(prev, IS_UNORDERED_LIST_1) ||
430              CHECK_BIT(prev, IS_UNORDERED_LIST_2) ||
431              CHECK_BIT(prev, IS_UNORDERED_LIST_3)) &&
432             offset >= unordered_list_offset) {
433
434             switch(unordered_list_level) {
435                 case 1: SET_BIT(bits, IS_UNORDERED_LIST_1); break;
436                 case 2: SET_BIT(bits, IS_UNORDERED_LIST_2); break;
437                 case 3: SET_BIT(bits, IS_UNORDERED_LIST_3); break;
438                 default: break;
439             }
440
441             // this line extends the previous list item
442             SET_BIT(bits, IS_UNORDERED_LIST_EXT);
443
444         // or reset indent level
445         } else {
446             unordered_list_level = 0;
447         }
448     }
449
450     if(!CHECK_BIT(bits, IS_UNORDERED_LIST_1) &&
451        !CHECK_BIT(bits, IS_UNORDERED_LIST_2) &&
452        !CHECK_BIT(bits, IS_UNORDERED_LIST_3)) {
453
454         // IS_CODE
455         if(offset >= CODE_INDENT &&
456            (CHECK_BIT(prev, IS_EMPTY) ||
457             CHECK_BIT(prev, IS_CODE)  ||
458             CHECK_BIT(prev, IS_STOP))) {
459             SET_BIT(bits, IS_CODE);
460
461         } else {
462
463             // IS_QUOTE
464             if(text->value[offset] == L'>') {
465                 SET_BIT(bits, IS_QUOTE);
466             }
467
468             // IS_CENTER
469             if(text->size >= offset + 3 &&
470                text->value[offset] == L'-' &&
471                text->value[offset + 1] == L'>' &&
472                iswspace(text->value[offset + 2])) {
473                 SET_BIT(bits, IS_CENTER);
474
475                 // remove start tag
476                 (text->strip)(text, offset, 3);
477                 eol -= 3;
478
479                 if(text->size >= offset + 3 &&
480                    text->value[eol - 1] == L'-' &&
481                    text->value[eol - 2] == L'<' &&
482                    iswspace(text->value[eol - 3])) {
483
484                     // remove end tags
485                     (text->strip)(text, eol - 3, 3);
486
487                     // adjust end of line
488                     for(eol = text->size; eol > offset && iswspace(text->value[eol - 1]); eol--);
489
490                 }
491             }
492
493             for(i = offset; i < eol; i++) {
494
495                 if(iswspace(text->value[i])) {
496                     spaces++;
497
498                 } else {
499                     switch(text->value[i]) {
500                         case L'=': equals++;  break;
501                         case L'#': hashes++;  break;
502                         case L'*': stars++;   break;
503                         case L'-': minus++;   break;
504                         case L'\\': other++; i++; break;
505                         default:  other++;   break;
506                     }
507                 }
508             }
509
510             // IS_H1
511             if(equals > 0 &&
512                hashes + stars + minus + spaces + other == 0) {
513                 SET_BIT(bits, IS_H1);
514             }
515             if(text->value[offset] == L'#' &&
516                iswspace(text->value[offset+1])) {
517                 SET_BIT(bits, IS_H1);
518                 SET_BIT(bits, IS_H1_ATX);
519             }
520
521             // IS_H2
522             if(minus > 0 &&
523                equals + hashes + stars + spaces + other == 0) {
524                 SET_BIT(bits, IS_H2);
525             }
526             if(text->value[offset] == L'#' &&
527                text->value[offset+1] == L'#' &&
528                iswspace(text->value[offset+2])) {
529                 SET_BIT(bits, IS_H2);
530                 SET_BIT(bits, IS_H2_ATX);
531             }
532
533             // IS_HR
534             if((minus >= 3 && equals + hashes + stars + other == 0) ||
535                (stars >= 3 && equals + hashes + minus + other == 0)) {
536
537                 SET_BIT(bits, IS_HR);
538             }
539
540             // IS_EMPTY
541             if(other == 0) {
542                 SET_BIT(bits, IS_EMPTY);
543             }
544         }
545     }
546
547     return bits;
548 }
549
550 void markdown_debug(deck_t *deck, int debug) {
551
552     int sc = 0; // slide count
553     int lc = 0; // line count
554
555     int offset;
556     line_t *header;
557
558     if(debug == 1) {
559         fwprintf(stderr, L"headers: %i\nslides: %i\n", deck->headers, deck->slides);
560
561     } else if(debug > 1) {
562
563         // print header to STDERR
564         if(deck->header) {
565             header = deck->header;
566             while(header &&
567                 header->length > 0 &&
568                 header->text->value[0] == L'%') {
569
570                 // skip descriptor word (e.g. %title:)
571                 offset = next_blank(header->text, 0) + 1;
572
573                 fwprintf(stderr, L"header: %S\n", &header->text->value[offset]);
574                 header = header->next;
575             }
576         }
577     }
578
579     slide_t *slide = deck->slide;
580     line_t *line;
581
582     // print slide/line count to STDERR
583     while(slide) {
584         sc++;
585
586         if(debug == 1) {
587             fwprintf(stderr, L"  slide %i: %i lines\n", sc, slide->lines);
588
589         } else if(debug > 1) {
590
591             // also print bits and line length
592             fwprintf(stderr, L"  slide %i:\n", sc);
593             line = slide->line;
594             lc = 0;
595             while(line) {
596                 lc++;
597                 fwprintf(stderr, L"    line %i: bits = %i, length = %i\n", lc, line->bits, line->length);
598                 line = line->next;
599             }
600         }
601
602         slide = slide->next;
603     }
604 }
605
606 void adjust_line_length(line_t *line) {
607     int l = 0;
608     const static wchar_t *special = L"\\*_`"; // list of interpreted chars
609     const wchar_t *c = &line->text->value[0];
610     cstack_t *stack = cstack_init();
611
612     // for each char in line
613     for(; *c; c++) {
614         // if char is in special char list
615         if(wcschr(special, *c)) {
616
617             // closing special char (or second backslash)
618             if((stack->top)(stack, *c)) {
619                 if(*c == L'\\') l++;
620                 (stack->pop)(stack);
621
622             // treat special as regular char
623             } else if((stack->top)(stack, L'\\')) {
624                 l++;
625                 (stack->pop)(stack);
626
627             // opening special char
628             } else {
629                 (stack->push)(stack, *c);
630             }
631
632         } else {
633             // remove backslash from stack
634             if((stack->top)(stack, L'\\'))
635                 (stack->pop)(stack);
636             l++;
637         }
638     }
639
640     if(CHECK_BIT(line->bits, IS_H1_ATX))
641         l -= 2;
642     if(CHECK_BIT(line->bits, IS_H2_ATX))
643         l -= 3;
644
645     line->length = l;
646
647     (stack->delete)(stack);
648 }
649
650 int next_nonblank(cstring_t *text, int i) {
651     while ((i < text->size) && iswspace((text->value)[i]))
652         i++;
653
654     return i;
655 }
656
657 int prev_blank(cstring_t *text, int i) {
658     while ((i > 0) && !iswspace((text->value)[i]))
659         i--;
660
661     return i;
662 }
663
664 int next_blank(cstring_t *text, int i) {
665     while ((i < text->size) && !iswspace((text->value)[i]))
666         i++;
667
668     return i;
669 }
670
671 int next_word(cstring_t *text, int i) {
672     return next_nonblank(text, next_blank(text, i));
673 }
674
675 int next_nontilde(cstring_t *text, int i) {
676     while ((i < text->size) && text->value[i] == L'~')
677         i++;
678
679     return i;
680 }
681