md.c (28036B)
1 #! /usr/bin/env sheepy 2 // 3 4 #include "libsheepyObject.h" 5 #include "shpPackages/md4c/md4c.h" 6 #include "fort.h" 7 8 #include "entities.h" 9 10 /* enable/disable logging */ 11 #undef pLog 12 #define pLog(...) 13 14 15 typ struct { 16 MD_BLOCKTYPE type; 17 unsigned olCount; 18 } blockt; 19 20 sliceT(blockst, blockt); 21 22 typedef struct { 23 smallArrayt *out; 24 smallStringt *current; 25 smallArrayt *span; 26 smallStringt *rspan; // recursive span string, copy to current on last leave span 27 MD_BLOCKTYPE blockquote; 28 MD_BLOCKTYPE h; 29 MD_BLOCKTYPE p; 30 MD_BLOCKTYPE blockcode; 31 MD_BLOCKTYPE tbl; 32 blockst blocks; 33 blockst spans; 34 smallArrayt table; 35 smallArrayt row; 36 int bqlevel; 37 smallJsont *entities; 38 char colorCode[40]; 39 } outt; 40 41 #define BLOCKQUOTE FNT"┃"RST" " 42 43 #define ADD_BLOCKQUOTE \ 44 if(r->blockquote == MD_BLOCK_QUOTE) {\ 45 loop(r->bqlevel) {\ 46 prependG(r->current, BLOCKQUOTE);\ 47 }\ 48 } 49 50 #define ADD_BLOCKCODE \ 51 if(r->blockcode == MD_BLOCK_CODE) {\ 52 pushG(r->current, BLD BGRED WHT "`````````" RST "\n" BLD MGT);\ 53 r->blockcode = 0;\ 54 } 55 56 57 internal int leave_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata); 58 internal int leave_all_spans(MD_SPANTYPE type, void* detail, void* userdata); 59 60 char *e2text[50]; // block 61 char *t2text[50]; // text 62 char *s2text[50]; // span 63 64 internal int 65 enter_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata) 66 { 67 cast(outt *, r, userdata); 68 69 logD(e2text[type]); 70 if (not sliceIsEmpty(&r->blocks)) { 71 logD("stack %s",e2text[sliceLast(&r->blocks).type]); 72 } 73 74 75 logVarG(r->current); 76 logVarG(sliceCount(&r->blocks)); 77 78 switch(type) { 79 case MD_BLOCK_DOC: /* noop */ 80 break; 81 case MD_BLOCK_QUOTE: 82 r->blockquote = MD_BLOCK_QUOTE; 83 ADD_BLOCKQUOTE; 84 pErrorNULL(pushG(r->out, r->current)); 85 rallocG(r->current, ""); 86 inc r->bqlevel; 87 //puts(MGT "blockquote" RST); 88 break; 89 case MD_BLOCK_UL:; 90 if (not sliceIsEmpty(&r->blocks) and sliceLast(&r->blocks).type == MD_BLOCK_LI) { 91 leave_block_callback(MD_BLOCK_LI, null, userdata); 92 } 93 cast(MD_BLOCK_UL_DETAIL *, uld, detail); 94 logVarG(uld->is_tight); 95 logD("uld->mark=%c",uld->mark); 96 if (sliceIsEmpty(&r->blocks)) { 97 // add an empty line before the list items 98 pushG(r->out, ""); 99 } 100 //puts(GRN "ul" RST); 101 sliceAppend(&r->blocks, (blockt){.type=MD_BLOCK_UL}); 102 break; 103 case MD_BLOCK_OL:; 104 if (not sliceIsEmpty(&r->blocks) and sliceLast(&r->blocks).type == MD_BLOCK_LI) { 105 leave_block_callback(MD_BLOCK_LI, null, userdata); 106 } 107 cast(MD_BLOCK_OL_DETAIL *, old, detail); 108 logVarG(old->start); 109 logVarG(old->is_tight); 110 logD("old->mark_delimiter=%c",old->mark_delimiter); 111 if (sliceIsEmpty(&r->blocks)) { 112 // add an empty line before the list items 113 pushG(r->out, ""); 114 } 115 //puts(GRN "ol" RST); 116 blockt t = {.type=MD_BLOCK_OL, .olCount=1}; 117 sliceAppend(&r->blocks, t); 118 break; 119 case MD_BLOCK_LI:; 120 cast(MD_BLOCK_LI_DETAIL *, lid, detail); 121 logVarG(lid->is_task); 122 logD("lid->task_mark=%c",lid->task_mark); 123 logVarG(lid->task_mark_offset); 124 if(!isEmptyG(r->current)) { 125 ADD_BLOCKQUOTE 126 ADD_BLOCKCODE 127 pushG(r->out, r->current); 128 pushG(r->out,""); 129 rallocG(r->current, ""); 130 } 131 //puts(GRN "li" RST); 132 sliceAppend(&r->blocks, (blockt){.type=MD_BLOCK_LI}); 133 break; 134 case MD_BLOCK_HR: 135 //puts(BLU "hr" RST); 136 break; 137 case MD_BLOCK_H: 138 r->h = MD_BLOCK_H; 139 if(!isEmptyG(r->current)) { 140 ADD_BLOCKCODE 141 pushG(r->out, r->current); 142 rallocG(r->current, ""); 143 } 144 //puts(BLU "hN" RST); 145 break; 146 case MD_BLOCK_CODE: 147 r->blockcode = MD_BLOCK_CODE; 148 pushG(r->out, "\n" BLD BGRED WHT "`````````" RST BLD MGT); 149 //puts(MGT "BLOCK_CODE" RST); 150 break; 151 /* case MD_BLOCK_HTML: #<{(| noop |)}># break; */ 152 case MD_BLOCK_P: 153 if ((sliceLast(&r->blocks).type != MD_BLOCK_LI) && !isEmptyG(r->current)) { 154 ADD_BLOCKQUOTE 155 ADD_BLOCKCODE 156 pushG(r->out, r->current); 157 rallocG(r->current, ""); 158 } 159 //puts(GRN "p" RST); 160 break; 161 case MD_BLOCK_TABLE: 162 initiateG(&r->table); 163 r->tbl = MD_BLOCK_TABLE; 164 break; 165 /* case MD_BLOCK_THEAD: RENDER_LITERAL(r, "<thead>\n"); break; */ 166 /* case MD_BLOCK_TBODY: RENDER_LITERAL(r, "<tbody>\n"); break; */ 167 case MD_BLOCK_TR: 168 initiateG(&r->row); 169 break; 170 /* case MD_BLOCK_TH: render_open_td_block(r, "th", (MD_BLOCK_TD_DETAIL*)detail); break; */ 171 /* case MD_BLOCK_TD: render_open_td_block(r, "td", (MD_BLOCK_TD_DETAIL*)detail); break; */ 172 } 173 174 return 0; 175 } 176 177 internal int 178 leave_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata) 179 { 180 cast(outt *, r, userdata); 181 /* MD_RENDER_HTML* r = (MD_RENDER_HTML*) userdata; */ 182 183 logD(e2text[type]); 184 if (not sliceIsEmpty(&r->blocks)) { 185 logD("stack %s",e2text[sliceLast(&r->blocks).type]); 186 } 187 188 logVarG(r->current); 189 logVarG(sliceCount(&r->blocks)); 190 191 leave_all_spans(0, null, userdata); 192 193 switch(type) { 194 case MD_BLOCK_DOC: /*noop*/ 195 break; 196 case MD_BLOCK_QUOTE: 197 ADD_BLOCKQUOTE; 198 pErrorNULL(pushG(r->out, r->current)); 199 rallocG(r->current, ""); 200 dec r->bqlevel; 201 if (!r->bqlevel) 202 r->blockquote = 0; 203 //puts(MGT "/blockquote" RST); 204 break; 205 case MD_BLOCK_UL: 206 if (not sliceIsEmpty(&r->blocks) and sliceLast(&r->blocks).type == MD_BLOCK_UL) { 207 sliceDelLast(&r->blocks); 208 } 209 if (sliceIsEmpty(&r->blocks)) { 210 pushG(r->out, ""); 211 } 212 //puts(GRN "/ul" RST); 213 break; 214 case MD_BLOCK_OL: 215 if (not sliceIsEmpty(&r->blocks) and sliceLast(&r->blocks).type == MD_BLOCK_OL) { 216 sliceDelLast(&r->blocks); 217 } 218 if (sliceIsEmpty(&r->blocks)) { 219 pushG(r->out, ""); 220 } 221 //puts(GRN "/ol" RST); 222 break; 223 case MD_BLOCK_LI: 224 if (not sliceIsEmpty(&r->blocks) and sliceLast(&r->blocks).type == MD_BLOCK_LI) { 225 sliceDelLast(&r->blocks); 226 } 227 //puts(GRN "/li" RST); 228 //logD("'%m'", r->current); 229 if (not isEmptyG(r->current)) { 230 if (sliceLast(&r->blocks).type == MD_BLOCK_UL) { 231 prependG(r->current, "- "); 232 loop(sliceCount(&r->blocks)-1/*list level*/) { 233 prependG(r->current, " "); 234 } 235 } 236 if (sliceLast(&r->blocks).type == MD_BLOCK_OL) { 237 char *s = intToS(sliceLast(&r->blocks).olCount); 238 pErrorNULL(pushG(&s, ". ")); 239 prependG(r->current, s); 240 free(s); 241 loop(sliceCount(&r->blocks)-1/*list level*/) { 242 prependG(r->current, " "); 243 } 244 sliceLast(&r->blocks).olCount++; 245 } 246 ADD_BLOCKQUOTE 247 pushG(r->out, r->current); 248 rallocG(r->current, ""); 249 } 250 break; 251 case MD_BLOCK_HR: 252 pushG(r->out, "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"); 253 break; 254 case MD_BLOCK_H: 255 //puts(BLU "</hN>" RST); 256 r->h = 0; 257 pushG(r->out, ""); 258 prependG(r->current, " "); 259 loop(((MD_BLOCK_H_DETAIL*)detail)->level) { 260 prependG(r->current, "#"); 261 } 262 colorG(r->current, BLD YLW); 263 pushG(r->out, r->current); 264 rallocG(r->current, ""); 265 break; 266 case MD_BLOCK_CODE: 267 if (not isEmptyG(r->current)) { 268 pushG(r->current, RST BLD BGRED WHT "`````````" RST "\n"); 269 pushG(r->out, r->current); 270 rallocG(r->current, ""); 271 } 272 //puts(MGT "/BLOCK_CODE" RST); 273 break; 274 case MD_BLOCK_HTML: /* noop */ 275 break; 276 case MD_BLOCK_P: 277 //puts(GRN "/p" RST); 278 if (sliceLast(&r->blocks).type == MD_BLOCK_LI) { 279 if (sliceAt(&r->blocks, sliceCount(&r->blocks)-2).type == MD_BLOCK_UL) { 280 prependG(r->current, "- "); 281 loop(sliceCount(&r->blocks)-2/*list level*/) { 282 prependG(r->current, " "); 283 } 284 } 285 if (sliceAt(&r->blocks, sliceCount(&r->blocks)-2).type == MD_BLOCK_OL) { 286 char *s = intToS(sliceAt(&r->blocks, sliceCount(&r->blocks)-2).olCount); 287 pErrorNULL(pushG(&s, ". ")); 288 prependG(r->current, s); 289 free(s); 290 loop(sliceCount(&r->blocks)-2/*list level*/) { 291 prependG(r->current, " "); 292 } 293 sliceAt(&r->blocks, sliceCount(&r->blocks)-2).olCount++; 294 } 295 } 296 ADD_BLOCKQUOTE 297 pErrorNULL(pushG(r->out, r->current)); 298 rallocG(r->current, ""); 299 break; 300 case MD_BLOCK_TABLE:; 301 int rows = lenG(&r->table); 302 int cols = 0; 303 iter(&r->table, Row) { 304 cast(smallArrayt*, row, Row); 305 cols = maxV(cols, lenG(row)); 306 } 307 char **t = malloc(rows * cols * sizeof(char*)); 308 int j = 0; 309 iter(&r->table, Row) { 310 cast(smallArrayt*, row, Row); 311 int i = 0; 312 iter(row, c) { 313 *(t + j * cols + i) = ssGet(c); 314 inc i; 315 } 316 if (i < cols) { 317 while (i < cols) { 318 *(t + j * cols + i) = ""; 319 inc i; 320 } 321 } 322 inc j; 323 } 324 ft_table_t *table2 = ft_create_table(); 325 326 ft_set_border_style(table2, FT_SIMPLE_STYLE); 327 //ft_set_border_style(table2, FT_DOUBLE_STYLE); 328 329 ft_table_write(table2, rows, cols, (const char **) t); 330 331 ft_set_cell_prop(table2, 0, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE, FT_ROW_HEADER); 332 range(i, cols) { 333 ft_set_cell_prop(table2, 0, i, FT_CPROP_CONT_TEXT_STYLE, FT_TSTYLE_BOLD); 334 } 335 range(i, rows) { 336 ft_set_cell_prop(table2, i, FT_ANY_COLUMN, FT_CPROP_CELL_BG_COLOR, FT_COLOR_DEFAULT); 337 ft_set_cell_prop(table2, i, FT_ANY_COLUMN, FT_CPROP_CELL_BG_RGBCOLOR, i & 1 ? 0x2f2f2f : 0x1f1f1f); 338 } 339 ft_set_cell_prop(table2, 0, FT_ANY_COLUMN, FT_CPROP_CELL_BG_RGBCOLOR, 0x4867ff); 340 341 // 0x4042f 342 // 0x2f2f2f 343 pErrorNULL(pushG(r->out, ft_to_string(table2))); 344 ft_destroy_table(table2); 345 free(t); 346 //logG(&r->table); 347 r->tbl = 0; 348 freeG(&r->table); 349 break; 350 /* case MD_BLOCK_THEAD: RENDER_LITERAL(r, "</thead>\n"); break; */ 351 /* case MD_BLOCK_TBODY: RENDER_LITERAL(r, "</tbody>\n"); break; */ 352 case MD_BLOCK_TR: 353 pushG(&r->table, &r->row); 354 break; 355 case MD_BLOCK_TH: 356 pErrorNULL(pushG(&r->row, r->current)); 357 rallocG(r->current, ""); 358 break; 359 case MD_BLOCK_TD: 360 pErrorNULL(pushG(&r->row, r->current)); 361 rallocG(r->current, ""); 362 break; 363 } 364 365 return 0; 366 } 367 368 369 internal int 370 enter_span_callback(MD_SPANTYPE type, void* detail, void* userdata) 371 { 372 cast(outt *, r, userdata); 373 374 logD(s2text[type]); 375 376 // check if span a specifies a color 377 // type is changed to MD_SPAN_COLOR 378 if (type == MD_SPAN_A) { 379 MD_SPAN_A_DETAIL *a = detail; 380 /* logVarG(a->href.text); */ 381 /* logVarG(a->href.size); */ 382 // TODO detect font 383 i32 fg = -1; 384 i32 bg = -1; 385 if (a->href.text[0] == '#' and a->href.size < 17 /* maximum size of hexadecimal rgb colors */) { 386 if (a->href.size > 1) { 387 char s[30]; 388 char colorString[17] = init0Var; 389 if (a->href.text[1] == 'x') { 390 if (a->href.size > 2) { 391 memcpy(colorString, a->href.text, a->href.size); 392 // search for background color 393 // minimum: #x?#? 394 i32 bgoff = -1; 395 if (a->href.size > 5) { 396 rangeFrom(i, 3, a->href.size) { 397 if (a->href.text[i] == '#') { 398 bgoff = i; 399 break; 400 } 401 } 402 if (bgoff > 0) { 403 if (bgoff+2 > a->href.size) 404 bgoff = -1; 405 else { 406 if (a->href.text[bgoff+1] < '0' and a->href.text[bgoff+1] > '9' and a->href.text[bgoff+1] != 'x') { 407 bgoff = -1; 408 } 409 elif (a->href.text[bgoff+1] == 'x' and bgoff+3 > a->href.size) 410 bgoff = -1; 411 } 412 } 413 } 414 colorString[0] = '0'; 415 fg = parseHex(colorString); 416 colorString[0] = '#'; 417 if (bgoff < 0) { 418 sprintf(r->colorCode, "\x1b[38;2;%u;%u;%um", fg >> 16, (fg&0xFF00)>>8, fg&0xFF); 419 } 420 else { 421 if (a->href.text[bgoff+1] >= '0' and a->href.text[bgoff+1] <= '9') { 422 bg = parseInt(a->href.text + bgoff); 423 if (bg >= 0 and bg < 8) { 424 sprintf(r->colorCode, "\x1b[38;2;%u;%u;%um\x1B[4%dm", fg >> 16, (fg&0xFF00)>>8, fg&0xFF, bg); 425 } 426 } 427 elif (a->href.text[bgoff+1] == 'x') { 428 colorString[bgoff] = '0'; 429 bg = parseHex(colorString + bgoff); 430 colorString[bgoff] = '#'; 431 sprintf(r->colorCode, "\x1b[38;2;%u;%u;%um\x1b[48;2;%u;%u;%um", fg >> 16, (fg&0xFF00)>>8, fg&0xFF, bg >> 16, (bg&0xFF00)>>8, bg&0xFF); 432 } 433 } 434 type = MD_SPAN_COLOR; 435 } 436 } 437 elif (a->href.text[1] >= '0' and a->href.text[1] <= '9') { 438 // check background color 439 // Minimum: #?#? 440 i32 bgoff = -1; 441 if (a->href.size > 3) { 442 rangeFrom(i, 2, a->href.size) { 443 if (a->href.text[i] == '#') { 444 bgoff = i; 445 break; 446 } 447 } 448 if (bgoff > 0) { 449 if (bgoff+2 > a->href.size) { 450 bgoff = -1; 451 } 452 else { 453 if (a->href.text[bgoff+1] < '0' and a->href.text[bgoff+1] > '9' and a->href.text[bgoff+1] != 'x') { 454 bgoff = -1; 455 } 456 elif (a->href.text[bgoff+1] == 'x' and bgoff+3 > a->href.size) { 457 bgoff = -1; 458 } 459 } 460 } 461 } 462 fg = parseInt(a->href.text); 463 char *bright = ""; 464 if (fg >= 8 and fg < 16) { 465 bright = BLD; 466 fg -= 8; 467 } 468 if (fg >= 0 and fg < 8) { 469 if (bgoff < 0) { 470 sprintf(r->colorCode, "%s\x1B[3%dm", bright, fg); 471 } 472 else { 473 if (a->href.text[bgoff+1] >= '0' and a->href.text[bgoff+1] <= '9') { 474 bg = parseInt(a->href.text + bgoff); 475 if (bg >= 0 and bg < 8) { 476 sprintf(r->colorCode, "%s\x1B[3%dm\x1B[4%dm", bright, fg, bg); 477 } 478 } 479 elif (a->href.text[bgoff+1] == 'x') { 480 memcpy(colorString, a->href.text, a->href.size); 481 colorString[bgoff] = '0'; 482 bg = parseHex(colorString + bgoff); 483 colorString[bgoff] = '#'; 484 sprintf(r->colorCode, "%s\x1B[3%dm\x1b[48;2;%u;%u;%um", bright, fg, bg >> 16, (bg&0xFF00)>>8, bg&0xFF); 485 } 486 } 487 type = MD_SPAN_COLOR; 488 } 489 } 490 elif (a->href.size > 2 and a->href.text[1] == '#') { 491 // ##? 492 // there is no foreground color 493 if (a->href.text[2] == 'x' and a->href.size > 3) { 494 // ##x? 495 memcpy(colorString, a->href.text, a->href.size); 496 colorString[1] = '0'; 497 bg = parseHex(colorString + 1); 498 sprintf(r->colorCode, "\x1b[48;2;%u;%u;%um", bg >> 16, (bg&0xFF00)>>8, bg&0xFF); 499 type = MD_SPAN_COLOR; 500 } 501 elif (a->href.text[2] >= '0' and a->href.text[2] <= '9') { 502 bg = parseInt(a->href.text); 503 if (bg >= 0 and bg < 8) { 504 sprintf(r->colorCode, "\x1B[4%dm", bg); 505 type = MD_SPAN_COLOR; 506 } 507 508 } 509 } 510 } 511 } 512 } 513 514 if (not sliceIsEmpty(&r->spans)) { 515 pushG(r->span, r->rspan); 516 rallocG(r->rspan, ""); 517 } 518 519 sliceAppend(&r->spans, (blockt){.type=type}); 520 521 switch(type) { 522 case MD_SPAN_EM: 523 prependG(r->rspan, ITL); 524 break; 525 case MD_SPAN_STRONG: 526 prependG(r->rspan, BLD); 527 break; 528 case MD_SPAN_U: 529 prependG(r->rspan, UDL); 530 break; 531 case MD_SPAN_A: 532 prependG(r->rspan, BLD UDL BLU); 533 break; 534 case MD_SPAN_IMG: 535 prependG(r->rspan, UDL RED); 536 break; 537 case MD_SPAN_CODE: 538 prependG(r->rspan, BGBLU); 539 break; 540 case MD_SPAN_DEL: 541 prependG(r->rspan, CRD); 542 break; 543 case MD_SPAN_FNT: 544 prependG(r->rspan, FNT); 545 break; 546 case MD_SPAN_INV: 547 prependG(r->rspan, INV); 548 break; 549 case MD_SPAN_COC: 550 prependG(r->rspan, COC); 551 break; 552 case MD_SPAN_BLI: 553 prependG(r->rspan, BLI); 554 break; 555 case MD_SPAN_ANCHOR: 556 prependG(r->rspan, GRN); 557 break; 558 case MD_SPAN_COLOR: 559 prependG(r->rspan, r->colorCode); 560 break; 561 } 562 return 0; 563 } 564 565 internal int 566 leave_all_spans(MD_SPANTYPE type, void* detail, void* userdata) 567 { 568 cast(outt *, r, userdata); 569 570 if (not sliceIsEmpty(&r->spans)) { 571 sliceEmpty(&r->spans); 572 pushG(r->rspan, RST); 573 pushG(r->span, r->rspan); 574 rallocG(r->rspan, ""); 575 cleanFinishSmallStringP(s) = joinG(r->span, " "); 576 freeG(r->span); 577 pushG(r->current, s); 578 } 579 580 return 0; 581 } 582 internal int 583 leave_span_callback(MD_SPANTYPE type, void* detail, void* userdata) 584 { 585 cast(outt *, r, userdata); 586 587 logD(s2text[type]); 588 589 if (not sliceIsEmpty(&r->spans)) { 590 sliceDelLast(&r->spans); 591 if (sliceIsEmpty(&r->spans)) { 592 pushG(r->rspan, RST); 593 pushG(r->span, r->rspan); 594 rallocG(r->rspan, ""); 595 cleanFinishSmallStringP(s) = joinG(r->span, " "); 596 freeG(r->span); 597 pushG(r->current, s); 598 } 599 else { 600 pushG(r->rspan, RST); 601 sliceForEach(&r->spans, e) { 602 switch(e->type) { 603 case MD_SPAN_EM: 604 pushG(r->rspan, ITL); 605 break; 606 case MD_SPAN_STRONG: 607 pushG(r->rspan, BLD); 608 break; 609 case MD_SPAN_U: 610 pushG(r->rspan, UDL); 611 break; 612 case MD_SPAN_A: 613 pushG(r->rspan, BLD UDL BLU); 614 break; 615 case MD_SPAN_IMG: 616 pushG(r->rspan, UDL RED); 617 break; 618 case MD_SPAN_CODE: 619 pushG(r->rspan, BGBLU); 620 break; 621 case MD_SPAN_DEL: 622 pushG(r->rspan, CRD); 623 break; 624 case MD_SPAN_FNT: 625 pushG(r->rspan, FNT); 626 break; 627 case MD_SPAN_INV: 628 pushG(r->rspan, INV); 629 break; 630 case MD_SPAN_COC: 631 pushG(r->rspan, COC); 632 break; 633 case MD_SPAN_BLI: 634 pushG(r->rspan, BLI); 635 break; 636 case MD_SPAN_ANCHOR: 637 pushG(r->rspan, GRN); 638 break; 639 case MD_SPAN_COLOR: 640 pushG(r->rspan, r->colorCode); 641 break; 642 } 643 } 644 pushG(r->span, r->rspan); 645 rallocG(r->rspan, ""); 646 } 647 } 648 //logG(r->span); 649 650 return 0; 651 } 652 653 internal int 654 text_callback(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata) 655 { 656 cast(outt *, r, userdata); 657 char *s = calloc(1, size+1); 658 smallStringt *t; 659 660 logD(t2text[type]); 661 662 switch(type) { 663 case MD_TEXT_NULLCHAR: 664 break; 665 case MD_TEXT_BR: 666 pushG(r->out, ""); 667 //puts(BLU "br" RST); 668 break; 669 case MD_TEXT_SOFTBR: 670 pushG(r->current, " "); 671 //puts(BLU "sbr" RST); 672 break; 673 case MD_TEXT_HTML: 674 strncpy(s, text, size); /*pushG(r->out, s);*/ //puts(BLU "html" RST); 675 break; 676 case MD_TEXT_ENTITY: 677 // spec https://html.spec.whatwg.org/entities.json 678 strncpy(s, text, size); 679 logVarG(s); 680 char utf8Code[10] = init0Var; 681 if (s[1] == '#') { 682 // numeric character reference 683 if (s[2] == 'x' or s[2] == 'X') { 684 // hexadecimal 685 s[1] = '0'; 686 rune c = parseHex(s+1); 687 pError0(bRune2CodeUTF8(utf8Code, c)); 688 s[1] = '#'; 689 } 690 else { 691 // decimal 692 rune c = parseIntG(s); 693 pError0(bRune2CodeUTF8(utf8Code, c)); 694 } 695 } 696 else { 697 // check entity list 698 if (!r->entities) { 699 initiateG(&r->entities); 700 parseG(r->entities, entitiesString); 701 } 702 char *u = getG(r->entities, rtChar, s); 703 if (!u) break; // not found 704 strcpy(utf8Code, u); 705 } 706 pushG(r->current, utf8Code); 707 break; 708 default: 709 strncpy(s, text, size); 710 t = allocG(s); 711 if (not sliceIsEmpty(&r->spans)) { 712 pushNFreeG(r->rspan, t); 713 break; 714 } 715 pushNFreeG(r->current, t); 716 //puts(BLU "default" RST); 717 //printf(">%s<\n", s); 718 break; 719 } 720 721 logVarG(s); 722 free(s); 723 724 return 0; 725 } 726 727 internal void 728 debug_log_callback(const char* msg, void* userdata) 729 { 730 shEPrintfS("md4c %s", msg); 731 } 732 733 smallArrayt * 734 md_highlight(const char *md_source) { 735 736 if (!md_source) { 737 return NULL; 738 } 739 740 outt result = init0Var; 741 742 result.out = allocG(rtSmallArrayt); 743 result.current = allocG(""); 744 result.span = allocG(rtSmallArrayt); 745 result.rspan = allocG(""); 746 sliceInitCount(&result.blocks, 16); 747 sliceInitCount(&result.spans, 16); 748 749 unsigned parser_flags = MD_DIALECT_GITHUB | MD_FLAG_UNDERLINE; 750 unsigned renderer_flags = 0; 751 752 MD_PARSER parser = { 753 0, 754 parser_flags, 755 enter_block_callback, 756 leave_block_callback, 757 enter_span_callback, 758 leave_span_callback, 759 text_callback, 760 debug_log_callback, 761 null 762 }; 763 764 md_parse(md_source, strlen(md_source), &parser, &result); 765 766 smashG(result.current); 767 terminateG(result.span); 768 terminateG(result.rspan); 769 sliceFree(&result.blocks); 770 sliceFree(&result.spans); 771 terminateG(result.entities); 772 return result.out; 773 } 774 775 #ifndef LIB 776 int main(int ARGC, char** ARGV) { 777 778 initLibsheepy(ARGV[0]); 779 setLogMode(LOG_FUNC); 780 781 if (ARGC < 2) { 782 puts(RED "Give a filename in parameter" RST); 783 XFAILURE 784 } 785 786 e2text[MD_BLOCK_DOC] = "MD_BLOCK_DOC"; 787 e2text[MD_BLOCK_QUOTE] = "MD_BLOCK_QUOTE"; 788 e2text[MD_BLOCK_UL] = "MD_BLOCK_UL"; 789 e2text[MD_BLOCK_OL] = "MD_BLOCK_OL"; 790 e2text[MD_BLOCK_LI] = "MD_BLOCK_LI"; 791 e2text[MD_BLOCK_HR] = "MD_BLOCK_HR"; 792 e2text[MD_BLOCK_H] = "MD_BLOCK_H"; 793 e2text[MD_BLOCK_CODE] = "MD_BLOCK_CODE"; 794 e2text[MD_BLOCK_HTML] = "MD_BLOCK_HTML"; 795 e2text[MD_BLOCK_P] = "MD_BLOCK_P"; 796 e2text[MD_BLOCK_TABLE] = "MD_BLOCK_TABLE"; 797 e2text[MD_BLOCK_THEAD] = "MD_BLOCK_THEAD"; 798 e2text[MD_BLOCK_TBODY] = "MD_BLOCK_TBODY"; 799 e2text[MD_BLOCK_TR] = "MD_BLOCK_TR"; 800 e2text[MD_BLOCK_TH] = "MD_BLOCK_TH"; 801 e2text[MD_BLOCK_TD] = "MD_BLOCK_TD"; 802 803 t2text[MD_TEXT_NORMAL] = "MD_TEXT_NORMAL"; 804 t2text[MD_TEXT_NULLCHAR] = "MD_TEXT_NULLCHAR"; 805 t2text[MD_TEXT_BR] = "MD_TEXT_BR"; 806 t2text[MD_TEXT_SOFTBR] = "MD_TEXT_SOFTBR"; 807 t2text[MD_TEXT_ENTITY] = "MD_TEXT_ENTITY"; 808 t2text[MD_TEXT_CODE] = "MD_TEXT_CODE"; 809 t2text[MD_TEXT_HTML] = "MD_TEXT_HTML"; 810 t2text[MD_TEXT_LATEXMATH] = "MD_TEXT_LATEXMATH"; 811 812 s2text[MD_SPAN_EM] = "MD_SPAN_EM"; 813 s2text[MD_SPAN_STRONG] = "MD_SPAN_STRONG"; 814 s2text[MD_SPAN_A] = "MD_SPAN_A"; 815 s2text[MD_SPAN_IMG] = "MD_SPAN_IMG"; 816 s2text[MD_SPAN_CODE] = "MD_SPAN_CODE"; 817 s2text[MD_SPAN_DEL] = "MD_SPAN_DEL"; 818 s2text[MD_SPAN_LATEXMATH] = "MD_SPAN_LATEXMATH"; 819 s2text[MD_SPAN_LATEXMATH_DISPLAY] = "MD_SPAN_LATEXMATH_DISPLAY"; 820 s2text[MD_SPAN_WIKILINK] = "MD_SPAN_WIKILINK"; 821 s2text[MD_SPAN_U] = "MD_SPAN_U"; 822 s2text[MD_SPAN_FNT] = "MD_SPAN_FNT"; 823 s2text[MD_SPAN_INV] = "MD_SPAN_INV"; 824 s2text[MD_SPAN_COC] = "MD_SPAN_COC"; 825 s2text[MD_SPAN_BLI] = "MD_SPAN_BLI"; 826 s2text[MD_SPAN_ANCHOR] = "MD_SPAN_ANCHOR"; 827 828 char *c = readFileG(c, ARGV[1]); 829 830 if (!c) { 831 puts(RED "Error reading:" RST); 832 puts(ARGV[1]); 833 XFAILURE 834 } 835 836 logG(md_highlight(c)); 837 838 //logVarG(result.out); 839 } 840 #endif