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;
}
/* 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;
}
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);
}
/* 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 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;
}
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;
}
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;
}
/**
* 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;
}
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_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;
}
/* 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; }
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;
}
/**
* 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;
}
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;
}
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;
}
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;
}
/* 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; }
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;
}
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);
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);
if (NIL_P(text))
return Qnil;
#ifdef HAVE_RUBY_ENCODING_H
{
struct rb_redcarpet_rndr *renderer;
Data_Get_Struct(rb_rndr, struct rb_redcarpet_rndr, renderer);
renderer->options.active_enc = rb_enc_get(text);
}
#endif
/* initialize buffers */
output_buf = bufnew(128);
/* render the magic */
sd_markdown_render(
output_buf,
(const uint8_t*)RSTRING_PTR(text),
RSTRING_LEN(text),
markdown);
/* build the Ruby string */
text = rb_enc_str_new((const char*)output_buf->data, output_buf->size, rb_enc_get(text));
bufrelease(output_buf);
if (rb_respond_to(rb_rndr, rb_intern("postprocess")))
text = rb_funcall(rb_rndr, rb_intern("postprocess"), 1, text);
return text;
}
static int markdown_link(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque) {
struct markdown_state *const state = opaque;
if(0 != bufprefix(link, "hash://")) {
return state->link(ob, link, title, content, opaque);
}
// TODO: Query string escaping
struct buf *rel = bufnew(strlen("?q=")+link->size);
bufputs(rel, "?q=");
bufput(rel, link->data, link->size);
int const r = state->link(ob, rel, title, content, opaque);
bufrelease(rel);
bufputs(ob, "<sup>[");
struct buf icon = BUF_STATIC("#");
struct buf info = BUF_STATIC("Hash address");
state->link(ob, link, &info, &icon, opaque);
bufputs(ob, "]</sup>");
return r;
}
QString markDown(QString text) {
struct sd_callbacks callbacks;
struct html_renderopt options;
sdhtml_renderer(&callbacks, &options, 0);
struct sd_markdown* markdown = sd_markdown_new(0, 16, &callbacks, &options);
struct buf* ob = bufnew(64);
// QByteArray ba = text.toLocal8Bit();
QByteArray ba = text.toUtf8();
sd_markdown_render(ob, (const unsigned char*)ba.constData(), ba.size(),
markdown);
sd_markdown_free(markdown);
// QString ret = QString::fromLocal8Bit((char*)ob->data, ob->size);
QString ret = QString::fromUtf8((char*)ob->data, ob->size);
bufrelease(ob);
return ret.trimmed();
}
BOOL CmdwEditorDoc::OnNewDocument()
{
if (!CDocument::OnNewDocument())
return FALSE;
// TODO: add reinitialization code here
// (SDI documents will reuse this document)
if(m_bHtmlExisted)
{
POSITION pos = this->GetFirstViewPosition();
CView* cv = NULL;
CEditView* pEv = NULL;
do {
cv = this->GetNextView(pos);
if( cv != NULL && cv->IsKindOf(RUNTIME_CLASS(CEditView))) {
pEv = (CEditView*)cv;
break;
}
} while(cv != NULL);
if(pEv != NULL)
pEv->SetWindowText(_T(" "));
if(mib_utf8 != NULL) {
bufrelease(mib_utf8);
mib_utf8 = NULL;
}
FILE *fp = _tfopen((LPCTSTR)m_htmlPath, _T("w"));
if(fp != NULL) {
char hHead[] = "<!DOCTYPE html><html><head><meta charset=""utf-8""></head><body></body></html>";
fwrite(hHead, 1, sizeof(hHead), fp);
fclose(fp);
}
this->UpdateAllViews(NULL, (LPARAM)(LPCTSTR)m_htmlPath, NULL);
}
return TRUE;
}
BOOL readUtf8Data(CFile* pCF)
{
int ret;
if(pCF == NULL) return FALSE;
if(mib_utf8 != NULL) {
bufrelease(mib_utf8);
mib_utf8 = NULL;
}
/* reading everything */
mib_utf8 = bufnew(READ_UNIT);
bufgrow(mib_utf8, READ_UNIT);
while ((ret = pCF->Read(mib_utf8->data + mib_utf8->size, mib_utf8->asize - mib_utf8->size)) > 0) {
mib_utf8->size += ret;
bufgrow(mib_utf8, mib_utf8->size + READ_UNIT);
}
return TRUE;
}
tdRenderer::~tdRenderer()
{
bufrelease(m_buffer);
bufrelease(m_tmpbuffer);
sd_markdown_free(m_markdown);
}
static Rboolean render_to_html(struct buf *ib, struct buf *ob,
SEXP Soptions, SEXP Sextensions)
{
struct sd_callbacks callbacks;
struct html_renderopt renderopt;
unsigned int exts=0, options=0;
struct sd_markdown *markdown;
struct buf *htmlbuf;
Rboolean toc = FALSE, smarty = FALSE;
/* Marshal extensions */
if (isString(Sextensions))
{
int i;
for (i = 0; i < LENGTH(Sextensions); i++)
{
if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"NO_INTRA_EMPHASIS") == 0)
exts |= MKDEXT_NO_INTRA_EMPHASIS;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"TABLES") == 0)
exts |= MKDEXT_TABLES;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"FENCED_CODE") == 0)
exts |= MKDEXT_FENCED_CODE;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"AUTOLINK") == 0)
exts |= MKDEXT_AUTOLINK;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"STRIKETHROUGH") == 0)
exts |= MKDEXT_STRIKETHROUGH;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"LAX_SPACING") == 0)
exts |= MKDEXT_LAX_SPACING;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"SPACE_HEADERS") == 0)
exts |= MKDEXT_SPACE_HEADERS;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"SUPERSCRIPT") == 0)
exts |= MKDEXT_SUPERSCRIPT;
else if (strcasecmp(CHAR(STRING_ELT(Sextensions,i)),
"LATEX_MATH") == 0)
exts |= MKDEXT_LATEX_MATH;
}
}
/* Marshal HTML options */
if (isString(Soptions))
{
int i;
for (i = 0; i < LENGTH(Soptions); i++)
{
if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"SKIP_HTML") == 0)
options |= HTML_SKIP_HTML;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"SKIP_STYLE") == 0)
options |= HTML_SKIP_STYLE;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"SKIP_IMAGES") == 0)
options |= HTML_SKIP_IMAGES;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"SKIP_LINKS") == 0)
options |= HTML_SKIP_LINKS;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"SAFELINK") == 0)
options |= HTML_SAFELINK;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"TOC") == 0)
{
options |= HTML_TOC;
toc = TRUE;
}
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"HARD_WRAP") == 0)
options |= HTML_HARD_WRAP;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"USE_XHTML") == 0)
options |= HTML_USE_XHTML;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"ESCAPE") == 0)
options |= HTML_ESCAPE;
else if (strcasecmp(CHAR(STRING_ELT(Soptions,i)),
"SMARTYPANTS") == 0)
smarty = TRUE;
}
}
htmlbuf = bufnew(OUTPUT_UNIT);
if (!htmlbuf)
{
RMD_WARNING_NOMEM;
return FALSE;
}
if (toc==TRUE)
{
struct buf *tocbuf = bufnew(OUTPUT_UNIT);
if (!tocbuf)
{
RMD_WARNING_NOMEM;
return FALSE;
}
sdhtml_toc_renderer(&callbacks, &renderopt);
markdown = sd_markdown_new(exts,16,&callbacks,(void *)&renderopt);
if (!markdown)
{
RMD_WARNING_NOMEM;
return FALSE;
}
sd_markdown_render(tocbuf, ib->data, ib->size, markdown);
sd_markdown_free(markdown);
bufputs(htmlbuf,"<div id=\"toc\">\n");
bufputs(htmlbuf,"<div id=\"toc_header\">Table of Contents</div>\n");
bufput(htmlbuf,tocbuf->data,tocbuf->size);
bufputs(htmlbuf,"</div>\n");
bufputs(htmlbuf,"\n");
bufrelease(tocbuf);
}
sdhtml_renderer(&callbacks, &renderopt, options);
markdown = sd_markdown_new(exts,16,&callbacks,(void *)&renderopt);
if (!markdown)
{
RMD_WARNING_NOMEM;
return FALSE;
}
sd_markdown_render(htmlbuf, ib->data, ib->size, markdown);
sd_markdown_free(markdown);
if (smarty==TRUE)
{
struct buf *smartybuf = bufnew(OUTPUT_UNIT);
if (!smartybuf)
{
RMD_WARNING_NOMEM;
return FALSE;
}
sdhtml_smartypants(smartybuf,htmlbuf->data,htmlbuf->size);
bufrelease(htmlbuf);
htmlbuf = smartybuf;
}
bufput(ob,htmlbuf->data,htmlbuf->size);
bufrelease(htmlbuf);
return TRUE;
}
static PyObject *
snudown_md(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {"text", "nofollow", "target", "toc_id_prefix", "renderer", "enable_toc", NULL};
struct buf ib, *ob;
PyObject *py_result;
const char* result_text;
int renderer = RENDERER_USERTEXT;
int enable_toc = 0;
struct snudown_renderer _snudown;
int nofollow = 0;
char* target = NULL;
char* toc_id_prefix = NULL;
unsigned int flags;
memset(&ib, 0x0, sizeof(struct buf));
/* Parse arguments */
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|izzii", kwlist,
&ib.data, &ib.size, &nofollow,
&target, &toc_id_prefix, &renderer, &enable_toc)) {
return NULL;
}
if (renderer < 0 || renderer >= RENDERER_COUNT) {
PyErr_SetString(PyExc_ValueError, "Invalid renderer");
return NULL;
}
_snudown = sundown[renderer];
struct snudown_renderopt *options = &(_snudown.state->options);
options->nofollow = nofollow;
options->target = target;
/* Output buffer */
ob = bufnew(128);
flags = options->html.flags;
if (enable_toc) {
_snudown.toc_state->options.html.toc_id_prefix = toc_id_prefix;
sd_markdown_render(ob, ib.data, ib.size, _snudown.toc_renderer);
_snudown.toc_state->options.html.toc_id_prefix = NULL;
options->html.flags |= HTML_TOC;
}
options->html.toc_id_prefix = toc_id_prefix;
/* do the magic */
sd_markdown_render(ob, ib.data, ib.size, _snudown.main_renderer);
options->html.toc_id_prefix = NULL;
options->html.flags = flags;
/* 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;
}
