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