478da5b3c22bf868a9feda245500f33b99c104f2
[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) 2014 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 <stdio.h>
26 #include <stdlib.h>
27
28 #include "parser.h"
29
30 deck_t *markdown_load(FILE *input) {
31
32     int c = 0;    // char
33     int i = 0;    // increment
34     int l = 0;    // line length
35     int hc = 0;   // header count
36     int lc = 0;   // line count
37     int sc = 0;   // slide count
38     int bits = 0; // markdown bits
39
40     deck_t *deck = new_deck();
41     slide_t *slide = new_slide();
42     line_t *line = NULL;
43     line_t *tmp = NULL;
44     cstring_t *text = cstring_init();
45
46     // assign first slide to deck
47     deck->slide = slide;
48     sc++;
49
50     while ((c = fgetc(input)) != EOF) {
51         if(c == '\n') {
52
53             // markdown analyse
54             bits = markdown_analyse(text);
55
56             // if first line in file is markdown hr
57             if(!line && CHECK_BIT(bits, IS_HR)) {
58
59                 // clear text
60                 (text->reset)(text);
61
62             // if text is markdown hr
63             } else if(CHECK_BIT(bits, IS_HR) &&
64                       CHECK_BIT(line->bits, IS_EMPTY)) {
65
66                 slide->lines = lc;
67
68                 // clear text
69                 (text->reset)(text);
70                 l = 0;
71
72                 // create next slide
73                 slide = next_slide(slide);
74                 sc++;
75
76             } else {
77
78                 // if slide ! has line
79                 if(!slide->line) {
80
81                     // create new line
82                     line = new_line();
83                     slide->line = line;
84                     lc = 1;
85
86                 } else {
87
88                     // create next line
89                     line = next_line(line);
90                     lc++;
91
92                 }
93
94                 // add text to line
95                 line->text = text;
96
97                 // add bits to line
98                 line->bits = bits;
99
100                 // add length to line
101                 line->length = l;
102
103                 // calc offset
104                 line->offset = next_nonblank(text, 0);
105
106                 // new text
107                 text = cstring_init();
108                 l = 0;
109             }
110
111         } else if(c == '\t') {
112
113             // expand tab to spaces
114             for (i = 0;  i < EXPAND_TABS;  i++) {
115                 (text->expand)(text, ' ');
116                 l++;
117             }
118
119         } else if(c == '\\') {
120
121             // add char to line
122             (text->expand)(text, c);
123             l++;
124
125             // if !IS_CODE add next char to line
126             // and do not increase line count
127             if(next_nonblank(text, 0) < CODE_INDENT) {
128
129                 c = fgetc(input);
130                 (text->expand)(text, c);
131
132                 if(is_utf8(c)) {
133
134                     // if utf-8 char > 1 byte add remaing to line
135                     for(i = 0; i < length_utf8(c) - 1; i++) {
136                         c = fgetc(input);
137                         (text->expand)(text, c);
138                     }
139                 }
140
141             }
142
143         } else if(isprint(c) || isspace((unsigned char) c)) {
144
145             // add char to line
146             (text->expand)(text, c);
147             l++;
148
149         } else if(is_utf8(c)) {
150
151             // add char to line
152             (text->expand)(text, c);
153
154             // if utf-8 char > 1 byte add remaing to line
155             for(i = 0; i < length_utf8(c) - 1; i++) {
156                 c = fgetc(input);
157                 (text->expand)(text, c);
158             }
159
160             l++;
161         }
162     }
163
164     slide->lines = lc;
165     deck->slides = sc;
166
167     // detect header
168     line = deck->slide->line;
169     if(line && line->text->size > 0 && line->text->text[0] == '%') {
170
171         // assign header to deck
172         deck->header = line;
173
174         // find first non-header line
175         while(line->text->size > 0 && line->text->text[0] == '%') {
176             hc++;
177             line = line->next;
178         }
179
180         // split linked list
181         line->prev->next = (void*)0;
182         line->prev = (void*)0;
183
184         // remove header lines from slide
185         deck->slide->line = line;
186
187         // adjust counts
188         deck->headers += hc;
189         deck->slide->lines -= hc;
190     }
191
192     // combine underlined H1/H2 in single line
193     slide = deck->slide;
194     while(slide) {
195         line = slide->line;
196         while(line) {
197             if((CHECK_BIT(line->bits, IS_H1) ||
198                 CHECK_BIT(line->bits, IS_H2)) &&
199                CHECK_BIT(line->bits, IS_EMPTY) &&
200                line->prev &&
201                !CHECK_BIT(line->prev->bits, IS_EMPTY)) {
202
203                 // remove line from linked list
204                 line->prev->next = line->next;
205                 if(line->next)
206                     line->next->prev = line->prev;
207
208                 // set bits on previous line
209                 if(CHECK_BIT(line->bits, IS_H1)) {
210                     SET_BIT(line->prev->bits, IS_H1);
211                 } else {
212                     SET_BIT(line->prev->bits, IS_H2);
213                 }
214
215                 // adjust line count
216                 slide->lines -= 1;
217
218                 // maintain loop condition
219                 tmp = line;
220                 line = line->prev;
221
222                 // delete line
223                 (tmp->text->delete)(tmp->text);
224                 free(tmp);
225             }
226             line = line->next;
227         }
228         slide = slide->next;
229     }
230
231     return deck;
232 }
233
234 int markdown_analyse(cstring_t *text) {
235
236     int i = 0;      // increment
237     int bits = 0;   // markdown bits
238     int offset = 0; // text offset
239     int eol    = 0; // end of line
240
241     int equals = 0, hashes = 0,
242         stars  = 0, minus  = 0,
243         spaces = 0, other  = 0; // special character counts
244
245     // count leading spaces
246     offset = next_nonblank(text, 0);
247
248     // strip trailing spaces
249     for(eol = text->size; eol > offset && isspace((unsigned char) text->text[eol - 1]); eol--);
250
251     // IS_CODE
252     if(offset >= CODE_INDENT) {
253         SET_BIT(bits, IS_CODE);
254     }
255
256     for(i = offset; i < eol; i++) {
257
258         if(text->text[i] == ' ') {
259             spaces++;
260
261         } else if(CHECK_BIT(bits, IS_CODE)) {
262             other++;
263
264         } else {
265             switch(text->text[i]) {
266                 case '=': equals++;  break;
267                 case '#': hashes++;  break;
268                 case '*': stars++;   break;
269                 case '-': minus++;   break;
270                 case '\\': other++; i++; break;
271                 default:  other++;   break;
272             }
273         }
274     }
275
276     // IS_H1
277     if((equals > 0 &&
278         hashes + stars + minus + spaces + other == 0) ||
279        (text &&
280         text->text &&
281         text->text[offset] == '#' &&
282         text->text[offset+1] != '#')) {
283
284         SET_BIT(bits, IS_H1);
285     }
286
287     // IS_H2
288     if((minus > 0 &&
289         equals + hashes + stars + spaces + other == 0) ||
290        (text &&
291         text->text &&
292         text->text[offset] == '#' &&
293         text->text[offset+1] == '#')) {
294
295         SET_BIT(bits, IS_H2);
296     }
297
298     // IS_QUOTE
299     if(text &&
300        text->text &&
301        text->text[offset] == '>') {
302
303         SET_BIT(bits, IS_QUOTE);
304     }
305
306     // IS_HR
307     if((minus >= 3 && equals + hashes + stars + other == 0) ||
308        (stars >= 3 && equals + hashes + minus + other == 0)) {
309
310         SET_BIT(bits, IS_HR);
311     }
312
313     // IS_EMPTY
314     if(other == 0) {
315         SET_BIT(bits, IS_EMPTY);
316     }
317
318     return bits;
319 }
320
321 void markdown_debug(deck_t *deck, int debug) {
322
323     int sc = 0; // slide count
324     int lc = 0; // line count
325
326     int offset;
327     line_t *header;
328
329     if(debug == 1) {
330         fprintf(stderr, "headers: %i\nslides: %i\n", deck->headers, deck->slides);
331
332     } else if(debug > 1) {
333
334         // print header to STDERR
335         if(deck->header) {
336             header = deck->header;
337             while(header &&
338                 header->length > 0 &&
339                 header->text->text[0] == '%') {
340
341                 // skip descriptor word (e.g. %title:)
342                 offset = next_blank(header->text, 0) + 1;
343
344                 fprintf(stderr, "header: %s\n", &header->text->text[offset]);
345                 header = header->next;
346             }
347         }
348     }
349
350     slide_t *slide = deck->slide;
351     line_t *line;
352
353     // print slide/line count to STDERR
354     while(slide) {
355         sc++;
356
357         if(debug == 1) {
358             fprintf(stderr, "  slide %i: %i lines\n", sc, slide->lines);
359
360         } else if(debug > 1) {
361
362             // also print bits and line length
363             fprintf(stderr, "  slide %i:\n", sc);
364             line = slide->line;
365             lc = 0;
366             while(line) {
367                 lc++;
368                 fprintf(stderr, "    line %i: bits = %i, length = %i\n", lc, line->bits, line->length);
369                 line = line->next;
370             }
371         }
372
373         slide = slide->next;
374     }
375 }
376
377 int is_utf8(char ch) {
378     return (ch & 0x80);
379 }
380
381 int length_utf8(char ch) {
382
383     int i = 0; // increment
384
385     while(is_utf8(ch)) {
386         i++;
387         ch <<= 1;
388     }
389
390     return i;
391 }
392
393 int next_nonblank(cstring_t *text, int i) {
394     while ((i < text->size) && isspace((unsigned char) (text->text)[i]))
395         i++;
396
397     return i;
398 }
399
400 int next_blank(cstring_t *text, int i) {
401     while ((i < text->size) && !isspace((unsigned char) (text->text)[i]))
402         i++;
403
404     return i;
405 }
406
407 int next_word(cstring_t *text, int i) {
408     return next_nonblank(text, next_blank(text, i));
409 }
410