pax_global_header00006660000000000000000000000064125745076230014525gustar00rootroot0000000000000052 comment=bc05e0bd55e70cd7824cb324af3a13f36ecdcf63 tclsoldout-0.1.1/000077500000000000000000000000001257450762300137205ustar00rootroot00000000000000tclsoldout-0.1.1/.fossil-settings/000077500000000000000000000000001257450762300171335ustar00rootroot00000000000000tclsoldout-0.1.1/.fossil-settings/ignore-glob000066400000000000000000000000251257450762300212570ustar00rootroot00000000000000*.o libtclsoldout.so tclsoldout-0.1.1/404.md000066400000000000000000000000721257450762300145500ustar00rootroot00000000000000

Not Found

tclsoldout-0.1.1/Makefile000066400000000000000000000025041257450762300153610ustar00rootroot00000000000000PREFIX = /usr LIBDIR = ${PREFIX}/lib MANDIR = ${PREFIX}/man VERSION = 0.1.1 CC ?= gcc MAKE ?= make CFLAGS += -fPIC -Wall -Wextra -pedantic LDFLAGS = -ltcl -shared SRC = extern/array.c \ extern/buffer.c \ extern/markdown.c \ extern/renderers.c \ tclsoldout.c OBJ = ${SRC:.c=.o} all: libtclsoldout.so clean: rm -f ${OBJ} libtclsoldout.so dist: all fossil tarball v${VERSION} --name tclsoldout-${VERSION} \ tclsoldout-${VERSION}.tar.gz html: mandoc -Thtml -Wall -Ostyle=http://dl.juef.tk/misc/man.css \ tclsoldout.n > www/tclsoldout.n.html install: all mkdir -p ${DESTDIR}${LIBDIR}/tclsoldout cp -f libtclsoldout.so ${DESTDIR}${LIBDIR}/tclsoldout chmod 0444 ${DESTDIR}${LIBDIR}/tclsoldout/libtclsoldout.so cp -f pkgIndex.tcl ${DESTDIR}${LIBDIR}/tclsoldout chmod 0444 ${DESTDIR}${LIBDIR}/tclsoldout/pkgIndex.tcl mkdir -p ${DESTDIR}${MANDIR}/mann cp -f tclsoldout.n ${DESTDIR}${MANDIR}/mann chmod 0444 ${DESTDIR}${MANDIR}/mann/tclsoldout.n md5: dist openssl dgst -md5 tclsoldout-${VERSION}.tar.gz \ > tclsoldout-${VERSION}.md5 test: all @cd ./tests; ${MAKE} uninstall: rm -rf ${DESTDIR}${LIBDIR}/tclsoldout rm -f ${DESTDIR}${MANDIR}/mann/tclsoldout.n .c.o: ${CC} ${CFLAGS} -c $< -o $@ libtclsoldout.so: ${OBJ} ${CC} ${LDFLAGS} ${OBJ} -o $@ .PHONY: all clean dist html install md5 test uninstall tclsoldout-0.1.1/extern/000077500000000000000000000000001257450762300152255ustar00rootroot00000000000000tclsoldout-0.1.1/extern/LICENSE000066400000000000000000000013321257450762300162310ustar00rootroot00000000000000Copyright (c) 2009, Natacha Porté Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. tclsoldout-0.1.1/extern/array.c000066400000000000000000000172201257450762300165110ustar00rootroot00000000000000/* array.c - automatic dynamic array for pointers */ /* * Copyright (c) 2008, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "array.h" #include /*************************** * STATIC HELPER FUNCTIONS * ***************************/ /* arr_realloc • realloc memory of a struct array */ static int arr_realloc(struct array* arr, int neosz) { void* neo; neo = realloc(arr->base, neosz * arr->unit); if (neo == 0) return 0; arr->base = neo; arr->asize = neosz; if (arr->size > neosz) arr->size = neosz; return 1; } /* parr_realloc • realloc memory of a struct parray */ static int parr_realloc(struct parray* arr, int neosz) { void* neo; neo = realloc(arr->item, neosz * sizeof (void*)); if (neo == 0) return 0; arr->item = neo; arr->asize = neosz; if (arr->size > neosz) arr->size = neosz; return 1; } /*************************** * GENERIC ARRAY FUNCTIONS * ***************************/ /* arr_adjust • shrink the allocated memory to fit exactly the needs */ int arr_adjust(struct array *arr) { return arr_realloc(arr, arr->size); } /* arr_free • frees the structure contents (buf NOT the struct itself) */ void arr_free(struct array *arr) { if (!arr) return; free(arr->base); arr->base = 0; arr->size = arr->asize = 0; } /* arr_grow • increases the array size to fit the given number of elements */ int arr_grow(struct array *arr, int need) { if (arr->asize >= need) return 1; else return arr_realloc(arr, need); } /* arr_init • initialization of the contents of the struct */ void arr_init(struct array *arr, size_t unit) { arr->base = 0; arr->size = arr->asize = 0; arr->unit = unit; } /* arr_insert • inserting nb elements before the nth one */ int arr_insert(struct array *arr, int nb, int n) { char *src, *dst; size_t len; if (!arr || nb <= 0 || n < 0 || !arr_grow(arr, arr->size + nb)) return 0; if (n < arr->size) { src = arr->base; src += n * arr->unit; dst = src + nb * arr->unit; len = (arr->size - n) * arr->unit; memmove(dst, src, len); } arr->size += nb; return 1; } /* arr_item • returns a pointer to the n-th element */ void * arr_item(struct array *arr, int no) { char *ptr; if (!arr || no < 0 || no >= arr->size) return 0; ptr = arr->base; ptr += no * arr->unit; return ptr; } /* arr_newitem • returns the index of a new element appended to the array */ int arr_newitem(struct array *arr) { if (!arr_grow(arr, arr->size + 1)) return -1; arr->size += 1; return arr->size - 1; } /* arr_remove • removes the n-th elements of the array */ void arr_remove(struct array *arr, int idx) { if (!arr || idx < 0 || idx >= arr->size) return; arr->size -= 1; if (idx < arr->size) { char *dst = arr->base; char *src; dst += idx * arr->unit; src = dst + arr->unit; memmove(dst, src, (arr->size - idx) * arr->unit); } } /* arr_sorted_find • O(log n) search in a sorted array, returning entry */ void * arr_sorted_find(struct array *arr, void *key, array_cmp_fn cmp) { int mi, ma, cu, ret; char *ptr = arr->base; mi = -1; ma = arr->size; while (mi < ma - 1) { cu = mi + (ma - mi) / 2; ret = cmp(key, ptr + cu * arr->unit); if (ret == 0) return ptr + cu * arr->unit; else if (ret < 0) ma = cu; else /* if (ret > 0) */ mi = cu; } return 0; } /* arr_sorted_find_i • O(log n) search in a sorted array, * returning index of the smallest element larger than the key */ int arr_sorted_find_i(struct array *arr, void *key, array_cmp_fn cmp) { int mi, ma, cu, ret; char *ptr = arr->base; mi = -1; ma = arr->size; while (mi < ma - 1) { cu = mi + (ma - mi) / 2; ret = cmp(key, ptr + cu * arr->unit); if (ret == 0) { while (cu < arr->size && ret == 0) { cu += 1; ret = cmp(key, ptr + cu * arr->unit); } return cu; } else if (ret < 0) ma = cu; else /* if (ret > 0) */ mi = cu; } return ma; } /*************************** * POINTER ARRAY FUNCTIONS * ***************************/ /* parr_adjust • shrinks the allocated memory to fit exactly the needs */ int parr_adjust(struct parray* arr) { return parr_realloc (arr, arr->size); } /* parr_free • frees the structure contents (buf NOT the struct itself) */ void parr_free(struct parray *arr) { if (!arr) return; free (arr->item); arr->item = 0; arr->size = 0; arr->asize = 0; } /* parr_grow • increases the array size to fit the given number of elements */ int parr_grow(struct parray *arr, int need) { if (arr->asize >= need) return 1; else return parr_realloc (arr, need); } /* parr_init • initialization of the struct (which is equivalent to zero) */ void parr_init(struct parray *arr) { arr->item = 0; arr->size = 0; arr->asize = 0; } /* parr_insert • inserting nb elements before the nth one */ int parr_insert(struct parray *parr, int nb, int n) { char *src, *dst; size_t len, i; if (!parr || nb <= 0 || n < 0 || !parr_grow(parr, parr->size + nb)) return 0; if (n < parr->size) { src = (void *)parr->item; src += n * sizeof (void *); dst = src + nb * sizeof (void *); len = (parr->size - n) * sizeof (void *); memmove(dst, src, len); for (i = 0; i < nb; ++i) parr->item[n + i] = 0; } parr->size += nb; return 1; } /* parr_pop • pops the last item of the array and returns it */ void * parr_pop(struct parray *arr) { if (arr->size <= 0) return 0; arr->size -= 1; return arr->item[arr->size]; } /* parr_push • pushes a pointer at the end of the array (= append) */ int parr_push(struct parray *arr, void *i) { if (!parr_grow(arr, arr->size + 1)) return 0; arr->item[arr->size] = i; arr->size += 1; return 1; } /* parr_remove • removes the n-th element of the array and returns it */ void * parr_remove(struct parray *arr, int idx) { void* ret; int i; if (!arr || idx < 0 || idx >= arr->size) return 0; ret = arr->item[idx]; for (i = idx+1; i < arr->size; ++i) arr->item[i - 1] = arr->item[i]; arr->size -= 1; return ret; } /* parr_sorted_find • O(log n) search in a sorted array, returning entry */ void * parr_sorted_find(struct parray *arr, void *key, array_cmp_fn cmp) { int mi, ma, cu, ret; mi = -1; ma = arr->size; while (mi < ma - 1) { cu = mi + (ma - mi) / 2; ret = cmp(key, arr->item[cu]); if (ret == 0) return arr->item[cu]; else if (ret < 0) ma = cu; else /* if (ret > 0) */ mi = cu; } return 0; } /* parr_sorted_find_i • O(log n) search in a sorted array, * returning index of the smallest element larger than the key */ int parr_sorted_find_i(struct parray *arr, void *key, array_cmp_fn cmp) { int mi, ma, cu, ret; mi = -1; ma = arr->size; while (mi < ma - 1) { cu = mi + (ma - mi) / 2; ret = cmp(key, arr->item[cu]); if (ret == 0) { while (cu < arr->size && ret == 0) { cu += 1; ret = cmp(key, arr->item[cu]); } return cu; } else if (ret < 0) ma = cu; else /* if (ret > 0) */ mi = cu; } return ma; } /* parr_top • returns the top the stack (i.e. the last element of the array) */ void * parr_top(struct parray *arr) { if (arr == 0 || arr->size <= 0) return 0; else return arr->item[arr->size - 1]; } /* vim: set filetype=c: */ tclsoldout-0.1.1/extern/array.h000066400000000000000000000101351257450762300165140ustar00rootroot00000000000000/* array.h - automatic dynamic array for pointers */ /* * Copyright (c) 2008, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef LITHIUM_ARRAY_H #define LITHIUM_ARRAY_H #include /******************** * TYPE DEFINITIONS * ********************/ /* struct array • generic linear array */ struct array { void* base; int size; int asize; size_t unit; }; /* struct parray • array of pointers */ struct parray { void ** item; int size; int asize; }; /* array_cmp_fn • comparison functions for sorted arrays */ typedef int (*array_cmp_fn)(void *key, void *array_entry); /*************************** * GENERIC ARRAY FUNCTIONS * ***************************/ /* arr_adjust • shrink the allocated memory to fit exactly the needs */ int arr_adjust(struct array *); /* arr_free • frees the structure contents (buf NOT the struct itself) */ void arr_free(struct array *); /* arr_grow • increases the array size to fit the given number of elements */ int arr_grow(struct array *, int); /* arr_init • initialization of the contents of the struct */ void arr_init(struct array *, size_t); /* arr_insert • inserting elements nb before the nth one */ int arr_insert(struct array *, int nb, int n); /* arr_item • returns a pointer to the n-th element */ void * arr_item(struct array *, int); /* arr_newitem • returns the index of a new element appended to the array */ int arr_newitem(struct array *); /* arr_remove • removes the n-th elements of the array */ void arr_remove(struct array *, int); /* arr_sorted_find • O(log n) search in a sorted array, returning entry */ /* equivalent to bsearch(key, arr->base, arr->size, arr->unit, cmp) */ void * arr_sorted_find(struct array *, void *key, array_cmp_fn cmp); /* arr_sorted_find_i • O(log n) search in a sorted array, * returning index of the smallest element larger than the key */ int arr_sorted_find_i(struct array *, void *key, array_cmp_fn cmp); /*************************** * POINTER ARRAY FUNCTIONS * ***************************/ /* parr_adjust • shrinks the allocated memory to fit exactly the needs */ int parr_adjust(struct parray *); /* parr_free • frees the structure contents (buf NOT the struct itself) */ void parr_free(struct parray *); /* parr_grow • increases the array size to fit the given number of elements */ int parr_grow(struct parray *, int); /* parr_init • initialization of the struct (which is equivalent to zero) */ void parr_init(struct parray *); /* parr_insert • inserting nb elements before the nth one */ int parr_insert(struct parray *, int nb, int n); /* parr_pop • pops the last item of the array and returns it */ void * parr_pop(struct parray *); /* parr_push • pushes a pointer at the end of the array (= append) */ int parr_push(struct parray *, void *); /* parr_remove • removes the n-th element of the array and returns it */ void * parr_remove(struct parray *, int); /* parr_sorted_find • O(log n) search in a sorted array, returning entry */ void * parr_sorted_find(struct parray *, void *key, array_cmp_fn cmp); /* parr_sorted_find_i • O(log n) search in a sorted array, * returning index of the smallest element larger than the key */ int parr_sorted_find_i(struct parray *, void *key, array_cmp_fn cmp); /* parr_top • returns the top the stack (i.e. the last element of the array) */ void * parr_top(struct parray *); #endif /* ndef LITHIUM_ARRAY_H */ /* vim: set filetype=c: */ tclsoldout-0.1.1/extern/buffer.c000066400000000000000000000170561257450762300166530ustar00rootroot00000000000000/* buffer.c - automatic buffer structure */ /* * Copyright (c) 2008, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * COMPILE TIME OPTIONS * * BUFFER_STATS • if defined, stats are kept about memory usage */ #define BUFFER_STATS #define BUFFER_STDARG #include "buffer.h" #include #include #include /******************** * GLOBAL VARIABLES * ********************/ #ifdef BUFFER_STATS long buffer_stat_nb = 0; size_t buffer_stat_alloc_bytes = 0; #endif /*************************** * STATIC HELPER FUNCTIONS * ***************************/ /* lower • returns the lower-case variant of the input char */ static char lower(char c) { return (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c; } /******************** * BUFFER FUNCTIONS * ********************/ /* bufcasecmp • case-insensitive buffer comparison */ int bufcasecmp(const struct buf *a, const struct buf *b) { size_t i = 0; size_t cmplen; if (a == b) return 0; if (!a) return -1; else if (!b) return 1; cmplen = (a->size < b->size) ? a->size : b->size; while (i < cmplen && lower(a->data[i]) == lower(b->data[i])) ++i; if (i < a->size) { if (i < b->size) return lower(a->data[i]) - lower(b->data[i]); else return 1; } else { if (i < b->size) return -1; else return 0; } } /* bufcmp • case-sensitive buffer comparison */ int bufcmp(const struct buf *a, const struct buf *b) { size_t i = 0; size_t cmplen; if (a == b) return 0; if (!a) return -1; else if (!b) return 1; cmplen = (a->size < b->size) ? a->size : b->size; while (i < cmplen && a->data[i] == b->data[i]) ++i; if (i < a->size) { if (i < b->size) return a->data[i] - b->data[i]; else return 1; } else { if (i < b->size) return -1; else return 0; } } /* bufcmps • case-sensitive comparison of a string to a buffer */ int bufcmps(const struct buf *a, const char *b) { const size_t len = strlen(b); size_t cmplen = len; int r; if (!a || !a->size) return b ? 0 : -1; if (len < a->size) cmplen = a->size; r = strncmp(a->data, b, cmplen); if (r) return r; else if (a->size == len) return 0; else if (a->size < len) return -1; else return 1; } /* bufdup • buffer duplication */ struct buf * bufdup(const struct buf *src, size_t dupunit) { size_t blocks; struct buf *ret; if (src == 0) return 0; ret = malloc(sizeof (struct buf)); if (ret == 0) return 0; ret->unit = dupunit; ret->size = src->size; ret->ref = 1; if (!src->size) { ret->asize = 0; ret->data = 0; return ret; } blocks = (src->size + dupunit - 1) / dupunit; ret->asize = blocks * dupunit; ret->data = malloc(ret->asize); if (ret->data == 0) { free(ret); return 0; } memcpy(ret->data, src->data, src->size); #ifdef BUFFER_STATS buffer_stat_nb += 1; buffer_stat_alloc_bytes += ret->asize; #endif return ret; } /* bufgrow • increasing the allocated size to the given value */ int bufgrow(struct buf *buf, size_t neosz) { size_t neoasz; void *neodata; if (!buf || !buf->unit) return 0; if (buf->asize >= neosz) return 1; neoasz = buf->asize + buf->unit; while (neoasz < neosz) neoasz += buf->unit; neodata = realloc(buf->data, neoasz); if (!neodata) return 0; #ifdef BUFFER_STATS buffer_stat_alloc_bytes += (neoasz - buf->asize); #endif buf->data = neodata; buf->asize = neoasz; return 1; } /* bufnew • allocation of a new buffer */ struct buf * bufnew(size_t unit) { struct buf *ret; ret = malloc(sizeof (struct buf)); if (ret) { #ifdef BUFFER_STATS buffer_stat_nb += 1; #endif ret->data = 0; ret->size = ret->asize = 0; ret->ref = 1; ret->unit = unit; } return ret; } /* bufnullterm • NUL-termination of the string array (making a C-string) */ void bufnullterm(struct buf *buf) { if (!buf || !buf->unit) return; if (buf->size < buf->asize && buf->data[buf->size] == 0) return; if (buf->size + 1 <= buf->asize || bufgrow(buf, buf->size + 1)) buf->data[buf->size] = 0; } /* bufprintf • formatted printing to a buffer */ void bufprintf(struct buf *buf, const char *fmt, ...) { va_list ap; if (!buf || !buf->unit) return; va_start(ap, fmt); vbufprintf(buf, fmt, ap); va_end(ap); } /* bufput • appends raw data to a buffer */ void bufput(struct buf *buf, const void *data, size_t len) { if (!buf) return; if (buf->size + len > buf->asize && !bufgrow(buf, buf->size + len)) return; memcpy(buf->data + buf->size, data, len); buf->size += len; } /* bufputs • appends a NUL-terminated string to a buffer */ void bufputs(struct buf *buf, const char *str) { bufput(buf, str, strlen (str)); } /* bufputc • appends a single char to a buffer */ void bufputc(struct buf *buf, char c) { if (!buf) return; if (buf->size + 1 > buf->asize && !bufgrow(buf, buf->size + 1)) return; buf->data[buf->size] = c; buf->size += 1; } /* bufrelease • decrease the reference count and free the buffer if needed */ void bufrelease(struct buf *buf) { if (!buf || !buf->unit) return; buf->ref -= 1; if (buf->ref == 0) { #ifdef BUFFER_STATS buffer_stat_nb -= 1; buffer_stat_alloc_bytes -= buf->asize; #endif free(buf->data); free(buf); } } /* bufreset • frees internal data of the buffer */ void bufreset(struct buf *buf) { if (!buf || !buf->unit || !buf->asize) return; #ifdef BUFFER_STATS buffer_stat_alloc_bytes -= buf->asize; #endif free(buf->data); buf->data = 0; buf->size = buf->asize = 0; } /* bufset • safely assigns a buffer to another */ void bufset(struct buf **dest, struct buf *src) { if (src) { if (!src->asize) src = bufdup(src, 1); else src->ref += 1; } bufrelease(*dest); *dest = src; } /* bufslurp • removes a given number of bytes from the head of the array */ void bufslurp(struct buf *buf, size_t len) { if (!buf || !buf->unit || len <= 0) return; if (len >= buf->size) { buf->size = 0; return; } buf->size -= len; memmove(buf->data, buf->data + len, buf->size); } /* buftoi • converts the numbers at the beginning of the buf into an int */ int buftoi(struct buf *buf, size_t offset_i, size_t *offset_o) { int r = 0, neg = 0; size_t i = offset_i; if (!buf || !buf->size) return 0; if (buf->data[i] == '+') i += 1; else if (buf->data[i] == '-') { neg = 1; i += 1; } while (i < buf->size && buf->data[i] >= '0' && buf->data[i] <= '9') { r = (r * 10) + buf->data[i] - '0'; i += 1; } if (offset_o) *offset_o = i; return neg ? -r : r; } /* vbufprintf • stdarg variant of formatted printing into a buffer */ void vbufprintf(struct buf *buf, const char *fmt, va_list ap) { int n; va_list ap_save; if (buf == 0 || (buf->size >= buf->asize && !bufgrow (buf, buf->size + 1))) return; va_copy(ap_save, ap); n = vsnprintf(buf->data + buf->size, buf->asize - buf->size, fmt, ap); if (n >= buf->asize - buf->size) { if (buf->size + n + 1 > buf->asize && !bufgrow (buf, buf->size + n + 1)) return; n = vsnprintf (buf->data + buf->size, buf->asize - buf->size, fmt, ap_save); } va_end(ap_save); if (n < 0) return; buf->size += n; } /* vim: set filetype=c: */ tclsoldout-0.1.1/extern/buffer.h000066400000000000000000000103321257450762300166460ustar00rootroot00000000000000/* buffer.h - automatic buffer structure */ /* * Copyright (c) 2008, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef LITHIUM_BUFFER_H #define LITHIUM_BUFFER_H #include /******************** * TYPE DEFINITIONS * ********************/ /* struct buf • character array buffer */ struct buf { char * data; /* actual character data */ size_t size; /* size of the string */ size_t asize; /* allocated size (0 = volatile buffer) */ size_t unit; /* reallocation unit size (0 = read-only buffer) */ int ref; }; /* reference count */ /********** * MACROS * **********/ /* CONST_BUF • global buffer from a string literal */ #define CONST_BUF(name, string) \ static struct buf name = { string, sizeof string -1, sizeof string } /* VOLATILE_BUF • macro for creating a volatile buffer on the stack */ #define VOLATILE_BUF(name, strname) \ struct buf name = { strname, strlen(strname) } /* BUFPUTSL • optimized bufputs of a string literal */ #define BUFPUTSL(output, literal) \ bufput(output, literal, sizeof literal - 1) /*********************** * FUNCTION ATTRIBUTES * ***********************/ /* BUF_ALLOCATOR • the function returns a completely new pointer */ #ifdef __GNUC__ #define BUF_ALLOCATOR \ __attribute__ ((malloc)) #else #define BUF_ALLOCATOR #endif /* BUF_PRINTF_LIKE • marks the function as behaving like printf */ #ifdef __GNUC__ #define BUF_PRINTF_LIKE(format_index, first_variadic_index) \ __attribute__ ((format (printf, format_index, first_variadic_index))); #else #define BUF_PRINTF_LIKE(format_index, first_variadic_index) #endif /******************** * BUFFER FUNCTIONS * ********************/ /* bufcasecmp • case-insensitive buffer comparison */ int bufcasecmp(const struct buf *, const struct buf *); /* bufcmp • case-sensitive buffer comparison */ int bufcmp(const struct buf *, const struct buf *); /* bufcmps • case-sensitive comparison of a string to a buffer */ int bufcmps(const struct buf *, const char *); /* bufdup • buffer duplication */ struct buf * bufdup(const struct buf *, size_t) BUF_ALLOCATOR; /* bufgrow • increasing the allocated size to the given value */ int bufgrow(struct buf *, size_t); /* bufnew • allocation of a new buffer */ struct buf * bufnew(size_t) BUF_ALLOCATOR; /* bufnullterm • NUL-termination of the string array (making a C-string) */ void bufnullterm(struct buf *); /* bufprintf • formatted printing to a buffer */ void bufprintf(struct buf *, const char *, ...) BUF_PRINTF_LIKE(2, 3); /* bufput • appends raw data to a buffer */ void bufput(struct buf *, const void*, size_t); /* bufputs • appends a NUL-terminated string to a buffer */ void bufputs(struct buf *, const char*); /* bufputc • appends a single char to a buffer */ void bufputc(struct buf *, char); /* bufrelease • decrease the reference count and free the buffer if needed */ void bufrelease(struct buf *); /* bufreset • frees internal data of the buffer */ void bufreset(struct buf *); /* bufset • safely assigns a buffer to another */ void bufset(struct buf **, struct buf *); /* bufslurp • removes a given number of bytes from the head of the array */ void bufslurp(struct buf *, size_t); /* buftoi • converts the numbers at the beginning of the buf into an int */ int buftoi(struct buf *, size_t, size_t *); #ifdef BUFFER_STDARG #include /* vbufprintf • stdarg variant of formatted printing into a buffer */ void vbufprintf(struct buf *, const char*, va_list); #endif /* def BUFFER_STDARG */ #endif /* ndef LITHIUM_BUFFER_H */ /* vim: set filetype=c: */ tclsoldout-0.1.1/extern/markdown.c000066400000000000000000001435011257450762300172170ustar00rootroot00000000000000/* markdown.c - generic markdown parser */ /* * Copyright (c) 2009, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "markdown.h" #include "array.h" #include #include #include /* for strncasecmp */ #define TEXT_UNIT 64 /* unit for the copy of the input buffer */ #define WORK_UNIT 64 /* block-level working buffer */ #define MKD_LI_END 8 /* internal list flag */ /*************** * LOCAL TYPES * ***************/ /* link_ref • reference to a link */ struct link_ref { struct buf * id; struct buf * link; struct buf * title; }; /* char_trigger • function pointer to render active chars */ /* returns the number of chars taken care of */ /* data is the pointer of the beginning of the span */ /* offset is the number of valid chars before data */ struct render; typedef size_t (*char_trigger)(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size); /* render • structure containing one particular render */ struct render { struct mkd_renderer make; struct array refs; char_trigger active_char[256]; struct parray work; }; /* html_tag • structure for quick HTML tag search (inspired from discount) */ struct html_tag { char * text; int size; }; /******************** * GLOBAL VARIABLES * ********************/ /* block_tags • recognised block tags, sorted by cmp_html_tag */ static struct html_tag block_tags[] = { /*0*/ { "p", 1 }, { "dl", 2 }, { "h1", 2 }, { "h2", 2 }, { "h3", 2 }, { "h4", 2 }, { "h5", 2 }, { "h6", 2 }, { "ol", 2 }, { "ul", 2 }, /*10*/ { "del", 3 }, { "div", 3 }, /*12*/ { "ins", 3 }, { "pre", 3 }, { "form", 4 }, { "math", 4 }, { "table", 5 }, { "iframe", 6 }, { "script", 6 }, { "fieldset", 8 }, { "noscript", 8 }, { "blockquote", 10 } }; #define INS_TAG (block_tags + 12) #define DEL_TAG (block_tags + 10) /*************************** * STATIC HELPER FUNCTIONS * ***************************/ /* build_ref_id • collapse whitespace from input text to make it a ref id */ static int build_ref_id(struct buf *id, const char *data, size_t size) { size_t beg, i; /* skip leading whitespace */ while (size > 0 && (data[0] == ' ' || data[0] == '\t' || data[0] == '\n')) { data += 1; size -= 1; } /* skip trailing whitespace */ while (size > 0 && (data[size - 1] == ' ' || data[size - 1] == '\t' || data[size - 1] == '\n')) size -= 1; if (size == 0) return -1; /* making the ref id */ i = 0; id->size = 0; while (i < size) { /* copy non-whitespace into the output buffer */ beg = i; while (i < size && !(data[i] == ' ' || data[i] == '\t' || data[i] == '\n')) i += 1; bufput(id, data + beg, i - beg); /* add a single space and skip all consecutive whitespace */ if (i < size) bufputc(id, ' '); while (i < size && (data[i] == ' ' || data[i] == '\t' || data[i] == '\n')) i += 1; } return 0; } /* cmp_link_ref • comparison function for link_ref sorted arrays */ static int cmp_link_ref(void *key, void *array_entry) { struct link_ref *lr = array_entry; return bufcasecmp(key, lr->id); } /* cmp_link_ref_sort • comparison function for link_ref qsort */ static int cmp_link_ref_sort(const void *a, const void *b) { const struct link_ref *lra = a; const struct link_ref *lrb = b; return bufcasecmp(lra->id, lrb->id); } /* cmp_html_tag • comparison function for bsearch() (stolen from discount) */ static int cmp_html_tag(const void *a, const void *b) { const struct html_tag *hta = a; const struct html_tag *htb = b; if (hta->size != htb->size) return hta->size - htb->size; return strncasecmp(hta->text, htb->text, hta->size); } /* find_block_tag • returns the current block tag */ static struct html_tag * find_block_tag(char *data, size_t size) { size_t i = 0; struct html_tag key; /* looking for the word end */ while (i < size && ((data[i] >= '0' && data[i] <= '9') || (data[i] >= 'A' && data[i] <= 'Z') || (data[i] >= 'a' && data[i] <= 'z'))) i += 1; if (i >= size) return 0; /* binary search of the tag */ key.text = data; key.size = i; return bsearch(&key, block_tags, sizeof block_tags / sizeof block_tags[0], sizeof block_tags[0], cmp_html_tag); } /* new_work_buffer • get a new working buffer from the stack or create one */ static struct buf * new_work_buffer(struct render *rndr) { struct buf *ret = 0; if (rndr->work.size < rndr->work.asize) { ret = rndr->work.item[rndr->work.size ++]; ret->size = 0; } else { ret = bufnew(WORK_UNIT); parr_push(&rndr->work, ret); } return ret; } /* release_work_buffer • release the given working buffer */ static void release_work_buffer(struct render *rndr, struct buf *buf) { assert(rndr->work.size > 0 && rndr->work.item[rndr->work.size - 1] == buf); rndr->work.size -= 1; } /**************************** * INLINE PARSING FUNCTIONS * ****************************/ /* is_mail_autolink • looks for the address part of a mail autolink and '>' */ /* this is less strict than the original markdown e-mail address matching */ static size_t is_mail_autolink(char *data, size_t size) { size_t i = 0, nb = 0; /* address is assumed to be: [-@._a-zA-Z0-9]+ with exactly one '@' */ while (i < size && (data[i] == '-' || data[i] == '.' || data[i] == '_' || data[i] == '@' || (data[i] >= 'a' && data[i] <= 'z') || (data[i] >= 'A' && data[i] <= 'Z') || (data[i] >= '0' && data[i] <= '9'))) { if (data[i] == '@') nb += 1; i += 1; } if (i >= size || data[i] != '>' || nb != 1) return 0; return i + 1; } /* tag_length • returns the length of the given tag, or 0 if it's not valid */ static size_t tag_length(char *data, size_t size, enum mkd_autolink *autolink) { size_t i, j; /* a valid tag can't be shorter than 3 chars */ if (size < 3) return 0; /* begins with a '<' optionally followed by '/', followed by letter */ if (data[0] != '<') return 0; i = (data[1] == '/') ? 2 : 1; if ((data[i] < 'a' || data[i] > 'z') && (data[i] < 'A' || data[i] > 'Z')) return 0; /* scheme test */ *autolink = MKDA_NOT_AUTOLINK; if (size > 6 && strncasecmp(data + 1, "http", 4) == 0 && (data[5] == ':' || ((data[5] == 's' || data[5] == 'S') && data[6] == ':'))) { i = data[5] == ':' ? 6 : 7; *autolink = MKDA_NORMAL; } else if (size > 5 && strncasecmp(data + 1, "ftp:", 4) == 0) { i = 5; *autolink = MKDA_NORMAL; } else if (size > 7 && strncasecmp(data + 1, "mailto:", 7) == 0) { i = 8; /* not changing *autolink to go to the address test */ } /* completing autolink test: no whitespace or ' or " */ if (i >= size || i == '>') *autolink = MKDA_NOT_AUTOLINK; else if (*autolink) { j = i; while (i < size && data[i] != '>' && data[i] != '\'' && data[i] != '"' && data[i] != ' ' && data[i] != '\t' && data[i] != '\t') i += 1; if (i >= size) return 0; if (i > j && data[i] == '>') return i + 1; /* one of the forbidden chars has been found */ *autolink = MKDA_NOT_AUTOLINK; } else if ((j = is_mail_autolink(data + i, size - i)) != 0) { *autolink = (i == 8) ? MKDA_EXPLICIT_EMAIL : MKDA_IMPLICIT_EMAIL; return i + j; } /* looking for something like a tag end */ while (i < size && data[i] != '>') i += 1; if (i >= size) return 0; return i + 1; } /* parse_inline • parses inline markdown elements */ static void parse_inline(struct buf *ob, struct render *rndr, char *data, size_t size) { size_t i = 0, end = 0; char_trigger action = 0; struct buf work = { 0, 0, 0, 0, 0 }; if (rndr->work.size > rndr->make.max_work_stack) { if (size) bufput(ob, data, size); return; } while (i < size) { /* copying inactive chars into the output */ while (end < size && (action = rndr->active_char[(unsigned char)data[end]]) == 0) end += 1; if (rndr->make.normal_text) { work.data = data + i; work.size = end - i; rndr->make.normal_text(ob, &work, rndr->make.opaque); } else bufput(ob, data + i, end - i); if (end >= size) break; i = end; /* calling the trigger */ end = action(ob, rndr, data + i, i, size - i); if (!end) /* no action from the callback */ end = i + 1; else { i += end; end = i; } } } /* find_emph_char • looks for the next emph char, skipping other constructs */ static size_t find_emph_char(char *data, size_t size, char c) { size_t i = 1; while (i < size) { while (i < size && data[i] != c && data[i] != '`' && data[i] != '[') i += 1; if (i >= size) return 0; if (data[i] == c) return i; /* not counting escaped chars */ if (i && data[i - 1] == '\\') { i += 1; continue; } /* skipping a code span */ if (data[i] == '`') { size_t span_nb = 0, bt; size_t tmp_i = 0; /* counting the number of opening backticks */ while (i < size && data[i] == '`') { i += 1; span_nb += 1; } if (i >= size) return 0; /* finding the matching closing sequence */ bt = 0; while (i < size && bt < span_nb) { if (!tmp_i && data[i] == c) tmp_i = i; if (data[i] == '`') bt += 1; else bt = 0; i += 1; } if (i >= size) return tmp_i; i += 1; } /* skipping a link */ else if (data[i] == '[') { size_t tmp_i = 0; char cc; i += 1; while (i < size && data[i] != ']') { if (!tmp_i && data[i] == c) tmp_i = i; i += 1; } i += 1; while (i < size && (data[i] == ' ' || data[i] == '\t' || data[i] == '\n')) i += 1; if (i >= size) return tmp_i; if (data[i] != '[' && data[i] != '(') { /* not a link*/ if (tmp_i) return tmp_i; else continue; } cc = data[i]; i += 1; while (i < size && data[i] != cc) { if (!tmp_i && data[i] == c) tmp_i = i; i += 1; } if (i >= size) return tmp_i; i += 1; } } return 0; } /* parse_emph1 • parsing single emphase */ /* closed by a symbol not preceded by whitespace and not followed by symbol */ static size_t parse_emph1(struct buf *ob, struct render *rndr, char *data, size_t size, char c) { size_t i = 0, len; struct buf *work = 0; int r; if (!rndr->make.emphasis) return 0; /* skipping one symbol if coming from emph3 */ if (size > 1 && data[0] == c && data[1] == c) i = 1; while (i < size) { len = find_emph_char(data + i, size - i, c); if (!len) return 0; i += len; if (i >= size) return 0; if (i + 1 < size && data[i + 1] == c) { i += 1; continue; } if (data[i] == c && data[i - 1] != ' ' && data[i - 1] != '\t' && data[i - 1] != '\n') { work = new_work_buffer(rndr); parse_inline(work, rndr, data, i); r = rndr->make.emphasis(ob, work, c, rndr->make.opaque); release_work_buffer(rndr, work); return r ? i + 1 : 0; } } return 0; } /* parse_emph2 • parsing single emphase */ static size_t parse_emph2(struct buf *ob, struct render *rndr, char *data, size_t size, char c) { size_t i = 0, len; struct buf *work = 0; int r; if (!rndr->make.double_emphasis) return 0; while (i < size) { len = find_emph_char(data + i, size - i, c); if (!len) return 0; i += len; if (i + 1 < size && data[i] == c && data[i + 1] == c && i && data[i - 1] != ' ' && data[i - 1] != '\t' && data[i - 1] != '\n') { work = new_work_buffer(rndr); parse_inline(work, rndr, data, i); r = rndr->make.double_emphasis(ob, work, c, rndr->make.opaque); release_work_buffer(rndr, work); return r ? i + 2 : 0; } i += 1; } return 0; } /* parse_emph3 • parsing single emphase */ /* finds the first closing tag, and delegates to the other emph */ static size_t parse_emph3(struct buf *ob, struct render *rndr, char *data, size_t size, char c) { size_t i = 0, len; int r; while (i < size) { len = find_emph_char(data + i, size - i, c); if (!len) return 0; i += len; /* skip whitespace preceded symbols */ if (data[i] != c || data[i - 1] == ' ' || data[i - 1] == '\t' || data[i - 1] == '\n') continue; if (i + 2 < size && data[i + 1] == c && data[i + 2] == c && rndr->make.triple_emphasis) { /* triple symbol found */ struct buf *work = new_work_buffer(rndr); parse_inline(work, rndr, data, i); r = rndr->make.triple_emphasis(ob, work, c, rndr->make.opaque); release_work_buffer(rndr, work); return r ? i + 3 : 0; } else if (i + 1 < size && data[i + 1] == c) { /* double symbol found, handing over to emph1 */ len = parse_emph1(ob, rndr, data - 2, size + 2, c); if (!len) return 0; else return len - 2; } else { /* single symbol found, handing over to emph2 */ len = parse_emph2(ob, rndr, data - 1, size + 1, c); if (!len) return 0; else return len - 1; } } return 0; } /* char_emphasis • single and double emphasis parsing */ static size_t char_emphasis(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size) { char c = data[0]; size_t ret; if (size > 2 && data[1] != c) { /* whitespace cannot follow an opening emphasis */ if (data[1] == ' ' || data[1] == '\t' || data[1] == '\n' || (ret = parse_emph1(ob, rndr, data + 1, size - 1, c)) == 0) return 0; return ret + 1; } if (size > 3 && data[1] == c && data[2] != c) { if (data[2] == ' ' || data[2] == '\t' || data[2] == '\n' || (ret = parse_emph2(ob, rndr, data + 2, size - 2, c)) == 0) return 0; return ret + 2; } if (size > 4 && data[1] == c && data[2] == c && data[3] != c) { if (data[3] == ' ' || data[3] == '\t' || data[3] == '\n' || (ret = parse_emph3(ob, rndr, data + 3, size - 3, c)) == 0) return 0; return ret + 3; } return 0; } /* char_linebreak • '\n' preceded by two spaces (assuming linebreak != 0) */ static size_t char_linebreak(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size) { if (offset < 2 || data[-1] != ' ' || data[-2] != ' ') return 0; /* removing the last space from ob and rendering */ if (ob->size && ob->data[ob->size - 1] == ' ') ob->size -= 1; return rndr->make.linebreak(ob, rndr->make.opaque) ? 1 : 0; } /* char_codespan • '`' parsing a code span (assuming codespan != 0) */ static size_t char_codespan(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size) { size_t end, nb = 0, i, f_begin, f_end; /* counting the number of backticks in the delimiter */ while (nb < size && data[nb] == '`') nb += 1; /* finding the next delimiter */ i = 0; for (end = nb; end < size && i < nb; end += 1) if (data[end] == '`') i += 1; else i = 0; if (i < nb && end >= size) return 0; /* no matching delimiter */ /* trimming outside whitespaces */ f_begin = nb; while (f_begin < end && (data[f_begin] == ' ' || data[f_begin] == '\t')) f_begin += 1; f_end = end - nb; while (f_end > nb && (data[f_end-1] == ' ' || data[f_end-1] == '\t')) f_end -= 1; /* real code span */ if (f_begin < f_end) { struct buf work = { data + f_begin, f_end - f_begin, 0, 0, 0 }; if (!rndr->make.codespan(ob, &work, rndr->make.opaque)) end = 0; } else { if (!rndr->make.codespan(ob, 0, rndr->make.opaque)) end = 0; } return end; } /* char_escape • '\\' backslash escape */ static size_t char_escape(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size) { struct buf work = { 0, 0, 0, 0, 0 }; if (size > 1) { if (rndr->make.normal_text) { work.data = data + 1; work.size = 1; rndr->make.normal_text(ob, &work, rndr->make.opaque); } else bufputc(ob, data[1]); } return 2; } /* char_entity • '&' escaped when it doesn't belong to an entity */ /* valid entities are assumed to be anything mathing &#?[A-Za-z0-9]+; */ static size_t char_entity(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size) { size_t end = 1; struct buf work; if (end < size && data[end] == '#') end += 1; while (end < size && ((data[end] >= '0' && data[end] <= '9') || (data[end] >= 'a' && data[end] <= 'z') || (data[end] >= 'A' && data[end] <= 'Z'))) end += 1; if (end < size && data[end] == ';') { /* real entity */ end += 1; } else { /* lone '&' */ return 0; } if (rndr->make.entity) { work.data = data; work.size = end; rndr->make.entity(ob, &work, rndr->make.opaque); } else bufput(ob, data, end); return end; } /* char_langle_tag • '<' when tags or autolinks are allowed */ static size_t char_langle_tag(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size) { enum mkd_autolink altype = MKDA_NOT_AUTOLINK; size_t end = tag_length(data, size, &altype); struct buf work = { data, end, 0, 0, 0 }; int ret = 0; if (end) { if (rndr->make.autolink && altype != MKDA_NOT_AUTOLINK) { work.data = data + 1; work.size = end - 2; ret = rndr->make.autolink(ob, &work, altype, rndr->make.opaque); } else if (rndr->make.raw_html_tag) ret = rndr->make.raw_html_tag(ob, &work, rndr->make.opaque); } if (!ret) return 0; else return end; } /* get_link_inline • extract inline-style link and title from parenthesed data*/ static int get_link_inline(struct buf *link, struct buf *title, char *data, size_t size) { size_t i = 0, mark; size_t link_b, link_e; size_t title_b = 0, title_e = 0; link->size = title->size = 0; /* skipping initial whitespace */ while (i < size && (data[i] == ' ' || data[i] == '\t' || data[i] == '\n')) i += 1; link_b = i; /* looking for link end: ' " */ while (i < size && data[i] != '\'' && data[i] != '"') i += 1; link_e = i; /* looking for title end if present */ if (data[i] == '\'' || data[i] == '"') { i += 1; title_b = i; /* skipping whitespaces after title */ title_e = size - 1; while (title_e > title_b && (data[title_e] == ' ' || data[title_e] == '\t' || data[title_e] == '\n')) title_e -= 1; /* checking for closing quote presence */ if (data[title_e] != '\'' && data[title_e] != '"') { title_b = title_e = 0; link_e = i; } } /* remove whitespace at the end of the link */ while (link_e > link_b && (data[link_e - 1] == ' ' || data[link_e - 1] == '\t' || data[link_e - 1] == '\n')) link_e -= 1; /* remove optional angle brackets around the link */ if (data[link_b] == '<') link_b += 1; if (data[link_e - 1] == '>') link_e -= 1; /* escape backslashed character from link */ link->size = 0; i = link_b; while (i < link_e) { mark = i; while (i < link_e && data[i] != '\\') i += 1; bufput(link, data + mark, i - mark); while (i < link_e && data[i] == '\\') i += 1; } /* handing back title */ title->size = 0; if (title_e > title_b) bufput(title, data + title_b, title_e - title_b); /* this function always succeed */ return 0; } /* get_link_ref • extract referenced link and title from id */ static int get_link_ref(struct render *rndr, struct buf *link, struct buf *title, char * data, size_t size) { struct link_ref *lr; /* find the link from its id (stored temporarily in link) */ link->size = 0; if (build_ref_id(link, data, size) < 0) return -1; lr = arr_sorted_find(&rndr->refs, link, cmp_link_ref); if (!lr) return -1; /* fill the output buffers */ link->size = 0; if (lr->link) bufput(link, lr->link->data, lr->link->size); title->size = 0; if (lr->title) bufput(title, lr->title->data, lr->title->size); return 0; } /* char_link • '[': parsing a link or an image */ static size_t char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size) { int is_img = (offset && data[-1] == '!'), level; size_t i = 1, txt_e; struct buf *content = 0; struct buf *link = 0; struct buf *title = 0; int ret; /* checking whether the correct renderer exists */ if ((is_img && !rndr->make.image) || (!is_img && !rndr->make.link)) return 0; /* looking for the matching closing bracket */ for (level = 1; i < size; i += 1) if (data[i - 1] == '\\') continue; else if (data[i] == '[') level += 1; else if (data[i] == ']') { level -= 1; if (level <= 0) break; } if (i >= size) return 0; txt_e = i; i += 1; /* skip any amount of whitespace or newline */ /* (this is much more laxist than original markdown syntax) */ while (i < size && (data[i] == ' ' || data[i] == '\t' || data[i] == '\n')) i += 1; /* allocate temporary buffers to store content, link and title */ content = new_work_buffer(rndr); link = new_work_buffer(rndr); title = new_work_buffer(rndr); ret = 0; /* error if we don't get to the callback */ /* inline style link */ if (i < size && data[i] == '(') { size_t span_end = i; while (span_end < size && !(data[span_end] == ')' && (span_end == i || data[span_end - 1] != '\\'))) span_end += 1; if (span_end >= size || get_link_inline(link, title, data + i+1, span_end - (i+1)) < 0) goto char_link_cleanup; i = span_end + 1; } /* reference style link */ else if (i < size && data[i] == '[') { char *id_data; size_t id_size, id_end = i; while (id_end < size && data[id_end] != ']') id_end += 1; if (id_end >= size) goto char_link_cleanup; if (i + 1 == id_end) { /* implicit id - use the contents */ id_data = data + 1; id_size = txt_e - 1; } else { /* explici id - between brackets */ id_data = data + i + 1; id_size = id_end - (i + 1); } if (get_link_ref(rndr, link, title, id_data, id_size) < 0) goto char_link_cleanup; i = id_end + 1; } /* shortcut reference style link */ else { if (get_link_ref(rndr, link, title, data + 1, txt_e - 1) < 0) goto char_link_cleanup; /* rewinding the whitespace */ i = txt_e + 1; } /* building content: img alt is escaped, link content is parsed */ if (txt_e > 1) { if (is_img) bufput(content, data + 1, txt_e - 1); else parse_inline(content, rndr, data + 1, txt_e - 1); } /* calling the relevant rendering function */ if (is_img) { if (ob->size && ob->data[ob->size - 1] == '!') ob->size -= 1; ret = rndr->make.image(ob, link, title, content, rndr->make.opaque); } else ret = rndr->make.link(ob, link, title, content, rndr->make.opaque); /* cleanup */ char_link_cleanup: release_work_buffer(rndr, title); release_work_buffer(rndr, link); release_work_buffer(rndr, content); return ret ? i : 0; } /********************************* * BLOCK-LEVEL PARSING FUNCTIONS * *********************************/ /* is_empty • returns the line length when it is empty, 0 otherwise */ static size_t is_empty(char *data, size_t size) { size_t i; for (i = 0; i < size && data[i] != '\n'; i += 1) if (data[i] != ' ' && data[i] != '\t') return 0; return i + 1; } /* is_hrule • returns whether a line is a horizontal rule */ static int is_hrule(char *data, size_t size) { size_t i = 0, n = 0; char c; /* skipping initial spaces */ if (size < 3) return 0; if (data[0] == ' ') { i += 1; if (data[1] == ' ') { i += 1; if (data[2] == ' ') { i += 1; } } } /* looking at the hrule char */ if (i + 2 >= size || (data[i] != '*' && data[i] != '-' && data[i] != '_')) return 0; c = data[i]; /* the whole line must be the char or whitespace */ while (i < size && data[i] != '\n') { if (data[i] == c) n += 1; else if (data[i] != ' ' && data[i] != '\t') return 0; i += 1; } return n >= 3; } /* is_headerline • returns whether the line is a setext-style hdr underline */ static int is_headerline(char *data, size_t size) { size_t i = 0; /* test of level 1 header */ if (data[i] == '=') { for (i = 1; i < size && data[i] == '='; i += 1); while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; return (i >= size || data[i] == '\n') ? 1 : 0; } /* test of level 2 header */ if (data[i] == '-') { for (i = 1; i < size && data[i] == '-'; i += 1); while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; return (i >= size || data[i] == '\n') ? 2 : 0; } return 0; } /* is_table_sep • returns wether there is a table separator at the given pos */ static int is_table_sep(char *data, size_t pos) { return data[pos] == '|' && (pos == 0 || data[pos - 1] != '\\'); } /* is_tableline • returns the number of column tables in the given line */ static int is_tableline(char *data, size_t size) { size_t i = 0; int n_sep = 0, outer_sep = 0; /* skip initial blanks */ while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; /* check for initial '|' */ if (i < size && data[i] == '|') outer_sep += 1; /* count the number of pipes in the line */ for (n_sep = 0; i < size && data[i] != '\n'; i += 1) if (is_table_sep(data, i)) n_sep += 1; /* march back to check for optional last '|' before blanks and EOL */ while (i && (data[i - 1] == ' ' || data[i - 1] == '\t' || data[i - 1] == '\n')) i -= 1; if (i && is_table_sep(data, i - 1)) outer_sep += 1; /* return the number of column or 0 if it's not a table line */ return (n_sep > 0) ? (n_sep - outer_sep + 1) : 0; } /* prefix_quote • returns blockquote prefix length */ static size_t prefix_quote(char *data, size_t size) { size_t i = 0; if (i < size && data[i] == ' ') i += 1; if (i < size && data[i] == ' ') i += 1; if (i < size && data[i] == ' ') i += 1; if (i < size && data[i] == '>') { if (i + 1 < size && (data[i + 1] == ' ' || data[i+1] == '\t')) return i + 2; else return i + 1; } else return 0; } /* prefix_code • returns prefix length for block code*/ static size_t prefix_code(char *data, size_t size) { if (size > 0 && data[0] == '\t') return 1; if (size > 3 && data[0] == ' ' && data[1] == ' ' && data[2] == ' ' && data[3] == ' ') return 4; return 0; } /* prefix_oli • returns ordered list item prefix */ static size_t prefix_oli(char *data, size_t size) { size_t i = 0; if (i < size && data[i] == ' ') i += 1; if (i < size && data[i] == ' ') i += 1; if (i < size && data[i] == ' ') i += 1; if (i >= size || data[i] < '0' || data[i] > '9') return 0; while (i < size && data[i] >= '0' && data[i] <= '9') i += 1; if (i + 1 >= size || data[i] != '.' || (data[i + 1] != ' ' && data[i + 1] != '\t')) return 0; i = i + 2; while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; return i; } /* prefix_uli • returns ordered list item prefix */ static size_t prefix_uli(char *data, size_t size) { size_t i = 0; if (i < size && data[i] == ' ') i += 1; if (i < size && data[i] == ' ') i += 1; if (i < size && data[i] == ' ') i += 1; if (i + 1 >= size || (data[i] != '*' && data[i] != '+' && data[i] != '-') || (data[i + 1] != ' ' && data[i + 1] != '\t')) return 0; i = i + 2; while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; return i; } /* parse_block • parsing of one block, returning next char to parse */ static void parse_block(struct buf *ob, struct render *rndr, char *data, size_t size); /* parse_blockquote • handles parsing of a blockquote fragment */ static size_t parse_blockquote(struct buf *ob, struct render *rndr, char *data, size_t size) { size_t beg, end = 0, pre, work_size = 0; char *work_data = 0; struct buf *out = new_work_buffer(rndr); beg = 0; while (beg < size) { for (end = beg + 1; end < size && data[end - 1] != '\n'; end += 1); pre = prefix_quote(data + beg, end - beg); if (pre) beg += pre; /* skipping prefix */ else if (is_empty(data + beg, end - beg) && (end >= size || (prefix_quote(data + end, size - end) == 0 && !is_empty(data + end, size - end)))) /* empty line followed by non-quote line */ break; if (beg < end) { /* copy into the in-place working buffer */ /* bufput(work, data + beg, end - beg); */ if (!work_data) work_data = data + beg; else if (data + beg != work_data + work_size) memmove(work_data + work_size, data + beg, end - beg); work_size += end - beg; } beg = end; } parse_block(out, rndr, work_data, work_size); if (rndr->make.blockquote) rndr->make.blockquote(ob, out, rndr->make.opaque); release_work_buffer(rndr, out); return end; } /* parse_blockquote • handles parsing of a regular paragraph */ static size_t parse_paragraph(struct buf *ob, struct render *rndr, char *data, size_t size) { size_t i = 0, end = 0; int level = 0; struct buf work = { data, 0, 0, 0, 0 }; /* volatile working buffer */ while (i < size) { for (end = i + 1; end < size && data[end - 1] != '\n'; end += 1); if (is_empty(data + i, size - i) || (level = is_headerline(data + i, size - i)) != 0) break; if ((i && data[i] == '#') || is_hrule(data + i, size - i)) { end = i; break; } i = end; } work.size = i; while (work.size && data[work.size - 1] == '\n') work.size -= 1; if (!level) { struct buf *tmp = new_work_buffer(rndr); parse_inline(tmp, rndr, work.data, work.size); if (rndr->make.paragraph) rndr->make.paragraph(ob, tmp, rndr->make.opaque); release_work_buffer(rndr, tmp); } else { if (work.size) { size_t beg; i = work.size; work.size -= 1; while (work.size && data[work.size] != '\n') work.size -= 1; beg = work.size + 1; while (work.size && data[work.size - 1] == '\n') work.size -= 1; if (work.size) { struct buf *tmp = new_work_buffer(rndr); parse_inline(tmp, rndr, work.data, work.size); if (rndr->make.paragraph) rndr->make.paragraph(ob, tmp, rndr->make.opaque); release_work_buffer(rndr, tmp); work.data += beg; work.size = i - beg; } else work.size = i; } if (rndr->make.header) { struct buf *span = new_work_buffer(rndr); parse_inline(span, rndr, work.data, work.size); rndr->make.header(ob, span, level,rndr->make.opaque); release_work_buffer(rndr, span); } } return end; } /* parse_blockquote • handles parsing of a block-level code fragment */ static size_t parse_blockcode(struct buf *ob, struct render *rndr, char *data, size_t size) { size_t beg, end, pre; struct buf *work = new_work_buffer(rndr); beg = 0; while (beg < size) { for (end = beg + 1; end < size && data[end - 1] != '\n'; end += 1); pre = prefix_code(data + beg, end - beg); if (pre) beg += pre; /* skipping prefix */ else if (!is_empty(data + beg, end - beg)) /* non-empty non-prefixed line breaks the pre */ break; if (beg < end) { /* verbatim copy to the working buffer, escaping entities */ if (is_empty(data + beg, end - beg)) bufputc(work, '\n'); else bufput(work, data + beg, end - beg); } beg = end; } while (work->size && work->data[work->size - 1] == '\n') work->size -= 1; bufputc(work, '\n'); if (rndr->make.blockcode) rndr->make.blockcode(ob, work, rndr->make.opaque); release_work_buffer(rndr, work); return beg; } /* parse_listitem • parsing of a single list item */ /* assuming initial prefix is already removed */ static size_t parse_listitem(struct buf *ob, struct render *rndr, char *data, size_t size, int *flags) { struct buf *work = 0, *inter = 0; size_t beg = 0, end, pre, sublist = 0, orgpre = 0, i; int in_empty = 0, has_inside_empty = 0; /* keeping book of the first indentation prefix */ if (size > 1 && data[0] == ' ') { orgpre = 1; if (size > 2 && data[1] == ' ') { orgpre = 2; if (size > 3 && data[2] == ' ') { orgpre = 3; } } } beg = prefix_uli(data, size); if (!beg) beg = prefix_oli(data, size); if (!beg) return 0; /* skipping to the beginning of the following line */ end = beg; while (end < size && data[end - 1] != '\n') end += 1; /* getting working buffers */ work = new_work_buffer(rndr); inter = new_work_buffer(rndr); /* putting the first line into the working buffer */ bufput(work, data + beg, end - beg); beg = end; /* process the following lines */ while (beg < size) { end += 1; while (end < size && data[end - 1] != '\n') end += 1; /* process an empty line */ if (is_empty(data + beg, end - beg)) { in_empty = 1; beg = end; continue; } /* calculating the indentation */ i = 0; if (end - beg > 1 && data[beg] == ' ') { i = 1; if (end - beg > 2 && data[beg + 1] == ' ') { i = 2; if (end - beg > 3 && data[beg + 2] == ' ') { i = 3; if (end - beg > 3 && data[beg + 3] == ' ') { i = 4; } } } } pre = i; if (data[beg] == '\t') { i = 1; pre = 8; } /* checking for a new item */ if ((prefix_uli(data + beg + i, end - beg - i) && !is_hrule(data + beg + i, end - beg - i)) || prefix_oli(data + beg + i, end - beg - i)) { if (in_empty) has_inside_empty = 1; if (pre == orgpre) /* the following item must have */ break; /* the same indentation */ if (!sublist) sublist = work->size; } /* joining only indented stuff after empty lines */ else if (in_empty && i < 4 && data[beg] != '\t') { *flags |= MKD_LI_END; break; } else if (in_empty) { bufputc(work, '\n'); has_inside_empty = 1; } in_empty = 0; /* adding the line without prefix into the working buffer */ bufput(work, data + beg + i, end - beg - i); beg = end; } /* render of li contents */ if (has_inside_empty) *flags |= MKD_LI_BLOCK; if (*flags & MKD_LI_BLOCK) { /* intermediate render of block li */ if (sublist && sublist < work->size) { parse_block(inter, rndr, work->data, sublist); parse_block(inter, rndr, work->data + sublist, work->size - sublist); } else parse_block(inter, rndr, work->data, work->size); } else { /* intermediate render of inline li */ if (sublist && sublist < work->size) { parse_inline(inter, rndr, work->data, sublist); parse_block(inter, rndr, work->data + sublist, work->size - sublist); } else parse_inline(inter, rndr, work->data, work->size); } /* render of li itself */ if (rndr->make.listitem) rndr->make.listitem(ob, inter, *flags, rndr->make.opaque); release_work_buffer(rndr, inter); release_work_buffer(rndr, work); return beg; } /* parse_list • parsing ordered or unordered list block */ static size_t parse_list(struct buf *ob, struct render *rndr, char *data, size_t size, int flags) { struct buf *work = new_work_buffer(rndr); size_t i = 0, j; while (i < size) { j = parse_listitem(work, rndr, data + i, size - i, &flags); i += j; if (!j || (flags & MKD_LI_END)) break; } if (rndr->make.list) rndr->make.list(ob, work, flags, rndr->make.opaque); release_work_buffer(rndr, work); return i; } /* parse_atxheader • parsing of atx-style headers */ static size_t parse_atxheader(struct buf *ob, struct render *rndr, char *data, size_t size) { int level = 0; size_t i, end, skip, span_beg, span_size; if (!size || data[0] != '#') return 0; while (level < size && level < 6 && data[level] == '#') level += 1; for (i = level; i < size && (data[i] == ' ' || data[i] == '\t'); i += 1); span_beg = i; for (end = i; end < size && data[end] != '\n'; end += 1); skip = end; if (end <= i) return parse_paragraph(ob, rndr, data, size); while (end && data[end - 1] == '#') end -= 1; while (end && (data[end - 1] == ' ' || data[end - 1] == '\t')) end -= 1; if (end <= i) return parse_paragraph(ob, rndr, data, size); span_size = end - span_beg; if (rndr->make.header) { struct buf *span = new_work_buffer(rndr); parse_inline(span, rndr, data + span_beg, span_size); rndr->make.header(ob, span, level, rndr->make.opaque); release_work_buffer(rndr, span); } return skip; } /* htmlblock_end • checking end of HTML block : [ \t]*\n[ \t*]\n */ /* returns the length on match, 0 otherwise */ static size_t htmlblock_end(struct html_tag *tag, char *data, size_t size) { size_t i, w; /* assuming data[0] == '<' && data[1] == '/' already tested */ /* checking tag is a match */ if (tag->size + 3 >= size || strncasecmp(data + 2, tag->text, tag->size) || data[tag->size + 2] != '>') return 0; /* checking white lines */ i = tag->size + 3; w = 0; if (i < size && (w = is_empty(data + i, size - i)) == 0) return 0; /* non-blank after tag */ i += w; w = 0; if (i < size && (w = is_empty(data + i, size - i)) == 0) return 0; /* non-blank line after tag line */ return i + w; } /* parse_htmlblock • parsing of inline HTML block */ static size_t parse_htmlblock(struct buf *ob, struct render *rndr, char *data, size_t size) { size_t i, j = 0; struct html_tag *curtag; int found; struct buf work = { data, 0, 0, 0, 0 }; /* identification of the opening tag */ if (size < 2 || data[0] != '<') return 0; curtag = find_block_tag(data + 1, size - 1); /* handling of special cases */ if (!curtag) { /* HTML comment, laxist form */ if (size > 5 && data[1] == '!' && data[2] == '-' && data[3] == '-') { i = 5; while (i < size && !(data[i - 2] == '-' && data[i - 1] == '-' && data[i] == '>')) i += 1; i += 1; if (i < size) j = is_empty(data + i, size - i); if (j) { work.size = i + j; if (rndr->make.blockhtml) rndr->make.blockhtml(ob, &work, rndr->make.opaque); return work.size; } } /* HR, which is the only self-closing block tag considered */ if (size > 4 && (data[1] == 'h' || data[1] == 'H') && (data[2] == 'r' || data[2] == 'R')) { i = 3; while (i < size && data[i] != '>') i += 1; if (i + 1 < size) { i += 1; j = is_empty(data + i, size - i); if (j) { work.size = i + j; if (rndr->make.blockhtml) rndr->make.blockhtml(ob, &work, rndr->make.opaque); return work.size; } } } /* no special case recognised */ return 0; } /* looking for an unindented matching closing tag */ /* followed by a blank line */ i = 1; found = 0; #if 0 while (i < size) { i += 1; while (i < size && !(data[i - 2] == '\n' && data[i - 1] == '<' && data[i] == '/')) i += 1; if (i + 2 + curtag->size >= size) break; j = htmlblock_end(curtag, data + i - 1, size - i + 1); if (j) { i += j - 1; found = 1; break; } } #endif /* if not found, trying a second pass looking for indented match */ /* but not if tag is "ins" or "del" (following original Markdown.pl) */ if (!found && curtag != INS_TAG && curtag != DEL_TAG) { i = 1; while (i < size) { i += 1; while (i < size && !(data[i - 1] == '<' && data[i] == '/')) i += 1; if (i + 2 + curtag->size >= size) break; j = htmlblock_end(curtag, data + i - 1, size - i + 1); if (j) { i += j - 1; found = 1; break; } } } if (!found) return 0; /* the end of the block has been found */ work.size = i; if (rndr->make.blockhtml) rndr->make.blockhtml(ob, &work, rndr->make.opaque); return i; } /* parse_table_cell • parse a cell inside a table */ static void parse_table_cell(struct buf *ob, struct render *rndr, char *data, size_t size, int flags) { struct buf *span = new_work_buffer(rndr); parse_inline(span, rndr, data, size); rndr->make.table_cell(ob, span, flags, rndr->make.opaque); release_work_buffer(rndr, span); } /* parse_table_row • parse an input line into a table row */ static size_t parse_table_row(struct buf *ob, struct render *rndr, char *data, size_t size, int *aligns, size_t align_size, int flags) { size_t i = 0, col = 0; size_t beg, end, total = 0; struct buf *cells = new_work_buffer(rndr); int align; /* skip leading blanks and sperator */ while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; if (i < size && data[i] == '|') i += 1; /* go over all the cells */ while (i < size && total == 0) { /* check optional left/center align marker */ align = 0; if (data[i] == ':') { align |= MKD_CELL_ALIGN_LEFT; i += 1; } /* skip blanks */ while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; beg = i; /* forward to the next separator or EOL */ while (i < size && !is_table_sep(data, i) && data[i] != '\n') i += 1; end = i; if (i < size) { i += 1; if (data[i - 1] == '\n') total = i; } /* check optional right/center align marker */ if (i > beg && data[end - 1] == ':') { align |= MKD_CELL_ALIGN_RIGHT; end -= 1; } /* remove trailing blanks */ while (end > beg && (data[end - 1] == ' ' || data[end - 1] == '\t')) end -= 1; /* skip the last cell if it was only blanks */ /* (because it is only the optional end separator) */ if (total && end <= beg) continue; /* fallback on default alignment if not explicit */ if (align == 0 && aligns && col < align_size) align = aligns[col]; /* render cells */ parse_table_cell(cells, rndr, data + beg, end - beg, align | flags); col += 1; } /* render the whole row and clean up */ rndr->make.table_row(ob, cells, flags, rndr->make.opaque); release_work_buffer(rndr, cells); return total ? total : size; } /* parse_table • parsing of a whole table */ static size_t parse_table(struct buf *ob, struct render *rndr, char *data, size_t size) { size_t i = 0, head_end, col; size_t align_size = 0; int *aligns = 0; struct buf *head = 0; struct buf *rows = new_work_buffer(rndr); /* skip the first (presumably header) line */ while (i < size && data[i] != '\n') i += 1; head_end = i; /* fallback on end of input */ if (i >= size) { parse_table_row(rows, rndr, data, size, 0, 0, 0); rndr->make.table(ob, 0, rows, rndr->make.opaque); release_work_buffer(rndr, rows); return i; } /* attempt to parse a table rule, i.e. blanks, dash, colons and sep */ i += 1; col = 0; while (i < size && (data[i] == ' ' || data[i] == '\t' || data[i] == '-' || data[i] == ':' || data[i] == '|')) { if (data[i] == '|') align_size += 1; if (data[i] == ':') col = 1; i += 1; } if (i < size && data[i] == '\n') { align_size += 1; /* render the header row */ head = new_work_buffer(rndr); parse_table_row(head, rndr, data, head_end, 0, 0, MKD_CELL_HEAD); /* parse alignments if provided */ if (col && (aligns = malloc(align_size * sizeof *aligns)) != 0){ for (i = 0; i < align_size; i += 1) aligns[i] = 0; col = 0; i = head_end + 1; /* skip initial white space and optional separator */ while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1; if (data[i] == '|') i += 1; /* compute default alignment for each column */ while (i < size && data[i] != '\n') { if (data[i] == ':') aligns[col] |= MKD_CELL_ALIGN_LEFT; while (i < size && data[i] != '|' && data[i] != '\n') i += 1; if (data[i - 1] == ':') aligns[col] |= MKD_CELL_ALIGN_RIGHT; if (i < size && data[i] == '|') i += 1; col += 1; } } /* point i to the beginning of next line/row */ i += 1; } else { /* there is no valid ruler, continuing without header */ i = 0; } /* render the table body lines */ while (i < size && is_tableline(data + i, size - i)) i += parse_table_row(rows, rndr, data + i, size - i, aligns, align_size, 0); /* render the full table */ rndr->make.table(ob, head, rows, rndr->make.opaque); /* cleanup */ if (head) release_work_buffer(rndr, head); release_work_buffer(rndr, rows); free(aligns); return i; } /* parse_block • parsing of one block, returning next char to parse */ static void parse_block(struct buf *ob, struct render *rndr, char *data, size_t size) { size_t beg, end, i; char *txt_data; int has_table = (rndr->make.table && rndr->make.table_row && rndr->make.table_cell); if (rndr->work.size > rndr->make.max_work_stack) { if (size) bufput(ob, data, size); return; } beg = 0; while (beg < size) { txt_data = data + beg; end = size - beg; if (data[beg] == '#') beg += parse_atxheader(ob, rndr, txt_data, end); else if (data[beg] == '<' && rndr->make.blockhtml && (i = parse_htmlblock(ob, rndr, txt_data, end)) != 0) beg += i; else if ((i = is_empty(txt_data, end)) != 0) beg += i; else if (is_hrule(txt_data, end)) { if (rndr->make.hrule) rndr->make.hrule(ob, rndr->make.opaque); while (beg < size && data[beg] != '\n') beg += 1; beg += 1; } else if (prefix_quote(txt_data, end)) beg += parse_blockquote(ob, rndr, txt_data, end); else if (prefix_code(txt_data, end)) beg += parse_blockcode(ob, rndr, txt_data, end); else if (prefix_uli(txt_data, end)) beg += parse_list(ob, rndr, txt_data, end, 0); else if (prefix_oli(txt_data, end)) beg += parse_list(ob, rndr, txt_data, end, MKD_LIST_ORDERED); else if (has_table && is_tableline(txt_data, end)) beg += parse_table(ob, rndr, txt_data, end); else beg += parse_paragraph(ob, rndr, txt_data, end); } } /********************* * REFERENCE PARSING * *********************/ /* is_ref • returns whether a line is a reference or not */ static int is_ref(char *data, size_t beg, size_t end, size_t *last, struct array *refs) { size_t i = 0; size_t id_offset, id_end; size_t link_offset, link_end; size_t title_offset, title_end; size_t line_end; struct link_ref *lr; struct buf *id; /* up to 3 optional leading spaces */ if (beg + 3 >= end) return 0; if (data[beg] == ' ') { i = 1; if (data[beg + 1] == ' ') { i = 2; if (data[beg + 2] == ' ') { i = 3; if (data[beg + 3] == ' ') return 0; } } } i += beg; /* id part: anything but a newline between brackets */ if (data[i] != '[') return 0; i += 1; id_offset = i; while (i < end && data[i] != '\n' && data[i] != '\r' && data[i] != ']') i += 1; if (i >= end || data[i] != ']') return 0; id_end = i; /* spacer: colon (space | tab)* newline? (space | tab)* */ i += 1; if (i >= end || data[i] != ':') return 0; i += 1; while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1; if (i < end && (data[i] == '\n' || data[i] == '\r')) { i += 1; if (i < end && data[i] == '\r' && data[i - 1] == '\n') i += 1; } while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1; if (i >= end) return 0; /* link: whitespace-free sequence, optionally between angle brackets */ if (data[i] == '<') i += 1; link_offset = i; while (i < end && data[i] != ' ' && data[i] != '\t' && data[i] != '\n' && data[i] != '\r') i += 1; if (data[i - 1] == '>') link_end = i - 1; else link_end = i; /* optional spacer: (space | tab)* (newline | '\'' | '"' | '(' ) */ while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1; if (i < end && data[i] != '\n' && data[i] != '\r' && data[i] != '\'' && data[i] != '"' && data[i] != '(') return 0; line_end = 0; /* computing end-of-line */ if (i >= end || data[i] == '\r' || data[i] == '\n') line_end = i; if (i + 1 < end && data[i] == '\n' && data[i + 1] == '\r') line_end = i + 1; /* optional (space|tab)* spacer after a newline */ if (line_end) { i = line_end + 1; while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1; } /* optional title: any non-newline sequence enclosed in '"() alone on its line */ title_offset = title_end = 0; if (i + 1 < end && (data[i] == '\'' || data[i] == '"' || data[i] == '(')) { i += 1; title_offset = i; /* looking for EOL */ while (i < end && data[i] != '\n' && data[i] != '\r') i += 1; if (i + 1 < end && data[i] == '\n' && data[i + 1] == '\r') title_end = i + 1; else title_end = i; /* stepping back */ i -= 1; while (i > title_offset && (data[i] == ' ' || data[i] == '\t')) i -= 1; if (i > title_offset && (data[i] == '\'' || data[i] == '"' || data[i] == ')')) { line_end = title_end; title_end = i; } } if (!line_end) return 0; /* garbage after the link */ /* a valid ref has been found, filling-in return structures */ if (last) *last = line_end; if (!refs) return 1; id = bufnew(WORK_UNIT); if (build_ref_id(id, data + id_offset, id_end - id_offset) < 0) { bufrelease(id); return 0; } lr = arr_item(refs, arr_newitem(refs)); lr->id = id; lr->link = bufnew(link_end - link_offset); bufput(lr->link, data + link_offset, link_end - link_offset); if (title_end > title_offset) { lr->title = bufnew(title_end - title_offset); bufput(lr->title, data + title_offset, title_end - title_offset); } else lr->title = 0; return 1; } /********************** * EXPORTED FUNCTIONS * **********************/ /* markdown • parses the input buffer and renders it into the output buffer */ void markdown(struct buf *ob, struct buf *ib, const struct mkd_renderer *rndrer) { struct link_ref *lr; struct buf *text = bufnew(TEXT_UNIT); size_t i, beg, end; struct render rndr; /* filling the render structure */ if (!rndrer) return; rndr.make = *rndrer; if (rndr.make.max_work_stack < 1) rndr.make.max_work_stack = 1; arr_init(&rndr.refs, sizeof (struct link_ref)); parr_init(&rndr.work); for (i = 0; i < 256; i += 1) rndr.active_char[i] = 0; if ((rndr.make.emphasis || rndr.make.double_emphasis || rndr.make.triple_emphasis) && rndr.make.emph_chars) for (i = 0; rndr.make.emph_chars[i]; i += 1) rndr.active_char[(unsigned char)rndr.make.emph_chars[i]] = char_emphasis; if (rndr.make.codespan) rndr.active_char['`'] = char_codespan; if (rndr.make.linebreak) rndr.active_char['\n'] = char_linebreak; if (rndr.make.image || rndr.make.link) rndr.active_char['['] = char_link; rndr.active_char['<'] = char_langle_tag; rndr.active_char['\\'] = char_escape; rndr.active_char['&'] = char_entity; /* first pass: looking for references, copying everything else */ beg = 0; while (beg < ib->size) /* iterating over lines */ if (is_ref(ib->data, beg, ib->size, &end, &rndr.refs)) beg = end; else { /* skipping to the next line */ end = beg; while (end < ib->size && ib->data[end] != '\n' && ib->data[end] != '\r') end += 1; /* adding the line body if present */ if (end > beg) bufput(text, ib->data + beg, end - beg); while (end < ib->size && (ib->data[end] == '\n' || ib->data[end] == '\r')) { /* add one \n per newline */ if (ib->data[end] == '\n' || (end + 1 < ib->size && ib->data[end + 1] != '\n')) bufputc(text, '\n'); end += 1; } beg = end; } /* sorting the reference array */ if (rndr.refs.size) qsort(rndr.refs.base, rndr.refs.size, rndr.refs.unit, cmp_link_ref_sort); /* adding a final newline if not already present */ if (text->size && text->data[text->size - 1] != '\n' && text->data[text->size - 1] != '\r') bufputc(text, '\n'); /* second pass: actual rendering */ if (rndr.make.prolog) rndr.make.prolog(ob, rndr.make.opaque); parse_block(ob, &rndr, text->data, text->size); if (rndr.make.epilog) rndr.make.epilog(ob, rndr.make.opaque); /* clean-up */ bufrelease(text); lr = rndr.refs.base; for (i = 0; i < rndr.refs.size; i += 1) { bufrelease(lr[i].id); bufrelease(lr[i].link); bufrelease(lr[i].title); } arr_free(&rndr.refs); assert(rndr.work.size == 0); for (i = 0; i < rndr.work.asize; i += 1) bufrelease(rndr.work.item[i]); parr_free(&rndr.work); } /* vim: set filetype=c: */ tclsoldout-0.1.1/extern/markdown.h000066400000000000000000000102661257450762300172250ustar00rootroot00000000000000/* markdown.h - generic markdown parser */ /* * Copyright (c) 2009, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef LITHIUM_MARKDOWN_H #define LITHIUM_MARKDOWN_H #include "buffer.h" /******************** * TYPE DEFINITIONS * ********************/ /* mkd_autolink • type of autolink */ enum mkd_autolink { MKDA_NOT_AUTOLINK, /* used internally when it is not an autolink*/ MKDA_NORMAL, /* normal http/http/ftp/etc link */ MKDA_EXPLICIT_EMAIL, /* e-mail link with explit mailto: */ MKDA_IMPLICIT_EMAIL /* e-mail link without mailto: */ }; /* mkd_renderer • functions for rendering parsed data */ struct mkd_renderer { /* document level callbacks */ void (*prolog)(struct buf *ob, void *opaque); void (*epilog)(struct buf *ob, void *opaque); /* block level callbacks - NULL skips the block */ void (*blockcode)(struct buf *ob, struct buf *text, void *opaque); void (*blockquote)(struct buf *ob, struct buf *text, void *opaque); void (*blockhtml)(struct buf *ob, struct buf *text, void *opaque); void (*header)(struct buf *ob, struct buf *text, int level, void *opaque); void (*hrule)(struct buf *ob, void *opaque); void (*list)(struct buf *ob, struct buf *text, int flags, void *opaque); void (*listitem)(struct buf *ob, struct buf *text, int flags, void *opaque); void (*paragraph)(struct buf *ob, struct buf *text, void *opaque); void (*table)(struct buf *ob, struct buf *head_row, struct buf *rows, void *opaque); void (*table_cell)(struct buf *ob, struct buf *text, int flags, void *opaque); void (*table_row)(struct buf *ob, struct buf *cells, int flags, void *opaque); /* span level callbacks - NULL or return 0 prints the span verbatim */ int (*autolink)(struct buf *ob, struct buf *link, enum mkd_autolink type, void *opaque); int (*codespan)(struct buf *ob, struct buf *text, void *opaque); int (*double_emphasis)(struct buf *ob, struct buf *text, char c, void *opaque); int (*emphasis)(struct buf *ob, struct buf *text, char c,void*opaque); int (*image)(struct buf *ob, struct buf *link, struct buf *title, struct buf *alt, void *opaque); int (*linebreak)(struct buf *ob, void *opaque); int (*link)(struct buf *ob, struct buf *link, struct buf *title, struct buf *content, void *opaque); int (*raw_html_tag)(struct buf *ob, struct buf *tag, void *opaque); int (*triple_emphasis)(struct buf *ob, struct buf *text, char c, void *opaque); /* low level callbacks - NULL copies input directly into the output */ void (*entity)(struct buf *ob, struct buf *entity, void *opaque); void (*normal_text)(struct buf *ob, struct buf *text, void *opaque); /* renderer data */ int max_work_stack; /* prevent arbitrary deep recursion, cf README */ const char *emph_chars; /* chars that trigger emphasis rendering */ void *opaque; /* opaque data send to every rendering callback */ }; /********* * FLAGS * *********/ /* list/listitem flags */ #define MKD_LIST_ORDERED 1 #define MKD_LI_BLOCK 2 /*
  • containing block data */ /* table cell flags */ #define MKD_CELL_ALIGN_DEFAULT 0 #define MKD_CELL_ALIGN_LEFT 1 #define MKD_CELL_ALIGN_RIGHT 2 #define MKD_CELL_ALIGN_CENTER 3 /* LEFT | RIGHT */ #define MKD_CELL_ALIGN_MASK 3 #define MKD_CELL_HEAD 4 /********************** * EXPORTED FUNCTIONS * **********************/ /* markdown • parses the input buffer and renders it into the output buffer */ void markdown(struct buf *ob, struct buf *ib, const struct mkd_renderer *rndr); #endif /* ndef LITHIUM_MARKDOWN_H */ /* vim: set filetype=c: */ tclsoldout-0.1.1/extern/renderers.c000066400000000000000000000430271257450762300173700ustar00rootroot00000000000000/* renderers.h - example markdown renderers */ /* * Copyright (c) 2009, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "renderers.h" #include /***************************** * EXPORTED HELPER FUNCTIONS * *****************************/ /* lus_attr_escape • copy the buffer entity-escaping '<', '>', '&' and '"' */ void lus_attr_escape(struct buf *ob, char *src, size_t size) { size_t i = 0, org; while (i < size) { /* copying directly unescaped characters */ org = i; while (i < size && src[i] != '<' && src[i] != '>' && src[i] != '&' && src[i] != '"') i += 1; if (i > org) bufput(ob, src + org, i - org); /* escaping */ if (i >= size) break; else if (src[i] == '<') BUFPUTSL(ob, "<"); else if (src[i] == '>') BUFPUTSL(ob, ">"); else if (src[i] == '&') BUFPUTSL(ob, "&"); else if (src[i] == '"') BUFPUTSL(ob, """); i += 1; } } /* lus_body_escape • copy the buffer entity-escaping '<', '>' and '&' */ void lus_body_escape(struct buf *ob, char *src, size_t size) { size_t i = 0, org; while (i < size) { /* copying directly unescaped characters */ org = i; while (i < size && src[i] != '<' && src[i] != '>' && src[i] != '&') i += 1; if (i > org) bufput(ob, src + org, i - org); /* escaping */ if (i >= size) break; else if (src[i] == '<') BUFPUTSL(ob, "<"); else if (src[i] == '>') BUFPUTSL(ob, ">"); else if (src[i] == '&') BUFPUTSL(ob, "&"); i += 1; } } /******************** * GENERIC RENDERER * ********************/ static int rndr_autolink(struct buf *ob, struct buf *link, enum mkd_autolink type, void *opaque) { if (!link || !link->size) return 0; BUFPUTSL(ob, "data, link->size); BUFPUTSL(ob, "\">"); if (type == MKDA_EXPLICIT_EMAIL && link->size > 7) lus_body_escape(ob, link->data + 7, link->size - 7); else lus_body_escape(ob, link->data, link->size); BUFPUTSL(ob, ""); return 1; } static void rndr_blockcode(struct buf *ob, struct buf *text, void *opaque) { if (ob->size) bufputc(ob, '\n'); BUFPUTSL(ob, "
    ");
	if (text) lus_body_escape(ob, text->data, text->size);
	BUFPUTSL(ob, "
    \n"); } static void rndr_blockquote(struct buf *ob, struct buf *text, void *opaque) { if (ob->size) bufputc(ob, '\n'); BUFPUTSL(ob, "
    \n"); if (text) bufput(ob, text->data, text->size); BUFPUTSL(ob, "
    \n"); } static int rndr_codespan(struct buf *ob, struct buf *text, void *opaque) { BUFPUTSL(ob, ""); if (text) lus_body_escape(ob, text->data, text->size); BUFPUTSL(ob, ""); return 1; } static int rndr_double_emphasis(struct buf *ob, struct buf *text, char c, void *opaque) { if (!text || !text->size) return 0; BUFPUTSL(ob, ""); bufput(ob, text->data, text->size); BUFPUTSL(ob, ""); return 1; } static int rndr_emphasis(struct buf *ob, struct buf *text, char c, void *opaque) { if (!text || !text->size) return 0; BUFPUTSL(ob, ""); if (text) bufput(ob, text->data, text->size); BUFPUTSL(ob, ""); return 1; } static void rndr_header(struct buf *ob, struct buf *text, int level, void *opaque) { if (ob->size) bufputc(ob, '\n'); bufprintf(ob, "", level); if (text) bufput(ob, text->data, text->size); bufprintf(ob, "\n", level); } static int rndr_link(struct buf *ob, struct buf *link, struct buf *title, struct buf *content, void *opaque) { BUFPUTSL(ob, "size) lus_attr_escape(ob, link->data, link->size); if (title && title->size) { BUFPUTSL(ob, "\" title=\""); lus_attr_escape(ob, title->data, title->size); } BUFPUTSL(ob, "\">"); if (content && content->size) bufput(ob, content->data, content->size); BUFPUTSL(ob, ""); return 1; } static void rndr_list(struct buf *ob, struct buf *text, int flags, void *opaque) { if (ob->size) bufputc(ob, '\n'); bufput(ob, flags & MKD_LIST_ORDERED ? "
      \n" : "
        \n", 5); if (text) bufput(ob, text->data, text->size); bufput(ob, flags & MKD_LIST_ORDERED ? "
    \n" : "\n", 6); } static void rndr_listitem(struct buf *ob, struct buf *text, int flags, void *opaque) { BUFPUTSL(ob, "
  • "); if (text) { while (text->size && text->data[text->size - 1] == '\n') text->size -= 1; bufput(ob, text->data, text->size); } BUFPUTSL(ob, "
    • \n"); } static void rndr_normal_text(struct buf *ob, struct buf *text, void *opaque) { if (text) lus_body_escape(ob, text->data, text->size); } static void rndr_paragraph(struct buf *ob, struct buf *text, void *opaque) { if (ob->size) bufputc(ob, '\n'); BUFPUTSL(ob, "

    "); if (text) bufput(ob, text->data, text->size); BUFPUTSL(ob, "

    \n"); } static void rndr_raw_block(struct buf *ob, struct buf *text, void *opaque) { size_t org, sz; if (!text) return; sz = text->size; while (sz > 0 && text->data[sz - 1] == '\n') sz -= 1; org = 0; while (org < sz && text->data[org] == '\n') org += 1; if (org >= sz) return; if (ob->size) bufputc(ob, '\n'); bufput(ob, text->data + org, sz - org); bufputc(ob, '\n'); } static int rndr_raw_inline(struct buf *ob, struct buf *text, void *opaque) { bufput(ob, text->data, text->size); return 1; } static int rndr_triple_emphasis(struct buf *ob, struct buf *text, char c, void *opaque) { if (!text || !text->size) return 0; BUFPUTSL(ob, ""); bufput(ob, text->data, text->size); BUFPUTSL(ob, ""); return 1; } /******************* * HTML 4 RENDERER * *******************/ static void html_hrule(struct buf *ob, void *opaque) { if (ob->size) bufputc(ob, '\n'); BUFPUTSL(ob, "
    \n"); } static int html_image(struct buf *ob, struct buf *link, struct buf *title, struct buf *alt, void *opaque) { if (!link || !link->size) return 0; BUFPUTSL(ob, "data, link->size); BUFPUTSL(ob, "\" alt=\""); if (alt && alt->size) lus_attr_escape(ob, alt->data, alt->size); if (title && title->size) { BUFPUTSL(ob, "\" title=\""); lus_attr_escape(ob, title->data, title->size); } BUFPUTSL(ob, "\">"); return 1; } static int html_linebreak(struct buf *ob, void *opaque) { BUFPUTSL(ob, "
    \n"); return 1; } /* exported renderer structure */ const struct mkd_renderer mkd_html = { NULL, NULL, rndr_blockcode, rndr_blockquote, rndr_raw_block, rndr_header, html_hrule, rndr_list, rndr_listitem, rndr_paragraph, NULL, NULL, NULL, rndr_autolink, rndr_codespan, rndr_double_emphasis, rndr_emphasis, html_image, html_linebreak, rndr_link, rndr_raw_inline, rndr_triple_emphasis, NULL, rndr_normal_text, 64, "*_", NULL }; /********************** * XHTML 1.0 RENDERER * **********************/ static void xhtml_hrule(struct buf *ob, void *opaque) { if (ob->size) bufputc(ob, '\n'); BUFPUTSL(ob, "
    \n"); } static int xhtml_image(struct buf *ob, struct buf *link, struct buf *title, struct buf *alt, void *opaque) { if (!link || !link->size) return 0; BUFPUTSL(ob, "data, link->size); BUFPUTSL(ob, "\" alt=\""); if (alt && alt->size) lus_attr_escape(ob, alt->data, alt->size); if (title && title->size) { BUFPUTSL(ob, "\" title=\""); lus_attr_escape(ob, title->data, title->size); } BUFPUTSL(ob, "\" />"); return 1; } static int xhtml_linebreak(struct buf *ob, void *opaque) { BUFPUTSL(ob, "
    \n"); return 1; } /* exported renderer structure */ const struct mkd_renderer mkd_xhtml = { NULL, NULL, rndr_blockcode, rndr_blockquote, rndr_raw_block, rndr_header, xhtml_hrule, rndr_list, rndr_listitem, rndr_paragraph, NULL, NULL, NULL, rndr_autolink, rndr_codespan, rndr_double_emphasis, rndr_emphasis, xhtml_image, xhtml_linebreak, rndr_link, rndr_raw_inline, rndr_triple_emphasis, NULL, rndr_normal_text, 64, "*_", NULL }; /********************** * DISCOUNT RENDERERS * **********************/ static int print_link_wxh(struct buf *ob, struct buf *link) { size_t eq, ex, end; eq = link->size - 1; while (eq > 0 && (link->data[eq - 1] != ' ' || link->data[eq] != '=')) eq -= 1; if (eq <= 0) return 0; ex = eq + 1; while (ex < link->size && link->data[ex] >= '0' && link->data[ex] <= '9') ex += 1; if (ex >= link->size || ex == eq + 1 || link->data[ex] != 'x') return 0; end = ex + 1; while (end < link->size && link->data[end] >= '0' && link->data[end] <= '9') end += 1; if (end == ex + 1) return 0; /* everything is fine, proceeding to actual printing */ lus_attr_escape(ob, link->data, eq - 1); BUFPUTSL(ob, "\" width="); bufput(ob, link->data + eq + 1, ex - eq - 1); BUFPUTSL(ob, " height="); bufput(ob, link->data + ex + 1, end - ex - 1); return 1; } static int discount_image(struct buf *ob, struct buf *link, struct buf *title, struct buf *alt, int xhtml) { if (!link || !link->size) return 0; BUFPUTSL(ob, "data, link->size); bufputc(ob, '"'); } BUFPUTSL(ob, " alt=\""); if (alt && alt->size) lus_attr_escape(ob, alt->data, alt->size); if (title && title->size) { BUFPUTSL(ob, "\" title=\""); lus_attr_escape(ob, title->data, title->size); } bufputs(ob, xhtml ? "\" />" : "\">"); return 1; } static int html_discount_image(struct buf *ob, struct buf *link, struct buf *title, struct buf *alt, void *opaque) { return discount_image(ob, link, title, alt, 0); } static int xhtml_discount_image(struct buf *ob, struct buf *link, struct buf *title, struct buf *alt, void *opaque) { return discount_image(ob, link, title, alt, 1); } static int discount_link(struct buf *ob, struct buf *link, struct buf *title, struct buf *content, void *opaque) { if (!link) return rndr_link(ob, link, title, content, opaque); else if (link->size > 5 && !strncasecmp(link->data, "abbr:", 5)) { BUFPUTSL(ob, "data + 5, link->size - 5); BUFPUTSL(ob, "\">"); bufput(ob, content->data, content->size); BUFPUTSL(ob, ""); return 1; } else if (link->size > 6 && !strncasecmp(link->data, "class:", 6)) { BUFPUTSL(ob, "data + 6, link->size - 6); BUFPUTSL(ob, "\">"); bufput(ob, content->data, content->size); BUFPUTSL(ob, ""); return 1; } else if (link->size > 3 && !strncasecmp(link->data, "id:", 3)) { BUFPUTSL(ob, "data + 3, link->size - 3); BUFPUTSL(ob, "\">"); bufput(ob, content->data, content->size); BUFPUTSL(ob, ""); return 1; } else if (link->size > 4 && !strncasecmp(link->data, "raw:", 4)) { bufput(ob, link->data + 4, link->size - 4); return 1; } return rndr_link(ob, link, title, content, opaque); } static void discount_blockquote(struct buf *ob, struct buf *text, void *opaque) { size_t i = 5, size = text->size; char *data = text->data; if (text->size < 5 || strncasecmp(text->data, "

    %", 4)) { rndr_blockquote(ob, text, opaque); return; } while (i < size && data[i] != '\n' && data[i] != '%') i += 1; if (i >= size || data[i] != '%') { rndr_blockquote(ob, text, opaque); return; } BUFPUTSL(ob, "

    data + 4, i - 4); BUFPUTSL(ob, "\">

    "); i += 1; if (i + 4 >= text->size && !strncasecmp(text->data + i, "

    ", 4)) { size_t old_i = i; i += 4; while (i + 3 < text->size && (data[i] != '<' || data[i + 1] != 'p' || data[i + 2] != '>')) i += 1; if (i + 3 >= text->size) i = old_i; } bufput(ob, text->data + i, text->size - i); BUFPUTSL(ob, "
    \n"); } static void discount_table(struct buf *ob, struct buf *head_row, struct buf *rows, void *opaque) { if (ob->size) bufputc(ob, '\n'); BUFPUTSL(ob, "\n"); if (head_row) { BUFPUTSL(ob, "\n"); bufput(ob, head_row->data, head_row->size); BUFPUTSL(ob, "\n\n"); } if (rows) bufput(ob, rows->data, rows->size); if (head_row) BUFPUTSL(ob, "\n"); BUFPUTSL(ob, "
    \n"); } static void discount_table_row(struct buf *ob, struct buf *cells, int flags, void *opaque){ (void)flags; BUFPUTSL(ob, " \n"); if (cells) bufput(ob, cells->data, cells->size); BUFPUTSL(ob, " \n"); } static void discount_table_cell(struct buf *ob, struct buf *text, int flags, void *opaque){ if (flags & MKD_CELL_HEAD) BUFPUTSL(ob, " '); if (text) bufput(ob, text->data, text->size); if (flags & MKD_CELL_HEAD) BUFPUTSL(ob, "\n"); else BUFPUTSL(ob, "\n"); } /* exported renderer structures */ const struct mkd_renderer discount_html = { NULL, NULL, rndr_blockcode, discount_blockquote, rndr_raw_block, rndr_header, html_hrule, rndr_list, rndr_listitem, rndr_paragraph, discount_table, discount_table_cell, discount_table_row, rndr_autolink, rndr_codespan, rndr_double_emphasis, rndr_emphasis, html_discount_image, html_linebreak, discount_link, rndr_raw_inline, rndr_triple_emphasis, NULL, rndr_normal_text, 64, "*_", NULL }; const struct mkd_renderer discount_xhtml = { NULL, NULL, rndr_blockcode, discount_blockquote, rndr_raw_block, rndr_header, xhtml_hrule, rndr_list, rndr_listitem, rndr_paragraph, discount_table, discount_table_cell, discount_table_row, rndr_autolink, rndr_codespan, rndr_double_emphasis, rndr_emphasis, xhtml_discount_image, xhtml_linebreak, discount_link, rndr_raw_inline, rndr_triple_emphasis, NULL, rndr_normal_text, 64, "*_", NULL }; /**************************** * NATACHA'S OWN EXTENSIONS * ****************************/ static void nat_span(struct buf *ob, struct buf *text, char *tag) { bufprintf(ob, "<%s>", tag); bufput(ob, text->data, text->size); bufprintf(ob, "", tag); } static int nat_emphasis(struct buf *ob, struct buf *text, char c, void *opaque) { if (!text || !text->size || c == '+' || c == '-') return 0; if (c == '|') nat_span(ob, text, "span"); else nat_span(ob, text, "em"); return 1; } static int nat_double_emphasis(struct buf *ob, struct buf *text, char c, void *opaque) { if (!text || !text->size || c == '|') return 0; if (c == '+') nat_span(ob, text, "ins"); else if (c == '-') nat_span(ob, text, "del"); else nat_span(ob, text, "strong"); return 1; } static int nat_triple_emphasis(struct buf *ob, struct buf *text, char c, void *opaque) { if (!text || !text->size || c == '+' || c == '-' || c == '|') return 0; BUFPUTSL(ob, ""); bufput(ob, text->data, text->size); BUFPUTSL(ob, ""); return 1; } static void nat_header(struct buf *ob, struct buf *text, int level, void *opaque) { size_t i = 0; if (ob->size) bufputc(ob, '\n'); while (i < text->size && (text->data[i] == '-' || text->data[i] == '_' || text->data[i] == '.' || text->data[i] == ':' || (text->data[i] >= 'a' && text->data[i] <= 'z') || (text->data[i] >= 'A' && text->data[i] <= 'Z') || (text->data[i] >= '0' && text->data[i] <= '0'))) i += 1; bufprintf(ob, "size && text->data[i] == '#') { bufprintf(ob, " id=\"%.*s\">", (int)i, text->data); i += 1; } else { bufputc(ob, '>'); i = 0; } bufput(ob, text->data + i, text->size - i); bufprintf(ob, "\n", level); } static void nat_paragraph(struct buf *ob, struct buf *text, void *opaque) { size_t i = 0; if (ob->size) bufputc(ob, '\n'); BUFPUTSL(ob, "size && text->data[0] == '(') { i = 1; while (i < text->size && (text->data[i] == ' ' /* this seems to be a bit more restrictive than */ /* what is allowed for class names */ || (text->data[i] >= 'a' && text->data[i] <= 'z') || (text->data[i] >= 'A' && text->data[i] <= 'Z') || (text->data[i] >= '0' && text->data[i] <= '0'))) i += 1; if (i < text->size && text->data[i] == ')') { bufprintf(ob, " class=\"%.*s\"", (int)(i - 1), text->data + 1); i += 1; } else i = 0; } bufputc(ob, '>'); if (text) bufput(ob, text->data + i, text->size - i); BUFPUTSL(ob, "

    \n"); } /* exported renderer structures */ const struct mkd_renderer nat_html = { NULL, NULL, rndr_blockcode, discount_blockquote, rndr_raw_block, nat_header, html_hrule, rndr_list, rndr_listitem, nat_paragraph, NULL, NULL, NULL, rndr_autolink, rndr_codespan, nat_double_emphasis, nat_emphasis, html_discount_image, html_linebreak, discount_link, rndr_raw_inline, nat_triple_emphasis, NULL, rndr_normal_text, 64, "*_-+|", NULL }; const struct mkd_renderer nat_xhtml = { NULL, NULL, rndr_blockcode, discount_blockquote, rndr_raw_block, nat_header, xhtml_hrule, rndr_list, rndr_listitem, nat_paragraph, NULL, NULL, NULL, rndr_autolink, rndr_codespan, nat_double_emphasis, nat_emphasis, xhtml_discount_image, xhtml_linebreak, discount_link, rndr_raw_inline, nat_triple_emphasis, NULL, rndr_normal_text, 64, "*_-+|", NULL }; tclsoldout-0.1.1/extern/renderers.h000066400000000000000000000034701257450762300173730ustar00rootroot00000000000000/* renderers.h - example markdown renderers */ /* * Copyright (c) 2009, Natacha Porté * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef MARKDOWN_RENDERERS_H #define MARKDOWN_RENDERERS_H #include "markdown.h" /***************************** * EXPORTED HELPER FUNCTIONS * *****************************/ /* lus_attr_escape • copy the buffer entity-escaping '<', '>', '&' and '"' */ void lus_attr_escape(struct buf *ob, char *src, size_t size); /* lus_body_escape • copy the buffer entity-escaping '<', '>' and '&' */ void lus_body_escape(struct buf *ob, char *src, size_t size); /*********************** * RENDERER STRUCTURES * ***********************/ /* original markdown renderers */ extern const struct mkd_renderer mkd_html; /* HTML 4 renderer */ extern const struct mkd_renderer mkd_xhtml; /* XHTML 1.0 renderer */ /* renderers with some discount extensions */ extern const struct mkd_renderer discount_html; extern const struct mkd_renderer discount_xhtml; /* renderers with Natasha's own extensions */ extern const struct mkd_renderer nat_html; extern const struct mkd_renderer nat_xhtml; #endif /* ndef MARKDOWN_RENDERERS_H */ tclsoldout-0.1.1/pkgIndex.tcl000066400000000000000000000001261257450762300161740ustar00rootroot00000000000000package ifneeded TclSoldout 0.1.1 \ [list load [file join $dir libtclsoldout.so]] tclsoldout-0.1.1/tclsoldout.c000066400000000000000000000106231257450762300162620ustar00rootroot00000000000000/* * Copyright (c) 2015 Svyatoslav Mishyn * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the * above copyright notice and this permission notice appear in all * copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ #include #include #include #include "extern/markdown.h" #include "extern/renderers.h" #define INPUT_UNIT 1024 #define OUTPUT_UNIT 64 #define NS "soldout" #define VERSION "0.1.1" static int convertMkd(Tcl_Interp *, Tcl_Obj *, const struct mkd_renderer *); static int x_html(Tcl_Interp *, int, Tcl_Obj *const [], int); static int escape_html(ClientData, Tcl_Interp *, int, Tcl_Obj *const []); static int mkd2html(ClientData, Tcl_Interp *, int, Tcl_Obj *const []); static int mkd2xhtml(ClientData, Tcl_Interp *, int, Tcl_Obj *const []); int Tclsoldout_Init(Tcl_Interp *); static int convertMkd(Tcl_Interp *interp, Tcl_Obj *mkd, const struct mkd_renderer *rndr) { struct buf *ib, *ob; size_t len; len = (size_t)mkd->length; if (!len) { Tcl_SetObjResult(interp, Tcl_NewStringObj("empty string", 12)); return TCL_ERROR; } ib = bufnew(INPUT_UNIT); ib->size = len; bufgrow(ib, ib->size + INPUT_UNIT); memcpy(ib->data, Tcl_GetString(mkd), ib->size + 1); ob = bufnew(OUTPUT_UNIT); markdown(ob, ib, rndr); Tcl_SetObjResult(interp, Tcl_NewStringObj(ob->data, ob->size - 1)); bufrelease(ib); bufrelease(ob); return TCL_OK; } static int x_html(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int html) { Tcl_Obj *mkd; const struct mkd_renderer *rndr; const char *opt; if (objc == 2) { rndr = html ? &mkd_html : &mkd_xhtml; mkd = objv[1]; } else if (objc == 3 && objv[1]->bytes[0] == '-') { opt = Tcl_GetString(objv[1]); if (strcmp(opt, "-discount") == 0) { rndr = html ? &discount_html : &discount_xhtml; } else if (strcmp(opt, "-natext") == 0) { rndr = html ? &nat_html : &nat_xhtml; } else { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "unknown option \"%s\", must be: " "-discount or -natext", opt)); return TCL_ERROR; } mkd = objv[2]; } else { Tcl_WrongNumArgs(interp, 1, objv, "?-discount|-natext? markdown"); return TCL_ERROR; } if (convertMkd(interp, mkd, rndr) != TCL_OK) { return TCL_ERROR; } return TCL_OK; } /* only '<', '>', '&' and '"' */ static int escape_html(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { struct buf *ob; size_t len; if (objc == 2) { len = (size_t)objv[1]->length; if (!len) { Tcl_SetObjResult(interp, Tcl_NewStringObj("empty string", 12)); return TCL_ERROR; } ob = bufnew(OUTPUT_UNIT); lus_attr_escape(ob, Tcl_GetString(objv[1]), len); Tcl_SetObjResult(interp, Tcl_NewStringObj(ob->data, ob->size)); bufrelease(ob); return TCL_OK; } else { Tcl_WrongNumArgs(interp, 1, objv, "string"); return TCL_ERROR; } } static int mkd2html(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { return x_html(interp, objc, objv, 1); } static int mkd2xhtml(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { return x_html(interp, objc, objv, 0); } int Tclsoldout_Init(Tcl_Interp *interp) { Tcl_Namespace *nsPtr; if ( #ifdef USE_TCL_STUBS Tcl_InitStubs(interp, "8.1", 0) #else Tcl_PkgRequire(interp, "Tcl", "8.1", 0) #endif == NULL) { return TCL_ERROR; } if (Tcl_PkgProvide(interp, "TclSoldout", VERSION) != TCL_OK) { return TCL_ERROR; } if ((nsPtr = Tcl_CreateNamespace(interp, NS, NULL, NULL)) == NULL) { return TCL_ERROR; } if (Tcl_Export(interp, nsPtr, "*", 0) != TCL_OK) { return TCL_ERROR; } Tcl_CreateObjCommand(interp, NS "::escape_html", escape_html, NULL, NULL); Tcl_CreateObjCommand(interp, NS "::mkd2html", mkd2html, NULL, NULL); Tcl_CreateObjCommand(interp, NS "::mkd2xhtml", mkd2xhtml, NULL, NULL); return TCL_OK; } tclsoldout-0.1.1/tclsoldout.n000066400000000000000000000056271257450762300163050ustar00rootroot00000000000000.\" .\" Copyright (c) 2015 Svyatoslav Mishyn .\" .\" Permission to use, copy, modify, and/or distribute this software for .\" any purpose with or without fee is hereby granted, provided that the .\" above copyright notice and this permission notice appear in all .\" copies. .\" .\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL .\" WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED .\" WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE .\" AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL .\" DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR .\" PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER .\" TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR .\" PERFORMANCE OF THIS SOFTWARE. .\" .Dd September 11, 2015 .Dt TCLSOLDOUT n .Os .Sh NAME .Nm TclSoldout .Nd Markdown parser .Sh SYNOPSIS .Cm package require TclSoldout Op 0.1.1 .Pp .Cm ::soldout::escape_html .Ar string .Pp .Cm ::soldout::mkd2html .Op Fl discount | natext .Ar markdown .Pp .Cm ::soldout::mkd2xhtml .Op Fl discount | natext .Ar markdown .Sh DESCRIPTION The .Nm extension is a Tcl binding to libsoldout, a lightweight C library that can parse Markdown. .Pp The .Cm ::soldout::escape_html command replace '<', '>', '&' and '"' in the .Ar string with their HTML entities and return the modified text. .Pp The .Cm ::soldout::mkd2html command parse .Ar markdown text and return HTML (self-closing tags are rendered like this:
    ). .Pp The .Cm ::soldout::mkd2xhtml command parse .Ar markdown text and return XHTML (self-closing tags like:
    ). .Pp The options are as follows: .Bl -tag -width Ds .It Fl discount enable Discount extensions: .Bl -bullet -width 1m .It image size specification, by appending "=(width)x(height)" to the link .It pseudo-protocols in links: .Bl -bullet -width 1m .It abbr:description for ... .It class:name for ... .It id:name for ... .It raw:text for verbatim unprocessed text inclusion .El .It class blocks: blockquotes beginning with %class% will be rendered as a div of the given class(es) .El .Pp and PHP-Markdown-like tables. .It Fl natext enable Discount extensions and Natasha's own extensions: .Bl -bullet -width 1m .It id attribute for headers, using the syntax id#Header text .It class attribute for paragraphs, by putting class name(s) between parenthesis at the very beginning of the paragraph .It and spans, using respectively ++ and -- as delimiters (with emphasis-like restrictions, i.e. an opening delimiter cannot be followed by a whitespace, and a closing delimiter cannot be preceded by a whitespace) .It plain without attribute, using emphasis-like delimiter | .El .El .Sh SEE ALSO .Lk https://github.com/faelys/libsoldout libsoldout .Sh AUTHORS .Nm was written by .An Svyatoslav Mishyn Aq Mt juef@openmailbox.org . tclsoldout-0.1.1/tests/000077500000000000000000000000001257450762300150625ustar00rootroot00000000000000tclsoldout-0.1.1/tests/Makefile000066400000000000000000000000361257450762300165210ustar00rootroot00000000000000all: @./all.tcl .PHONY: all tclsoldout-0.1.1/tests/all.tcl000077500000000000000000000002601257450762300163370ustar00rootroot00000000000000#!/usr/bin/env tclsh package require tcltest ::tcltest::testsDirectory [file dirname [file normalize [info script]]] eval ::tcltest::configure $::argv ::tcltest::runAllTests tclsoldout-0.1.1/tests/escape_html.test000077500000000000000000000023331257450762300202530ustar00rootroot00000000000000#!/usr/bin/env tclsh lappend auto_path ../ package require tcltest package require TclSoldout namespace import ::tcltest::* ::soldout::* eval configure $::argv test 001 {escape_html} { escape_html {Lorem ipsum sit amet, consectetur adipiscing elit} } {Lorem ipsum <dolor> sit amet, consectetur adipiscing elit} test 002 {escape_html} { escape_html {Lorem ipsum dolor & sit amet, consectetur adipiscing elit} } {Lorem ipsum dolor & sit amet, consectetur adipiscing elit} test 003 {escape_html} { escape_html {Lorem ipsum dolor "sit amet", consectetur adipiscing elit} } {Lorem ipsum dolor "sit amet", consectetur adipiscing elit} test 004 {escape_html} { escape_html {Lorem ipsum & "sit amet", consectetur adipiscing elit} } {Lorem ipsum <dolor> & "sit amet", consectetur\ adipiscing elit} test 005 {escape_html} -body { escape_html } -returnCodes error -result {wrong # args: should be "escape_html string"} test 006 {escape_html} -body { escape_html {} } -returnCodes error -result {empty string} test 007 {escape_html} -body { escape_html {} {} } -returnCodes error -result {wrong # args: should be "escape_html string"} cleanupTests tclsoldout-0.1.1/tests/mkd2html.test000077500000000000000000000003701257450762300175100ustar00rootroot00000000000000#!/usr/bin/env tclsh lappend auto_path ../ package require tcltest package require TclSoldout namespace import ::tcltest::* ::soldout::* eval configure $::argv foreach f [glob -directory mkd2html -type f *.test] { source $f } cleanupTests tclsoldout-0.1.1/tests/mkd2html/000077500000000000000000000000001257450762300166045ustar00rootroot00000000000000tclsoldout-0.1.1/tests/mkd2html/automatic_links.test000066400000000000000000000004331257450762300226730ustar00rootroot00000000000000test 001 {| automatic links |} { mkd2html { } } {

    http://example.com/

    } test 002 {| automatic links |} { mkd2html { } } {

    address@example.com

    } tclsoldout-0.1.1/tests/mkd2html/backslash_escapes.test000066400000000000000000000050001257450762300231360ustar00rootroot00000000000000test 001 {| backslash escapes |} { mkd2html { Lorem ipsum \*dolor\* sit amet, consectetur adipiscing elit} } {

    Lorem ipsum *dolor* sit amet, consectetur adipiscing elit

    } test 002 {| backslash escapes |} { mkd2html { Lorem ipsum \\dolor\\ sit amet, consectetur adipiscing elit} } {

    Lorem ipsum \dolor\ sit amet, consectetur adipiscing elit

    } test 003 {| backslash escapes |} { mkd2html { Lorem ipsum \`dolor\` sit amet, consectetur adipiscing elit} } {

    Lorem ipsum `dolor` sit amet, consectetur adipiscing elit

    } test 004 {| backslash escapes |} { mkd2html { Lorem ipsum \_dolor\_ sit amet, consectetur adipiscing elit} } {

    Lorem ipsum _dolor_ sit amet, consectetur adipiscing elit

    } test 005 {| backslash escapes |} { mkd2html { Lorem ipsum \{dolor\} sit amet, consectetur adipiscing elit} } {

    Lorem ipsum {dolor} sit amet, consectetur adipiscing elit

    } test 006 {| backslash escapes |} { mkd2html { Lorem ipsum \[dolor\] sit amet, consectetur adipiscing elit} } {

    Lorem ipsum [dolor] sit amet, consectetur adipiscing elit

    } test 007 {| backslash escapes |} { mkd2html { Lorem ipsum \(dolor\) sit amet, consectetur adipiscing elit} } {

    Lorem ipsum (dolor) sit amet, consectetur adipiscing elit

    } test 008 {| backslash escapes |} { mkd2html { Lorem ipsum \#dolor\# sit amet, consectetur adipiscing elit} } {

    Lorem ipsum #dolor# sit amet, consectetur adipiscing elit

    } test 009 {| backslash escapes |} { mkd2html { Lorem ipsum \+dolor\+ sit amet, consectetur adipiscing elit} } {

    Lorem ipsum +dolor+ sit amet, consectetur adipiscing elit

    } test 010 {| backslash escapes |} { mkd2html { Lorem ipsum \-dolor\- sit amet, consectetur adipiscing elit} } {

    Lorem ipsum -dolor- sit amet, consectetur adipiscing elit

    } test 011 {| backslash escapes |} { mkd2html { Lorem ipsum \.dolor\. sit amet, consectetur adipiscing elit} } {

    Lorem ipsum .dolor. sit amet, consectetur adipiscing elit

    } test 012 {| backslash escapes |} { mkd2html { Lorem ipsum \!dolor\! sit amet, consectetur adipiscing elit} } {

    Lorem ipsum !dolor! sit amet, consectetur adipiscing elit

    } test 013 {| backslash escapes |} { mkd2html { Lorem ipsum \~dolor\~ sit amet, consectetur adipiscing elit} } {

    Lorem ipsum ~dolor~ sit amet, consectetur adipiscing elit

    } test 014 {| backslash escapes |} { mkd2html { Lorem ipsum \@dolor\@ sit amet, consectetur adipiscing elit} } {

    Lorem ipsum @dolor@ sit amet, consectetur adipiscing elit

    } tclsoldout-0.1.1/tests/mkd2html/blockquotes.test000066400000000000000000000014171257450762300220430ustar00rootroot00000000000000test 001 {| blockquotes |} { mkd2html { > # Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod\ tempor > incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis > > > nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\ consequat. > > ## Duis aute irure dolor in reprehenderit in voluptate velit esse cillum\ dolore} } {

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod\ tempor

    incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,\ quis

    nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\ consequat.

    Duis aute irure dolor in reprehenderit in voluptate velit esse cillum\ dolore

    } tclsoldout-0.1.1/tests/mkd2html/code.test000066400000000000000000000011021257450762300204110ustar00rootroot00000000000000test 001 {| code |} { mkd2html { Use the `printf()` function.} } {

    Use the printf() function.

    } test 002 {| code |} { mkd2html { ``There is a literal backtick (`) here.``} } {

    There is a literal backtick (`) here.

    } test 003 {| code |} { mkd2html { A single backtick in a code span: `` ` ``} } {

    A single backtick in a code span: `

    } test 004 {| code |} { mkd2html { A backtick-delimited string in a code span: `` `foo` ``} } {

    A backtick-delimited string in a code span: `foo`

    } tclsoldout-0.1.1/tests/mkd2html/code_blocks.test000066400000000000000000000005671257450762300217640ustar00rootroot00000000000000test 001 {| code blocks |} { mkd2html { This is a normal paragraph: This is a code block.} } {

    This is a normal paragraph:

    This is a code block.
    } test 002 {| code blocks |} { mkd2html { This is a normal paragraph: This is a code block.} } {

    This is a normal paragraph:

    This is a code block.
    } tclsoldout-0.1.1/tests/mkd2html/emphasis.test000066400000000000000000000014221257450762300213150ustar00rootroot00000000000000test 001 {| emphasis |} { mkd2html { Lorem *ipsum* dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 002 {| emphasis |} { mkd2html { Lorem _ipsum_ dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 003 {| emphasis |} { mkd2html { Lorem **ipsum** dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 004 {| emphasis |} { mkd2html { Lorem __ipsum__ dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 005 {| emphasis |} { mkd2html { Lorem ***ipsum*** dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 006 {| emphasis |} { mkd2html { Lorem ___ipsum___ dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } tclsoldout-0.1.1/tests/mkd2html/errors.test000066400000000000000000000016411257450762300210230ustar00rootroot00000000000000test 001 {| errors |} -body { mkd2html } -returnCodes error -result {wrong # args: should be "mkd2html ?-discount|-natext? markdown"} test 002 {| errors |} -body { mkd2html {} } -returnCodes error -result {empty string} test 003 {| errors |} -body { mkd2html {} {} } -returnCodes error -result {wrong # args: should be "mkd2html ?-discount|-natext? markdown"} test 004 {| errors |} -body { mkd2html -opt {} } -returnCodes error -result {unknown option "-opt", must be: -discount or -natext} test 005 {| errors |} -body { mkd2html -opt {} {} } -returnCodes error -result {wrong # args: should be "mkd2html ?-discount|-natext? markdown"} test 006 {| errors |} -body { mkd2html -discount {} } -returnCodes error -result {empty string} test 007 {| errors |} -body { mkd2html -discount {} {} } -returnCodes error -result {wrong # args: should be "mkd2html ?-discount|-natext? markdown"} tclsoldout-0.1.1/tests/mkd2html/headers.test000066400000000000000000000012711257450762300211210ustar00rootroot00000000000000test 001 {| headers |} { mkd2html { Lorem ipsum ===========} } {

    Lorem ipsum

    } test 002 {| headers |} { mkd2html { Lorem ipsum -----------} } {

    Lorem ipsum

    } test 003 {| headers |} { mkd2html { # Lorem ipsum} } {

    Lorem ipsum

    } test 004 {| headers |} { mkd2html { ## Lorem ipsum} } {

    Lorem ipsum

    } test 005 {| headers |} { mkd2html { ### Lorem ipsum} } {

    Lorem ipsum

    } test 006 {| headers |} { mkd2html { #### Lorem ipsum} } {

    Lorem ipsum

    } test 007 {| headers |} { mkd2html { ##### Lorem ipsum} } {
    Lorem ipsum
    } test 008 {| headers |} { mkd2html { ###### Lorem ipsum} } {
    Lorem ipsum
    } tclsoldout-0.1.1/tests/mkd2html/horizontal_rules.test000066400000000000000000000017161257450762300231150ustar00rootroot00000000000000test 001 {| horizontal rules |} { mkd2html { Lorem ipsum dolor sit amet, *** consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 002 {| horizontal rules |} { mkd2html { Lorem ipsum dolor sit amet, * * * consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 003 {| horizontal rules |} { mkd2html { Lorem ipsum dolor sit amet, - - - consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 004 {| horizontal rules |} { mkd2html { Lorem ipsum dolor sit amet, ___ consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 005 {| horizontal rules |} { mkd2html { Lorem ipsum dolor sit amet, _ _ _ consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } tclsoldout-0.1.1/tests/mkd2html/images.test000066400000000000000000000014101257450762300207460ustar00rootroot00000000000000test 001 {| images |} { mkd2html { ![Alt text](/path/to/img.jpg)} } {

    Alt text

    } test 002 {| images |} { mkd2html { ![Alt text](/path/to/img.jpg "Optional title")} } {

    Alt text

    } test 003 {| images |} { mkd2html { ![Alt text](/path/to/img.jpg 'Optional title')} } {

    Alt text

    } test 004 {| images |} { mkd2html { ![Alt text][id] [id]: /path/to/img.jpg "Optional title"} } {

    Alt text

    } test 005 {| images |} { mkd2html { ![Alt text][id] [id]: /path/to/img.jpg} } {

    Alt text

    } tclsoldout-0.1.1/tests/mkd2html/links.test000066400000000000000000000032211257450762300206230ustar00rootroot00000000000000test 001 {| links |} { mkd2html { This is [an example](http://example.com/ "Title") inline link.} } {

    This is an example\ inline link.

    } test 002 {| links |} { mkd2html { This is [an example](http://example.com/) inline link.} } {

    This is an example\ inline link.

    } test 003 {| links |} { mkd2html { This is [an example](/example/) link.} } {

    This is an example link.

    } test 004 {| links |} { mkd2html { This is [an example][id] reference-style link. [id]: "Optional Title Here"} } {

    This is an\ example reference-style link.

    } test 005 {| links |} { mkd2html { This is [an example][id] reference-style link. [id]: 'Optional Title Here'} } {

    This is an\ example reference-style link.

    } test 006 {| links |} { mkd2html { This is [an example][id] reference-style link. [id]: (Optional Title Here)} } {

    This is an\ example reference-style link.

    } test 007 {| links |} { mkd2html { This is [an example][id] reference-style link. [id]: } } {

    This is an example reference-style\ link.

    } test 008 {| links |} { mkd2html { This is [an example][id] reference-style link. [id]: http://example.com/} } {

    This is an example reference-style\ link.

    } tclsoldout-0.1.1/tests/mkd2html/lists.test000066400000000000000000000014371257450762300206500ustar00rootroot00000000000000test 001 {| lists |} { mkd2html { * Lorem * ipsum * dolor} } {
    • Lorem
    • ipsum
    • dolor
    } test 002 {| lists |} { mkd2html { + Lorem + ipsum + dolor} } {
    • Lorem
    • ipsum
    • dolor
    } test 003 {| lists |} { mkd2html { - Lorem - ipsum - dolor} } {
    • Lorem
    • ipsum
    • dolor
    } test 004 {| lists |} { mkd2html { 1. Lorem 2. ipsum 3. dolor} } {
    1. Lorem
    2. ipsum
    3. dolor
    } test 005 {| lists |} { mkd2html { * Lorem ipsum dolor sit amet, consectetur adipiscing elit, * sed do eiusmod tempor incididunt} } {

    • Lorem ipsum dolor sit amet,

      consectetur adipiscing elit,

    • sed do eiusmod tempor incididunt

    } tclsoldout-0.1.1/tests/mkd2html/paragraphs_and_line_breaks.test000066400000000000000000000010021257450762300250060ustar00rootroot00000000000000test 001 {| paragraphs and line breaks |} { mkd2html { Lorem ipsum dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 002 {| paragraphs and line breaks |} { mkd2html { Lorem ipsum dolor sit amet, consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 003 {| paragraphs and line breaks |} { mkd2html { Lorem ipsum dolor sit amet, consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,
    consectetur adipiscing elit

    } tclsoldout-0.1.1/tests/mkd2html_discount.test000077500000000000000000000004011257450762300214130ustar00rootroot00000000000000#!/usr/bin/env tclsh lappend auto_path ../ package require tcltest package require TclSoldout namespace import ::tcltest::* ::soldout::* eval configure $::argv foreach f [glob -directory mkd2html_discount -type f *.test] { source $f } cleanupTests tclsoldout-0.1.1/tests/mkd2html_discount/000077500000000000000000000000001257450762300205145ustar00rootroot00000000000000tclsoldout-0.1.1/tests/mkd2html_discount/blockquotes.test000066400000000000000000000006401257450762300237500ustar00rootroot00000000000000test 001 {| blockquotes |} { mkd2html -discount { > %class% > Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor > incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis} } {

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis

    } tclsoldout-0.1.1/tests/mkd2html_discount/images.test000066400000000000000000000011101257450762300226530ustar00rootroot00000000000000test 001 {| images |} { mkd2html -discount { ![Alt text](/path/to/img.jpg =100x200)} } {

    Alt text

    } test 002 {| images |} { mkd2html -discount { ![Alt text](/path/to/img.jpg =100x200 "Optional title")} } {

    Alt text

    } test 003 {| images |} { mkd2html -discount { ![Alt text](/path/to/img.jpg =100x200 'Optional title')} } {

    Alt text

    } tclsoldout-0.1.1/tests/mkd2html_discount/links.test000066400000000000000000000011751257450762300225410ustar00rootroot00000000000000test 001 {| links |} { mkd2html -discount { This is [an example](abbr:description) inline link.} } {

    This is an example inline link.

    } test 002 {| links |} { mkd2html -discount { This is [an example](class:name) inline link.} } {

    This is an example inline link.

    } test 003 {| links |} { mkd2html -discount { This is [an example](id:name) inline link.} } {

    This is an example inline link.

    } test 004 {| links |} { mkd2html -discount { This is [](raw:&&text&&) inline link.} } {

    This is &&text&& inline link.

    } tclsoldout-0.1.1/tests/mkd2html_discount/tables.test000066400000000000000000000032631257450762300226730ustar00rootroot00000000000000test 001 {| tables |} { mkd2html -discount { header 1 | header 2 | header 3 | header 4 ------------|:-------------:|--------------:|:-------------- first line | centered | right-aligned | left-aligned second line | centered |: centered :| left-aligned third line |: left-aglined | right-aligned | right-aligned : column-separator | don't need | to be | aligned in the source | extra speratators | are allowed | at both ends | of the line | | correct number of cell per row is not enforced | | pipe characters can be embedded in cell text by escaping it: \| |} } {
    header 1 header 2 header 3 header 4
    first line centered right-aligned left-aligned
    second line centered centered left-aligned
    third line left-aglined right-aligned right-aligned
    column-separator don't need to be aligned in the source
    extra speratators are allowed at both ends of the line
    correct number of cell per row is not enforced
    pipe characters can be embedded in cell text by escaping it: |
    } tclsoldout-0.1.1/tests/mkd2html_natext.test000077500000000000000000000003771257450762300211020ustar00rootroot00000000000000#!/usr/bin/env tclsh lappend auto_path ../ package require tcltest package require TclSoldout namespace import ::tcltest::* ::soldout::* eval configure $::argv foreach f [glob -directory mkd2html_natext -type f *.test] { source $f } cleanupTests tclsoldout-0.1.1/tests/mkd2html_natext/000077500000000000000000000000001257450762300201675ustar00rootroot00000000000000tclsoldout-0.1.1/tests/mkd2html_natext/emphasis.test000066400000000000000000000006541257450762300227060ustar00rootroot00000000000000test 001 {| emphasis |} { mkd2html -natext { ++Lorem++ ipsum dolor sit amet, consectetur --adipiscing-- elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 002 {| emphasis |} { mkd2html -natext { |Lorem| ipsum dolor sit amet, consectetur |adipiscing| elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } tclsoldout-0.1.1/tests/mkd2html_natext/headers.test000066400000000000000000000014371257450762300225100ustar00rootroot00000000000000test 001 {| headers |} { mkd2html -natext { #id#Lorem ipsum dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 002 {| headers |} { mkd2html -natext { ##id#Lorem ipsum dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 003 {| headers |} { mkd2html -natext { ###id#Lorem ipsum dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 004 {| headers |} { mkd2html -natext { ####id#Lorem ipsum dolor sit amet} } {

    Lorem ipsum dolor sit amet

    } test 005 {| headers |} { mkd2html -natext { #####id#Lorem ipsum dolor sit amet} } {
    Lorem ipsum dolor sit amet
    } test 006 {| headers |} { mkd2html -natext { ######id#Lorem ipsum dolor sit amet} } {
    Lorem ipsum dolor sit amet
    } tclsoldout-0.1.1/tests/mkd2html_natext/paragraphs.test000066400000000000000000000003161257450762300232200ustar00rootroot00000000000000test 001 {| paragraphs |} { mkd2html -natext { (class)Lorem ipsum dolor sit amet, consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } tclsoldout-0.1.1/tests/mkd2xhtml.test000077500000000000000000000003711257450762300177010ustar00rootroot00000000000000#!/usr/bin/env tclsh lappend auto_path ../ package require tcltest package require TclSoldout namespace import ::tcltest::* ::soldout::* eval configure $::argv foreach f [glob -directory mkd2xhtml -type f *.test] { source $f } cleanupTests tclsoldout-0.1.1/tests/mkd2xhtml/000077500000000000000000000000001257450762300167745ustar00rootroot00000000000000tclsoldout-0.1.1/tests/mkd2xhtml/horizontal_rules.test000066400000000000000000000017351257450762300233060ustar00rootroot00000000000000test 001 {| horizontal rules |} { mkd2xhtml { Lorem ipsum dolor sit amet, *** consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 002 {| horizontal rules |} { mkd2xhtml { Lorem ipsum dolor sit amet, * * * consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 003 {| horizontal rules |} { mkd2xhtml { Lorem ipsum dolor sit amet, - - - consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 004 {| horizontal rules |} { mkd2xhtml { Lorem ipsum dolor sit amet, ___ consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } test 005 {| horizontal rules |} { mkd2xhtml { Lorem ipsum dolor sit amet, _ _ _ consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,

    consectetur adipiscing elit

    } tclsoldout-0.1.1/tests/mkd2xhtml/images.test000066400000000000000000000014271257450762300211460ustar00rootroot00000000000000test 001 {| images |} { mkd2xhtml { ![Alt text](/path/to/img.jpg)} } {

    Alt text

    } test 002 {| images |} { mkd2xhtml { ![Alt text](/path/to/img.jpg "Optional title")} } {

    Alt text

    } test 003 {| images |} { mkd2xhtml { ![Alt text](/path/to/img.jpg 'Optional title')} } {

    Alt text

    } test 004 {| images |} { mkd2xhtml { ![Alt text][id] [id]: /path/to/img.jpg "Optional title"} } {

    Alt text

    } test 005 {| images |} { mkd2xhtml { ![Alt text][id] [id]: /path/to/img.jpg} } {

    Alt text

    } tclsoldout-0.1.1/tests/mkd2xhtml/paragraphs_and_line_breaks.test000066400000000000000000000003021257450762300252000ustar00rootroot00000000000000test 001 {| paragraphs and line breaks |} { mkd2xhtml { Lorem ipsum dolor sit amet, consectetur adipiscing elit} } {

    Lorem ipsum dolor sit amet,
    consectetur adipiscing elit

    } tclsoldout-0.1.1/www/000077500000000000000000000000001257450762300145445ustar00rootroot00000000000000tclsoldout-0.1.1/www/tclsoldout.n.html000066400000000000000000000112201257450762300200560ustar00rootroot00000000000000 TCLSOLDOUT(n)

    NAME

    TclSoldout — Markdown parser

    SYNOPSIS

    package require TclSoldout [0.1.1]
    ::soldout::escape_html string
    ::soldout::mkd2html [-discount | -natext] markdown
    ::soldout::mkd2xhtml [-discount | -natext] markdown

    DESCRIPTION

    The TclSoldout extension is a Tcl binding to libsoldout, a lightweight C library that can parse Markdown.
    The ::soldout::escape_html command replace '<', '>', '&' and '"' in the string with their HTML entities and return the modified text.
    The ::soldout::mkd2html command parse markdown text and return HTML (self-closing tags are rendered like this: <br>).
    The ::soldout::mkd2xhtml command parse markdown text and return XHTML (self-closing tags like: <br />).
    The options are as follows:
    -discount
    enable Discount extensions:
    • image size specification, by appending "=(width)x(height)" to the link
    • pseudo-protocols in links:
      • abbr:description for <abbr title="description">...</abbr>
      • class:name for <span class="name">...</span>
      • id:name for <span id="name">...</span>
      • raw:text for verbatim unprocessed text inclusion
    • class blocks: blockquotes beginning with %class% will be rendered as a div of the given class(es)
    and PHP-Markdown-like tables.
    -natext
    enable Discount extensions and Natasha's own extensions:
    • id attribute for headers, using the syntax id#Header text
    • class attribute for paragraphs, by putting class name(s) between parenthesis at the very beginning of the paragraph
    • <ins> and <del> spans, using respectively ++ and -- as delimiters (with emphasis-like restrictions, i.e. an opening delimiter cannot be followed by a whitespace, and a closing delimiter cannot be preceded by a whitespace)
    • plain <span> without attribute, using emphasis-like delimiter |

    SEE ALSO

    libsoldout

    AUTHORS

    TclSoldout was written by Svyatoslav Mishyn <juef@openmailbox.org>.