/* char* markdownify (char *in) { */
struct buf* markdownify (char *in) {
struct buf *ib, *ob, *ob1;
struct mkd_renderer renderer;
/* reading everything */
ib = bufnew (READ_UNIT);
ib->size = strlen (in);
ib->data = in;
ob = bufnew (OUTPUT_UNIT);
ob->size = 0;
ob1 = bufnew (OUTPUT_UNIT);
ob1->size = 0;
/* Markdown parse */
upshtml_renderer (&renderer, 65535);
ups_markdown (ob, ib, &renderer, 65535);
upshtml_free_renderer (&renderer);
bufrelease (ib);
upshtml_smartypants (ob1, ob);
bufrelease (ob);
return ob1;
}
SEXP rmd_render_smartypants(SEXP Sfile, SEXP Soutput, SEXP Stext)
{
struct buf *ib, *ob;
SEXP ret_val = R_NilValue;
Rboolean success;
ib = bufnew(READ_UNIT);
if (!ib)
error("Out of memory!");
success = rmd_input_to_buf(Sfile, Stext, ib);
if (!success)
{
bufrelease(ib);
error("Input error!");
}
ob = bufnew(OUTPUT_UNIT);
if (!ob)
error("Out of memory!");
sdhtml_smartypants(ob,ib->data,ib->size);
success = rmd_buf_to_output(ob,Soutput,&ret_val);
bufrelease(ib);
bufrelease(ob);
if (!success)
error("Output error!");
return ret_val;
}
/* sundown.markdown(input_string) ==> output_string */
static int sundown_markdown(lua_State *L) {
const char *indoc;
size_t indocSize;
struct buf *inbuf;
struct buf *outbuf;
struct html_renderopt options;
struct sd_callbacks callbacks;
struct sd_markdown *markdown;
/* read input_string */
indoc = luaL_checklstring(L, 1, &indocSize);
inbuf = bufnew(READ_UNIT);
bufgrow(inbuf, indocSize);
bufput(inbuf, indoc, indocSize);
/* prepare for output_string */
outbuf = bufnew(OUTPUT_UNIT);
sdhtml_renderer(&callbacks, &options, 0);
markdown = sd_markdown_new(0, 16, &callbacks, &options);
/* write output_string */
sd_markdown_render(outbuf, inbuf->data, inbuf->size, markdown);
lua_pushlstring(L, (const char*) outbuf->data, outbuf->size);
bufrelease(inbuf);
bufrelease(outbuf);
sd_markdown_free(markdown);
return 1;
}
static QString markdown(QString in){
struct buf *ib, *ob;
struct sd_callbacks cbs;
struct html_renderopt opts;
struct sd_markdown *mkd;
if(in.size() > 0){
QByteArray qba = in.toUtf8();
const char *txt = qba.constData();
if(NULL == txt) qDebug() << "txt was null!";
if(0 < qba.size()){
ib = bufnew(qba.size());
bufputs(ib,txt);
ob = bufnew(64);
sdhtml_renderer(&cbs,&opts,0);
mkd = sd_markdown_new(0,16,&cbs,&opts);
sd_markdown_render(ob,ib->data,ib->size,mkd);
sd_markdown_free(mkd);
return QString::fromUtf8(bufcstr(ob));
}
else
qDebug() <<"qstrlen was null";
}
return "";
}
Document Parser::parse(const char* mkd) {
document = Document();
if (mkd) {
struct buf *ib, *ob;
ib = bufnew(INPUT_UNIT);
bufputs(ib, mkd);
ob = bufnew(OUTPUT_UNIT);
mkd_callbacks.opaque = this;
//parse and assemble document
markdown(ob, ib, &mkd_callbacks);
for (std::map<int, Element>::iterator it = elementSoup.begin(); it != elementSoup.end(); ++it) {
document.append(it->second);
}
bufrelease(ib);
bufrelease(ob);
}
return document;
}
JNIEXPORT jstring JNICALL Java_com_commonsware_cwac_anddown_AndDown_markdownToHtml
(JNIEnv *env, jobject o, jstring raw) {
struct buf *ib, *ob;
int ret;
jstring result;
struct sd_callbacks callbacks;
struct html_renderopt options;
struct sd_markdown *markdown;
const char* str;
str = (*env)->GetStringUTFChars(env, raw, NULL);
ib = bufnew(INPUT_UNIT);
bufputs(ib, str);
ob = bufnew(OUTPUT_UNIT);
(*env)->ReleaseStringUTFChars(env, raw, str);
sdhtml_renderer(&callbacks, &options, 0);
markdown = sd_markdown_new(0, 16, &callbacks, &options);
sd_markdown_render(ob, ib->data, ib->size, markdown);
sd_markdown_free(markdown);
result=(*env)->NewStringUTF(env, bufcstr(ob));
/* cleanup */
bufrelease(ib);
bufrelease(ob);
return(result);
}
static VALUE rb_redcarpet__render(VALUE self, RendererType render_type)
{
VALUE text = rb_funcall(self, rb_intern("text"), 0);
VALUE result;
struct buf input_buf, *output_buf;
struct mkd_renderer renderer;
unsigned int enabled_extensions, render_flags;
Check_Type(text, T_STRING);
memset(&input_buf, 0x0, sizeof(struct buf));
input_buf.data = RSTRING_PTR(text);
input_buf.size = RSTRING_LEN(text);
output_buf = bufnew(128);
bufgrow(output_buf, RSTRING_LEN(text) * 1.2f);
rb_redcarpet__get_flags(self, &enabled_extensions, &render_flags);
switch (render_type) {
case REDCARPET_RENDER_HTML:
upshtml_renderer(&renderer, render_flags);
break;
case REDCARPET_RENDER_TOC:
upshtml_toc_renderer(&renderer);
break;
default:
return Qnil;
}
ups_markdown(output_buf, &input_buf, &renderer, enabled_extensions);
if (rb_funcall(self, rb_intern("smart"), 0) == Qtrue) {
struct buf *smart_buf = bufnew(128);
upshtml_smartypants(smart_buf, output_buf);
result = rb_str_new(smart_buf->data, smart_buf->size);
bufrelease(smart_buf);
} else {
result = rb_str_new(output_buf->data, output_buf->size);
}
bufrelease(output_buf);
upshtml_free_renderer(&renderer);
/* force the input encoding */
if (rb_respond_to(text, rb_intern("encoding"))) {
VALUE encoding = rb_funcall(text, rb_intern("encoding"), 0);
rb_funcall(result, rb_intern("force_encoding"), 1, encoding);
}
return result;
}
SEXP rmd_render_markdown(SEXP Sfile, SEXP Soutput, SEXP Stext, SEXP Srenderer,
SEXP Soptions, SEXP Sextensions)
{
const char *name;
struct buf *ib, *ob;
SEXP ret_val = R_NilValue;
Rboolean success;
name = CHAR(STRING_ELT(Srenderer,0));
if (!rmd_renderer_exists(name))
{
error("Renderer '%s' not registered!",name);
return R_NilValue;
}
ib = bufnew(READ_UNIT);
if (!ib)
error("Out of memory!");
success = rmd_input_to_buf(Sfile,Stext,ib);
if (!success)
{
bufrelease(ib);
error("Input error!");
}
skip_pandoc_title_block(ib);
skip_jekyll_front_matter(ib);
ob = bufnew(OUTPUT_UNIT);
if (!ob)
error("Out of memory!");
success = renderer(name)->render(ib,ob,Soptions,Sextensions);
if (!success)
{
bufrelease(ib);
bufrelease(ob);
error("Render error!");
}
success = rmd_buf_to_output(ob,Soutput,&ret_val);
bufrelease(ib);
bufrelease(ob);
if (!success)
error("Output error!");
return ret_val;
}
/* main • main function, interfacing STDIO with the parser */
int
main(int argc, char **argv)
{
struct buf *ib, *ob;
int ret;
FILE *in = stdin;
struct sd_callbacks callbacks;
struct html_renderopt options;
struct sd_markdown *markdown;
/* opening the file if given from the command line */
if (argc > 1) {
in = fopen(argv[1], "r");
if (!in) {
fprintf(stderr,"Unable to open input file \"%s\": %s\n", argv[1], strerror(errno));
return 1;
}
}
/* reading everything */
ib = bufnew(READ_UNIT);
bufgrow(ib, READ_UNIT);
while ((ret = fread(ib->data + ib->size, 1, ib->asize - ib->size, in)) > 0) {
ib->size += ret;
bufgrow(ib, ib->size + READ_UNIT);
}
if (in != stdin)
fclose(in);
/* performing markdown parsing */
ob = bufnew(OUTPUT_UNIT);
sdhtml_renderer(&callbacks, &options, 0);
markdown = sd_markdown_new(0, 16, &callbacks, &options);
sd_markdown_render(ob, ib->data, ib->size, markdown);
sd_markdown_free(markdown);
/* writing the result to stdout */
ret = fwrite(ob->data, 1, ob->size, stdout);
/* cleanup */
bufrelease(ib);
bufrelease(ob);
return (ret < 0) ? -1 : 0;
}
static VALUE rb_redcarpet_to_html(int argc, VALUE *argv, VALUE self)
{
VALUE text = rb_funcall(self, rb_intern("text"), 0);
VALUE result;
struct buf input_buf, *output_buf;
struct mkd_renderer redcarpet_render;
Check_Type(text, T_STRING);
memset(&input_buf, 0x0, sizeof(struct buf));
input_buf.data = RSTRING_PTR(text);
input_buf.size = RSTRING_LEN(text);
output_buf = bufnew(64);
rb_redcarpet__setup_render(self, &redcarpet_render);
markdown(output_buf, &input_buf, &redcarpet_render);
result = rb_str_new(output_buf->data, output_buf->size);
bufrelease(output_buf);
/* force the input encoding */
if (rb_respond_to(text, rb_intern("encoding"))) {
VALUE encoding = rb_funcall(text, rb_intern("encoding"), 0);
rb_funcall(result, rb_intern("force_encoding"), 1, encoding);
}
return result;
}
/**
* Generic template
*/
static VALUE
rb_eu__generic(
VALUE self, VALUE str,
houdini_cb callback,
size_t chunk_size)
{
VALUE result;
struct buf *out_buf;
if (NIL_P(str))
return rb_str_new2("");
Check_Type(str, T_STRING);
out_buf = bufnew(chunk_size);
callback(out_buf, (uint8_t *)RSTRING_PTR(str), RSTRING_LEN(str));
result = rb_str_new((char *)out_buf->data, out_buf->size);
bufrelease(out_buf);
#ifdef HAVE_RUBY_ENCODING_H
rb_enc_copy(result, str);
#endif
return result;
}
QByteArray md2html(const QByteArray &data, int ext)
{
if (data.isEmpty()) {
return data;
}
struct buf *ob;
struct sd_callbacks callbacks;
struct html_renderopt options;
struct sd_markdown *markdown;
/* performing markdown parsing */
ob = bufnew(OUTPUT_UNIT);
sdhtml_renderer(&callbacks, &options, 0);
markdown = sd_markdown_new(ext, 16, &callbacks, &options);
sd_markdown_render(ob, (uint8_t*)data.constData(), data.size(), markdown);
sd_markdown_free(markdown);
QByteArray out((char*)ob->data,ob->size);
/* cleanup */
bufrelease(ob);
return out;
}
/**
* HTML methods
*/
static VALUE rb_eu_escape_html(int argc, VALUE *argv, VALUE self)
{
VALUE rb_out_buf, str, rb_secure;
struct buf *out_buf;
int secure = g_html_secure;
if (rb_scan_args(argc, argv, "11", &str, &rb_secure) == 2) {
if (rb_secure == Qfalse) {
secure = 0;
}
}
Check_Type(str, T_STRING);
out_buf = bufnew(128);
houdini_escape_html0(out_buf, (uint8_t *)RSTRING_PTR(str), RSTRING_LEN(str), secure);
rb_out_buf = rb_str_new((char *)out_buf->data, out_buf->size);
bufrelease(out_buf);
#ifdef HAVE_RUBY_ENCODING_H
rb_enc_copy(rb_out_buf, str);
#endif
return rb_out_buf;
}
caryll_buffer *caryll_write_gsub_ligature_subtable(otl_subtable *_subtable) {
caryll_buffer *buf = bufnew();
subtable_gsub_ligature *subtable = &(_subtable->gsub_ligature);
ligature_aggerator *h = NULL, *s, *tmp;
uint16_t nLigatures = subtable->to->numGlyphs;
for (uint16_t j = 0; j < nLigatures; j++) {
int sgid = subtable->from[j]->glyphs[0].gid;
HASH_FIND_INT(h, &sgid, s);
if (!s) {
NEW(s);
s->gid = sgid;
s->ligid = HASH_COUNT(h);
HASH_ADD_INT(h, gid, s);
}
}
HASH_SORT(h, by_gid);
otl_coverage *startCoverage;
NEW(startCoverage);
startCoverage->numGlyphs = HASH_COUNT(h);
NEW_N(startCoverage->glyphs, startCoverage->numGlyphs);
uint16_t jj = 0;
foreach_hash(s, h) {
s->ligid = jj;
startCoverage->glyphs[jj].gid = s->gid;
startCoverage->glyphs[jj].name = NULL;
jj++;
}
static PyObject *
snudown_md(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {"text", "nofollow", "target", NULL};
struct buf ib, *ob;
PyObject *py_result;
const char* result_text;
memset(&ib, 0x0, sizeof(struct buf));
/* Parse arguments */
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|iz", kwlist,
&ib.data, &ib.size, &_state.options.nofollow, &_state.options.target)) {
return NULL;
}
/* Output buffer */
ob = bufnew(128);
/* do the magic */
sd_markdown_render(ob, ib.data, ib.size, sundown);
/* make a Python string */
result_text = "";
if (ob->data)
result_text = (const char*)ob->data;
py_result = Py_BuildValue("s#", result_text, (int)ob->size);
/* Cleanup */
bufrelease(ob);
return py_result;
}
static VALUE rb_redcarpet_md_render(VALUE self, VALUE text)
{
VALUE rb_rndr;
struct buf *output_buf;
struct sd_markdown *markdown;
Check_Type(text, T_STRING);
check_utf8_encoding(text);
rb_rndr = rb_iv_get(self, "@renderer");
Data_Get_Struct(self, struct sd_markdown, markdown);
if (rb_respond_to(rb_rndr, rb_intern("preprocess")))
text = rb_funcall(rb_rndr, rb_intern("preprocess"), 1, text);
/* initialize buffers */
output_buf = bufnew(128);
/* render the magic */
sd_markdown_render(
output_buf,
RSTRING_PTR(text),
RSTRING_LEN(text),
markdown);
/* build the Ruby string */
text = redcarpet_str_new(output_buf->data, output_buf->size);
bufrelease(output_buf);
if (rb_respond_to(rb_rndr, rb_intern("postprocess")))
text = rb_funcall(rb_rndr, rb_intern("postprocess"), 1, text);
return text;
}
int
main(int argc, char **argv)
{
int i;
bd_status_t sts = BD_SUCCESS;
struct buf *ib, *ob;
FILE *in;
/* performing markdown parsing */
ib = bufnew(READ_UNIT);
ob = bufnew(OUTPUT_UNIT);
if (ib && ob)
{
if (argc <= 1)
sts = bd_io(ob, ib, stdin);
for (i = 1; i < argc && BD_SUCCESS == sts; ++i)
{
if ((in = fopen(argv[i], "r")))
{
sts = bd_io(ob, ib, in);
fclose(in);
/* reset buffet for next step */
bufreset(ib);
bufreset(ob);
}
else
{
sts = BD_UNABLE_OPEN_FILE;
}
}
}
else
{
sts = BD_UNABLE_ALLOCATE_MEMORY;
}
/* cleanup */
bufrelease(ib);
bufrelease(ob);
/* result output with status */
bd_result(sts);
return sts;
}
caryll_Buffer *cff_build_Charset(cff_Charset cset) {
switch (cset.t) {
case cff_CHARSET_ISOADOBE:
case cff_CHARSET_EXPERT:
case cff_CHARSET_EXPERTSUBSET: {
return bufnew();
}
case cff_CHARSET_FORMAT0: {
caryll_Buffer *blob = bufnew();
blob->size = 1 + cset.s * 2;
NEW(blob->data, blob->size);
blob->data[0] = 0;
for (uint32_t i = 0; i < cset.s; i++)
blob->data[1 + 2 * i] = cset.f0.glyph[i] / 256, blob->data[2 + 2 * i] = cset.f0.glyph[i] % 256;
blob->cursor = blob->size;
return blob;
}
case cff_CHARSET_FORMAT1: {
caryll_Buffer *blob = bufnew();
blob->size = 1 + cset.s * 3;
NEW(blob->data, blob->size);
blob->data[0] = 1;
for (uint32_t i = 0; i < cset.s; i++)
blob->data[1 + 3 * i] = cset.f1.range1[i].first / 256,
blob->data[2 + 3 * i] = cset.f1.range1[i].first % 256,
blob->data[3 + 3 * i] = cset.f1.range1[i].nleft;
return blob;
}
case cff_CHARSET_FORMAT2: {
caryll_Buffer *blob = bufnew();
blob->size = 1 + cset.s * 4;
NEW(blob->data, blob->size);
blob->data[0] = 2;
for (uint32_t i = 0; i < cset.s; i++)
blob->data[1 + 4 * i] = cset.f2.range2[i].first / 256,
blob->data[2 + 4 * i] = cset.f2.range2[i].first % 256,
blob->data[3 + 4 * i] = cset.f2.range2[i].nleft / 256,
blob->data[4 + 4 * i] = cset.f2.range2[i].nleft % 256;
blob->cursor = blob->size;
return blob;
}
}
return NULL;
}
static PyObject *
misaka_render(const char *text, unsigned int extensions,
unsigned int render_flags, char toc_only)
{
struct buf *ib, *ob;
struct mkd_renderer renderer;
/* Input buffer */
ib = bufnew(1);
bufputs(ib, text);
/* Output buffer */
ob = bufnew(ib->size * 1.2);
/* Parse Markdown */
if (toc_only != -1) {
upshtml_toc_renderer(&renderer);
} else {
upshtml_renderer(&renderer, render_flags);
}
ups_markdown(ob, ib, &renderer, extensions);
upshtml_free_renderer(&renderer);
/* Smartypants actions */
if (render_flags & HTML_SMARTYPANTS)
{
struct buf *sb = bufnew(1);
upshtml_smartypants(sb, ob);
ob = bufdup(sb, sb->size); /* Duplicate Smartypants buffer to output buffer */
bufrelease(sb); /* Cleanup Smartypants buffer */
}
/* Append a null terminator to the output buffer and make a Python string */
bufnullterm(ob);
PyObject *html = Py_BuildValue("s", ob->data);
/* Cleanup */
bufrelease(ib);
bufrelease(ob);
return html;
}
int main()
{
const char TEST_STRING[] = "This ♣ is & just "an example♦"";
struct buf *buffer;
buffer = bufnew(128);
houdini_unescape_html(buffer, TEST_STRING, strlen(TEST_STRING));
printf("Result: %.*s\n", (int)buffer->size, buffer->data);
bufrelease(buffer);
return 0;
}
/* 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; }
caryll_Buffer *bufninit(uint32_t n, ...) {
caryll_Buffer *buf = bufnew();
bufbeforewrite(buf, n);
va_list ap;
va_start(ap, n);
for (uint16_t j = 0; j < n; j++) {
bufwrite8(buf, (uint8_t)va_arg(ap, int));
}
va_end(ap);
return buf;
}
int
main(int argc, char **argv)
{
struct buf *ib, *ob;
size_t ret;
FILE *in = stdin;
/* opening the file if given from the command line */
if (argc > 1) {
in = fopen(argv[1], "r");
if (!in) {
fprintf(stderr, "Unable to open input file \"%s\": %s\n", argv[0], strerror(errno));
return 1;
}
}
/* reading everything */
ib = bufnew(READ_UNIT);
bufgrow(ib, READ_UNIT);
while ((ret = fread(ib->data + ib->size, 1, ib->asize - ib->size, in)) > 0) {
ib->size += ret;
bufgrow(ib, ib->size + READ_UNIT);
}
if (in != stdin)
fclose(in);
/* performing markdown parsing */
ob = bufnew(OUTPUT_UNIT);
ups_xhtml_smartypants(ob, ib);
/* writing the result to stdout */
fwrite(ob->data, 1, ob->size, stdout);
/* cleanup */
bufrelease(ib);
bufrelease(ob);
return 0;
}
BOOL convMd2Html(LPCTSTR outpath, const CString& csspath)
{
struct buf *ob;
int ret;
FILE *outf = NULL;
unsigned int extensions = 0xff;
char hHead[] = "<!DOCTYPE html>\n<html>\n<head>\n<meta charset=""utf-8"">\n";
char hSym[] = "<link href=""%s"" rel=""stylesheet""></link>\n</head>\n<body>\n";
char hTail[] = "</body>\n</html>";
char *hCSS = NULL;
struct sd_callbacks callbacks;
struct html_renderopt options;
struct sd_markdown *markdown;
char *cssbuf = unicode2Utf8((LPCTSTR)csspath, csspath.GetLength());
int aclen = strlen(cssbuf) + strlen(hSym);
hCSS = (char*)malloc(aclen+1);
memset(hCSS, 0, aclen);
sprintf(hCSS, "<link href=""%s"" rel=""stylesheet""></link>\n</head>\n<body>\n", cssbuf);
free(cssbuf);
/* performing markdown parsing */
ob = bufnew(OUTPUT_UNIT);
//extensions = MKDEXT_TABLES|MKDEXT_FENCED_CODE|MKDEXT_AUTOLINK|MKDEXT_STRIKETHROUGH|MKDEXT_SUPERSCRIPT|MKDEXT_LAX_SPACING;
sdhtml_renderer(&callbacks, &options, 0);
markdown = sd_markdown_new(extensions, 16, &callbacks, &options);
sd_markdown_render(ob, mib_utf8->data, mib_utf8->size, markdown);
sd_markdown_free(markdown);
outf = _tfopen(outpath, _T("w"));
if(outf != NULL) {
fwrite(hHead, 1, strlen(hHead), outf);
fwrite(hCSS, 1, strlen(hCSS), outf);
/* writing the result to stdout */
ret = fwrite(ob->data, 1, ob->size, outf);
fwrite(hTail, 1, strlen(hTail), outf);
fclose(outf);
}
/* cleanup */
free(hCSS);
bufrelease(mib_utf8);
bufrelease(ob);
mib_utf8 = NULL;
return TRUE;
}
/* main • main function, interfacing STDIO with the parser */
int
main(int argc, char **argv) {
struct buf *ib, *ob;
size_t ret;
FILE *in = stdin;
/* opening the file if given from the command line */
if (argc > 1) {
in = fopen(argv[1], "r");
if (!in) {
fprintf(stderr,"Unable to open input file \"%s\": %s\n",
argv[1], strerror(errno));
return 1; } }
/* reading everything */
ib = bufnew(READ_UNIT);
bufgrow(ib, READ_UNIT);
while ((ret = fread(ib->data + ib->size, 1,
ib->asize - ib->size, in)) > 0) {
ib->size += ret;
bufgrow(ib, ib->size + READ_UNIT); }
if (in != stdin) fclose(in);
/* performing markdown to LaTeX */
ob = bufnew(OUTPUT_UNIT);
markdown(ob, ib, &to_latex);
/* writing the result to stdout */
ret = fwrite(ob->data, 1, ob->size, stdout);
if (ret < ob->size)
fprintf(stderr, "Warning: only %zu output byte written, "
"out of %zu\n",
ret,
ob->size);
/* cleanup */
bufrelease(ib);
bufrelease(ob);
return 0; }
void getEditText(LPCTSTR unicode, UINT nLen)
{
int idx = 0;
int len = WideCharToMultiByte(CP_UTF8, 0, unicode, nLen, NULL, 0, NULL, NULL);
mib_utf8 = bufnew(READ_UNIT);
bufgrow(mib_utf8, len+idx+1);
memset(mib_utf8->data, 0, mib_utf8->asize);
//memcpy(mib_utf8->data, UTF8_BOM, idx);
//mib_utf8->size += idx;
mib_utf8->size += WideCharToMultiByte(CP_UTF8, 0, unicode, nLen, (LPSTR)&mib_utf8->data[idx], len, NULL, NULL);
}
static inline struct buf *
rndr_newbuf(struct render *rndr)
{
struct buf *work = NULL;
if (rndr->work.size < rndr->work.asize) {
work = rndr->work.item[rndr->work.size++];
work->size = 0;
} else {
work = bufnew(WORK_UNIT);
parr_push(&rndr->work, work);
}
return work;
}
tdRenderer::tdRenderer(QPlainTextEdit *editor, int extensions, QWebElement body)
: QObject(editor),
m_ext(extensions),
m_editor(editor),
m_undoStack(new QUndoStack(this)),
m_buffer(bufnew(1024)),
m_tmpbuffer(bufnew(1024)),
m_markdown(initSundown()),
m_body(body),
m_fframe(0),
m_lframe(0),
m_count(0),
m_index(1),
m_pants(true),
m_undoSteps(0),
m_isUndoRedo(false)
{
connect(m_editor, SIGNAL(cursorPositionChanged()), this, SLOT(updateFrameInterval()));
connect(m_editor, SIGNAL(selectionChanged()), this, SLOT(updateFrameInterval()));
connect(editor->document(), SIGNAL(contentsChange(int, int, int)),
this, SLOT(parseMarkdown(int, int, int)));
updateFrameInterval();
}
static VALUE rb_redcarpet_smartypants_render(VALUE self, VALUE text)
{
VALUE result;
struct buf *output_buf;
Check_Type(text, T_STRING);
output_buf = bufnew(128);
sdhtml_smartypants(output_buf, RSTRING_PTR(text), RSTRING_LEN(text));
result = redcarpet_str_new(output_buf->data, output_buf->size, rb_enc_get(text));
bufrelease(output_buf);
return result;
}
/**
* returns html. NOTE that buffer NEEDS to be deallocated using bufrelease(output_buf);!!!
*/
static struct buf *ghmd_to_html(char const *text, const size_t textSize) {
struct buf *output_buf;
struct sd_markdown *md = g_markdown.md;
/* initialize buffers */
output_buf = bufnew(256);
/* render the magic */
sd_markdown_render(output_buf, text, textSize, md);
//printf((char const *) output_buf->data);
//printf("size %d\n", (int) output_buf->size);
//printf("asize %d\n", (int) output_buf->asize);
return output_buf;
}
