markdown/0000755000176200001440000000000012516002652012073 5ustar liggesusersmarkdown/inst/0000755000176200001440000000000012515736624013064 5ustar liggesusersmarkdown/inst/COPYING0000644000176200001440000004345312330062343014111 0ustar liggesusersThe markdown package is licensed to you under the GPLv2, the terms of which are included below. The markdown pacakge includes other open source software whose license terms can be found in the file NOTICE. GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. markdown/inst/examples/0000755000176200001440000000000012515340370014667 5ustar liggesusersmarkdown/inst/examples/HTMLOptions.R0000644000176200001440000000365212515340370017140 0ustar liggesusers# HTML OPTIONS # The following examples are short, so we allways add the HTML option 'fragment_only' tOpt <- "fragment_only" # skip_html example mkd = 'Hello' cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html"))) # skip_style example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_style"))) # skip_images example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_images"))) # skip_links example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_links"))) # safelink example cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt))) cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt, "safelink"))) # toc example mkd <- paste(c("# Header 1", "p1", "## Header 2", "p2"), collapse = "\n") cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "toc"))) # hard_wrap example cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt))) cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap"))) # use_xhtml example cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap"))) cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap", "use_xhtml"))) # escape example mkd = 'Hello' cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html"))) # overrides all 'skip_*' options cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html", "escape"))) # smartypants example cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt))) cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt, "smartypants"))) cat(smartypants(text = "1/2 (c)\n")) markdown/inst/examples/markdownExtensions.R0000644000176200001440000000434212330062343020713 0ustar liggesusers# The following examples are short, so we set the HTML option 'fragment_only' options(markdown.HTML.options = "fragment_only") # no_intra_emphasis example cat(markdownToHTML(text = "foo_bar_function", extensions = c())) cat(markdownToHTML(text = "foo_bar_function", extensions = c("no_intra_emphasis"))) # tables example (need 4 spaces at beginning of line here) cat(markdownToHTML(text = " First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell ", extensions = c())) # but not here cat(markdownToHTML(text = " First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell ", extensions = c("tables"))) # fenced_code example (need at least three leading ~ or `) fenced_block <- function(text, x = "`", n = 3) { fence <- paste(rep(x, n), collapse = "") paste(fence, text, fence, sep = "") } cat(markdownToHTML(text = fenced_block(" preformatted text here without having to indent first line. "), extensions = c())) cat(markdownToHTML(text = fenced_block(" preformatted text here without having to indent first line. "), extensions = c("fenced_code"))) # autolink example cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c())) cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c("autolink"))) # strikethrough example cat(markdownToHTML(text = "~~awesome~~", extensions = c())) cat(markdownToHTML(text = "~~awesome~~", extensions = c("strikethrough"))) # lax_spacing cat(markdownToHTML(text = " Embedding html without surrounding with empty newline.
_markdown_
extra text. ", extensions = c(""))) cat(markdownToHTML(text = " Embedding html without surrounding with empty newline.
_markdown_
extra text. ", extensions = c("lax_spacing"))) # space_headers example cat(markdownToHTML(text = "#A Header\neven though there is no space between # and A", extensions = c(""))) cat(markdownToHTML(text = "#Not A Header\nbecause there is no space between # and N", extensions = c("space_headers"))) # superscript example cat(markdownToHTML(text = "2^10", extensions = c())) cat(markdownToHTML(text = "2^10", extensions = c("superscript"))) markdown/inst/resources/0000755000176200001440000000000012452377124015072 5ustar liggesusersmarkdown/inst/resources/markdown.css0000644000176200001440000000332212364504110017413 0ustar liggesusersbody, td { font-family: sans-serif; background-color: white; font-size: 13px; } body { max-width: 800px; margin: auto; padding: 1em; line-height: 20px; } tt, code, pre { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; } h1 { font-size:2.2em; } h2 { font-size:1.8em; } h3 { font-size:1.4em; } h4 { font-size:1.0em; } h5 { font-size:0.9em; } h6 { font-size:0.8em; } a:visited { color: rgb(50%, 0%, 50%); } pre, img { max-width: 100%; } pre { overflow-x: auto; } pre code { display: block; padding: 0.5em; } code { font-size: 92%; border: 1px solid #ccc; } code[class] { background-color: #F8F8F8; } table, td, th { border: none; } blockquote { color:#666666; margin:0; padding-left: 1em; border-left: 0.5em #EEE solid; } hr { height: 0px; border-bottom: none; border-top-width: thin; border-top-style: dotted; border-top-color: #999999; } @media print { * { background: transparent !important; color: black !important; filter:none !important; -ms-filter: none !important; } body { font-size:12pt; max-width:100%; } a, a:visited { text-decoration: underline; } hr { visibility: hidden; page-break-before: always; } pre, blockquote { padding-right: 1em; page-break-inside: avoid; } tr, img { page-break-inside: avoid; } img { max-width: 100% !important; } @page :left { margin: 15mm 20mm 15mm 10mm; } @page :right { margin: 15mm 10mm 15mm 20mm; } p, h2, h3 { orphans: 3; widows: 3; } h2, h3 { page-break-after: avoid; } } markdown/inst/resources/markdown.html0000644000176200001440000000115712364515712017605 0ustar liggesusers #!title# #!r_highlight# #!mathjax# #!header# #!html_output# markdown/inst/resources/mathjax.html0000644000176200001440000000023112375213146017405 0ustar liggesusers markdown/inst/resources/r_highlight.html0000644000176200001440000002531012330062343020236 0ustar liggesusers markdown/inst/doc/0000755000176200001440000000000012515736624013631 5ustar liggesusersmarkdown/inst/doc/markdown-examples.Rmd0000644000176200001440000000133412515736624017734 0ustar liggesusers This vignette shows some examples for different Markdown extensions and HTML options. ```{r read-code, include=FALSE} library(knitr) opts_chunk$set(tidy = FALSE) # otherwise \n will cause problems read_chunk(system.file('examples', 'markdownExtensions.R', package = 'markdown'), labels = 'md-extensions') read_chunk(system.file('examples', 'HTMLOptions.R', package = 'markdown'), labels = 'html-options') ``` ```{r} library(markdown) ``` # Markdown Extensions ```{r md-extensions} ``` # HTML Options ```{r html-options} ``` ```{r include=FALSE} options(markdown.HTML.options=markdownHTMLOptions(defaults=TRUE)) ``` markdown/inst/doc/markdown-examples.html0000644000176200001440000006052412515736624020164 0ustar liggesusers Markdown Extensions

This vignette shows some examples for different Markdown extensions and HTML options.

library(markdown)

Markdown Extensions

# The following examples are short, so we set the HTML option 'fragment_only'

options(markdown.HTML.options = "fragment_only")

# no_intra_emphasis example
cat(markdownToHTML(text = "foo_bar_function", extensions = c()))

## <p>foo<em>bar</em>function</p>

cat(markdownToHTML(text = "foo_bar_function", extensions = c("no_intra_emphasis")))

## <p>foo_bar_function</p>

# tables example (need 4 spaces at beginning of line here)
cat(markdownToHTML(text = "
    First Header  | Second Header
    ------------- | -------------
    Content Cell  | Content Cell
    Content Cell  | Content Cell
", extensions = c()))

## <pre><code>First Header  | Second Header
## ------------- | -------------
## Content Cell  | Content Cell
## Content Cell  | Content Cell
## </code></pre>

# but not here
cat(markdownToHTML(text = "
First Header  | Second Header
------------- | -------------
Content Cell  | Content Cell
Content Cell  | Content Cell
", extensions = c("tables")))

## <table><thead>
## <tr>
## <th>First Header</th>
## <th>Second Header</th>
## </tr>
## </thead><tbody>
## <tr>
## <td>Content Cell</td>
## <td>Content Cell</td>
## </tr>
## <tr>
## <td>Content Cell</td>
## <td>Content Cell</td>
## </tr>
## </tbody></table>

# fenced_code example (need at least three leading ~ or `)
fenced_block <- function(text, x = "`", n = 3) {
  fence <- paste(rep(x, n), collapse = "")
  paste(fence, text, fence, sep = "")
}
cat(markdownToHTML(text = fenced_block("
preformatted text here without having to indent
first line.
"), extensions = c()))

## <p><code>
## preformatted text here without having to indent
## first line.
## </code></p>

cat(markdownToHTML(text = fenced_block("
preformatted text here without having to indent
first line.
"), extensions = c("fenced_code")))

## <pre><code>preformatted text here without having to indent
## first line.
## </code></pre>

# autolink example
cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c()))

## <p>http://www.r-project.org/</p>

cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c("autolink")))

## <p><a href="http://www.r-project.org/">http://www.r-project.org/</a></p>

# strikethrough example
cat(markdownToHTML(text = "~~awesome~~", extensions = c()))

## <p>~~awesome~~</p>

cat(markdownToHTML(text = "~~awesome~~", extensions = c("strikethrough")))

## <p><del>awesome</del></p>

# lax_spacing
cat(markdownToHTML(text = "
Embedding html without surrounding with empty newline.
<div>_markdown_</div>
extra text.
", extensions = c("")))

## <p>Embedding html without surrounding with empty newline.
## <div><em>markdown</em></div>
## extra text.</p>

cat(markdownToHTML(text = "
Embedding html without surrounding with empty newline.
<div>_markdown_</div>
extra text.
", extensions = c("lax_spacing")))

## <p>Embedding html without surrounding with empty newline.</p>
## 
## <div>_markdown_</div>
## 
## <p>extra text.</p>

# space_headers example
cat(markdownToHTML(text = "#A Header\neven though there is no space between # and A",
                   extensions = c("")))

## <h1>A Header</h1>
## 
## <p>even though there is no space between # and A</p>

cat(markdownToHTML(text = "#Not A Header\nbecause there is no space between # and N",
                   extensions = c("space_headers")))

## <p>#Not A Header
## because there is no space between # and N</p>

# superscript example
cat(markdownToHTML(text = "2^10", extensions = c()))

## <p>2^10</p>

cat(markdownToHTML(text = "2^10", extensions = c("superscript")))

## <p>2<sup>10</sup></p>

HTML Options

# HTML OPTIONS

# The following examples are short, so we allways add the HTML option 'fragment_only'
tOpt <- "fragment_only"

# skip_html example
mkd = '<style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a>'
cat(markdownToHTML(text = mkd, options = c(tOpt)))

## <p><style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a></p>

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))

## <p>Hello</p>

# skip_style example
cat(markdownToHTML(text = mkd, options = c(tOpt)))

## <p><style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a></p>

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_style")))

## <p><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a></p>

# skip_images example
cat(markdownToHTML(text = mkd, options = c(tOpt)))

## <p><style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a></p>

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_images")))

## <p><style></style><a href="#">Hello</a></p>

# skip_links example
cat(markdownToHTML(text = mkd, options = c(tOpt)))

## <p><style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a></p>

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_links")))

## <p><style></style><img src="http://cran.rstudio.com/Rlogo.jpg">Hello</p>

# safelink example
cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt)))

## <p><a href="http://google.com" title="baz">foo</a></p>

cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt, "safelink")))

## <p><a href="http://google.com" title="baz">foo</a></p>

# toc example
mkd <- paste(c("# Header 1", "p1", "## Header 2", "p2"), collapse = "\n")

cat(markdownToHTML(text = mkd, options = c(tOpt)))

## <h1>Header 1</h1>
## 
## <p>p1</p>
## 
## <h2>Header 2</h2>
## 
## <p>p2</p>

cat(markdownToHTML(text = mkd, options = c(tOpt, "toc")))

## <div id="toc">
## <div id="toc_header">Table of Contents</div>
## <ul>
## <li>
## <a href="#toc_0">Header 1</a>
## <ul>
## <li>
## <a href="#toc_1">Header 2</a>
## </li>
## </ul>
## </li>
## </ul>
## </div>
## 
## 
## <h1 id="toc_0">Header 1</h1>
## 
## <p>p1</p>
## 
## <h2 id="toc_1">Header 2</h2>
## 
## <p>p2</p>

# hard_wrap example
cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt)))

## <p>foo
## bar</p>

cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap")))

## <p>foo<br>
## bar</p>

# use_xhtml example
cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap")))

## <p>foo<br>
## bar</p>

cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap", "use_xhtml")))

## <p>foo<br/>
## bar</p>

# escape example
mkd = '<style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a>'
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))

## <p>Hello</p>

# overrides all 'skip_*' options
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html", "escape")))

## <p>&lt;style&gt;&lt;/style&gt;&lt;img src=&quot;http://cran.rstudio.com/Rlogo.jpg&quot;&gt;&lt;a href=&quot;#&quot;&gt;Hello&lt;/a&gt;</p>

# smartypants example
cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt)))

## <p>1/2 (c)</p>

cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt, "smartypants")))

## <p>&frac12; &copy;</p>

cat(smartypants(text = "1/2 (c)\n"))

## &frac12; &copy;
markdown/inst/doc/markdown-output.R0000644000176200001440000001216512515736624017141 0ustar liggesusers## ----read-code, include=FALSE-------------------------------------------- library(knitr) opts_chunk$set(tidy = FALSE) # otherwise \n will cause problems read_chunk(system.file('examples', 'markdownExtensions.R', package = 'markdown'), labels = 'md-extensions') read_chunk(system.file('examples', 'HTMLOptions.R', package = 'markdown'), labels = 'html-options') ## ------------------------------------------------------------------------ library(markdown) ## ----md-extensions------------------------------------------------------- # The following examples are short, so we set the HTML option 'fragment_only' options(markdown.HTML.options = "fragment_only") # no_intra_emphasis example cat(markdownToHTML(text = "foo_bar_function", extensions = c())) cat(markdownToHTML(text = "foo_bar_function", extensions = c("no_intra_emphasis"))) # tables example (need 4 spaces at beginning of line here) cat(markdownToHTML(text = " First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell ", extensions = c())) # but not here cat(markdownToHTML(text = " First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell ", extensions = c("tables"))) # fenced_code example (need at least three leading ~ or `) fenced_block <- function(text, x = "`", n = 3) { fence <- paste(rep(x, n), collapse = "") paste(fence, text, fence, sep = "") } cat(markdownToHTML(text = fenced_block(" preformatted text here without having to indent first line. "), extensions = c())) cat(markdownToHTML(text = fenced_block(" preformatted text here without having to indent first line. "), extensions = c("fenced_code"))) # autolink example cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c())) cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c("autolink"))) # strikethrough example cat(markdownToHTML(text = "~~awesome~~", extensions = c())) cat(markdownToHTML(text = "~~awesome~~", extensions = c("strikethrough"))) # lax_spacing cat(markdownToHTML(text = " Embedding html without surrounding with empty newline.
_markdown_
extra text. ", extensions = c(""))) cat(markdownToHTML(text = " Embedding html without surrounding with empty newline.
_markdown_
extra text. ", extensions = c("lax_spacing"))) # space_headers example cat(markdownToHTML(text = "#A Header\neven though there is no space between # and A", extensions = c(""))) cat(markdownToHTML(text = "#Not A Header\nbecause there is no space between # and N", extensions = c("space_headers"))) # superscript example cat(markdownToHTML(text = "2^10", extensions = c())) cat(markdownToHTML(text = "2^10", extensions = c("superscript"))) ## ----html-options-------------------------------------------------------- # HTML OPTIONS # The following examples are short, so we allways add the HTML option 'fragment_only' tOpt <- "fragment_only" # skip_html example mkd = 'Hello' cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html"))) # skip_style example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_style"))) # skip_images example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_images"))) # skip_links example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_links"))) # safelink example cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt))) cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt, "safelink"))) # toc example mkd <- paste(c("# Header 1", "p1", "## Header 2", "p2"), collapse = "\n") cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "toc"))) # hard_wrap example cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt))) cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap"))) # use_xhtml example cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap"))) cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap", "use_xhtml"))) # escape example mkd = 'Hello' cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html"))) # overrides all 'skip_*' options cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html", "escape"))) # smartypants example cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt))) cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt, "smartypants"))) cat(smartypants(text = "1/2 (c)\n")) ## ----include=FALSE------------------------------------------------------- options(markdown.HTML.options=markdownHTMLOptions(defaults=TRUE)) ## ----read, include=FALSE------------------------------------------------- library(knitr) opts_chunk$set(results = 'asis') out = knit_child(text = scan('markdown-examples.Rmd', what = 'character', skip = 7, sep = '\n')) markdown/inst/doc/markdown-output.html0000644000176200001440000005356712515736624017717 0ustar liggesusers Markdown Extensions

This vignette shows how the output looks like in HTML from the other vignette markdown-examples.Rmd, in which the literal HTML code was shown.

library(markdown)

Markdown Extensions

# The following examples are short, so we set the HTML option 'fragment_only'

options(markdown.HTML.options = "fragment_only")

# no_intra_emphasis example
cat(markdownToHTML(text = "foo_bar_function", extensions = c()))

foobarfunction

cat(markdownToHTML(text = "foo_bar_function", extensions = c("no_intra_emphasis")))

foo_bar_function

# tables example (need 4 spaces at beginning of line here)
cat(markdownToHTML(text = "
    First Header  | Second Header
    ------------- | -------------
    Content Cell  | Content Cell
    Content Cell  | Content Cell
", extensions = c()))

First Header  | Second Header
------------- | -------------
Content Cell  | Content Cell
Content Cell  | Content Cell

# but not here
cat(markdownToHTML(text = "
First Header  | Second Header
------------- | -------------
Content Cell  | Content Cell
Content Cell  | Content Cell
", extensions = c("tables")))
First Header Second Header
Content Cell Content Cell
Content Cell Content Cell 
# fenced_code example (need at least three leading ~ or `)
fenced_block <- function(text, x = "`", n = 3) {
  fence <- paste(rep(x, n), collapse = "")
  paste(fence, text, fence, sep = "")
}
cat(markdownToHTML(text = fenced_block("
preformatted text here without having to indent
first line.
"), extensions = c()))

preformatted text here without having to indent first line. 

cat(markdownToHTML(text = fenced_block("
preformatted text here without having to indent
first line.
"), extensions = c("fenced_code")))

preformatted text here without having to indent
first line.

# autolink example
cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c()))

http://www.r-project.org/

cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c("autolink")))

http://www.r-project.org/

# strikethrough example
cat(markdownToHTML(text = "~~awesome~~", extensions = c()))

~~awesome~~

cat(markdownToHTML(text = "~~awesome~~", extensions = c("strikethrough")))

awesome

# lax_spacing
cat(markdownToHTML(text = "
Embedding html without surrounding with empty newline.
<div>_markdown_</div>
extra text.
", extensions = c("")))

Embedding html without surrounding with empty newline.

markdown
extra text.

cat(markdownToHTML(text = "
Embedding html without surrounding with empty newline.
<div>_markdown_</div>
extra text.
", extensions = c("lax_spacing")))

Embedding html without surrounding with empty newline.

_markdown_

extra text.

# space_headers example
cat(markdownToHTML(text = "#A Header\neven though there is no space between # and A",
                   extensions = c("")))

A Header

even though there is no space between # and A

cat(markdownToHTML(text = "#Not A Header\nbecause there is no space between # and N",
                   extensions = c("space_headers")))

#Not A Header because there is no space between # and N

# superscript example
cat(markdownToHTML(text = "2^10", extensions = c()))

2^10

cat(markdownToHTML(text = "2^10", extensions = c("superscript")))

210

HTML Options

# HTML OPTIONS

# The following examples are short, so we allways add the HTML option 'fragment_only'
tOpt <- "fragment_only"

# skip_html example
mkd = '<style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a>'
cat(markdownToHTML(text = mkd, options = c(tOpt)))

Hello

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))

Hello

# skip_style example
cat(markdownToHTML(text = mkd, options = c(tOpt)))

Hello

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_style")))

Hello

# skip_images example
cat(markdownToHTML(text = mkd, options = c(tOpt)))

Hello

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_images")))

Hello

# skip_links example
cat(markdownToHTML(text = mkd, options = c(tOpt)))

Hello

cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_links")))

Hello

# safelink example
cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt)))

foo

cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt, "safelink")))

foo

# toc example
mkd <- paste(c("# Header 1", "p1", "## Header 2", "p2"), collapse = "\n")

cat(markdownToHTML(text = mkd, options = c(tOpt)))

Header 1

p1

Header 2

p2

cat(markdownToHTML(text = mkd, options = c(tOpt, "toc")))
Table of Contents

Header 1

p1

Header 2

p2

# hard_wrap example
cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt)))

foo bar

cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap")))

foo
bar

# use_xhtml example
cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap")))

foo
bar

cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap", "use_xhtml")))

foo
bar

# escape example
mkd = '<style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a>'
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))

Hello

# overrides all 'skip_*' options
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html", "escape")))

<style></style><img src=“http://cran.rstudio.com/Rlogo.jpg”><a href=“#”>Hello</a>

# smartypants example
cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt)))

½ ©

cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt, "smartypants")))

½ ©

cat(smartypants(text = "1/2 (c)\n"))

½ ©

markdown/inst/doc/markdown-examples.R0000644000176200001440000001162712515736624017421 0ustar liggesusers## ----read-code, include=FALSE-------------------------------------------- library(knitr) opts_chunk$set(tidy = FALSE) # otherwise \n will cause problems read_chunk(system.file('examples', 'markdownExtensions.R', package = 'markdown'), labels = 'md-extensions') read_chunk(system.file('examples', 'HTMLOptions.R', package = 'markdown'), labels = 'html-options') ## ------------------------------------------------------------------------ library(markdown) ## ----md-extensions------------------------------------------------------- # The following examples are short, so we set the HTML option 'fragment_only' options(markdown.HTML.options = "fragment_only") # no_intra_emphasis example cat(markdownToHTML(text = "foo_bar_function", extensions = c())) cat(markdownToHTML(text = "foo_bar_function", extensions = c("no_intra_emphasis"))) # tables example (need 4 spaces at beginning of line here) cat(markdownToHTML(text = " First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell ", extensions = c())) # but not here cat(markdownToHTML(text = " First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell ", extensions = c("tables"))) # fenced_code example (need at least three leading ~ or `) fenced_block <- function(text, x = "`", n = 3) { fence <- paste(rep(x, n), collapse = "") paste(fence, text, fence, sep = "") } cat(markdownToHTML(text = fenced_block(" preformatted text here without having to indent first line. "), extensions = c())) cat(markdownToHTML(text = fenced_block(" preformatted text here without having to indent first line. "), extensions = c("fenced_code"))) # autolink example cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c())) cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c("autolink"))) # strikethrough example cat(markdownToHTML(text = "~~awesome~~", extensions = c())) cat(markdownToHTML(text = "~~awesome~~", extensions = c("strikethrough"))) # lax_spacing cat(markdownToHTML(text = " Embedding html without surrounding with empty newline.
_markdown_
extra text. ", extensions = c(""))) cat(markdownToHTML(text = " Embedding html without surrounding with empty newline.
_markdown_
extra text. ", extensions = c("lax_spacing"))) # space_headers example cat(markdownToHTML(text = "#A Header\neven though there is no space between # and A", extensions = c(""))) cat(markdownToHTML(text = "#Not A Header\nbecause there is no space between # and N", extensions = c("space_headers"))) # superscript example cat(markdownToHTML(text = "2^10", extensions = c())) cat(markdownToHTML(text = "2^10", extensions = c("superscript"))) ## ----html-options-------------------------------------------------------- # HTML OPTIONS # The following examples are short, so we allways add the HTML option 'fragment_only' tOpt <- "fragment_only" # skip_html example mkd = 'Hello' cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html"))) # skip_style example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_style"))) # skip_images example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_images"))) # skip_links example cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_links"))) # safelink example cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt))) cat(markdownToHTML(text = '[foo](http://google.com "baz")', options = c(tOpt, "safelink"))) # toc example mkd <- paste(c("# Header 1", "p1", "## Header 2", "p2"), collapse = "\n") cat(markdownToHTML(text = mkd, options = c(tOpt))) cat(markdownToHTML(text = mkd, options = c(tOpt, "toc"))) # hard_wrap example cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt))) cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap"))) # use_xhtml example cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap"))) cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, "hard_wrap", "use_xhtml"))) # escape example mkd = 'Hello' cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html"))) # overrides all 'skip_*' options cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html", "escape"))) # smartypants example cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt))) cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt, "smartypants"))) cat(smartypants(text = "1/2 (c)\n")) ## ----include=FALSE------------------------------------------------------- options(markdown.HTML.options=markdownHTMLOptions(defaults=TRUE)) markdown/inst/doc/markdown-output.Rmd0000644000176200001440000000070512515736624017457 0ustar liggesusers This vignette shows how the output looks like in HTML from the other vignette `markdown-examples.Rmd`, in which the literal HTML code was shown. ```{r read, include=FALSE} library(knitr) opts_chunk$set(results = 'asis') out = knit_child(text = scan('markdown-examples.Rmd', what = 'character', skip = 7, sep = '\n')) ``` `r paste(out, collapse = '\n')` markdown/inst/NOTICE0000644000176200001440000000401312330062343013747 0ustar liggesusersThe markdown package includes a copy of the Sundown markdown library. The license for the Sundown library is as follows: 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. --- The markdown package also includes source code from http://base64.sourceforge.net/b64.c fetched on 2012-05-11. The license for b64.c is as follows: Copyright (c) 2001 Bob Trower, Trantor Standard Systems Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. markdown/inst/include/0000755000176200001440000000000012452377047014507 5ustar liggesusersmarkdown/inst/include/markdown.h0000644000176200001440000001136512330062343016471 0ustar liggesusers/* 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 UPSKIRT_MARKDOWN_H #define UPSKIRT_MARKDOWN_H #include "buffer.h" #include "autolink.h" #ifdef __cplusplus extern "C" { #endif #define SUNDOWN_VERSION "1.16.0" #define SUNDOWN_VER_MAJOR 1 #define SUNDOWN_VER_MINOR 16 #define SUNDOWN_VER_REVISION 0 /******************** * 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/mailto/etc link */ MKDA_EMAIL, /* e-mail link without explit mailto: */ }; enum mkd_tableflags { MKD_TABLE_ALIGN_L = 1, MKD_TABLE_ALIGN_R = 2, MKD_TABLE_ALIGN_CENTER = 3, MKD_TABLE_ALIGNMASK = 3, MKD_TABLE_HEADER = 4 }; enum mkd_extensions { MKDEXT_NO_INTRA_EMPHASIS = (1 << 0), MKDEXT_TABLES = (1 << 1), MKDEXT_FENCED_CODE = (1 << 2), MKDEXT_AUTOLINK = (1 << 3), MKDEXT_STRIKETHROUGH = (1 << 4), MKDEXT_SPACE_HEADERS = (1 << 6), MKDEXT_SUPERSCRIPT = (1 << 7), MKDEXT_LAX_SPACING = (1 << 8), }; /* sd_callbacks - functions for rendering parsed data */ struct sd_callbacks { /* block level callbacks - NULL skips the block */ void (*blockcode)(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque); void (*blockquote)(struct buf *ob, const struct buf *text, void *opaque); void (*blockhtml)(struct buf *ob,const struct buf *text, void *opaque); void (*header)(struct buf *ob, const struct buf *text, int level, void *opaque); void (*hrule)(struct buf *ob, void *opaque); void (*list)(struct buf *ob, const struct buf *text, int flags, void *opaque); void (*listitem)(struct buf *ob, const struct buf *text, int flags, void *opaque); void (*paragraph)(struct buf *ob, const struct buf *text, void *opaque); void (*table)(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque); void (*table_row)(struct buf *ob, const struct buf *text, void *opaque); void (*table_cell)(struct buf *ob, const struct buf *text, int flags, void *opaque); /* span level callbacks - NULL or return 0 prints the span verbatim */ int (*autolink)(struct buf *ob, const struct buf *link, enum mkd_autolink type, void *opaque); int (*codespan)(struct buf *ob, const struct buf *text, void *opaque); int (*double_emphasis)(struct buf *ob, const struct buf *text, void *opaque); int (*emphasis)(struct buf *ob, const struct buf *text, void *opaque); int (*image)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque); int (*linebreak)(struct buf *ob, void *opaque); int (*link)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque); int (*raw_html_tag)(struct buf *ob, const struct buf *tag, void *opaque); int (*triple_emphasis)(struct buf *ob, const struct buf *text, void *opaque); int (*strikethrough)(struct buf *ob, const struct buf *text, void *opaque); int (*superscript)(struct buf *ob, const struct buf *text, void *opaque); /* low level callbacks - NULL copies input directly into the output */ void (*entity)(struct buf *ob, const struct buf *entity, void *opaque); void (*normal_text)(struct buf *ob, const struct buf *text, void *opaque); /* header and footer */ void (*doc_header)(struct buf *ob, void *opaque); void (*doc_footer)(struct buf *ob, void *opaque); }; struct sd_markdown; /********* * FLAGS * *********/ /* list/listitem flags */ #define MKD_LIST_ORDERED 1 #define MKD_LI_BLOCK 2 /*
  • containing block data */ /********************** * EXPORTED FUNCTIONS * **********************/ extern struct sd_markdown * sd_markdown_new( unsigned int extensions, size_t max_nesting, const struct sd_callbacks *callbacks, void *opaque); extern void sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md); extern void sd_markdown_free(struct sd_markdown *md); extern void sd_version(int *major, int *minor, int *revision); #ifdef __cplusplus } #endif #endif /* vim: set filetype=c: */ markdown/inst/include/markdown_rstubs.h0000644000176200001440000000775012330062343020076 0ustar liggesusers/* * markdown_rstubs.h * * Copyright (C) 2009-2013 by RStudio, Inc. * * This program is licensed to you under the terms of version 2 of the * GNU General Public License. This program is distributed WITHOUT ANY * EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT, * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the * GPL (http://www.gnu.org/licenses/gpl-2.0.txt) for more details. * */ #ifndef MARKDOWN_RSTUBS #define MARKDOWN_RSTUBS #include #include #include "markdown.h" #ifdef __cplusplus extern "C" { #endif /* bufgrow: increasing the allocated size to the given value */ int rstub_bufgrow(struct buf *, size_t); #define bufgrow rstub_bufgrow /* bufnew: allocation of a new buffer */ struct buf *rstub_bufnew(size_t) __attribute__ ((malloc)); #define bufnew rstub_bufnew /* bufnullterm: NUL-termination of the string array (making a C-string) */ const char *rstub_bufcstr(struct buf *); #define bufcstr rstub_bufcstr /* bufprefix: compare the beginning of a buffer with a string */ int rstub_bufprefix(const struct buf *buf, const char *prefix); #define bufprefix rstub_bufprefix /* bufput: appends raw data to a buffer */ void rstub_bufput(struct buf *, const void *, size_t); #define bufput rstub_bufput /* bufputs: appends a NUL-terminated string to a buffer */ void rstub_bufputs(struct buf *, const char *); #define bufputs rstub_bufputs /* bufputc: appends a single char to a buffer */ void rstub_bufputc(struct buf *, int); #define bufputc rstub_bufputc /* bufrelease: decrease the reference count and free the buffer if needed */ void rstub_bufrelease(struct buf *); #define bufrelease rstub_bufrelease /* bufreset: frees internal data of the buffer */ void rstub_bufreset(struct buf *); #define bufreset rstub_bufreset /* bufslurp: removes a given number of bytes from the head of the array */ void rstub_bufslurp(struct buf *, size_t); #define bufslurp rstub_bufslurp /* bufprintf: formatted printing to a buffer */ void rstub_bufprintf(struct buf *, const char *, ...) __attribute__ ((format (printf, 2, 3))); #define bufprintf rstub_bufprintf extern int rstub_sd_autolink_issafe(const uint8_t *link, size_t link_len); #define sd_autolink_issafe rstub_sd_autolink_issafe extern size_t rstub_sd_autolink__www(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); #define sd_autolink__www rstub_sd_autolink__www extern size_t rstub_sd_autolink__email(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); #define sd_autolink__email rstub_sd_autolink__email extern size_t rstub_sd_autolink__url(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); #define sd_autolink__url rstub_sd_autolink__url extern struct sd_markdown * rstub_sd_markdown_new( unsigned int extensions, size_t max_nesting, const struct sd_callbacks *callbacks, void *opaque); #define sd_markdown_new rstub_sd_markdown_new extern void rstub_sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md); #define sd_markdown_render rstub_sd_markdown_render extern void rstub_sd_markdown_free(struct sd_markdown *md); #define sd_markdown_free rstub_sd_markdown_free extern void rstub_sd_version(int *major, int *minor, int *revision); #define sd_version rstub_sd_version struct rmd_renderer { char *name; Rboolean (*render)(struct buf *,struct buf *, SEXP, SEXP); }; Rboolean rstub_rmd_register_renderer(struct rmd_renderer *); #define rmd_register_renderer rstub_rmd_register_renderer Rboolean rstub_rmd_renderer_exists(const char *); #define rmd_renderer_exists rstub_rmd_renderer_exists Rboolean rstub_rmd_buf_to_output(struct buf *, SEXP, SEXP *); #define rmd_buf_to_output rstub_rmd_buf_to_output Rboolean rstub_rmd_input_to_buf(SEXP, SEXP, struct buf *); #define rmd_input_to_buf rstub_rmd_input_to_buf #ifdef __cplusplus } #endif #endif // MARKDOWN_RSTUBS markdown/inst/include/markdown_rstubs.c0000644000176200001440000001711112330062343020061 0ustar liggesusers/* * markdown_rstubs.c * * Copyright (C) 2009-2013 by RStudio, Inc. * * This program is licensed to you under the terms of version 2 of the * GNU General Public License. This program is distributed WITHOUT ANY * EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT, * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the * GPL (http://www.gnu.org/licenses/gpl-2.0.txt) for more details. * */ /* Inspird by Matrix/inst/include/Matrix_stubs.c */ #include "markdown_rstubs.h" int rstub_bufgrow(struct buf *buf, size_t sz) { static int (*fun)(struct buf *, size_t) = NULL; if (fun==NULL) fun = (int (*)(struct buf *,size_t))R_GetCCallable("markdown","bufgrow"); return fun(buf,sz); } struct buf *rstub_bufnew(size_t sz) { static struct buf *(*fun)(size_t) = NULL; if (fun==NULL) fun = (struct buf *(*)(size_t))R_GetCCallable("markdown","bufnew"); return fun(sz); } const char *rstub_bufcstr(struct buf *buf) { static const char *(*fun)(struct buf *) = NULL; if (fun==NULL) fun = (const char *(*)(struct buf *))R_GetCCallable("markdown","bufcstr"); return fun(buf); } int rstub_bufprefix(const struct buf *buf, const char *prefix) { static int (*fun)(const struct buf *, const char *) = NULL; if (fun==NULL) fun = (int (*)(const struct buf *, const char *))R_GetCCallable("markdown","bufprefix"); return fun(buf,prefix); } void rstub_bufput(struct buf *buf, const void *v, size_t sz) { static void (*fun)(struct buf *, const void *, size_t) = NULL; if (fun==NULL) fun = (void (*)(struct buf *, const void *, size_t))R_GetCCallable("markdown","bufput"); return fun(buf,v,sz); } void rstub_bufputs(struct buf *buf, const char *c) { static void (*fun)(struct buf *, const char *) = NULL; if (fun==NULL) fun = (void (*)(struct buf *, const char *))R_GetCCallable("markdown","bufputs"); return fun(buf,c); } void rstub_bufputc(struct buf *buf, int i) { static void (*fun)(struct buf *, int) = NULL; if (fun==NULL) fun = (void (*)(struct buf *, int))R_GetCCallable("markdown","bufputc"); return fun(buf,i); } void rstub_bufrelease(struct buf *buf) { static void (*fun)(struct buf *) = NULL; if (fun==NULL) fun = (void (*)(struct buf *t))R_GetCCallable("markdown","bufrelease"); return fun(buf); } void rstub_bufreset(struct buf *buf) { static void (*fun)(struct buf *) = NULL; if (fun==NULL) fun = (void (*)(struct buf *t))R_GetCCallable("markdown","bufreset"); return fun(buf); } void rstub_bufslurp(struct buf *buf, size_t sz) { static int (*fun)(struct buf *, size_t) = NULL; if (fun==NULL) fun = (int (*)(struct buf *,size_t))R_GetCCallable("markdown","bufslurp"); fun(buf,sz); } void rstub_bufprintf(struct buf *buf, const char *fmt, ...) { va_list ap; static int (*fun)(struct buf *, const char *, ...) = NULL; if (fun==NULL) fun = (int (*)(struct buf *,const char *, ...)) R_GetCCallable("markdown","bufprintf"); va_start(ap, fmt); fun(buf,fmt,ap); va_end(ap); } int rstub_sd_autolink_issafe(const uint8_t *link, size_t link_len){ static int (*fun)(const uint8_t *, size_t) = NULL; if (fun==NULL) fun = (int (*)(const uint8_t *, size_t)) R_GetCCallable("markdown","sd_autolink_issafe"); return fun(link,link_len); } size_t rstub_sd_autolink__www(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) { static size_t (*fun)(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) = NULL; if (fun==NULL) fun = (size_t (*)(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size)) R_GetCCallable("markdown","sd_autolink__www"); return fun(rewind_p,link,data,offset,size); } size_t rstub_sd_autolink__email(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) { static size_t (*fun)(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) = NULL; if (fun==NULL) fun = (size_t (*)(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size)) R_GetCCallable("markdown","sd_autolink__email"); return fun(rewind_p,link,data,offset,size); } size_t rstub_sd_autolink__url(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) { static size_t (*fun)(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) = NULL; if (fun==NULL) fun = (size_t (*)(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size)) R_GetCCallable("markdown","sd_autolink__url"); return fun(rewind_p,link,data,offset,size); } struct sd_markdown * rstub_sd_markdown_new(unsigned int extensions, size_t max_nesting, const struct sd_callbacks *callbacks, void *opaque) { static struct sd_markdown *(*fun)(unsigned int, size_t, const struct sd_callbacks *callbacks, void *) = NULL; if (fun==NULL) fun = (struct sd_markdown *(*)(unsigned int, size_t, const struct sd_callbacks *callbacks, void *)) R_GetCCallable("markdown","sd_markdown_new"); return fun(extensions,max_nesting,callbacks,opaque); } void rstub_sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md) { static void (*fun)(struct buf *, const uint8_t *, size_t, struct sd_markdown *) = NULL; if (fun==NULL) fun = (void (*)(struct buf *, const uint8_t *, size_t, struct sd_markdown *)) R_GetCCallable("markdown","sd_markdown_render"); return fun(ob,document,doc_size,md); } void rstub_sd_markdown_free(struct sd_markdown *md) { static void (*fun)(struct sd_markdown *) = NULL; if (fun==NULL) fun = (void (*)(struct sd_markdown *)) R_GetCCallable("markdown","sd_markdown_free"); return fun(md); } void rstub_sd_version(int *major, int *minor, int *revision) { static void (*fun)(int *, int *, int *) = NULL; if (fun==NULL) fun = (void (*)(int *, int *, int *)) R_GetCCallable("markdown","sd_version"); return fun(major,minor,revision); } Rboolean rstub_rmd_register_renderer(struct rmd_renderer *renderer) { static Rboolean (*fun)(struct rmd_renderer *) = NULL; if (fun==NULL) fun = (Rboolean (*)(struct rmd_renderer *)) R_GetCCallable("markdown","rmd_register_renderer"); return fun(renderer); } Rboolean rstub_rmd_renderer_exists(const char *name) { static SEXP (*fun)(SEXP) = NULL; if (fun==NULL) fun = (SEXP (*)(SEXP)) R_GetCCallable("markdown","rmd_renderer_exists"); return fun(name); } Rboolean rstub_rmd_buf_to_output(struct buf *ob, SEXP Soutput, SEXP *raw_vec) { static Rboolean (*fun)(struct buf *, SEXP, SEXP *) = NULL; if (fun==NULL) fun = (Rboolean (*)(struct buf *, SEXP, SEXP *)) R_GetCCallable("markdown","rmd_buf_to_output"); return fun(ob,Soutput,raw_vec); } Rboolean rstub_rmd_input_to_buf(SEXP Sfile, SEXP Stext, struct buf *ib) { static Rboolean (*fun)(SEXP, SEXP, struct buf *) = NULL; if (fun==NULL) fun = (Rboolean (*)(SEXP, SEXP, struct buf *)) R_GetCCallable("markdown","rmd_input_to_buf"); return fun(Sfile,Stext,ib); } markdown/inst/include/autolink.h0000644000176200001440000000252112330062343016467 0ustar liggesusers/* * Copyright (c) 2011, Vicent Marti * * 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 UPSKIRT_AUTOLINK_H #define UPSKIRT_AUTOLINK_H #include "buffer.h" #ifdef __cplusplus extern "C" { #endif extern int sd_autolink_issafe(const uint8_t *link, size_t link_len); extern size_t sd_autolink__www(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); extern size_t sd_autolink__email(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); extern size_t sd_autolink__url(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); #ifdef __cplusplus } #endif #endif /* vim: set filetype=c: */ markdown/inst/include/buffer.h0000644000176200001440000000563112330062343016117 0ustar liggesusers/* * Copyright (c) 2008, Natacha Porté * Copyright (c) 2011, Vicent Martí * * 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 BUFFER_H__ #define BUFFER_H__ #include #include #include #ifdef __cplusplus extern "C" { #endif #if defined(_MSC_VER) #define __attribute__(x) #define inline #endif typedef enum { BUF_OK = 0, BUF_ENOMEM = -1, } buferror_t; /* struct buf: character array buffer */ struct buf { uint8_t *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) */ }; /* CONST_BUF: global buffer from a string litteral */ #define BUF_STATIC(string) \ { (uint8_t *)string, sizeof string -1, sizeof string, 0, 0 } /* VOLATILE_BUF: macro for creating a volatile buffer on the stack */ #define BUF_VOLATILE(strname) \ { (uint8_t *)strname, strlen(strname), 0, 0, 0 } /* BUFPUTSL: optimized bufputs of a string litteral */ #define BUFPUTSL(output, literal) \ bufput(output, literal, sizeof literal - 1) /* 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) __attribute__ ((malloc)); /* bufnullterm: NUL-termination of the string array (making a C-string) */ const char *bufcstr(struct buf *); /* bufprefix: compare the beginning of a buffer with a string */ int bufprefix(const struct buf *buf, const char *prefix); /* 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 *, int); /* 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 *); /* bufslurp: removes a given number of bytes from the head of the array */ void bufslurp(struct buf *, size_t); /* bufprintf: formatted printing to a buffer */ void bufprintf(struct buf *, const char *, ...) __attribute__ ((format (printf, 2, 3))); #ifdef __cplusplus } #endif #endif markdown/tests/0000755000176200001440000000000012515342433013240 5ustar liggesusersmarkdown/tests/tests.Rout.save0000644000176200001440000001564512515342433016225 0ustar liggesusers R version 3.2.0 (2015-04-16) -- "Full of Ingredients" Copyright (C) 2015 The R Foundation for Statistical Computing Platform: x86_64-pc-linux-gnu (64-bit) R is free software and comes with ABSOLUTELY NO WARRANTY. You are welcome to redistribute it under certain conditions. Type 'license()' or 'licence()' for distribution details. Natural language support but running in an English locale R is a collaborative project with many contributors. Type 'contributors()' for more information and 'citation()' on how to cite R or R packages in publications. Type 'demo()' for some demos, 'help()' for on-line help, or 'help.start()' for an HTML browser interface to help. Type 'q()' to quit R. > library(markdown) > > source(system.file('examples', 'markdownExtensions.R', package = 'markdown'), echo = TRUE) > options(markdown.HTML.options = "fragment_only") > cat(markdownToHTML(text = "foo_bar_function", extensions = c()))

    foobarfunction

    > cat(markdownToHTML(text = "foo_bar_function", extensions = c("no_intra_emphasis")))

    foo_bar_function

    > cat(markdownToHTML(text = "\n First Header | Second Header\n ------------- | -------------\n Content Cell | Content Cell\n Content Cel ..." ... [TRUNCATED] 
    First Header  | Second Header
------------- | -------------
Content Cell  | Content Cell
Content Cell  | Content Cell
    > cat(markdownToHTML(text = "\nFirst Header | Second Header\n------------- | -------------\nContent Cell | Content Cell\nContent Cell | Content Cel ..." ... [TRUNCATED]
    First Header Second Header
    Content Cell Content Cell
    Content Cell Content Cell
    > fenced_block <- function(text, x = "`", n = 3) { + fence <- paste(rep(x, n), collapse = "") + paste(fence, text, fence, sep = "") + } > cat(markdownToHTML(text = fenced_block("\npreformatted text here without having to indent\nfirst line.\n"), + extensions = c()))

    preformatted text here without having to indent first line.

    > cat(markdownToHTML(text = fenced_block("\npreformatted text here without having to indent\nfirst line.\n"), + extensions = c("fenced_code"))) 
    preformatted text here without having to indent
first line.
    > cat(markdownToHTML(text = "http://www.r-project.org/", + extensions = c()))

    http://www.r-project.org/

    > cat(markdownToHTML(text = "http://www.r-project.org/", + extensions = c("autolink")))

    http://www.r-project.org/

    > cat(markdownToHTML(text = "~~awesome~~", extensions = c()))

    ~~awesome~~

    > cat(markdownToHTML(text = "~~awesome~~", extensions = c("strikethrough")))

    awesome

    > cat(markdownToHTML(text = "\nEmbedding html without surrounding with empty newline.\n
    _markdown_
    \nextra text.\n", + extensions = c("" .... [TRUNCATED]

    Embedding html without surrounding with empty newline.

    markdown
    extra text.

    > cat(markdownToHTML(text = "\nEmbedding html without surrounding with empty newline.\n
    _markdown_
    \nextra text.\n", + extensions = c("l ..." ... [TRUNCATED]

    Embedding html without surrounding with empty newline.

    _markdown_

    extra text.

    > cat(markdownToHTML(text = "#A Header\neven though there is no space between # and A", + extensions = c("")))

    A Header

    even though there is no space between # and A

    > cat(markdownToHTML(text = "#Not A Header\nbecause there is no space between # and N", + extensions = c("space_headers")))

    #Not A Header because there is no space between # and N

    > cat(markdownToHTML(text = "2^10", extensions = c()))

    2^10

    > cat(markdownToHTML(text = "2^10", extensions = c("superscript")))

    210

    > source(system.file('examples', 'HTMLOptions.R', package = 'markdown'), echo = TRUE) > tOpt <- "fragment_only" > mkd = "Hello" > cat(markdownToHTML(text = mkd, options = c(tOpt)))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt)))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_style")))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt)))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_images")))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt)))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_links")))

    Hello

    > cat(markdownToHTML(text = "[foo](http://google.com \"baz\")", + options = c(tOpt)))

    foo

    > cat(markdownToHTML(text = "[foo](http://google.com \"baz\")", + options = c(tOpt, "safelink")))

    foo

    > mkd <- paste(c("# Header 1", "p1", "## Header 2", + "p2"), collapse = "\n") > cat(markdownToHTML(text = mkd, options = c(tOpt)))

    Header 1

    p1

    Header 2

    p2

    > cat(markdownToHTML(text = mkd, options = c(tOpt, "toc")))
    Table of Contents

    Header 1

    p1

    Header 2

    p2

    > cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt)))

    foo bar

    > cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, + "hard_wrap")))

    foo
    bar

    > cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, + "hard_wrap")))

    foo
    bar

    > cat(markdownToHTML(text = "foo\nbar\n", options = c(tOpt, + "hard_wrap", "use_xhtml")))

    foo
    bar

    > mkd = "Hello" > cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))

    Hello

    > cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html", + "escape")))

    <style></style><img src="http://cran.rstudio.com/Rlogo.jpg"><a href="#">Hello</a>

    > cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt)))

    1/2 (c)

    > cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt, + "smartypants")))

    ½ ©

    > cat(smartypants(text = "1/2 (c)\n")) ½ © > > rm(mkd) > rm(tOpt) > markdown/tests/tests.R0000644000176200001440000000032412330062343014516 0ustar liggesuserslibrary(markdown) source(system.file('examples', 'markdownExtensions.R', package = 'markdown'), echo = TRUE) source(system.file('examples', 'HTMLOptions.R', package = 'markdown'), echo = TRUE) rm(mkd) rm(tOpt) markdown/src/0000755000176200001440000000000012515736624012676 5ustar liggesusersmarkdown/src/houdini.h0000644000176200001440000000250412515736624014507 0ustar liggesusers#ifndef HOUDINI_H__ #define HOUDINI_H__ #include "buffer.h" #ifdef __cplusplus extern "C" { #endif #ifdef HOUDINI_USE_LOCALE # define _isxdigit(c) isxdigit(c) # define _isdigit(c) isdigit(c) #else /* * Helper _isdigit methods -- do not trust the current locale * */ # define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL) # define _isdigit(c) ((c) >= '0' && (c) <= '9') #endif extern void houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure); extern void houdini_unescape_html(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_escape_xml(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_escape_uri(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_escape_url(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_unescape_uri(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_unescape_url(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_escape_js(struct buf *ob, const uint8_t *src, size_t size); extern void houdini_unescape_js(struct buf *ob, const uint8_t *src, size_t size); #ifdef __cplusplus } #endif #endif markdown/src/buffer.c0000644000176200001440000001056112515736624014316 0ustar liggesusers/* * Copyright (c) 2008, Natacha Porté * Copyright (c) 2011, Vicent Martí * * 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. */ #define BUFFER_MAX_ALLOC_SIZE (1024 * 1024 * 16) /* 16mb */ #include "buffer.h" #include #include #include #include /* MSVC compat */ #if defined(__MINGW32__) # define _buf_vsnprintf _vsnprintf #else # define _buf_vsnprintf vsnprintf #endif int bufprefix(const struct buf *buf, const char *prefix) { size_t i; assert(buf && buf->unit); for (i = 0; i < buf->size; ++i) { if (prefix[i] == 0) return 0; if (buf->data[i] != prefix[i]) return buf->data[i] - prefix[i]; } return 0; } /* bufgrow: increasing the allocated size to the given value */ int bufgrow(struct buf *buf, size_t neosz) { size_t neoasz; void *neodata; assert(buf && buf->unit); if (neosz > BUFFER_MAX_ALLOC_SIZE) return BUF_ENOMEM; if (buf->asize >= neosz) return BUF_OK; neoasz = buf->asize + buf->unit; while (neoasz < neosz) neoasz += buf->unit; neodata = realloc(buf->data, neoasz); if (!neodata) return BUF_ENOMEM; buf->data = neodata; buf->asize = neoasz; return BUF_OK; } /* bufnew: allocation of a new buffer */ struct buf * bufnew(size_t unit) { struct buf *ret; ret = malloc(sizeof (struct buf)); if (ret) { ret->data = 0; ret->size = ret->asize = 0; ret->unit = unit; } return ret; } /* bufnullterm: NULL-termination of the string array */ const char * bufcstr(struct buf *buf) { assert(buf && buf->unit); if (buf->size < buf->asize && buf->data[buf->size] == 0) return (char *)buf->data; if (buf->size + 1 <= buf->asize || bufgrow(buf, buf->size + 1) == 0) { buf->data[buf->size] = 0; return (char *)buf->data; } return NULL; } /* bufprintf: formatted printing to a buffer */ void bufprintf(struct buf *buf, const char *fmt, ...) { va_list ap; int n; assert(buf && buf->unit); if (buf->size >= buf->asize && bufgrow(buf, buf->size + 1) < 0) return; va_start(ap, fmt); n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap); va_end(ap); if (n < 0) { #ifdef __MINGW32__ va_start(ap, fmt); n = _vscprintf(fmt, ap); va_end(ap); #else return; #endif } if ((size_t)n >= buf->asize - buf->size) { if (bufgrow(buf, buf->size + n + 1) < 0) return; va_start(ap, fmt); n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap); va_end(ap); } if (n < 0) return; buf->size += n; } /* bufput: appends raw data to a buffer */ void bufput(struct buf *buf, const void *data, size_t len) { assert(buf && buf->unit); if (buf->size + len > buf->asize && bufgrow(buf, buf->size + len) < 0) 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 uint8_t to a buffer */ void bufputc(struct buf *buf, int c) { assert(buf && buf->unit); if (buf->size + 1 > buf->asize && bufgrow(buf, buf->size + 1) < 0) 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) return; free(buf->data); free(buf); } /* bufreset: frees internal data of the buffer */ void bufreset(struct buf *buf) { if (!buf) return; free(buf->data); buf->data = NULL; buf->size = buf->asize = 0; } /* bufslurp: removes a given number of bytes from the head of the array */ void bufslurp(struct buf *buf, size_t len) { assert(buf && buf->unit); if (len >= buf->size) { buf->size = 0; return; } buf->size -= len; memmove(buf->data, buf->data + len, buf->size); } markdown/src/stack.c0000644000176200001440000000210412515736624014144 0ustar liggesusers#include "stack.h" #include int stack_grow(struct stack *st, size_t new_size) { void **new_st; if (st->asize >= new_size) return 0; new_st = realloc(st->item, new_size * sizeof(void *)); if (new_st == NULL) return -1; memset(new_st + st->asize, 0x0, (new_size - st->asize) * sizeof(void *)); st->item = new_st; st->asize = new_size; if (st->size > new_size) st->size = new_size; return 0; } void stack_free(struct stack *st) { if (!st) return; free(st->item); st->item = NULL; st->size = 0; st->asize = 0; } int stack_init(struct stack *st, size_t initial_size) { st->item = NULL; st->size = 0; st->asize = 0; if (!initial_size) initial_size = 8; return stack_grow(st, initial_size); } void * stack_pop(struct stack *st) { if (!st->size) return NULL; return st->item[--st->size]; } int stack_push(struct stack *st, void *item) { if (stack_grow(st, st->size * 2) < 0) return -1; st->item[st->size++] = item; return 0; } void * stack_top(struct stack *st) { if (!st->size) return NULL; return st->item[st->size - 1]; } markdown/src/Rmarkdown.h0000644000176200001440000000262212515736624015015 0ustar liggesusers/* * Rmarkdown.h * * Copyright (C) 2009-2013 by RStudio, Inc. * * This program is licensed to you under the terms of version 2 of the * GNU General Public License. This program is distributed WITHOUT ANY * EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT, * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the * GPL (http://www.gnu.org/licenses/gpl-2.0.txt) for more details. * */ #include #include #include "markdown.h" #include "html.h" #define READ_UNIT 1024 #define OUTPUT_UNIT 64 #define RMD_WARNING_NOMEM warning("Out of memory!") /* * output_type should be either "raw" or "character" */ struct rmd_renderer { char *name; Rboolean (*render)(struct buf *,struct buf *, SEXP, SEXP); char *output_type; }; extern void rmd_init_renderer_list(); extern Rboolean rmd_buf_to_output(struct buf *, SEXP, SEXP *); extern Rboolean rmd_input_to_buf(SEXP, SEXP, struct buf *); extern Rboolean rmd_register_renderer(struct rmd_renderer *); extern Rboolean rmd_renderer_exists(const char *name); extern SEXP rmd_registered_renderers(void); extern SEXP rmd_render_markdown(SEXP Sfile, SEXP Soutput, SEXP Stext, SEXP Srenderer, SEXP Srender_options, SEXP Soptions); extern SEXP rmd_render_smartypants(SEXP Sfile, SEXP Soutput, SEXP Stext); extern SEXP rmd_b64encode_data( SEXP Sdata); markdown/src/Rbase64.c0000644000176200001440000000275012515736624014254 0ustar liggesusers#include "Rmarkdown.h" #include #include /* * Translation Table as described in RFC1113 */ static const char cb64[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /* * encodeblock * * encode 3 8-bit binary bytes as 4 '6-bit' characters */ void encodeblock( unsigned char in[3], unsigned char out[4], int len ) { out[0] = cb64[ in[0] >> 2 ]; out[1] = cb64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ]; out[2] = (unsigned char) (len > 1 ? cb64[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '='); out[3] = (unsigned char) (len > 2 ? cb64[ in[2] & 0x3f ] : '='); } SEXP rmd_b64encode_data( SEXP Sdata) { unsigned char in[3], out[4]; int i, len; int data_len = LENGTH(Sdata); int data_elem = 0; Rbyte *data = RAW(Sdata); SEXP ans; struct buf *databuf; databuf = bufnew(READ_UNIT); if (!databuf) { RMD_WARNING_NOMEM; return R_NilValue; } while( data_elem < data_len ) { len = 0; for( i = 0; i < 3; i++ ) { if( data_elem < data_len ) { in[i] = (unsigned char) data[data_elem++]; len++; } else { in[i] = 0; } } if( len ) { encodeblock( in, out, len ); for( i = 0; i < 4; i++ ) { bufputc(databuf,out[i]); } } } PROTECT(ans = allocVector(STRSXP,1)); SET_STRING_ELT(ans,0,mkChar(bufcstr(databuf))); bufrelease(databuf); UNPROTECT(1); return ans; } markdown/src/markdown.h0000644000176200001440000001165112515736624014675 0ustar liggesusers/* 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 UPSKIRT_MARKDOWN_H #define UPSKIRT_MARKDOWN_H #include "buffer.h" #include "autolink.h" #ifdef __cplusplus extern "C" { #endif #define SUNDOWN_VERSION "1.16.0" #define SUNDOWN_VER_MAJOR 1 #define SUNDOWN_VER_MINOR 16 #define SUNDOWN_VER_REVISION 0 /******************** * 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/mailto/etc link */ MKDA_EMAIL /* e-mail link without explit mailto: */ }; enum mkd_tableflags { MKD_TABLE_ALIGN_L = 1, MKD_TABLE_ALIGN_R = 2, MKD_TABLE_ALIGN_CENTER = 3, MKD_TABLE_ALIGNMASK = 3, MKD_TABLE_HEADER = 4 }; enum mkd_extensions { MKDEXT_NO_INTRA_EMPHASIS = (1 << 0), MKDEXT_TABLES = (1 << 1), MKDEXT_FENCED_CODE = (1 << 2), MKDEXT_AUTOLINK = (1 << 3), MKDEXT_STRIKETHROUGH = (1 << 4), MKDEXT_SPACE_HEADERS = (1 << 6), MKDEXT_SUPERSCRIPT = (1 << 7), MKDEXT_LAX_SPACING = (1 << 8), MKDEXT_LATEX_MATH = (1 << 9) }; /* sd_callbacks - functions for rendering parsed data */ struct sd_callbacks { /* block level callbacks - NULL skips the block */ void (*blockcode)(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque); void (*blockquote)(struct buf *ob, const struct buf *text, void *opaque); void (*blockhtml)(struct buf *ob,const struct buf *text, void *opaque); void (*header)(struct buf *ob, const struct buf *text, int level, void *opaque); void (*hrule)(struct buf *ob, void *opaque); void (*list)(struct buf *ob, const struct buf *text, int flags, void *opaque); void (*listitem)(struct buf *ob, const struct buf *text, int flags, void *opaque); void (*paragraph)(struct buf *ob, const struct buf *text, void *opaque); void (*table)(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque); void (*table_row)(struct buf *ob, const struct buf *text, void *opaque); void (*table_cell)(struct buf *ob, const struct buf *text, int flags, void *opaque); /* span level callbacks - NULL or return 0 prints the span verbatim */ int (*autolink)(struct buf *ob, const struct buf *link, enum mkd_autolink type, void *opaque); int (*codespan)(struct buf *ob, const struct buf *text, void *opaque); int (*double_emphasis)(struct buf *ob, const struct buf *text, void *opaque); int (*emphasis)(struct buf *ob, const struct buf *text, void *opaque); int (*image)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque); int (*linebreak)(struct buf *ob, void *opaque); int (*link)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque); int (*raw_html_tag)(struct buf *ob, const struct buf *tag, void *opaque); int (*triple_emphasis)(struct buf *ob, const struct buf *text, void *opaque); int (*strikethrough)(struct buf *ob, const struct buf *text, void *opaque); int (*superscript)(struct buf *ob, const struct buf *text, void *opaque); int (*inlinemath)(struct buf *ob, const struct buf *text, void *opaque); int (*displayedmath)(struct buf *ob, const struct buf *text, void *opaque); /* low level callbacks - NULL copies input directly into the output */ void (*entity)(struct buf *ob, const struct buf *entity, void *opaque); void (*normal_text)(struct buf *ob, const struct buf *text, void *opaque); /* header and footer */ void (*doc_header)(struct buf *ob, void *opaque); void (*doc_footer)(struct buf *ob, void *opaque); }; struct sd_markdown; /********* * FLAGS * *********/ /* list/listitem flags */ #define MKD_LIST_ORDERED 1 #define MKD_LI_BLOCK 2 /*
  • containing block data */ /********************** * EXPORTED FUNCTIONS * **********************/ extern struct sd_markdown * sd_markdown_new( unsigned int extensions, size_t max_nesting, const struct sd_callbacks *callbacks, void *opaque); extern void sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md); extern void sd_markdown_free(struct sd_markdown *md); extern void sd_version(int *major, int *minor, int *revision); #ifdef __cplusplus } #endif #endif /* vim: set filetype=c: */ markdown/src/houdini_href_e.c0000644000176200001440000000560612515736624016020 0ustar liggesusers#include #include #include #include "houdini.h" #define ESCAPE_GROW_FACTOR(x) (((x) * 12) / 10) /* * The following characters will not be escaped: * * -_.+!*'(),%#@?=;:/,+&$ alphanum * * Note that this character set is the addition of: * * - The characters which are safe to be in an URL * - The characters which are *not* safe to be in * an URL because they are RESERVED characters. * * We asume (lazily) that any RESERVED char that * appears inside an URL is actually meant to * have its native function (i.e. as an URL * component/separator) and hence needs no escaping. * * There are two exceptions: the chacters & (amp) * and ' (single quote) do not appear in the table. * They are meant to appear in the URL as components, * yet they require special HTML-entity escaping * to generate valid HTML markup. * * All other characters will be escaped to %XX. * */ static const char HREF_SAFE[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; void houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size) { static const char hex_chars[] = "0123456789ABCDEF"; size_t i = 0, org; char hex_str[3]; bufgrow(ob, ESCAPE_GROW_FACTOR(size)); hex_str[0] = '%'; while (i < size) { org = i; while (i < size && HREF_SAFE[src[i]] != 0) i++; if (i > org) bufput(ob, src + org, i - org); /* escaping */ if (i >= size) break; switch (src[i]) { /* amp appears all the time in URLs, but needs * HTML-entity escaping to be inside an href */ case '&': BUFPUTSL(ob, "&"); break; /* the single quote is a valid URL character * according to the standard; it needs HTML * entity escaping too */ case '\'': BUFPUTSL(ob, "'"); break; /* the space can be escaped to %20 or a plus * sign. we're going with the generic escape * for now. the plus thing is more commonly seen * when building GET strings */ #if 0 case ' ': bufputc(ob, '+'); break; #endif /* every other character goes with a %XX escaping */ default: hex_str[1] = hex_chars[(src[i] >> 4) & 0xF]; hex_str[2] = hex_chars[src[i] & 0xF]; bufput(ob, hex_str, 3); } i++; } } markdown/src/markdown.c0000644000176200001440000017532212515736624014676 0ustar liggesusers/* markdown.c - generic markdown parser */ /* * Copyright (c) 2009, Natacha Porté * Copyright (c) 2011, Vicent Marti * * 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 "stack.h" #include #include #include #include #if defined(_WIN32) #define strncasecmp _strnicmp #endif #define REF_TABLE_SIZE 8 #define BUFFER_BLOCK 0 #define BUFFER_SPAN 1 #define MKD_LI_END 8 /* internal list flag */ #define gperf_case_strncmp(s1, s2, n) strncasecmp(s1, s2, n) #define GPERF_DOWNCASE 1 #define GPERF_CASE_STRNCMP 1 #include "html_blocks.h" /*************** * LOCAL TYPES * ***************/ /* link_ref: reference to a link */ struct link_ref { unsigned int id; struct buf *link; struct buf *title; struct link_ref *next; }; /* 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 sd_markdown; typedef size_t (*char_trigger)(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_emphasis(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_linebreak(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_langle_tag(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_autolink_url(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_autolink_email(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_autolink_www(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); static size_t char_dollar(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size); enum markdown_char_t { MD_CHAR_NONE = 0, MD_CHAR_EMPHASIS, MD_CHAR_CODESPAN, MD_CHAR_LINEBREAK, MD_CHAR_LINK, MD_CHAR_LANGLE, MD_CHAR_ESCAPE, MD_CHAR_ENTITITY, MD_CHAR_AUTOLINK_URL, MD_CHAR_AUTOLINK_EMAIL, MD_CHAR_AUTOLINK_WWW, MD_CHAR_SUPERSCRIPT, MD_CHAR_DOLLAR }; static char_trigger markdown_char_ptrs[] = { NULL, &char_emphasis, &char_codespan, &char_linebreak, &char_link, &char_langle_tag, &char_escape, &char_entity, &char_autolink_url, &char_autolink_email, &char_autolink_www, &char_superscript, &char_dollar }; /* render • structure containing one particular render */ struct sd_markdown { struct sd_callbacks cb; void *opaque; struct link_ref *refs[REF_TABLE_SIZE]; uint8_t active_char[256]; struct stack work_bufs[2]; unsigned int ext_flags; size_t max_nesting; int in_link_body; }; /*************************** * HELPER FUNCTIONS * ***************************/ static inline struct buf * rndr_newbuf(struct sd_markdown *rndr, int type) { static const size_t buf_size[2] = {256, 64}; struct buf *work = NULL; struct stack *pool = &rndr->work_bufs[type]; if (pool->size < pool->asize && pool->item[pool->size] != NULL) { work = pool->item[pool->size++]; work->size = 0; } else { work = bufnew(buf_size[type]); stack_push(pool, work); } return work; } static inline void rndr_popbuf(struct sd_markdown *rndr, int type) { rndr->work_bufs[type].size--; } static void unscape_text(struct buf *ob, struct buf *src) { size_t i = 0, org; while (i < src->size) { org = i; while (i < src->size && src->data[i] != '\\') i++; if (i > org) bufput(ob, src->data + org, i - org); if (i + 1 >= src->size) break; bufputc(ob, src->data[i + 1]); i += 2; } } static unsigned int hash_link_ref(const uint8_t *link_ref, size_t length) { size_t i; unsigned int hash = 0; for (i = 0; i < length; ++i) hash = tolower(link_ref[i]) + (hash << 6) + (hash << 16) - hash; return hash; } static struct link_ref * add_link_ref( struct link_ref **references, const uint8_t *name, size_t name_size) { struct link_ref *ref = calloc(1, sizeof(struct link_ref)); if (!ref) return NULL; ref->id = hash_link_ref(name, name_size); ref->next = references[ref->id % REF_TABLE_SIZE]; references[ref->id % REF_TABLE_SIZE] = ref; return ref; } static struct link_ref * find_link_ref(struct link_ref **references, uint8_t *name, size_t length) { unsigned int hash = hash_link_ref(name, length); struct link_ref *ref = NULL; ref = references[hash % REF_TABLE_SIZE]; while (ref != NULL) { if (ref->id == hash) return ref; ref = ref->next; } return NULL; } static void free_link_refs(struct link_ref **references) { size_t i; for (i = 0; i < REF_TABLE_SIZE; ++i) { struct link_ref *r = references[i]; struct link_ref *next; while (r) { next = r->next; bufrelease(r->link); bufrelease(r->title); free(r); r = next; } } } /* * Check whether a char is a Markdown space. * Right now we only consider spaces the actual * space and a newline: tabs and carriage returns * are filtered out during the preprocessing phase. * * If we wanted to actually be UTF-8 compliant, we * should instead extract an Unicode codepoint from * this character and check for space properties. */ static inline int _isspace(int c) { return c == ' ' || c == '\n'; } /******************************** * LATEX MATH PARSING FUNCTIONS * ********************************/ /* org-mode inline latex math, e.g. $...$ * * Rules for parsing: * * 1. eqations must be attached to begin and end $ * 2. at most two newlines in the equation * 3. the closing $ must be followed by whitespace, punctuation, or a dash. */ static size_t prefix_math(uint8_t *data, size_t size) { /* $$latex */ if (7 < size && data[0] == '$' && data[1] == '$' && data[2] == 'l' && data[3] == 'a' && data[4] == 't' && data[5] == 'e' && data[6] == 'x') return 7; /* $latex */ if (6 < size && data[0] == '$' && data[1] == 'l' && data[2] == 'a' && data[3] == 't' && data[4] == 'e' && data[5] == 'x') return 6; /* $$ */ else if (2 < size && data[0] == '$' && data[1] == '$') return 2; /* $ */ else if (1 < size && data[0] == '$') return 1; return 0; } static size_t parse_orgmode_math(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { static const char *punct = "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~"; size_t i = 1, nl = 0, length = 0; struct buf *work; int r; if (!rndr->cb.inlinemath) return 0; if (i < size && (data[i] == ' ' || data[i] == '\n') ) return 0; while(i < size){ while (i < size && !(data[i] == '\n' || data[i] == '$')) { i++; length++; } if (i == size) return 0; if (data[i] == '\n') nl++; if (nl > 2) return 0; if (data[i] == '$'){ /* bail if there's whitespace before the dollar or */ if (data[i - 1] == ' ' || data[i - 1] == '\n') return 0; /* bail if there's not whitespace or punctuation following the * dollar. */ if (i < size && data[i + 1] != ' ' && data[i + 1] != '\n' && (strchr(punct,data[i + 1]) == NULL) ) return 0; i++; if (i <= size) { work = rndr_newbuf(rndr, BUFFER_SPAN); bufput(work, data + 1, length); r = rndr->cb.inlinemath(ob,work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); return r ? i : 0; } else { return 0; } } i++; length++; } return 0; } /* parse_escape_math • parse \(...\) or \[...\] and return */ static size_t parse_escape_math(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { int (*render_method)(struct buf *ob, const struct buf *text, void *opaque); size_t i = 1, length = 0; uint8_t c; struct buf *work; int r; if (i < size) { switch (data[i]) { case '(': if (!rndr->cb.inlinemath) return 0; render_method = rndr->cb.inlinemath; c = ')'; break; case '[': if (!rndr->cb.displayedmath) return 0; render_method = rndr->cb.displayedmath; c = ']'; break; default: return 0; } } i++; while (i < size) { while (i < size && data[i] != '\\') { i++; length++; } if (i == size) return 0; if (i + 1 < size && data[i + 1] == c){ i += 2; work = rndr_newbuf(rndr, BUFFER_SPAN); bufput(work, data + 2, length); r = render_method(ob,work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); return r ? i : 0; } i++; length++; } return 0; } static size_t parse_inline_math(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t i = 0, pre; struct buf *work; int r; if (!rndr->cb.inlinemath) return 0; pre = prefix_math(data, size); if (pre == 0) return 0; i = pre; while (i < size && data[i] != '$') i++; if (i == size) return 0; work = rndr_newbuf(rndr, BUFFER_SPAN); bufput(work, data + pre, i - pre); r = rndr->cb.inlinemath(ob,work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); i++; return r ? i : 0; } static size_t parse_displayed_math(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t i = 0, pre; struct buf *work; int r; if (!rndr->cb.displayedmath) return 0; pre = prefix_math(data, size); if (pre == 0) return 0; i = pre; while (i + 1 < size && !(data[i] == '$' && data[i + 1] == '$') ) i++; if (i == size - 1) return 0; work = rndr_newbuf(rndr, BUFFER_SPAN); bufput(work, data + pre, i - pre); r = rndr->cb.displayedmath(ob,work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); i += 2; /* passed the $$ */ return r ? i : 0; } static size_t char_dollar(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { size_t i; i = prefix_math(data, size); if (i == 0) return 0; if (i > 1) { /* $$latex or $$ */ if (data[0] == '$' && data[1] == '$') return parse_displayed_math(ob, rndr, data, size); /* $latex */ return parse_inline_math(ob, rndr, data, size); } /* $ */ if (i == 1) return parse_orgmode_math(ob, rndr, data, size); return 0; } /**************************** * 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(uint8_t *data, size_t size) { size_t i = 0, nb = 0; /* address is assumed to be: [-@._a-zA-Z0-9]+ with exactly one '@' */ for (i = 0; i < size; ++i) { if (isalnum(data[i])) continue; switch (data[i]) { case '@': nb++; case '-': case '.': case '_': break; case '>': return (nb == 1) ? i + 1 : 0; default: return 0; } } return 0; } /* tag_length • returns the length of the given tag, or 0 is it's not valid */ static size_t tag_length(uint8_t *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 or number */ if (data[0] != '<') return 0; i = (data[1] == '/') ? 2 : 1; if (!isalnum(data[i])) return 0; /* scheme test */ *autolink = MKDA_NOT_AUTOLINK; /* try to find the beginning of an URI */ while (i < size && (isalnum(data[i]) || data[i] == '.' || data[i] == '+' || data[i] == '-')) i++; if (i > 1 && data[i] == '@') { if ((j = is_mail_autolink(data + i, size - i)) != 0) { *autolink = MKDA_EMAIL; return i + j; } } if (i > 2 && data[i] == ':') { *autolink = MKDA_NORMAL; i++; } /* completing autolink test: no whitespace or ' or " */ if (i >= size) *autolink = MKDA_NOT_AUTOLINK; else if (*autolink) { j = i; while (i < size) { if (data[i] == '\\') i += 2; else if (data[i] == '>' || data[i] == '\'' || data[i] == '"' || data[i] == ' ' || data[i] == '\n') break; else i++; } 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; } /* looking for sometinhg looking like a tag end */ while (i < size && data[i] != '>') i++; if (i >= size) return 0; return i + 1; } /* parse_inline • parses inline markdown elements */ static void parse_inline(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t i = 0, end = 0; uint8_t action = 0; struct buf work = { 0, 0, 0, 0 }; if (rndr->work_bufs[BUFFER_SPAN].size + rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting) return; while (i < size) { /* copying inactive chars into the output */ while (end < size && (action = rndr->active_char[data[end]]) == 0) { end++; } if (rndr->cb.normal_text) { work.data = data + i; work.size = end - i; rndr->cb.normal_text(ob, &work, rndr->opaque); } else bufput(ob, data + i, end - i); if (end >= size) break; i = end; end = markdown_char_ptrs[(int)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 uint8_t, skipping other constructs */ static size_t find_emph_char(uint8_t *data, size_t size, uint8_t c) { size_t i = 1; while (i < size) { while (i < size && data[i] != c && data[i] != '`' && data[i] != '[') i++; if (i == size) return 0; if (data[i] == c) return i; /* not counting escaped chars */ if (i && data[i - 1] == '\\') { i++; continue; } 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++; span_nb++; } 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++; else bt = 0; i++; } if (i >= size) return tmp_i; } /* skipping a link */ else if (data[i] == '[') { size_t tmp_i = 0; uint8_t cc; i++; while (i < size && data[i] != ']') { if (!tmp_i && data[i] == c) tmp_i = i; i++; } i++; while (i < size && (data[i] == ' ' || data[i] == '\n')) i++; if (i >= size) return tmp_i; switch (data[i]) { case '[': cc = ']'; break; case '(': cc = ')'; break; default: if (tmp_i) return tmp_i; else continue; } i++; while (i < size && data[i] != cc) { if (!tmp_i && data[i] == c) tmp_i = i; i++; } if (i >= size) return tmp_i; i++; } } 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 sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c) { size_t i = 0, len; struct buf *work = 0; int r; if (!rndr->cb.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 (data[i] == c && !_isspace(data[i - 1])) { if (rndr->ext_flags & MKDEXT_NO_INTRA_EMPHASIS) { if (!(i + 1 == size || _isspace(data[i + 1]) || ispunct(data[i + 1]))) continue; } work = rndr_newbuf(rndr, BUFFER_SPAN); parse_inline(work, rndr, data, i); r = rndr->cb.emphasis(ob, work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); return r ? i + 1 : 0; } } return 0; } /* parse_emph2 • parsing single emphase */ static size_t parse_emph2(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c) { int (*render_method)(struct buf *ob, const struct buf *text, void *opaque); size_t i = 0, len; struct buf *work = 0; int r; render_method = (c == '~') ? rndr->cb.strikethrough : rndr->cb.double_emphasis; if (!render_method) 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 && !_isspace(data[i - 1])) { work = rndr_newbuf(rndr, BUFFER_SPAN); parse_inline(work, rndr, data, i); r = render_method(ob, work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); return r ? i + 2 : 0; } i++; } 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 sd_markdown *rndr, uint8_t *data, size_t size, uint8_t 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 || _isspace(data[i - 1])) continue; if (i + 2 < size && data[i + 1] == c && data[i + 2] == c && rndr->cb.triple_emphasis) { /* triple symbol found */ struct buf *work = rndr_newbuf(rndr, BUFFER_SPAN); parse_inline(work, rndr, data, i); r = rndr->cb.triple_emphasis(ob, work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); 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 sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { uint8_t c = data[0]; size_t ret; if (size > 2 && data[1] != c) { /* whitespace cannot follow an opening emphasis; * strikethrough only takes two characters '~~' */ if (c == '~' || _isspace(data[1]) || (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 (_isspace(data[2]) || (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 (c == '~' || _isspace(data[3]) || (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 sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { if (offset < 2 || data[-1] != ' ' || data[-2] != ' ') return 0; /* removing the last space from ob and rendering */ while (ob->size && ob->data[ob->size - 1] == ' ') ob->size--; return rndr->cb.linebreak(ob, rndr->opaque) ? 1 : 0; } /* char_codespan • '`' parsing a code span (assuming codespan != 0) */ static size_t char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *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++; /* finding the next delimiter */ i = 0; for (end = nb; end < size && i < nb; end++) { if (data[end] == '`') i++; 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] == ' ') f_begin++; f_end = end - nb; while (f_end > nb && data[f_end-1] == ' ') f_end--; /* real code span */ if (f_begin < f_end) { struct buf work = {0, 0, 0, 0}; work.data = data + f_begin; work.size = f_end - f_begin; if (!rndr->cb.codespan(ob, &work, rndr->opaque)) end = 0; } else { if (!rndr->cb.codespan(ob, 0, rndr->opaque)) end = 0; } return end; } /* char_escape • '\\' backslash escape */ static size_t char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { static const char *escape_chars = "\\`*_{}[]()#+-.!:|&<>^~$"; struct buf work = { 0, 0, 0, 0 }; if (size > 1) { size_t i; if (strchr(escape_chars, data[1]) == NULL) return 0; if (size > 2 && (data[1] == '(' || data[1] == '[') && ((rndr->ext_flags & MKDEXT_LATEX_MATH) != 0) && ((i = parse_escape_math(ob, rndr, data, size)) != 0) ) return i; if (rndr->cb.normal_text) { work.data = data + 1; work.size = 1; rndr->cb.normal_text(ob, &work, rndr->opaque); } else bufputc(ob, data[1]); } else if (size == 1) { bufputc(ob, data[0]); } return 2; } /* char_entity • '&' escaped when it doesn't belong to an entity */ /* valid entities are assumed to be anything matching &#?[A-Za-z0-9]+; */ static size_t char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { size_t end = 1; struct buf work = { 0, 0, 0, 0 }; if (end < size && data[end] == '#') end++; while (end < size && isalnum(data[end])) end++; if (end < size && data[end] == ';') end++; /* real entity */ else return 0; /* lone '&' */ if (rndr->cb.entity) { work.data = data; work.size = end; rndr->cb.entity(ob, &work, rndr->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 sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { enum mkd_autolink altype = MKDA_NOT_AUTOLINK; size_t end = tag_length(data, size, &altype); int ret = 0; struct buf work = { 0, 0, 0, 0 }; work.data = data; work.size = end; if (end > 2) { if (rndr->cb.autolink && altype != MKDA_NOT_AUTOLINK) { struct buf *u_link = rndr_newbuf(rndr, BUFFER_SPAN); work.data = data + 1; work.size = end - 2; unscape_text(u_link, &work); ret = rndr->cb.autolink(ob, u_link, altype, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); } else if (rndr->cb.raw_html_tag) ret = rndr->cb.raw_html_tag(ob, &work, rndr->opaque); } if (!ret) return 0; else return end; } static size_t char_autolink_www(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { struct buf *link, *link_url, *link_text; size_t link_len, rewind; if (!rndr->cb.link || rndr->in_link_body) return 0; link = rndr_newbuf(rndr, BUFFER_SPAN); if ((link_len = sd_autolink__www(&rewind, link, data, offset, size)) > 0) { link_url = rndr_newbuf(rndr, BUFFER_SPAN); BUFPUTSL(link_url, "http://"); bufput(link_url, link->data, link->size); ob->size -= rewind; if (rndr->cb.normal_text) { link_text = rndr_newbuf(rndr, BUFFER_SPAN); rndr->cb.normal_text(link_text, link, rndr->opaque); rndr->cb.link(ob, link_url, NULL, link_text, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); } else { rndr->cb.link(ob, link_url, NULL, link, rndr->opaque); } rndr_popbuf(rndr, BUFFER_SPAN); } rndr_popbuf(rndr, BUFFER_SPAN); return link_len; } static size_t char_autolink_email(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { struct buf *link; size_t link_len, rewind; if (!rndr->cb.autolink || rndr->in_link_body) return 0; link = rndr_newbuf(rndr, BUFFER_SPAN); if ((link_len = sd_autolink__email(&rewind, link, data, offset, size)) > 0) { ob->size -= rewind; rndr->cb.autolink(ob, link, MKDA_EMAIL, rndr->opaque); } rndr_popbuf(rndr, BUFFER_SPAN); return link_len; } static size_t char_autolink_url(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { struct buf *link; size_t link_len, rewind; if (!rndr->cb.autolink || rndr->in_link_body) return 0; link = rndr_newbuf(rndr, BUFFER_SPAN); if ((link_len = sd_autolink__url(&rewind, link, data, offset, size)) > 0) { ob->size -= rewind; rndr->cb.autolink(ob, link, MKDA_NORMAL, rndr->opaque); } rndr_popbuf(rndr, BUFFER_SPAN); return link_len; } /* char_link • '[': parsing a link or an image */ static size_t char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { int is_img = (offset && data[-1] == '!'), level; size_t i = 1, txt_e, link_b = 0, link_e = 0, title_b = 0, title_e = 0; struct buf *content = 0; struct buf *link = 0; struct buf *title = 0; struct buf *u_link = 0; size_t org_work_size = rndr->work_bufs[BUFFER_SPAN].size; int text_has_nl = 0, ret = 0; int in_title = 0, qtype = 0; /* checking whether the correct renderer exists */ if ((is_img && !rndr->cb.image) || (!is_img && !rndr->cb.link)) goto cleanup; /* looking for the matching closing bracket */ for (level = 1; i < size; i++) { if (data[i] == '\n') text_has_nl = 1; else if (data[i - 1] == '\\') continue; else if (data[i] == '[') level++; else if (data[i] == ']') { level--; if (level <= 0) break; } } if (i >= size) goto cleanup; txt_e = i; i++; /* skip any amount of whitespace or newline */ /* (this is much more laxist than original markdown syntax) */ while (i < size && _isspace(data[i])) i++; /* inline style link */ if (i < size && data[i] == '(') { /* skipping initial whitespace */ i++; while (i < size && _isspace(data[i])) i++; link_b = i; /* looking for link end: ' " ) */ while (i < size) { if (data[i] == '\\') i += 2; else if (data[i] == ')') break; else if (i >= 1 && _isspace(data[i-1]) && (data[i] == '\'' || data[i] == '"')) break; else i++; } if (i >= size) goto cleanup; link_e = i; /* looking for title end if present */ if (data[i] == '\'' || data[i] == '"') { qtype = data[i]; in_title = 1; i++; title_b = i; while (i < size) { if (data[i] == '\\') i += 2; else if (data[i] == qtype) {in_title = 0; i++;} else if ((data[i] == ')') && !in_title) break; else i++; } if (i >= size) goto cleanup; /* skipping whitespaces after title */ title_e = i - 1; while (title_e > title_b && _isspace(data[title_e])) title_e--; /* 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 && _isspace(data[link_e - 1])) link_e--; /* remove optional angle brackets around the link */ if (data[link_b] == '<') link_b++; if (data[link_e - 1] == '>') link_e--; /* building escaped link and title */ if (link_e > link_b) { link = rndr_newbuf(rndr, BUFFER_SPAN); bufput(link, data + link_b, link_e - link_b); } if (title_e > title_b) { title = rndr_newbuf(rndr, BUFFER_SPAN); bufput(title, data + title_b, title_e - title_b); } i++; } /* reference style link */ else if (i < size && data[i] == '[') { struct buf id = { 0, 0, 0, 0 }; struct link_ref *lr; /* looking for the id */ i++; link_b = i; while (i < size && data[i] != ']') i++; if (i >= size) goto cleanup; link_e = i; /* finding the link_ref */ if (link_b == link_e) { if (text_has_nl) { struct buf *b = rndr_newbuf(rndr, BUFFER_SPAN); size_t j; for (j = 1; j < txt_e; j++) { if (data[j] != '\n') bufputc(b, data[j]); else if (data[j - 1] != ' ') bufputc(b, ' '); } id.data = b->data; id.size = b->size; } else { id.data = data + 1; id.size = txt_e - 1; } } else { id.data = data + link_b; id.size = link_e - link_b; } lr = find_link_ref(rndr->refs, id.data, id.size); if (!lr) goto cleanup; /* keeping link and title from link_ref */ link = lr->link; title = lr->title; i++; } /* shortcut reference style link */ else { struct buf id = { 0, 0, 0, 0 }; struct link_ref *lr; /* crafting the id */ if (text_has_nl) { struct buf *b = rndr_newbuf(rndr, BUFFER_SPAN); size_t j; for (j = 1; j < txt_e; j++) { if (data[j] != '\n') bufputc(b, data[j]); else if (data[j - 1] != ' ') bufputc(b, ' '); } id.data = b->data; id.size = b->size; } else { id.data = data + 1; id.size = txt_e - 1; } /* finding the link_ref */ lr = find_link_ref(rndr->refs, id.data, id.size); if (!lr) goto cleanup; /* keeping link and title from link_ref */ link = lr->link; title = lr->title; /* rewinding the whitespace */ i = txt_e + 1; } /* building content: img alt is escaped, link content is parsed */ if (txt_e > 1) { content = rndr_newbuf(rndr, BUFFER_SPAN); if (is_img) { bufput(content, data + 1, txt_e - 1); } else { /* disable autolinking when parsing inline the * content of a link */ rndr->in_link_body = 1; parse_inline(content, rndr, data + 1, txt_e - 1); rndr->in_link_body = 0; } } if (link) { u_link = rndr_newbuf(rndr, BUFFER_SPAN); unscape_text(u_link, link); } /* calling the relevant rendering function */ if (is_img) { if (ob->size && ob->data[ob->size - 1] == '!') ob->size -= 1; ret = rndr->cb.image(ob, u_link, title, content, rndr->opaque); } else { ret = rndr->cb.link(ob, u_link, title, content, rndr->opaque); } /* cleanup */ cleanup: rndr->work_bufs[BUFFER_SPAN].size = (int)org_work_size; return ret ? i : 0; } static size_t char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size) { size_t sup_start, sup_len; struct buf *sup; if (!rndr->cb.superscript) return 0; if (size < 2) return 0; if (data[1] == '(') { sup_start = sup_len = 2; while (sup_len < size && data[sup_len] != ')' && data[sup_len - 1] != '\\') sup_len++; if (sup_len == size) return 0; } else { sup_start = sup_len = 1; while (sup_len < size && !_isspace(data[sup_len])) sup_len++; } if (sup_len - sup_start == 0) return (sup_start == 2) ? 3 : 0; sup = rndr_newbuf(rndr, BUFFER_SPAN); parse_inline(sup, rndr, data + sup_start, sup_len - sup_start); rndr->cb.superscript(ob, sup, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); return (sup_start == 2) ? sup_len + 1 : sup_len; } /********************************* * BLOCK-LEVEL PARSING FUNCTIONS * *********************************/ /* is_empty • returns the line length when it is empty, 0 otherwise */ static size_t is_empty(uint8_t *data, size_t size) { size_t i; for (i = 0; i < size && data[i] != '\n'; i++) if (data[i] != ' ') return 0; return i + 1; } /* is_hrule • returns whether a line is a horizontal rule */ static int is_hrule(uint8_t *data, size_t size) { size_t i = 0, n = 0; uint8_t c; /* skipping initial spaces */ if (size < 3) return 0; if (data[0] == ' ') { i++; if (data[1] == ' ') { i++; if (data[2] == ' ') { i++; } } } /* looking at the hrule uint8_t */ 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++; else if (data[i] != ' ') return 0; i++; } return n >= 3; } /* check if a line begins with a code fence; return the * width of the code fence */ static size_t prefix_codefence(uint8_t *data, size_t size) { size_t i = 0, n = 0; uint8_t c; /* skipping initial spaces */ if (size < 3) return 0; if (data[0] == ' ') { i++; if (data[1] == ' ') { i++; if (data[2] == ' ') { i++; } } } /* looking at the hrule uint8_t */ if (i + 2 >= size || !(data[i] == '~' || data[i] == '`')) return 0; c = data[i]; /* the whole line must be the uint8_t or whitespace */ while (i < size && data[i] == c) { n++; i++; } if (n < 3) return 0; return i; } /* check if a line is a code fence; return its size if it is */ static size_t is_codefence(uint8_t *data, size_t size, struct buf *syntax) { size_t i = 0, syn_len = 0; uint8_t *syn_start; i = prefix_codefence(data, size); if (i == 0) return 0; while (i < size && data[i] == ' ') i++; syn_start = data + i; if (i < size && data[i] == '{') { i++; syn_start++; while (i < size && data[i] != '}' && data[i] != '\n') { syn_len++; i++; } if (i == size || data[i] != '}') return 0; /* strip all whitespace at the beginning and the end * of the {} block */ while (syn_len > 0 && _isspace(syn_start[0])) { syn_start++; syn_len--; } while (syn_len > 0 && _isspace(syn_start[syn_len - 1])) syn_len--; i++; } else { while (i < size && !_isspace(data[i])) { syn_len++; i++; } } if (syntax) { syntax->data = syn_start; syntax->size = syn_len; } while (i < size && data[i] != '\n') { if (!_isspace(data[i])) return 0; i++; } return i + 1; } /* is_atxheader • returns whether the line is a hash-prefixed header */ static int is_atxheader(struct sd_markdown *rndr, uint8_t *data, size_t size) { if (data[0] != '#') return 0; if (rndr->ext_flags & MKDEXT_SPACE_HEADERS) { size_t level = 0; while (level < size && level < 6 && data[level] == '#') level++; if (level < size && data[level] != ' ') return 0; } return 1; } /* is_headerline • returns whether the line is a setext-style hdr underline */ static int is_headerline(uint8_t *data, size_t size) { size_t i = 0; /* test of level 1 header */ if (data[i] == '=') { for (i = 1; i < size && data[i] == '='; i++); while (i < size && data[i] == ' ') i++; return (i >= size || data[i] == '\n') ? 1 : 0; } /* test of level 2 header */ if (data[i] == '-') { for (i = 1; i < size && data[i] == '-'; i++); while (i < size && data[i] == ' ') i++; return (i >= size || data[i] == '\n') ? 2 : 0; } return 0; } static int is_next_headerline(uint8_t *data, size_t size) { size_t i = 0; while (i < size && data[i] != '\n') i++; if (++i >= size) return 0; return is_headerline(data + i, size - i); } /* prefix_quote • returns blockquote prefix length */ static size_t prefix_quote(uint8_t *data, size_t size) { size_t i = 0; if (i < size && data[i] == ' ') i++; if (i < size && data[i] == ' ') i++; if (i < size && data[i] == ' ') i++; if (i < size && data[i] == '>') { if (i + 1 < size && data[i + 1] == ' ') return i + 2; return i + 1; } return 0; } /* prefix_code • returns prefix length for block code*/ static size_t prefix_code(uint8_t *data, size_t size) { 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(uint8_t *data, size_t size) { size_t i = 0; if (i < size && data[i] == ' ') i++; if (i < size && data[i] == ' ') i++; if (i < size && data[i] == ' ') i++; if (i >= size || data[i] < '0' || data[i] > '9') return 0; while (i < size && data[i] >= '0' && data[i] <= '9') i++; if (i + 1 >= size || data[i] != '.' || data[i + 1] != ' ') return 0; if (is_next_headerline(data + i, size - i)) return 0; return i + 2; } /* prefix_uli • returns ordered list item prefix */ static size_t prefix_uli(uint8_t *data, size_t size) { size_t i = 0; if (i < size && data[i] == ' ') i++; if (i < size && data[i] == ' ') i++; if (i < size && data[i] == ' ') i++; if (i + 1 >= size || (data[i] != '*' && data[i] != '+' && data[i] != '-') || data[i + 1] != ' ') return 0; if (is_next_headerline(data + i, size - i)) return 0; return i + 2; } /* parse_block • parsing of one block, returning next uint8_t to parse */ static void parse_block(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size); /* parse_blockquote • handles parsing of a blockquote fragment */ static size_t parse_blockquote(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t beg, end = 0, pre, work_size = 0; uint8_t *work_data = 0; struct buf *out = 0; out = rndr_newbuf(rndr, BUFFER_BLOCK); beg = 0; while (beg < size) { for (end = beg + 1; end < size && data[end - 1] != '\n'; end++); pre = prefix_quote(data + beg, end - beg); if (pre) beg += pre; /* skipping prefix */ /* empty line followed by non-quote line */ else if (is_empty(data + beg, end - beg) && (end >= size || (prefix_quote(data + end, size - end) == 0 && !is_empty(data + end, size - end)))) 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->cb.blockquote) rndr->cb.blockquote(ob, out, rndr->opaque); rndr_popbuf(rndr, BUFFER_BLOCK); return end; } static size_t parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render); /* parse_blockquote • handles parsing of a regular paragraph */ static size_t parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t i = 0, end = 0; int level = 0; struct buf work = { 0, 0, 0, 0 }; work.data = data; while (i < size) { for (end = i + 1; end < size && data[end - 1] != '\n'; end++) /* empty */; if (is_empty(data + i, size - i)) break; if ((level = is_headerline(data + i, size - i)) != 0) break; if (is_atxheader(rndr, data + i, size - i) || is_hrule(data + i, size - i) || prefix_quote(data + i, size - i)) { end = i; break; } /* * Early termination of a paragraph with the same logic * as Markdown 1.0.0. If this logic is applied, the * Markdown 1.0.3 test suite won't pass cleanly * * :: If the first character in a new line is not a letter, * let's check to see if there's some kind of block starting * here */ if ((rndr->ext_flags & MKDEXT_LAX_SPACING) && !isalnum(data[i])) { if (prefix_oli(data + i, size - i) || prefix_uli(data + i, size - i)) { end = i; break; } /* see if an html block starts here */ if (data[i] == '<' && rndr->cb.blockhtml && parse_htmlblock(ob, rndr, data + i, size - i, 0)) { end = i; break; } /* see if a code fence starts here */ if ((rndr->ext_flags & MKDEXT_FENCED_CODE) != 0 && is_codefence(data + i, size - i, NULL) != 0) { end = i; break; } } i = end; } work.size = i; while (work.size && data[work.size - 1] == '\n') work.size--; if (!level) { struct buf *tmp = rndr_newbuf(rndr, BUFFER_BLOCK); parse_inline(tmp, rndr, work.data, work.size); if (rndr->cb.paragraph) rndr->cb.paragraph(ob, tmp, rndr->opaque); rndr_popbuf(rndr, BUFFER_BLOCK); } else { struct buf *header_work; 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 > 0) { struct buf *tmp = rndr_newbuf(rndr, BUFFER_BLOCK); parse_inline(tmp, rndr, work.data, work.size); if (rndr->cb.paragraph) rndr->cb.paragraph(ob, tmp, rndr->opaque); rndr_popbuf(rndr, BUFFER_BLOCK); work.data += beg; work.size = i - beg; } else work.size = i; } header_work = rndr_newbuf(rndr, BUFFER_SPAN); parse_inline(header_work, rndr, work.data, work.size); if (rndr->cb.header) rndr->cb.header(ob, header_work, (int)level, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); } return end; } /* parse_fencedcode • handles parsing of a block-level code fragment */ static size_t parse_fencedcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t beg, end; struct buf *work = 0; struct buf lang = { 0, 0, 0, 0 }; beg = is_codefence(data, size, &lang); if (beg == 0) return 0; work = rndr_newbuf(rndr, BUFFER_BLOCK); while (beg < size) { size_t fence_end; struct buf fence_trail = { 0, 0, 0, 0 }; fence_end = is_codefence(data + beg, size - beg, &fence_trail); if (fence_end != 0 && fence_trail.size == 0) { beg += fence_end; break; } for (end = beg + 1; end < size && data[end - 1] != '\n'; end++); 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; } if (work->size && work->data[work->size - 1] != '\n') bufputc(work, '\n'); if (rndr->cb.blockcode) rndr->cb.blockcode(ob, work, lang.size ? &lang : NULL, rndr->opaque); rndr_popbuf(rndr, BUFFER_BLOCK); return beg; } static size_t parse_blockcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t beg, end, pre; struct buf *work = 0; work = rndr_newbuf(rndr, BUFFER_BLOCK); beg = 0; while (beg < size) { for (end = beg + 1; end < size && data[end - 1] != '\n'; end++) {}; 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->cb.blockcode) rndr->cb.blockcode(ob, work, NULL, rndr->opaque); rndr_popbuf(rndr, BUFFER_BLOCK); 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 sd_markdown *rndr, uint8_t *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, in_fence = 0; /* keeping track of the first indentation prefix */ while (orgpre < 3 && orgpre < size && data[orgpre] == ' ') orgpre++; 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++; /* getting working buffers */ work = rndr_newbuf(rndr, BUFFER_SPAN); inter = rndr_newbuf(rndr, BUFFER_SPAN); /* putting the first line into the working buffer */ bufput(work, data + beg, end - beg); beg = end; /* process the following lines */ while (beg < size) { size_t has_next_uli = 0, has_next_oli = 0; end++; while (end < size && data[end - 1] != '\n') end++; /* process an empty line */ if (is_empty(data + beg, end - beg)) { in_empty = 1; beg = end; continue; } /* calculating the indentation */ i = 0; while (i < 4 && beg + i < end && data[beg + i] == ' ') i++; pre = i; if (rndr->ext_flags & MKDEXT_FENCED_CODE) { if (is_codefence(data + beg + i, end - beg - i, NULL) != 0) in_fence = !in_fence; } /* Only check for new list items if we are **not** inside * a fenced code block */ if (!in_fence) { has_next_uli = prefix_uli(data + beg + i, end - beg - i); has_next_oli = prefix_oli(data + beg + i, end - beg - i); } /* checking for ul/ol switch */ if (in_empty && ( ((*flags & MKD_LIST_ORDERED) && has_next_uli) || (!(*flags & MKD_LIST_ORDERED) && has_next_oli))){ *flags |= MKD_LI_END; break; /* the following item must have same list type */ } /* checking for a new item */ if ((has_next_uli && !is_hrule(data + beg + i, end - beg - i)) || has_next_oli) { 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; * note that now we only require 1 space of indentation * to continue a list */ else if (in_empty && pre == 0) { *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->cb.listitem) rndr->cb.listitem(ob, inter, *flags, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); rndr_popbuf(rndr, BUFFER_SPAN); return beg; } /* parse_list • parsing ordered or unordered list block */ static size_t parse_list(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int flags) { struct buf *work = 0; size_t i = 0, j; work = rndr_newbuf(rndr, BUFFER_BLOCK); while (i < size) { j = parse_listitem(work, rndr, data + i, size - i, &flags); i += j; if (!j || (flags & MKD_LI_END)) break; } if (rndr->cb.list) rndr->cb.list(ob, work, flags, rndr->opaque); rndr_popbuf(rndr, BUFFER_BLOCK); return i; } /* parse_atxheader • parsing of atx-style headers */ static size_t parse_atxheader(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t level = 0; size_t i, end, skip; while (level < size && level < 6 && data[level] == '#') level++; for (i = level; i < size && data[i] == ' '; i++); for (end = i; end < size && data[end] != '\n'; end++); skip = end; while (end && data[end - 1] == '#') end--; while (end && data[end - 1] == ' ') end--; if (end > i) { struct buf *work = rndr_newbuf(rndr, BUFFER_SPAN); parse_inline(work, rndr, data + i, end - i); if (rndr->cb.header) rndr->cb.header(ob, work, (int)level, rndr->opaque); rndr_popbuf(rndr, BUFFER_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_tag( const char *tag, size_t tag_len, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t i, w; /* checking if tag is a match */ if (tag_len + 3 >= size || strncasecmp((char *)data + 2, tag, tag_len) != 0 || data[tag_len + 2] != '>') return 0; /* checking white lines */ i = tag_len + 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); return i + w; } static size_t htmlblock_end(const char *curtag, struct sd_markdown *rndr, uint8_t *data, size_t size, int start_of_line) { size_t tag_size = strlen(curtag); size_t i = 1, end_tag; int block_lines = 0; while (i < size) { i++; while (i < size && !(data[i - 1] == '<' && data[i] == '/')) { if (data[i] == '\n') block_lines++; i++; } /* If we are only looking for unindented tags, skip the tag * if it doesn't follow a newline. * * The only exception to this is if the tag is still on the * initial line; in that case it still counts as a closing * tag */ if (start_of_line && block_lines > 0 && data[i - 2] != '\n') continue; if (i + 2 + tag_size >= size) break; end_tag = htmlblock_end_tag(curtag, tag_size, rndr, data + i - 1, size - i + 1); if (end_tag) return i + end_tag - 1; } return 0; } /* parse_htmlblock • parsing of inline HTML block */ static size_t parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render) { size_t i, j = 0, tag_end; const char *curtag = NULL; struct buf work = { 0, 0, 0, 0 }; work.data = data; /* identification of the opening tag */ if (size < 2 || data[0] != '<') return 0; i = 1; while (i < size && data[i] != '>' && data[i] != ' ') i++; if (i < size) curtag = find_block_tag((char *)data + 1, (int)i - 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++; i++; if (i < size) j = is_empty(data + i, size - i); if (j) { work.size = i + j; if (do_render && rndr->cb.blockhtml) rndr->cb.blockhtml(ob, &work, rndr->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++; if (i + 1 < size) { i++; j = is_empty(data + i, size - i); if (j) { work.size = i + j; if (do_render && rndr->cb.blockhtml) rndr->cb.blockhtml(ob, &work, rndr->opaque); return work.size; } } } /* no special case recognised */ return 0; } /* looking for an unindented matching closing tag */ /* followed by a blank line */ tag_end = htmlblock_end(curtag, rndr, data, size, 1); /* if not found, trying a second pass looking for indented match */ /* but not if tag is "ins" or "del" (following original Markdown.pl) */ if (!tag_end && strcmp(curtag, "ins") != 0 && strcmp(curtag, "del") != 0) { tag_end = htmlblock_end(curtag, rndr, data, size, 0); } if (!tag_end) return 0; /* the end of the block has been found */ work.size = tag_end; if (do_render && rndr->cb.blockhtml) rndr->cb.blockhtml(ob, &work, rndr->opaque); return tag_end; } static void parse_table_row( struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, size_t columns, int *col_data, int header_flag) { size_t i = 0, col; struct buf *row_work = 0; if (!rndr->cb.table_cell || !rndr->cb.table_row) return; row_work = rndr_newbuf(rndr, BUFFER_SPAN); if (i < size && data[i] == '|') i++; for (col = 0; col < columns && i < size; ++col) { size_t cell_start, cell_end; struct buf *cell_work; cell_work = rndr_newbuf(rndr, BUFFER_SPAN); while (i < size && _isspace(data[i])) i++; cell_start = i; while (i < size && data[i] != '|') i++; cell_end = i - 1; while (cell_end > cell_start && _isspace(data[cell_end])) cell_end--; parse_inline(cell_work, rndr, data + cell_start, 1 + cell_end - cell_start); rndr->cb.table_cell(row_work, cell_work, col_data[col] | header_flag, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); i++; } for (; col < columns; ++col) { struct buf empty_cell = { 0, 0, 0, 0 }; rndr->cb.table_cell(row_work, &empty_cell, col_data[col] | header_flag, rndr->opaque); } rndr->cb.table_row(ob, row_work, rndr->opaque); rndr_popbuf(rndr, BUFFER_SPAN); } static size_t parse_table_header( struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, size_t *columns, int **column_data) { int pipes; size_t i = 0, col, header_end, under_end; pipes = 0; while (i < size && data[i] != '\n') if (data[i++] == '|') pipes++; if (i == size || pipes == 0) return 0; header_end = i; while (header_end > 0 && _isspace(data[header_end - 1])) header_end--; if (data[0] == '|') pipes--; if (header_end && data[header_end - 1] == '|') pipes--; *columns = pipes + 1; *column_data = calloc(*columns, sizeof(int)); /* Parse the header underline */ i++; if (i < size && data[i] == '|') i++; under_end = i; while (under_end < size && data[under_end] != '\n') under_end++; for (col = 0; col < *columns && i < under_end; ++col) { size_t dashes = 0; while (i < under_end && data[i] == ' ') i++; if (data[i] == ':') { i++; (*column_data)[col] |= MKD_TABLE_ALIGN_L; dashes++; } while (i < under_end && data[i] == '-') { i++; dashes++; } if (i < under_end && data[i] == ':') { i++; (*column_data)[col] |= MKD_TABLE_ALIGN_R; dashes++; } while (i < under_end && data[i] == ' ') i++; if (i < under_end && data[i] != '|') break; if (dashes < 3) break; i++; } if (col < *columns) return 0; parse_table_row( ob, rndr, data, header_end, *columns, *column_data, MKD_TABLE_HEADER ); return under_end + 1; } static size_t parse_table( struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t i; struct buf *header_work = 0; struct buf *body_work = 0; size_t columns; int *col_data = NULL; header_work = rndr_newbuf(rndr, BUFFER_SPAN); body_work = rndr_newbuf(rndr, BUFFER_BLOCK); i = parse_table_header(header_work, rndr, data, size, &columns, &col_data); if (i > 0) { while (i < size) { size_t row_start; int pipes = 0; row_start = i; while (i < size && data[i] != '\n') if (data[i++] == '|') pipes++; if (pipes == 0 || i == size) { i = row_start; break; } parse_table_row( body_work, rndr, data + row_start, i - row_start, columns, col_data, 0 ); i++; } if (rndr->cb.table) rndr->cb.table(ob, header_work, body_work, rndr->opaque); } free(col_data); rndr_popbuf(rndr, BUFFER_SPAN); rndr_popbuf(rndr, BUFFER_BLOCK); return i; } /* parse_block • parsing of one block, returning next uint8_t to parse */ static void parse_block(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size) { size_t beg, end, i; uint8_t *txt_data; beg = 0; if (rndr->work_bufs[BUFFER_SPAN].size + rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting) return; while (beg < size) { txt_data = data + beg; end = size - beg; if (is_atxheader(rndr, txt_data, end)) beg += parse_atxheader(ob, rndr, txt_data, end); else if (data[beg] == '<' && rndr->cb.blockhtml && (i = parse_htmlblock(ob, rndr, txt_data, end, 1)) != 0) beg += i; else if ((i = is_empty(txt_data, end)) != 0) beg += i; else if (is_hrule(txt_data, end)) { if (rndr->cb.hrule) rndr->cb.hrule(ob, rndr->opaque); while (beg < size && data[beg] != '\n') beg++; beg++; } else if ((rndr->ext_flags & MKDEXT_FENCED_CODE) != 0 && (i = parse_fencedcode(ob, rndr, txt_data, end)) != 0) beg += i; else if ((rndr->ext_flags & MKDEXT_TABLES) != 0 && (i = parse_table(ob, rndr, txt_data, end)) != 0) beg += i; 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 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(const uint8_t *data, size_t beg, size_t end, size_t *last, struct link_ref **refs) { /* int n; */ 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; /* 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++; id_offset = i; while (i < end && data[i] != '\n' && data[i] != '\r' && data[i] != ']') i++; if (i >= end || data[i] != ']') return 0; id_end = i; /* spacer: colon (space | tab)* newline? (space | tab)* */ i++; if (i >= end || data[i] != ':') return 0; i++; while (i < end && data[i] == ' ') i++; if (i < end && (data[i] == '\n' || data[i] == '\r')) { i++; if (i < end && data[i] == '\r' && data[i - 1] == '\n') i++; } while (i < end && data[i] == ' ') i++; if (i >= end) return 0; /* link: whitespace-free sequence, optionally between angle brackets */ if (data[i] == '<') i++; link_offset = i; while (i < end && data[i] != ' ' && data[i] != '\n' && data[i] != '\r') i++; if (data[i - 1] == '>') link_end = i - 1; else link_end = i; /* optional spacer: (space | tab)* (newline | '\'' | '"' | '(' ) */ while (i < end && data[i] == ' ') i++; 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] == ' ') i++; } /* 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++; title_offset = i; /* looking for EOL */ while (i < end && data[i] != '\n' && data[i] != '\r') i++; 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] == ' ') i -= 1; if (i > title_offset && (data[i] == '\'' || data[i] == '"' || data[i] == ')')) { line_end = title_end; title_end = i; } } if (!line_end || link_end == link_offset) return 0; /* garbage after the link empty link */ /* a valid ref has been found, filling-in return structures */ if (last) *last = line_end; if (refs) { struct link_ref *ref; ref = add_link_ref(refs, data + id_offset, id_end - id_offset); if (!ref) return 0; ref->link = bufnew(link_end - link_offset); bufput(ref->link, data + link_offset, link_end - link_offset); if (title_end > title_offset) { ref->title = bufnew(title_end - title_offset); bufput(ref->title, data + title_offset, title_end - title_offset); } } return 1; } static void expand_tabs(struct buf *ob, const uint8_t *line, size_t size) { size_t i = 0, tab = 0; while (i < size) { size_t org = i; while (i < size && line[i] != '\t') { i++; tab++; } if (i > org) bufput(ob, line + org, i - org); if (i >= size) break; do { bufputc(ob, ' '); tab++; } while (tab % 4); i++; } } /********************** * EXPORTED FUNCTIONS * **********************/ struct sd_markdown * sd_markdown_new( unsigned int extensions, size_t max_nesting, const struct sd_callbacks *callbacks, void *opaque) { struct sd_markdown *md = NULL; assert(max_nesting > 0 && callbacks); md = malloc(sizeof(struct sd_markdown)); if (!md) return NULL; memcpy(&md->cb, callbacks, sizeof(struct sd_callbacks)); stack_init(&md->work_bufs[BUFFER_BLOCK], 4); stack_init(&md->work_bufs[BUFFER_SPAN], 8); memset(md->active_char, 0x0, 256); if (md->cb.emphasis || md->cb.double_emphasis || md->cb.triple_emphasis) { md->active_char['*'] = MD_CHAR_EMPHASIS; md->active_char['_'] = MD_CHAR_EMPHASIS; if (extensions & MKDEXT_STRIKETHROUGH) md->active_char['~'] = MD_CHAR_EMPHASIS; } if (md->cb.codespan) md->active_char['`'] = MD_CHAR_CODESPAN; if (md->cb.linebreak) md->active_char['\n'] = MD_CHAR_LINEBREAK; if (md->cb.image || md->cb.link) md->active_char['['] = MD_CHAR_LINK; md->active_char['<'] = MD_CHAR_LANGLE; md->active_char['\\'] = MD_CHAR_ESCAPE; md->active_char['&'] = MD_CHAR_ENTITITY; if (extensions & MKDEXT_AUTOLINK) { md->active_char[':'] = MD_CHAR_AUTOLINK_URL; md->active_char['@'] = MD_CHAR_AUTOLINK_EMAIL; md->active_char['w'] = MD_CHAR_AUTOLINK_WWW; } if (extensions & MKDEXT_SUPERSCRIPT) md->active_char['^'] = MD_CHAR_SUPERSCRIPT; if (extensions & MKDEXT_LATEX_MATH) md->active_char['$'] = MD_CHAR_DOLLAR; /* Extension data */ md->ext_flags = extensions; md->opaque = opaque; md->max_nesting = max_nesting; md->in_link_body = 0; return md; } void sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md) { #define MARKDOWN_GROW(x) ((x) + ((x) >> 1)) static const uint8_t UTF8_BOM[] = {0xEF, 0xBB, 0xBF}; struct buf *text; size_t beg, end; text = bufnew(64); if (!text) return; /* Preallocate enough space for our buffer to avoid expanding while copying */ bufgrow(text, doc_size); /* reset the references table */ memset(&md->refs, 0x0, REF_TABLE_SIZE * sizeof(void *)); /* first pass: looking for references, copying everything else */ beg = 0; /* Skip a possible UTF-8 BOM, even though the Unicode standard * discourages having these in UTF-8 documents */ if (doc_size >= 3 && memcmp(document, UTF8_BOM, 3) == 0) beg += 3; while (beg < doc_size) /* iterating over lines */ if (is_ref(document, beg, doc_size, &end, md->refs)) beg = end; else { /* skipping to the next line */ end = beg; while (end < doc_size && document[end] != '\n' && document[end] != '\r') end++; /* adding the line body if present */ if (end > beg) expand_tabs(text, document + beg, end - beg); while (end < doc_size && (document[end] == '\n' || document[end] == '\r')) { /* add one \n per newline */ if (document[end] == '\n' || (end + 1 < doc_size && document[end + 1] != '\n')) bufputc(text, '\n'); end++; } beg = end; } /* pre-grow the output buffer to minimize allocations */ bufgrow(ob, MARKDOWN_GROW(text->size)); /* second pass: actual rendering */ if (md->cb.doc_header) md->cb.doc_header(ob, md->opaque); if (text->size) { /* adding a final newline if not already present */ if (text->data[text->size - 1] != '\n' && text->data[text->size - 1] != '\r') bufputc(text, '\n'); parse_block(ob, md, text->data, text->size); } if (md->cb.doc_footer) md->cb.doc_footer(ob, md->opaque); /* clean-up */ bufrelease(text); free_link_refs(md->refs); assert(md->work_bufs[BUFFER_SPAN].size == 0); assert(md->work_bufs[BUFFER_BLOCK].size == 0); } void sd_markdown_free(struct sd_markdown *md) { size_t i; for (i = 0; i < (size_t)md->work_bufs[BUFFER_SPAN].asize; ++i) bufrelease(md->work_bufs[BUFFER_SPAN].item[i]); for (i = 0; i < (size_t)md->work_bufs[BUFFER_BLOCK].asize; ++i) bufrelease(md->work_bufs[BUFFER_BLOCK].item[i]); stack_free(&md->work_bufs[BUFFER_SPAN]); stack_free(&md->work_bufs[BUFFER_BLOCK]); free(md); } void sd_version(int *ver_major, int *ver_minor, int *ver_revision) { *ver_major = SUNDOWN_VER_MAJOR; *ver_minor = SUNDOWN_VER_MINOR; *ver_revision = SUNDOWN_VER_REVISION; } /* vim: set filetype=c: */ markdown/src/autolink.c0000644000176200001440000001303212515736624014667 0ustar liggesusers/* * Copyright (c) 2011, Vicent Marti * * 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 "buffer.h" #include #include #include #include #if defined(_WIN32) #define strncasecmp _strnicmp #endif int sd_autolink_issafe(const uint8_t *link, size_t link_len) { static const size_t valid_uris_count = 5; static const char *valid_uris[] = { "/", "http://", "https://", "ftp://", "mailto:" }; size_t i; for (i = 0; i < valid_uris_count; ++i) { size_t len = strlen(valid_uris[i]); if (link_len > len && strncasecmp((char *)link, valid_uris[i], len) == 0 && isalnum(link[len])) return 1; } return 0; } static size_t autolink_delim(uint8_t *data, size_t link_end, size_t offset, size_t size) { uint8_t cclose, copen = 0; size_t i; for (i = 0; i < link_end; ++i) if (data[i] == '<') { link_end = i; break; } while (link_end > 0) { if (strchr("?!.,", data[link_end - 1]) != NULL) link_end--; else if (data[link_end - 1] == ';') { size_t new_end = link_end - 2; while (new_end > 0 && isalpha(data[new_end])) new_end--; if (new_end < link_end - 2 && data[new_end] == '&') link_end = new_end; else link_end--; } else break; } if (link_end == 0) return 0; cclose = data[link_end - 1]; switch (cclose) { case '"': copen = '"'; break; case '\'': copen = '\''; break; case ')': copen = '('; break; case ']': copen = '['; break; case '}': copen = '{'; break; } if (copen != 0) { size_t closing = 0; size_t opening = 0; size_t i = 0; /* Try to close the final punctuation sign in this same line; * if we managed to close it outside of the URL, that means that it's * not part of the URL. If it closes inside the URL, that means it * is part of the URL. * * Examples: * * foo http://www.pokemon.com/Pikachu_(Electric) bar * => http://www.pokemon.com/Pikachu_(Electric) * * foo (http://www.pokemon.com/Pikachu_(Electric)) bar * => http://www.pokemon.com/Pikachu_(Electric) * * foo http://www.pokemon.com/Pikachu_(Electric)) bar * => http://www.pokemon.com/Pikachu_(Electric)) * * (foo http://www.pokemon.com/Pikachu_(Electric)) bar * => foo http://www.pokemon.com/Pikachu_(Electric) */ while (i < link_end) { if (data[i] == copen) opening++; else if (data[i] == cclose) closing++; i++; } if (closing != opening) link_end--; } return link_end; } static size_t check_domain(uint8_t *data, size_t size) { size_t i, np = 0; if (!isalnum(data[0])) return 0; for (i = 1; i < size - 1; ++i) { if (data[i] == '.') np++; else if (!isalnum(data[i]) && data[i] != '-') break; } /* a valid domain needs to have at least a dot. * that's as far as we get */ return np ? i : 0; } size_t sd_autolink__www(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) { size_t link_end; if (offset > 0 && !ispunct(data[-1]) && !isspace(data[-1])) return 0; if (size < 4 || memcmp(data, "www.", strlen("www.")) != 0) return 0; link_end = check_domain(data, size); if (link_end == 0) return 0; while (link_end < size && !isspace(data[link_end])) link_end++; link_end = autolink_delim(data, link_end, offset, size); if (link_end == 0) return 0; bufput(link, data, link_end); *rewind_p = 0; return (int)link_end; } size_t sd_autolink__email(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) { size_t link_end, rewind; int nb = 0, np = 0; for (rewind = 0; rewind < offset; ++rewind) { uint8_t c = data[-rewind - 1]; if (isalnum(c)) continue; if (strchr(".+-_", c) != NULL) continue; break; } if (rewind == 0) return 0; for (link_end = 0; link_end < size; ++link_end) { uint8_t c = data[link_end]; if (isalnum(c)) continue; if (c == '@') nb++; else if (c == '.' && link_end < size - 1) np++; else if (c != '-' && c != '_') break; } if (link_end < 2 || nb != 1 || np == 0) return 0; link_end = autolink_delim(data, link_end, offset, size); if (link_end == 0) return 0; bufput(link, data - rewind, link_end + rewind); *rewind_p = rewind; return link_end; } size_t sd_autolink__url(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size) { size_t link_end, rewind = 0, domain_len; if (size < 4 || data[1] != '/' || data[2] != '/') return 0; while (rewind < offset && isalpha(data[-rewind - 1])) rewind++; if (!sd_autolink_issafe(data - rewind, size + rewind)) return 0; link_end = strlen("://"); domain_len = check_domain(data + link_end, size - link_end); if (domain_len == 0) return 0; link_end += domain_len; while (link_end < size && !isspace(data[link_end])) link_end++; link_end = autolink_delim(data, link_end, offset, size); if (link_end == 0) return 0; bufput(link, data - rewind, link_end + rewind); *rewind_p = rewind; return link_end; } markdown/src/houdini_html_e.c0000644000176200001440000000377512515736624016045 0ustar liggesusers#include #include #include #include "houdini.h" #define ESCAPE_GROW_FACTOR(x) (((x) * 12) / 10) /* this is very scientific, yes */ /** * According to the OWASP rules: * * & --> & * < --> < * > --> > * " --> " * ' --> ' ' is not recommended * / --> / forward slash is included as it helps end an HTML entity * */ static const char HTML_ESCAPE_TABLE[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; static const char *HTML_ESCAPES[] = { "", """, "&", "'", "/", "<", ">" }; void houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure) { size_t i = 0, org, esc = 0; bufgrow(ob, ESCAPE_GROW_FACTOR(size)); while (i < size) { org = i; while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0) i++; if (i > org) bufput(ob, src + org, i - org); /* escaping */ if (i >= size) break; /* The forward slash is only escaped in secure mode */ if (src[i] == '/' && !secure) { bufputc(ob, '/'); } else { bufputs(ob, HTML_ESCAPES[esc]); } i++; } } void houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size) { houdini_escape_html0(ob, src, size, 1); } markdown/src/html_blocks.h0000644000176200001440000001532212515736624015353 0ustar liggesusers/* C code produced by gperf version 3.0.3 */ /* Command-line: gperf -N find_block_tag -H hash_block_tag -C -c -E --ignore-case html_block_names.txt */ /* Computed positions: -k'1-2' */ #if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) /* The character set is not based on ISO-646. */ error "gperf generated tables don't work with this execution character set. Please report a bug to ." #endif /* maximum key range = 37, duplicates = 0 */ #ifndef GPERF_DOWNCASE #define GPERF_DOWNCASE 1 static unsigned char gperf_downcase[256] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 }; #endif #ifndef GPERF_CASE_STRNCMP #define GPERF_CASE_STRNCMP 1 static int gperf_case_strncmp (s1, s2, n) register const char *s1; register const char *s2; register unsigned int n; { for (; n > 0;) { unsigned char c1 = gperf_downcase[(unsigned char)*s1++]; unsigned char c2 = gperf_downcase[(unsigned char)*s2++]; if (c1 != 0 && c1 == c2) { n--; continue; } return (int)c1 - (int)c2; } return 0; } #endif #ifdef __GNUC__ __inline #else #ifdef __cplusplus inline #endif #endif static unsigned int hash_block_tag (str, len) register const char *str; register unsigned int len; { static const unsigned char asso_values[] = { 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 8, 30, 25, 20, 15, 10, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 0, 38, 0, 38, 5, 5, 5, 15, 0, 38, 38, 0, 15, 10, 0, 38, 38, 15, 0, 5, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 0, 38, 0, 38, 5, 5, 5, 15, 0, 38, 38, 0, 15, 10, 0, 38, 38, 15, 0, 5, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38 }; register int hval = len; switch (hval) { default: hval += asso_values[(unsigned char)str[1]+1]; /*FALLTHROUGH*/ case 1: hval += asso_values[(unsigned char)str[0]]; break; } return hval; } #ifdef __GNUC__ __inline #ifdef __GNUC_STDC_INLINE__ __attribute__ ((__gnu_inline__)) #endif #endif const char * find_block_tag (str, len) register const char *str; register unsigned int len; { enum { TOTAL_KEYWORDS = 24, MIN_WORD_LENGTH = 1, MAX_WORD_LENGTH = 10, MIN_HASH_VALUE = 1, MAX_HASH_VALUE = 37 }; static const char * const wordlist[] = { "", "p", "dl", "div", "math", "table", "", "ul", "del", "form", "blockquote", "figure", "ol", "fieldset", "", "h1", "", "h6", "pre", "", "", "script", "h5", "noscript", "", "style", "iframe", "h4", "ins", "", "", "", "h3", "", "", "", "", "h2" }; if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) { register int key = hash_block_tag (str, len); if (key <= MAX_HASH_VALUE && key >= 0) { register const char *s = wordlist[key]; if ((((unsigned char)*str ^ (unsigned char)*s) & ~32) == 0 && !gperf_case_strncmp (str, s, len) && s[len] == '\0') return s; } } return 0; } markdown/src/stack.h0000644000176200001440000000064212515736624014156 0ustar liggesusers#ifndef STACK_H__ #define STACK_H__ #include #ifdef __cplusplus extern "C" { #endif struct stack { void **item; size_t size; size_t asize; }; void stack_free(struct stack *); int stack_grow(struct stack *, size_t); int stack_init(struct stack *, size_t); int stack_push(struct stack *, void *); void *stack_pop(struct stack *); void *stack_top(struct stack *); #ifdef __cplusplus } #endif #endif markdown/src/html_smartypants.c0000644000176200001440000002514212515736624016457 0ustar liggesusers/* * Copyright (c) 2011, Vicent Marti * * 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 "buffer.h" #include "html.h" #include #include #include #include #if defined(_WIN32) #define snprintf _snprintf #endif struct smartypants_data { int in_squote; int in_dquote; }; static size_t smartypants_cb__ltag(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__dquote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__amp(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__period(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__number(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__dash(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__parens(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__squote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__backtick(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t smartypants_cb__escape(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size); static size_t (*smartypants_cb_ptrs[]) (struct buf *, struct smartypants_data *, uint8_t, const uint8_t *, size_t) = { NULL, /* 0 */ smartypants_cb__dash, /* 1 */ smartypants_cb__parens, /* 2 */ smartypants_cb__squote, /* 3 */ smartypants_cb__dquote, /* 4 */ smartypants_cb__amp, /* 5 */ smartypants_cb__period, /* 6 */ smartypants_cb__number, /* 7 */ smartypants_cb__ltag, /* 8 */ smartypants_cb__backtick, /* 9 */ smartypants_cb__escape, /* 10 */ }; static const uint8_t smartypants_cb_chars[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 3, 2, 0, 0, 0, 0, 1, 6, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; static inline int word_boundary(uint8_t c) { return c == 0 || isspace(c) || ispunct(c); } static int smartypants_quotes(struct buf *ob, uint8_t previous_char, uint8_t next_char, uint8_t quote, int *is_open) { char ent[8]; if (*is_open && !word_boundary(next_char)) return 0; if (!(*is_open) && !word_boundary(previous_char)) return 0; snprintf(ent, sizeof(ent), "&%c%cquo;", (*is_open) ? 'r' : 'l', quote); *is_open = !(*is_open); bufputs(ob, ent); return 1; } static size_t smartypants_cb__squote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (size >= 2) { uint8_t t1 = tolower(text[1]); if (t1 == '\'') { if (smartypants_quotes(ob, previous_char, size >= 3 ? text[2] : 0, 'd', &smrt->in_dquote)) return 1; } if ((t1 == 's' || t1 == 't' || t1 == 'm' || t1 == 'd') && (size == 3 || word_boundary(text[2]))) { BUFPUTSL(ob, "’"); return 0; } if (size >= 3) { uint8_t t2 = tolower(text[2]); if (((t1 == 'r' && t2 == 'e') || (t1 == 'l' && t2 == 'l') || (t1 == 'v' && t2 == 'e')) && (size == 4 || word_boundary(text[3]))) { BUFPUTSL(ob, "’"); return 0; } } } if (smartypants_quotes(ob, previous_char, size > 0 ? text[1] : 0, 's', &smrt->in_squote)) return 0; bufputc(ob, text[0]); return 0; } static size_t smartypants_cb__parens(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (size >= 3) { uint8_t t1 = tolower(text[1]); uint8_t t2 = tolower(text[2]); if (t1 == 'c' && t2 == ')') { BUFPUTSL(ob, "©"); return 2; } if (t1 == 'r' && t2 == ')') { BUFPUTSL(ob, "®"); return 2; } if (size >= 4 && t1 == 't' && t2 == 'm' && text[3] == ')') { BUFPUTSL(ob, "™"); return 3; } } bufputc(ob, text[0]); return 0; } static size_t smartypants_cb__dash(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (size >= 3 && text[1] == '-' && text[2] == '-') { BUFPUTSL(ob, "—"); return 2; } if (size >= 2 && text[1] == '-') { BUFPUTSL(ob, "–"); return 1; } bufputc(ob, text[0]); return 0; } static size_t smartypants_cb__amp(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (size >= 6 && memcmp(text, """, 6) == 0) { if (smartypants_quotes(ob, previous_char, size >= 7 ? text[6] : 0, 'd', &smrt->in_dquote)) return 5; } if (size >= 4 && memcmp(text, "�", 4) == 0) return 3; bufputc(ob, '&'); return 0; } static size_t smartypants_cb__period(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (size >= 3 && text[1] == '.' && text[2] == '.') { BUFPUTSL(ob, "…"); return 2; } if (size >= 5 && text[1] == ' ' && text[2] == '.' && text[3] == ' ' && text[4] == '.') { BUFPUTSL(ob, "…"); return 4; } bufputc(ob, text[0]); return 0; } static size_t smartypants_cb__backtick(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (size >= 2 && text[1] == '`') { if (smartypants_quotes(ob, previous_char, size >= 3 ? text[2] : 0, 'd', &smrt->in_dquote)) return 1; } return 0; } static size_t smartypants_cb__number(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (word_boundary(previous_char) && size >= 3) { if (text[0] == '1' && text[1] == '/' && text[2] == '2') { if (size == 3 || word_boundary(text[3])) { BUFPUTSL(ob, "½"); return 2; } } if (text[0] == '1' && text[1] == '/' && text[2] == '4') { if (size == 3 || word_boundary(text[3]) || (size >= 5 && tolower(text[3]) == 't' && tolower(text[4]) == 'h')) { BUFPUTSL(ob, "¼"); return 2; } } if (text[0] == '3' && text[1] == '/' && text[2] == '4') { if (size == 3 || word_boundary(text[3]) || (size >= 6 && tolower(text[3]) == 't' && tolower(text[4]) == 'h' && tolower(text[5]) == 's')) { BUFPUTSL(ob, "¾"); return 2; } } } bufputc(ob, text[0]); return 0; } static size_t smartypants_cb__dquote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (!smartypants_quotes(ob, previous_char, size > 0 ? text[1] : 0, 'd', &smrt->in_dquote)) BUFPUTSL(ob, """); return 0; } static size_t smartypants_cb__ltag(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { static const char *skip_tags[] = { "pre", "code", "var", "samp", "kbd", "math", "script", "style" }; static const size_t skip_tags_count = 8; size_t tag, i = 0; while (i < size && text[i] != '>') i++; for (tag = 0; tag < skip_tags_count; ++tag) { if (sdhtml_is_tag(text, size, skip_tags[tag]) == HTML_TAG_OPEN) break; } if (tag < skip_tags_count) { for (;;) { while (i < size && text[i] != '<') i++; if (i == size) break; if (sdhtml_is_tag(text + i, size - i, skip_tags[tag]) == HTML_TAG_CLOSE) break; i++; } while (i < size && text[i] != '>') i++; } bufput(ob, text, i + 1); return i; } static size_t smartypants_cb__escape(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size) { if (size < 2) return 0; switch (text[1]) { case '\\': case '"': case '\'': case '.': case '-': case '`': bufputc(ob, text[1]); return 1; default: bufputc(ob, '\\'); return 0; } } #if 0 static struct { uint8_t c0; const uint8_t *pattern; const uint8_t *entity; int skip; } smartypants_subs[] = { { '\'', "'s>", "’", 0 }, { '\'', "'t>", "’", 0 }, { '\'', "'re>", "’", 0 }, { '\'', "'ll>", "’", 0 }, { '\'', "'ve>", "’", 0 }, { '\'', "'m>", "’", 0 }, { '\'', "'d>", "’", 0 }, { '-', "--", "—", 1 }, { '-', "<->", "–", 0 }, { '.', "...", "…", 2 }, { '.', ". . .", "…", 4 }, { '(', "(c)", "©", 2 }, { '(', "(r)", "®", 2 }, { '(', "(tm)", "™", 3 }, { '3', "<3/4>", "¾", 2 }, { '3', "<3/4ths>", "¾", 2 }, { '1', "<1/2>", "½", 2 }, { '1', "<1/4>", "¼", 2 }, { '1', "<1/4th>", "¼", 2 }, { '&', "�", 0, 3 }, }; #endif void sdhtml_smartypants(struct buf *ob, const uint8_t *text, size_t size) { size_t i; struct smartypants_data smrt = {0, 0}; if (!text) return; bufgrow(ob, size); for (i = 0; i < size; ++i) { size_t org; uint8_t action = 0; org = i; while (i < size && (action = smartypants_cb_chars[text[i]]) == 0) i++; if (i > org) bufput(ob, text + org, i - org); if (i < size) { i += smartypants_cb_ptrs[(int)action] (ob, &smrt, i ? text[i - 1] : 0, text + i, size - i); } } } markdown/src/html.h0000644000176200001440000000367312515736624014024 0ustar liggesusers/* * Copyright (c) 2011, Vicent Marti * * 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 UPSKIRT_HTML_H #define UPSKIRT_HTML_H #include "markdown.h" #include "buffer.h" #include #ifdef __cplusplus extern "C" { #endif struct html_renderopt { struct { int header_count; int current_level; int level_offset; } toc_data; unsigned int flags; /* extra callbacks */ void (*link_attributes)(struct buf *ob, const struct buf *url, void *self); }; typedef enum { HTML_SKIP_HTML = (1 << 0), HTML_SKIP_STYLE = (1 << 1), HTML_SKIP_IMAGES = (1 << 2), HTML_SKIP_LINKS = (1 << 3), HTML_EXPAND_TABS = (1 << 4), HTML_SAFELINK = (1 << 5), HTML_TOC = (1 << 6), HTML_HARD_WRAP = (1 << 7), HTML_USE_XHTML = (1 << 8), HTML_ESCAPE = (1 << 9) } html_render_mode; typedef enum { HTML_TAG_NONE = 0, HTML_TAG_OPEN, HTML_TAG_CLOSE } html_tag; int sdhtml_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname); extern void sdhtml_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options_ptr, unsigned int render_flags); extern void sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options_ptr); extern void sdhtml_smartypants(struct buf *ob, const uint8_t *text, size_t size); #ifdef __cplusplus } #endif #endif markdown/src/autolink.h0000644000176200001440000000252112515736624014675 0ustar liggesusers/* * Copyright (c) 2011, Vicent Marti * * 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 UPSKIRT_AUTOLINK_H #define UPSKIRT_AUTOLINK_H #include "buffer.h" #ifdef __cplusplus extern "C" { #endif extern int sd_autolink_issafe(const uint8_t *link, size_t link_len); extern size_t sd_autolink__www(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); extern size_t sd_autolink__email(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); extern size_t sd_autolink__url(size_t *rewind_p, struct buf *link, uint8_t *data, size_t offset, size_t size); #ifdef __cplusplus } #endif #endif /* vim: set filetype=c: */ markdown/src/html.c0000644000176200001440000003462112515736624014014 0ustar liggesusers/* * Copyright (c) 2009, Natacha Porté * Copyright (c) 2011, Vicent Marti * * 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 "html.h" #include #include #include #include #include "houdini.h" #define USE_XHTML(opt) (opt->flags & HTML_USE_XHTML) int sdhtml_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname) { size_t i; int closed = 0; if (tag_size < 3 || tag_data[0] != '<') return HTML_TAG_NONE; i = 1; if (tag_data[i] == '/') { closed = 1; i++; } for (; i < tag_size; ++i, ++tagname) { if (*tagname == 0) break; if (tag_data[i] != *tagname) return HTML_TAG_NONE; } if (i == tag_size) return HTML_TAG_NONE; if (isspace(tag_data[i]) || tag_data[i] == '>') return closed ? HTML_TAG_CLOSE : HTML_TAG_OPEN; return HTML_TAG_NONE; } static inline void escape_html(struct buf *ob, const uint8_t *source, size_t length) { houdini_escape_html0(ob, source, length, 0); } static inline void escape_href(struct buf *ob, const uint8_t *source, size_t length) { houdini_escape_href(ob, source, length); } /******************** * GENERIC RENDERER * ********************/ static int rndr_autolink(struct buf *ob, const struct buf *link, enum mkd_autolink type, void *opaque) { struct html_renderopt *options = opaque; if (!link || !link->size) return 0; if ((options->flags & HTML_SAFELINK) != 0 && !sd_autolink_issafe(link->data, link->size) && type != MKDA_EMAIL) return 0; BUFPUTSL(ob, "data, link->size); if (options->link_attributes) { bufputc(ob, '\"'); options->link_attributes(ob, link, opaque); bufputc(ob, '>'); } else { BUFPUTSL(ob, "\">"); } /* * Pretty printing: if we get an email address as * an actual URI, e.g. `mailto:foo@bar.com`, we don't * want to print the `mailto:` prefix */ if (bufprefix(link, "mailto:") == 0) { escape_html(ob, link->data + 7, link->size - 7); } else { escape_html(ob, link->data, link->size); } BUFPUTSL(ob, ""); return 1; } static void rndr_blockcode(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque) { if (ob->size) bufputc(ob, '\n'); if (lang && lang->size) { size_t i, cls; BUFPUTSL(ob, "
    size; ++i, ++cls) {
			while (i < lang->size && isspace(lang->data[i]))
				i++;

			if (i < lang->size) {
				size_t org = i;
				while (i < lang->size && !isspace(lang->data[i]))
					i++;

				if (lang->data[org] == '.')
					org++;

				if (cls) bufputc(ob, ' ');
				escape_html(ob, lang->data + org, i - org);
			}
		}

		BUFPUTSL(ob, "\">");
	} else
		BUFPUTSL(ob, "
    ");

	if (text)
		escape_html(ob, text->data, text->size);

	BUFPUTSL(ob, "
    \n");
}

static void
rndr_blockquote(struct buf *ob, const 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_displayedmath(struct buf *ob, const struct buf *text, void *opaque)
{
	if (!text || !text->size)
		return 0;

	BUFPUTSL(ob, "\\[");
	if (text) bufput(ob, text->data, text->size);
	BUFPUTSL(ob, "\\]");
	return 1;
}

static int
rndr_inlinemath(struct buf *ob, const struct buf *text, void *opaque)
{
	if (!text || !text->size)
		return 0;

	BUFPUTSL(ob, "\\(");
	if (text) bufput(ob, text->data, text->size);
	BUFPUTSL(ob, "\\)");
	return 1;
}

static int
rndr_codespan(struct buf *ob, const struct buf *text, void *opaque)
{
	BUFPUTSL(ob, "");
	if (text) escape_html(ob, text->data, text->size);
	BUFPUTSL(ob, "");
	return 1;
}

static int
rndr_strikethrough(struct buf *ob, const struct buf *text, void *opaque)
{
	if (!text || !text->size)
		return 0;

	BUFPUTSL(ob, "");
	bufput(ob, text->data, text->size);
	BUFPUTSL(ob, "");
	return 1;
}

static int
rndr_double_emphasis(struct buf *ob, const struct buf *text, 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, const struct buf *text, void *opaque)
{
	if (!text || !text->size) return 0;
	BUFPUTSL(ob, "");
	if (text) bufput(ob, text->data, text->size);
	BUFPUTSL(ob, "");
	return 1;
}

static int
rndr_linebreak(struct buf *ob, void *opaque)
{
	struct html_renderopt *options = opaque;
	bufputs(ob, USE_XHTML(options) ? "
    \n" : "
    \n");
	return 1;
}

static void
rndr_header(struct buf *ob, const struct buf *text, int level, void *opaque)
{
	struct html_renderopt *options = opaque;

	if (ob->size)
		bufputc(ob, '\n');

	if (options->flags & HTML_TOC)
		bufprintf(ob, "", level, options->toc_data.header_count++);
	else
		bufprintf(ob, "", level);

	if (text) bufput(ob, text->data, text->size);
	bufprintf(ob, "\n", level);
}

static int
rndr_link(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque)
{
	struct html_renderopt *options = opaque;

	if (link != NULL && (options->flags & HTML_SAFELINK) != 0 && !sd_autolink_issafe(link->data, link->size))
		return 0;

	BUFPUTSL(ob, "size)
		escape_href(ob, link->data, link->size);

	if (title && title->size) {
		BUFPUTSL(ob, "\" title=\"");
		escape_html(ob, title->data, title->size);
	}

	if (options->link_attributes) {
		bufputc(ob, '\"');
		options->link_attributes(ob, link, opaque);
		bufputc(ob, '>');
	} else {
		BUFPUTSL(ob, "\">");
	}

	if (content && content->size) bufput(ob, content->data, content->size);
	BUFPUTSL(ob, "");
	return 1;
}

static void
rndr_list(struct buf *ob, const 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, const struct buf *text, int flags, void *opaque)
{
	BUFPUTSL(ob, "
  • ");
	if (text) {
		size_t size = text->size;
		while (size && text->data[size - 1] == '\n')
			size--;

		bufput(ob, text->data, size);
	}
	BUFPUTSL(ob, "
    • \n");
}

static void
rndr_paragraph(struct buf *ob, const struct buf *text, void *opaque)
{
	struct html_renderopt *options = opaque;
	size_t i = 0;

	if (ob->size) bufputc(ob, '\n');

	if (!text || !text->size)
		return;

	while (i < text->size && isspace(text->data[i])) i++;

	if (i == text->size)
		return;

	BUFPUTSL(ob, "
    ");
	if (options->flags & HTML_HARD_WRAP) {
		size_t org;
		while (i < text->size) {
			org = i;
			while (i < text->size && text->data[i] != '\n')
				i++;

			if (i > org)
				bufput(ob, text->data + org, i - org);

			/*
			 * do not insert a line break if this newline
			 * is the last character on the paragraph
			 */
			if (i >= text->size - 1)
				break;

			rndr_linebreak(ob, opaque);
			i++;
		}
	} else {
		bufput(ob, &text->data[i], text->size - i);
	}
	BUFPUTSL(ob, "
    \n");
}

static void
rndr_raw_block(struct buf *ob, const struct buf *text, void *opaque)
{
	size_t org, sz;
	if (!text) return;
	sz = text->size;
	while (sz > 0 && text->data[sz - 1] == '\n') sz--;
	org = 0;
	while (org < sz && text->data[org] == '\n') org++;
	if (org >= sz) return;
	if (ob->size) bufputc(ob, '\n');
	bufput(ob, text->data + org, sz - org);
	bufputc(ob, '\n');
}

static int
rndr_triple_emphasis(struct buf *ob, const struct buf *text, void *opaque)
{
	if (!text || !text->size) return 0;
	BUFPUTSL(ob, "");
	bufput(ob, text->data, text->size);
	BUFPUTSL(ob, "");
	return 1;
}

static void
rndr_hrule(struct buf *ob, void *opaque)
{
	struct html_renderopt *options = opaque;
	if (ob->size) bufputc(ob, '\n');
	bufputs(ob, USE_XHTML(options) ? "
    \n" : "
    \n");
}

static int
rndr_image(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque)
{
	struct html_renderopt *options = opaque;
	if (!link || !link->size) return 0;

	BUFPUTSL(ob, "data, link->size);
	BUFPUTSL(ob, "\" alt=\"");

	if (alt && alt->size)
		escape_html(ob, alt->data, alt->size);

	if (title && title->size) {
		BUFPUTSL(ob, "\" title=\"");
		escape_html(ob, title->data, title->size); }

	bufputs(ob, USE_XHTML(options) ? "\"/>" : "\">");
	return 1;
}

static int
rndr_raw_html(struct buf *ob, const struct buf *text, void *opaque)
{
	struct html_renderopt *options = opaque;

	/* HTML_ESCAPE overrides SKIP_HTML, SKIP_STYLE, SKIP_LINKS and SKIP_IMAGES
	* It doens't see if there are any valid tags, just escape all of them. */
	if((options->flags & HTML_ESCAPE) != 0) {
		escape_html(ob, text->data, text->size);
		return 1;
	}

	if ((options->flags & HTML_SKIP_HTML) != 0)
		return 1;

	if ((options->flags & HTML_SKIP_STYLE) != 0 &&
		sdhtml_is_tag(text->data, text->size, "style"))
		return 1;

	if ((options->flags & HTML_SKIP_LINKS) != 0 &&
		sdhtml_is_tag(text->data, text->size, "a"))
		return 1;

	if ((options->flags & HTML_SKIP_IMAGES) != 0 &&
		sdhtml_is_tag(text->data, text->size, "img"))
		return 1;

	bufput(ob, text->data, text->size);
	return 1;
}

static void
rndr_table(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque)
{
	if (ob->size) bufputc(ob, '\n');
	BUFPUTSL(ob, "\n");
	if (header)
		bufput(ob, header->data, header->size);
	BUFPUTSL(ob, "\n");
	if (body)
		bufput(ob, body->data, body->size);
	BUFPUTSL(ob, "
    \n");
}

static void
rndr_tablerow(struct buf *ob, const struct buf *text, void *opaque)
{
	BUFPUTSL(ob, "\n");
	if (text)
		bufput(ob, text->data, text->size);
	BUFPUTSL(ob, "\n");
}

static void
rndr_tablecell(struct buf *ob, const struct buf *text, int flags, void *opaque)
{
	if (flags & MKD_TABLE_HEADER) {
		BUFPUTSL(ob, "");
		break;

	case MKD_TABLE_ALIGN_L:
		BUFPUTSL(ob, " align=\"left\">");
		break;

	case MKD_TABLE_ALIGN_R:
		BUFPUTSL(ob, " align=\"right\">");
		break;

	default:
		BUFPUTSL(ob, ">");
	}

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

	if (flags & MKD_TABLE_HEADER) {
		BUFPUTSL(ob, "\n");
	} else {
		BUFPUTSL(ob, "\n");
	}
}

static int
rndr_superscript(struct buf *ob, const struct buf *text, void *opaque)
{
	if (!text || !text->size) return 0;
	BUFPUTSL(ob, "");
	bufput(ob, text->data, text->size);
	BUFPUTSL(ob, "");
	return 1;
}

static void
rndr_normal_text(struct buf *ob, const struct buf *text, void *opaque)
{
	if (text)
		escape_html(ob, text->data, text->size);
}

static void
toc_header(struct buf *ob, const struct buf *text, int level, void *opaque)
{
	struct html_renderopt *options = opaque;

	/* set the level offset if this is the first header
	 * we're parsing for the document */
	if (options->toc_data.current_level == 0) {
		options->toc_data.level_offset = level - 1;
	}
	level -= options->toc_data.level_offset;

	if (level > options->toc_data.current_level) {
		while (level > options->toc_data.current_level) {
			BUFPUTSL(ob, "
      \n
    • \n");
			options->toc_data.current_level++;
		}
	} else if (level < options->toc_data.current_level) {
		BUFPUTSL(ob, "
      • \n");
		while (level < options->toc_data.current_level) {
			BUFPUTSL(ob, "
    \n
    • \n"); options->toc_data.current_level--; } BUFPUTSL(ob,"
  • \n"); } else { BUFPUTSL(ob,"
    • \n
  • \n"); } bufprintf(ob, "", options->toc_data.header_count++); if (text) escape_html(ob, text->data, text->size); BUFPUTSL(ob, "\n"); } static int toc_link(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque) { if (content && content->size) bufput(ob, content->data, content->size); return 1; } static void toc_finalize(struct buf *ob, void *opaque) { struct html_renderopt *options = opaque; while (options->toc_data.current_level > 0) { BUFPUTSL(ob, "
    • \n\n"); options->toc_data.current_level--; } } void sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options) { static const struct sd_callbacks cb_default = { NULL, NULL, NULL, toc_header, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, rndr_codespan, rndr_double_emphasis, rndr_emphasis, NULL, NULL, toc_link, NULL, rndr_triple_emphasis, rndr_strikethrough, rndr_superscript, NULL, NULL, NULL, NULL, NULL, toc_finalize, }; memset(options, 0x0, sizeof(struct html_renderopt)); options->flags = HTML_TOC; memcpy(callbacks, &cb_default, sizeof(struct sd_callbacks)); } void sdhtml_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options, unsigned int render_flags) { static const struct sd_callbacks cb_default = { rndr_blockcode, rndr_blockquote, rndr_raw_block, rndr_header, rndr_hrule, rndr_list, rndr_listitem, rndr_paragraph, rndr_table, rndr_tablerow, rndr_tablecell, rndr_autolink, rndr_codespan, rndr_double_emphasis, rndr_emphasis, rndr_image, rndr_linebreak, rndr_link, rndr_raw_html, rndr_triple_emphasis, rndr_strikethrough, rndr_superscript, rndr_inlinemath, rndr_displayedmath, NULL, rndr_normal_text, NULL, NULL, }; /* Prepare the options pointer */ memset(options, 0x0, sizeof(struct html_renderopt)); options->flags = render_flags; /* Prepare the callbacks */ memcpy(callbacks, &cb_default, sizeof(struct sd_callbacks)); if (render_flags & HTML_SKIP_IMAGES) callbacks->image = NULL; if (render_flags & HTML_SKIP_LINKS) { callbacks->link = NULL; callbacks->autolink = NULL; } if (render_flags & HTML_SKIP_HTML || render_flags & HTML_ESCAPE) callbacks->blockhtml = NULL; } markdown/src/Rinit.c0000644000176200001440000000327412515736624014135 0ustar liggesusers/* * Rinit.c * * Copyright (C) 2009-2013 by RStudio, Inc. * * This program is licensed to you under the terms of version 2 of the * GNU General Public License. This program is distributed WITHOUT ANY * EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT, * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the * GPL (http://www.gnu.org/licenses/gpl-2.0.txt) for more details. * */ #include #include "markdown.h" #include "Rmarkdown.h" #define CALLDEF(name, n) {#name,(DL_FUNC) &name, n} static R_CallMethodDef CallEntries[] = { CALLDEF(rmd_render_markdown,6), CALLDEF(rmd_registered_renderers,0), CALLDEF(rmd_render_smartypants,3), CALLDEF(rmd_b64encode_data,1), {NULL,NULL,0} }; void R_init_markdown(DllInfo *dll) { R_registerRoutines(dll,NULL,CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); rmd_init_renderer_list(); /* Callable functions from other packages' C code */ #define RREGDEF(name) R_RegisterCCallable("markdown", #name, (DL_FUNC) name) RREGDEF(bufput); RREGDEF(bufgrow); RREGDEF(bufnew); RREGDEF(bufcstr); RREGDEF(bufprefix); RREGDEF(bufput); RREGDEF(bufputs); RREGDEF(bufputc); RREGDEF(bufrelease); RREGDEF(bufreset); RREGDEF(bufslurp); RREGDEF(bufprintf); RREGDEF(sd_autolink_issafe); RREGDEF(sd_autolink__www); RREGDEF(sd_autolink__email); RREGDEF(sd_autolink__url); RREGDEF(sd_markdown_new); RREGDEF(sd_markdown_render); RREGDEF(sd_markdown_free); RREGDEF(sd_version); /* markdown C calls */ RREGDEF(rmd_register_renderer); RREGDEF(rmd_renderer_exists); RREGDEF(rmd_input_to_buf); RREGDEF(rmd_buf_to_output); } markdown/src/buffer.h0000644000176200001440000000552212515736624014324 0ustar liggesusers/* * Copyright (c) 2008, Natacha Porté * Copyright (c) 2011, Vicent Martí * * 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 BUFFER_H__ #define BUFFER_H__ #include #include #include #ifdef __cplusplus extern "C" { #endif typedef enum { BUF_OK = 0, BUF_ENOMEM = -1 } buferror_t; /* struct buf: character array buffer */ struct buf { uint8_t *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) */ }; /* CONST_BUF: global buffer from a string litteral */ #define BUF_STATIC(string) \ { (uint8_t *)string, sizeof string -1, sizeof string, 0, 0 } /* VOLATILE_BUF: macro for creating a volatile buffer on the stack */ #define BUF_VOLATILE(strname) \ { (uint8_t *)strname, strlen(strname), 0, 0, 0 } /* BUFPUTSL: optimized bufputs of a string litteral */ #define BUFPUTSL(output, literal) \ bufput(output, literal, sizeof literal - 1) /* 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) __attribute__ ((malloc)); /* bufnullterm: NUL-termination of the string array (making a C-string) */ const char *bufcstr(struct buf *); /* bufprefix: compare the beginning of a buffer with a string */ int bufprefix(const struct buf *buf, const char *prefix); /* 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 *, int); /* 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 *); /* bufslurp: removes a given number of bytes from the head of the array */ void bufslurp(struct buf *, size_t); /* bufprintf: formatted printing to a buffer */ void bufprintf(struct buf *, const char *, ...) __attribute__ ((format (printf, 2, 3))); #ifdef __cplusplus } #endif #endif markdown/src/Rmarkdown.c0000644000176200001440000003164312515736624015015 0ustar liggesusers/* * Rmarkdown.c * * Copyright (C) 2009-2013 by RStudio, Inc. * * This program is licensed to you under the terms of version 2 of the * GNU General Public License. This program is distributed WITHOUT ANY * EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT, * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the * GPL (http://www.gnu.org/licenses/gpl-2.0.txt) for more details. * */ #include "Rmarkdown.h" #define NREND 8 static struct rmd_renderer RENDERERS[NREND]; static struct rmd_renderer *renderer(const char *name); 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,"
    \n"); bufputs(htmlbuf,"
    Table of Contents
    \n"); bufput(htmlbuf,tocbuf->data,tocbuf->size); bufputs(htmlbuf,"
    \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; } void rmd_init_renderer_list() { int i; struct rmd_renderer *html; for (i=0;iname = "HTML"; html->render = render_to_html; html->output_type = "character"; } Rboolean rmd_renderer_exists(const char *name) { return (renderer(name) != NULL)? TRUE: FALSE; } Rboolean rmd_register_renderer(struct rmd_renderer *renderer) { int i, empty_slot = -1, name_exists = -1; if (!renderer) return FALSE; for (i=0;iname)==0) name_exists = i; } /* replace old renderer without warning */ if (name_exists>=0) empty_slot = name_exists; if (empty_slot>=0) { if (RENDERERS[empty_slot].name != NULL) { free(RENDERERS[empty_slot].name); free(RENDERERS[empty_slot].output_type); } RENDERERS[empty_slot].name = strdup(renderer->name); RENDERERS[empty_slot].render = renderer->render; RENDERERS[empty_slot].output_type = strdup(renderer->output_type); } else { error("Renderer list full!"); return FALSE; } return TRUE; } SEXP rmd_registered_renderers(void) { SEXP ans; SEXP names; char *name, *output_type; int i; PROTECT(ans = allocVector(STRSXP,NREND)); PROTECT(names = allocVector(STRSXP,NREND)); for (i=0;i 0) { bufgrow(ib,len); bufput(ib,(const void *)text,len); } else { warning("Input text is zero length!"); return FALSE; } } else { FILE *in; size_t ret; const char *file = CHAR(STRING_ELT(Sfile,0)); in = fopen(file,"r"); if (!in) { warning("Cannot open %s!", file); return FALSE; } 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); } fclose(in); } return TRUE; } Rboolean rmd_buf_to_output(struct buf *ob, SEXP Soutput, SEXP *raw_vec) { /* Output */ if (isNull(Soutput)) { PROTECT(*raw_vec = allocVector(RAWSXP, ob->size)); memcpy(RAW(*raw_vec),ob->data,ob->size); UNPROTECT(1); } else { const char *filename = CHAR(STRING_ELT(Soutput,0)); FILE *out = fopen(filename,"w"); if (!out) { warning("Cannot save output to %s!", filename); return FALSE; } fwrite(ob->data, 1, ob->size, out); fclose(out); if (ferror (out)) { warning("Error occurred writing to %s!", filename); return FALSE; } } return TRUE; } /* Pandoc title blocks are prepended with percents '%'. They start on the * first line of the document and contain 3 elements: 'title','author', * and date. Both 'title' and 'author' can extend to multiple lines so * long as that line starts with a space, but 'date' cannot. */ void skip_pandoc_title_block(struct buf *ib){ int i = 0; size_t pos = 0; /* pandoc 1.9.1.1 expects title blocks to start on the first line */ if (ib->data[0] != '%') return; /* We search for at most 3 elements: title, author, and date */ for (i = 0; i < 3; i++){ if (ib->data[pos] != '%') break; /* Search for end of line */ while (pos < ib->size && ib->data[pos] != '\n') pos++; if (pos < ib->size) pos++; else break; do { /* Only title and author can contain continuation lines, * e.g. i < 2 */ if (ib->data[pos] == ' ' && i < 2){ while (pos < ib->size && ib->data[pos] != '\n') pos++; if (pos < ib->size) pos++; else break; } else { break; } } while(1); } /* If we've seen a title block, we'll take it off * the beginning of our buffer by slurping up pos bytes. */ if (pos > 0) bufslurp(ib,pos); } /* Jekyll front matter begins on the first line and the first three characters * of the line are '---'. Front matter ends when a line is started with '---'. * We skip everything in between including the ending '---'. */ void skip_jekyll_front_matter(struct buf *ib){ int front_matter_found = 0; size_t pos = 0; /* Jekyll 0.12.0 expects front matter to start on the first line */ if (ib->size < 3 || !(ib->data[0] == '-' && ib->data[1] == '-' && ib->data[2] == '-') ) return; pos = 3; do { while (pos < ib->size && ib->data[pos] != '\n') pos++; if (pos == ib->size) break; if (pos+3 < ib->size){ if (ib->data[pos+1] == '-' && ib->data[pos+2] == '-' && ib->data[pos+3] == '-'){ front_matter_found = 1; pos += 4; break; } else { pos++; } } else { break; } } while(1); if (front_matter_found && pos > 0) bufslurp(ib,pos); } 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; } 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; } markdown/src/sundown_version.h0000644000176200001440000000011112515736624016302 0ustar liggesusers#define RSTUDIO_SUNDOWN_VERSION 07d0d98cec0df93e07debbcf562cac9eaca998f8 markdown/NAMESPACE0000644000176200001440000000040512515337413013316 0ustar liggesusersexport(markdownExtensions) export(markdownHTMLOptions) export(markdownToHTML) export(registeredRenderers) export(renderMarkdown) export(rendererExists) export(rendererOutputType) export(rpubsUpload) export(smartypants) useDynLib(markdown, .registration = TRUE) markdown/NEWS0000644000176200001440000001421312444456333012604 0ustar liggesusers CHANGES IN markdown VERSION 0.7.7 BUG FIXES o renderMarkdown() works now even if text = character(0) or "" o added an `encoding` argument to renderMarkdown() since multi-byte characters in renderMarkdown() did not work on Windows (thanks, Kohske Takahashi, #63) o fixed #64: invalid 'n' argument in rpubsUpload() (thanks, Wouter van Atteveldt) MAJOR CHANGES o if renderMarkdown() returns a character vector, it will be marked with the UTF-8 encoding if it contains multi-byte characters CHANGES IN markdown VERSION 0.7.4 NEW FEATURES o when an image is the only element of its parent node in the HTML output document, it is automatically centered on the page MINOR CHANGES o images that have already been base64 encoded will not be encoded again (#61) o the URL of the MathJax CDN was updated to cdn.mathjax.org CHANGES IN markdown VERSION 0.7.2 BUG FIXES o fixed #60: MathJax may be included even if it is unnecessary when syntax highlighting is enabled (thanks, @aoles) o fixed a bug which may hang R when building R Markdown vignettes in a wrong locale (thanks, Dan Tenenbaum, yihui/knitr#782) CHANGES IN markdown VERSION 0.7 BUG FIXES o if both the 'file' and 'text' arguments are provided but file = NULL, e.g. markdownToHTML(file = NULL, text = ?), markdownToHTML() can throw an error indicating the file is invalid (thanks, Tyler Rinker, hadley/staticdocs#66) o markdownToHTML(text = ?, output = ?) was broken (#54) CHANGES IN markdown VERSION 0.6.5 NEW FEATURES o added an argument 'encoding' to markdownToHTML() to specify the character encoding of the input markdown file, and the HTML output file is always encoded in UTF-8 now (thanks, Kohske Takahashi, #50) CHANGES IN markdown VERSION 0.6.4 NEW FEATURES o added 'mathjax_embed' to HTML options for embedding the MathJax JavaScript in the HTML document rather than linking to it online. Note the JavaScript code is read from the http instead of https MathJax URL. Contributed by Henrik Bengtsson. o added another vignette to show the HTML output of the original vignette (see browseVignettes('markdown')) o the default CSS style was tweaked (major changes include: page width is at most 800px, more line height, slightly larger fonts, and a different syntax highlighting theme) CHANGES IN markdown VERSION 0.6.3 NEW FEATURES o added a new argument 'template' to markdownToHTML() so that we can customize the HTML template (by default, it uses the template 'resources/markdown.html' in this package); thanks, Nacho Caballero o the options markdown.HTML.stylesheet and markdown.HTML.header used in markdownToHTML() can be character vectors (they will be processed by paste(x, collapse = '\n') MAJOR CHANGES o the 'text' argument in markdownToHTML() and renderMarkdown() is treated as lines of input now, i.e. if 'text' is provided, it is passed to the markdown renderer as paste(text, collapse = '\n'); in the previous versions, it was processed by paste(text, collapse = '') CHANGES IN markdown VERSION 0.6 DOCUMENTATION o added a package vignette; see browseVignettes(package = 'markdown') CHANGES IN markdown VERSION 0.5.5 NEW FEATURES o added a new argument 'header' to markdownToHTML() to insert code into the HTML header (e.g. custom CSS styles) BUG FIXES o fixed #25 and #27: minor documentation problems o fixed #26: the HTML output file will be written relative to the current working directory now when it contains images that need to be base64 encoded o fixed #28: the image URL should be decoded before the image is based64 encoded MISC o Yihui Xie has taken over the maintainership for this package from Jeffrey Horner CHANGES IN markdown VERSION 0.5.4 NEW FEATURES o Both Pandoc title blocks and Jekyll front matter sections are skipped when rendering markdown documents. CHANGES IN markdown VERSION 0.5.3 NEW FEATURES o C/C++ is now a supported language for code block highlighting. MAJOR CHANGES o 'hard_wrap' has been dropped while 'mathjax' and 'highlight_code' have been added to the default list of html options. BUG FIXES o fixed parsing of math equations when located at the end of a line. CHANGES IN markdown VERSION 0.5.2 NEW FEATURES o with the new 'latex_math' markdown extensions, users can include math equations using several syntaxes. For block level equations, use $$latex ... $$, $$ ... $$, or \[ ... \]. For inline equations, use $latex...$, $...$, or \( ... \). MAJOR CHANGES o the markdown extension 'ingore_math' was replaced with 'latex_math'. o users can now use the markdown.HTML.stylesheet option to override the package default stylesheet. o setting the fragment_only rendering option or the fragment.only parameter to markdownToHTML will base64 encode images if applicable. version 0.5.1 did not. CHANGES IN markdown VERSION 0.5.1 BUG FIXES o fixed a GUIDgenerator bug; for escaping math equations before markdown parsing begins. o image encoding was fixed for the case when there are more than one included in a markdown document. CHANGES IN markdown VERSION 0.5 NEW FEATURES o added fragment.only parameter to markdownToHTML o added new html rendering options base64_images, fragment_only, mathjax, and highlight_code o added new markdown extension ignore_math MAJOR CHANGES o removed safelink from default html rendering options o the default html rendering options are now hard_wrap, use_xhtml, smartypants, and base64_images. BUG FIXES o fixed syntax errors in C exports CHANGES IN markdown VERSION 0.4 NEW FEATURES o added support for post-processing HTML using smartypants filter o added optional support for rendering a table of contents MAJOR CHANGES o changed exported C functions to use an rmd_ prefix (eliminating potential symbol conflicts with other packages) o changed default html rendering options to use_xhtml, hard_wrap, safelink, and smartypants BUG FIXES o eliminated name collision with render_markdown function in knitr markdown/R/0000755000176200001440000000000012452375665012314 5ustar liggesusersmarkdown/R/markdown-package.R0000644000176200001440000000176412330062343015637 0ustar liggesusers#' Markdown rendering for R #' #' \pkg{Markdown} is a plain-text formatting syntax that can be converted to #' XHTML or other formats. This package provides R bindings to the Sundown #' (\url{https://github.com/vmg/sundown}) markdown rendering library. #' #' The R function \code{\link{markdownToHTML}} renders a markdown file to HTML #' (respecting the specified \code{\link{markdownExtensions}} and #' \code{\link{markdownHTMLOptions}}). #' #' The package also exports the underlying Sundown C extension API which enables #' creating and calling custom renderers using the \code{\link{renderMarkdown}} #' function. #' #' To learn more about markdown syntax see: #' #' \url{http://en.wikipedia.org/wiki/Markdown} #' @name markdown #' @docType package #' @author JJ Allaire, Jeffrey Horner, Vicent Marti, and Natacha Porte #' #' Maintainer: Yihui Xie #' @seealso \code{\link{markdownToHTML}} \code{\link{renderMarkdown}} #' @useDynLib markdown, .registration = TRUE #' @keywords package NULL markdown/R/renderMarkdown.R0000644000176200001440000005551512444455765015435 0ustar liggesusers# # renderMarkdown.R # # Copyright (C) 2009-2014 by RStudio, Inc. # # This program is licensed to you under the terms of version 2 of the # GNU General Public License. This program is distributed WITHOUT ANY # EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT, # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the # GPL (http://www.gnu.org/licenses/gpl-2.0.txt) for more details. # # #' List of Registered Markdown Renderers #' #' \code{registeredRenderers} returns a named character vector listing all the #' registered renderers known to the \pkg{markdown} package. \pkg{markdown} #' allows up to seven renderers to be registered by users; HTML is provided by #' the package. #' @return A named \code{character} vector listing all available renderers. #' Vector value contain renderer names, and named values contain the renderer #' output type, either \code{character} or \code{raw}. #' @seealso \link{markdownToHTML}, \link{rendererOutputType} #' @export registeredRenderers #' @examples #' # List all available renderers #' registeredRenderers() registeredRenderers <- function() .Call(rmd_registered_renderers) #' Testing for existence of a markdown renderer #' #' \code{rendererExists} determines whether or not a certain renderer exists in #' the markdown library. #' @param name name of renderer. #' @return \code{TRUE} or \code{FALSE} for whether or not the renderer exists. #' @export rendererExists #' @examples rendererExists("HTML") rendererExists <- function(name) name[1] %in% registeredRenderers() #' Fetch the Renderer Output Type #' #' \pkg{markdown} allows up to seven renderers to be registered by users, and #' each must provide the type of output returned, either \code{character} or #' \code{raw} for binary output. HTML is provided by the package and outputs #' \code{character}. #' @param name a character string naming the renderer. #' @return The character string with a value of either \code{character} or #' \code{raw}. #' @seealso \link{markdownToHTML}, \link{registeredRenderers} #' @export rendererOutputType #' @examples #' # List all available renderers #' rendererOutputType("HTML") rendererOutputType <- function(name) { rnds <- registeredRenderers() if (!name[1] %in% rnds) { warning('Renderer is not registered!') return('') } names(which(rnds == name[1])) } #' Render markdown to an HTML fragment #' #' \code{renderMarkdown} transforms the \emph{markdown} text provided by the #' user in either the \code{file} or \code{text} variable. The transformation is #' either written to the \code{output} file or returned to the user. The default #' rendering target is "HTML". #' #' \pkg{markdown} uses (and ships with) the popular Sundown library provided by #' GitHub. C stubs are available to implement new renderers. #' @inheritParams markdownToHTML #' @param renderer the name of the renderer that will be used to transform the #' \code{file} or \code{text}. #' @param renderer.options options that are passed to the renderer. For #' \code{HTML} renderer options see \code{\link{markdownHTMLOptions}}. #' @return \code{renderMarkdown} returns NULL invisibly when output is to a #' file, and either \code{character} (with the UTF-8 encoding) or \code{raw} #' vector depending on the renderer output type. #' @seealso \code{\link{markdownExtensions}}, \code{\link{markdownHTMLOptions}}, #' \code{\link{markdownToHTML}}. #' #' For a description of the original \emph{markdown} version: #' \url{http://daringfireball.net/projects/markdown/} #' #' The original Sundown library on github: #' \url{https://github.com/vmg/sundown} #' #' C stubs for writing new renders are in inst/include/markdown_rstubs.[ch]. #' @export renderMarkdown #' @examples #' (renderMarkdown(text = "Hello World!")) #' # a few corner cases #' (renderMarkdown(text = character(0))) #' (renderMarkdown(text = '')) renderMarkdown <- function( file, output = NULL, text = NULL, renderer = 'HTML', renderer.options = NULL, extensions = getOption('markdown.extensions'), encoding = getOption('encoding') ) { if (!rendererExists(renderer)) stop("Renderer '", renderer, "' is not registered!") # Input from either a file or character vector if (!is.character(text)) { # If input is file, it needs to be read with the appropriate encoding. Here, # instead of tweaking rmd_render_markdown in Rmarkdown.c, read a file with # the encoding and convert it to UTF-8. Finally, output will be marked as # UTF-8 as well. con <- base::file(file, encoding = encoding) text <- tryCatch(readLines(con), finally = close(con)) } text <- enc2utf8(text) if (length(text) > 1) text <- paste(text, collapse = '\n') file <- NULL # Options if (is.null(renderer.options)) renderer.options <- getOption(paste('markdown', renderer, 'options', sep = '.')) # HTML options must be a character vector. if (renderer == 'HTML') { if (!is.null(renderer.options) && !is.character(renderer.options)) stop('HTML options must be a character vector') } if (length(text) == 0 || text == '') { if (is.null(output)) return(invisible(character(length(text)))) file.create(output) return() } ret <- .Call(rmd_render_markdown, file, output, text, renderer, renderer.options, extensions) if (is.raw(ret) && rendererOutputType(renderer) == 'character') { ret <- rawToChar(ret) Encoding(ret) <- 'UTF-8' } invisible(ret) } .b64EncodeFile <- function(inFile) { fileSize <- file.info(inFile)$size if (fileSize <= 0) { warning(inFile, 'is empty!') return(inFile) } paste( 'data:', mime::guess_type(inFile), ';base64,', .Call(rmd_b64encode_data, readBin(inFile, 'raw', n = fileSize)), sep = '') } .b64EncodeImages <- function(html) { reg <- "<\\s*[Ii][Mm][Gg]\\s+[Ss][Rr][Cc]\\s*=\\s*[\"']([^\"']+)[\"']" m <- gregexpr(reg, html, perl = TRUE) if (m[[1]][1] != -1) { .b64EncodeImgSrc <- function(imgSrc) { src <- sub(reg, '\\1', imgSrc) # already base64 encoded? if (grepl('^data:.+;base64,.+', src)) return(imgSrc) inFile <- URLdecode(src) if (length(inFile) && file.exists(inFile)) imgSrc <- sub(src, .b64EncodeFile(inFile), imgSrc, fixed = TRUE) imgSrc } regmatches(html, m) <- list(unlist(lapply(regmatches(html, m)[[1]], .b64EncodeImgSrc))) } html } .mathJax <- local({ js <- NULL function(embed=FALSE, force=FALSE) { if (!embed) return(paste(readLines(system.file( 'resources', 'mathjax.html', package = 'markdown' )), collapse = '\n')) # http://docs.mathjax.org/en/latest/start.html url <- 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML' # Insert or link to MathJax script? html <- c('', if (embed) { # Already in cache? if (force || is.null(js)) { js <<- readLines(url, warn=FALSE) } c('') paste(html, collapse="\n") } }) .requiresMathJax <- function(html) { regs <- c('\\\\\\(([\\s\\S]+?)\\\\\\)', '\\\\\\[([\\s\\S]+?)\\\\\\]') for (i in regs) if (any(grepl(i, html, perl = TRUE))) return(TRUE) FALSE } .requiresHighlighting <- function(html) any(grepl('
     tag will be base64 encoded and
#' included in the output HTML.
#'
#' }
#'
#' See the DETAILS section below and \code{\link{markdownHTMLOptions}} for more
#' information.
#'
#' There are two basic modes to \code{markdownToHTML} determined by the value of
#' the \code{fragment.only} argument:
#'
#' When \code{FALSE}, \code{markdownToHTML} creates well-formed stand-alone HTML
#' pages complete with HTML header, title, and body tags. The default template
#' used for this mode may be found here:
#'
#' \code{system.file('resources', 'markdown.html', package = 'markdown')}
#'
#' Also, \code{markdownToHTML} will automatically determine whether or not
#' mathjax and R code highlighting are needed and will include the appropriate
#' Javascript libraries in the output. Thus, there's no need to explicitly set
#' the \code{'mathjax'} or \code{'highlight_code'} options (see
#' \code{\link{markdownHTMLOptions}} for more details).
#'
#' When \code{fragment.only} is TRUE, nothing extra is added.
#'
#' @param file a character string giving the pathname of the file to read from.
#'   If it is omitted from the argument list, then it is presumed that the
#'   \code{text} argument will be used instead.
#' @param output a character string giving the pathname of the file to write to.
#'   If it is omitted (\code{NULL}), then it is presumed that the user expects
#'   the results returned as a \code{character} vector.
#' @param text a character vector containing the \emph{markdown} text to
#'   transform (each element of this vector is treated as a line in a file).
#' @param options options that are passed to the renderer.  see
#'   \code{\link{markdownHTMLOptions}}.
#' @param extensions options that are passed to the \emph{markdown} engine. See
#'   \code{\link{markdownExtensions}}.
#' @param title The HTML title.
#' @param stylesheet either valid CSS or a file containing CSS. will be included
#'   in the output.
#' @param header either valid HTML or a file containing HTML will be included in
#'   the header of the output.
#' @param template an HTML file used as template.
#' @param fragment.only Whether or not to produce an HTML fragment without the
#'   HTML header and body tags, CSS, and Javascript components.
#' @param encoding the encoding of the input file; see \code{\link{file}}
#' @return Invisible \code{NULL} when output is to a file, and a character
#'   vector otherwise.
#' @seealso \code{\link{markdownExtensions}}, \code{\link{markdownHTMLOptions}},
#'   \code{\link{renderMarkdown}}.
#' @export
#' @examples
#' (markdownToHTML(text = "Hello World!", fragment.only = TRUE))
#' (markdownToHTML(file = NULL, text = "_text_ will override _file_",
#'   fragment.only = TRUE))
#' # write HTML to an output file
#' markdownToHTML(text = "_Hello_, **World**!", output = "test.html")
markdownToHTML <- function(
  file, output = NULL, text = NULL, options = getOption('markdown.HTML.options'),
  extensions = getOption('markdown.extensions'),
  title = '',
  stylesheet = getOption('markdown.HTML.stylesheet'),
  header = getOption('markdown.HTML.header'),
  template = getOption('markdown.HTML.template'),
  fragment.only = FALSE,
  encoding = getOption('encoding')
) {
  if (fragment.only) options <- c(options, 'fragment_only')

  ret <- renderMarkdown(
    file, output = NULL, text, renderer = 'HTML',
    renderer.options = options, extensions = extensions, encoding = encoding
  )
  ret <- enc2native(ret)

  if ('base64_images' %in% options) {
    filedir <- if (!missing(file) && is.character(file) && file.exists(file)) {
      dirname(file)
    } else '.'
    ret <- local({
      oldwd <- setwd(filedir)
      on.exit(setwd(oldwd))
      .b64EncodeImages(ret)
    })
  }

  if (!'fragment_only' %in% options) {
    if (is.null(template))
      template <- system.file('resources', 'markdown.html', package = 'markdown')
    html <- paste(readLines(template), collapse = '\n')
    html <- sub('#!html_output#', ret, html, fixed = TRUE)

    if (is.character(stylesheet)) {
      html <- sub('#!markdown_css#', option2char(stylesheet), html, fixed = TRUE)
    } else {
      warning('stylesheet must either be valid CSS or a file containing CSS!')
    }

    html <- sub('#!header#', option2char(header), html, fixed = TRUE)

    if (!is.character(title) || title == '') {
      # Guess title
      m <- regexpr('<[Hh][1-6].*?>(.*)', html, perl = TRUE)
      if (m > -1) {
        title <- regmatches(html, m)
        title <- sub('<[Hh][1-6].*?>', '', title)
        title <- sub('', '', title)
      } else {
        title <- ''
      }
    }

    # Need to scrub title more, e.g. strip html, etc.
    html <- sub('#!title#', title, html, fixed = TRUE)

    if ('mathjax' %in% options && .requiresMathJax(html)) {
      mathjax <- .mathJax(embed = 'mathjax_embed' %in% options)
    } else mathjax <- ''
    html <- sub('#!mathjax#', mathjax, html, fixed = TRUE)

    if ('highlight_code' %in% options && .requiresHighlighting(html)) {
      highlight <- paste(readLines(system.file(
        'resources', 'r_highlight.html', package = 'markdown'
      )), collapse = '\n')
    } else highlight <- ''
    html <- sub('#!r_highlight#', highlight, html, fixed = TRUE)

    ret <- html
  }

  if (is.character(output)) {
    # Output should be always UTF8 in accordance with HTML charset
    ret2 <- iconv(ret, to = 'UTF-8')
    if (any(is.na(ret2))) {
      warning('failed to convert output to UTF-8; wrong input encoding or locale?')
    } else ret <- ret2
    writeLines(ret, output, useBytes = TRUE)
    ret <- NULL
  }

  invisible(ret)
}

# from an option to an appropriate character string of CSS/header/...
option2char <- function(x) {
  if (!is.character(x)) return('')
  paste(if (length(x) == 1 && file.exists(x)) readLines(x) else x, collapse = '\n')
}

#' smartypants: ASCII punctuation to HTML entities
#'
#' \code{smartypants} transforms plain ASCII punctuation characters into
#' \emph{smart} typographic punctuation HTML entities.
#' @param file a character string giving the pathname of the file to read from.
#'   If it is omitted from the argument list, then it is presumed that the
#'   \code{text} argument will be used instead.
#' @param output a character string giving the pathname of the file to write to.
#'   If it is omitted, then it is presumed that the user expects the results
#'   returned as a character string.
#' @param text a character vector containing the \emph{markdown} text to
#'   transform.
#' @return \code{smartypants} returns NULL invisibly when output is to a file,
#'   and a character string otherwise.
#' @seealso \code{\link{markdownExtensions}}, \code{\link{markdownHTMLOptions}},
#'   \code{\link{markdownToHTML}}.
#'
#'   For a description of the original \emph{markdown} version:
#'
#'   \url{http://daringfireball.net/projects/markdown/}
#'
#'   The original Sundown library on github:
#'
#'   \url{https://github.com/vmg/sundown}
#'
#'   C stubs for writing new renders are in inst/include/markdown_rstubs.[ch].
#' @export smartypants
#' @examples
#' cat(smartypants(text = "1/2 (c)\n"))
smartypants <- function(file, output, text) {
  # Input from either a file or character vector
  if (!missing(file) && is.character(file) && file.exists(file)) {
    text <- NULL
  } else if (!missing(text) && !is.null(text) && is.character(text)) {
    file <- NULL
    if (length(text) > 1) text <- paste(text, collapse = '')
  } else stop('Need input from either a file or a text string')

  # Output is either returned or written to a file
  if (missing(output)) output <- NULL else if (!is.character(output))
    stop('output variable must be a file name!');

  ret <- .Call(rmd_render_smartypants, file, output, text)
  if (is.raw(ret)) ret <- rawToChar(ret)

  invisible(ret)
}

# Markdown extensions.
#
# To turn on all extensions:
#
# options(markdown.extensions = markdownExtensions())
#
# To turn off all extensions:
#
# options(markdown.extensions = c())
#


#' Markdown extensions
#'
#' \code{markdownExtensions} returns a character vector listing all the
#' extensions that are available in the \pkg{markdown} package.
#'
#' They are all ON by default.
#'
#' The \pkg{Sundown} library (upon which \pkg{markdown} is built) has optional
#' support for several extensions described below. To turn these on globally in
#' the \pkg{markdown} package, simply place some or all of them in a character
#' vector and assign to the global option \code{markdown.extensions} like so:
#'
#' \code{options(markdown.extensions = markdownExtensions())}
#'
#' To override the global option, pass the \code{extensions} as an argument to
#' one of the render functions, e.g.:
#'
#' \code{markdownToHTML(..., extensions = c('no_intra_emphasis'))}
#'
#' Description of all extensions:
#'
#' \describe{
#'
#' \item{\code{'no_intra_emphasis'}}{ skip markdown embedded in words.  }
#'
#' \item{\code{'tables'}}{ create HTML tables (see Examples). }
#'
#' \item{\code{'fenced_code'}}{ treat text as verbatim when surrounded with
#' begin and ending lines with three ~ or \emph{`} characters.  }
#'
#' \item{\code{'autolink'}}{ create HTML links from urls and email addresses. }
#'
#' \item{\code{'strikethrough'}}{ create strikethroughs by surrounding text with
#' ~~.  }
#'
#' \item{\code{'lax_spacing'}}{ allow HTML tags inside paragraphs without being
#' surrounded by newlines.  }
#'
#' \item{\code{'space_headers'}}{ add a space between header hashes and the
#' header itself.  }
#'
#' \item{\code{'superscript'}}{ translate ^ and subsequent text into HTML
#' superscript. }
#'
#' \item{\code{'latex_math'}}{ transforms all math equations into syntactically
#' correct MathJax equations.  }
#'
#' }
#'
#' See the EXAMPLES section to see the output of each extension turned on or
#' off.
#' @return A \code{character} vector listing all available extensions.
#' @seealso \link{markdownHTMLOptions}
#' @export markdownExtensions
#' @examples
#' # List all available extensions:
#' markdownExtensions()
#'
#' # To turn on all markdown extensions globally:
#' options(markdown.extensions = markdownExtensions())
#'
#' # To turn off all markdown extensions globally:
#' options(markdown.extensions = NULL)
#'
#' @example inst/examples/markdownExtensions.R
markdownExtensions <- function()
  c('no_intra_emphasis', 'tables', 'fenced_code', 'autolink', 'strikethrough',
    'lax_spacing', 'space_headers', 'superscript', 'latex_math')

# HTML renderer options.
#
# To turn on all options:
#
# options(markdown.HTML.options = markdownHTMLOptions())
#
# To turn on default options:
#
# options(markdown.HTML.options = markdownHTMLOptions(defaults = TRUE))
#
# To turn off all options:
#
# options(markdown.HTML.options = c())
#


#' Markdown HTML rendering options
#'
#' \code{markdownHTMLOptions} returns a character vector listing all the options
#' that are available for the HTML renderer in the \pkg{markdown} package. As a
#' convenience, the package default options were chosen to render well-formed
#' stand-alone HTML pages when using \code{\link{markdownToHTML}()}. The default
#' options are \code{'use_xhtml'}, \code{'smartypants'}, \code{'base64_images'},
#' \code{'mathjax'}, and \code{'highlight_code'}.
#'
#' The HTML renderer provides several options described below. To turn these on
#' globally in the \pkg{markdown} package, simply place some or all of them in a
#' character vector and assign to the global option \code{markdown.HTML.options}
#' like so:
#'
#' \code{options(markdown.HTML.options = markdownHTMLOptions())}
#'
#' To reset the options to package default, use:
#'
#' \code{options(markdown.HTML.options = markdownHTMLOptions(default = TRUE))}
#'
#' To override the global option, pass the \code{options} as an argument:
#'
#' \code{markdownToHTML(..., options = c('skip_images'))}
#'
#' Description of all options:
#'
#' \describe{
#'
#' \item{\code{'skip_html'}}{ suppress output of all HTML tags in the document.}
#'
#' \item{\code{'skip_style'}}{ suppress output of HTML style tags.}
#'
#' \item{\code{'skip_images'}}{ suppress output of HTML image tags.}
#'
#' \item{\code{'skip_links'}}{ suppress output of HTML anchor tags.}
#'
#' \item{\code{'safelink'}}{ only create links for known url types, e.g. http,
#' ftp, http, etc.}
#'
#' \item{\code{'toc'}}{ assigns an HTML id to each header of the form 'toc_%d'
#' where '%d' is replaced with the position of the header within the document
#' (starting at 0), and creates the table of contents.}
#'
#' \item{\code{'hard_wrap'}}{ adds an HTML br tag for every newline (excluding
#' trailing) found within a paragraph.}
#'
#' \item{\code{'use_xhtml'}}{ create XHMTL 1.0 compliant HTML tags.}
#'
#' \item{\code{'escape'}}{ escape all HTML found within the \emph{markdown}.
#' Overrides all of the \code{'skip_*'} options mentioned above.}
#'
#' \item{\code{'smartypants'}}{ translates plain ASCII punctuation characters
#' into \emph{smart} typographic punctuation HTML entities. }
#'
#' \item{\code{'fragment_only'}}{ eliminates the inclusion of any HTML header or
#' body tags, CSS, or Javascript components. }
#'
#' \item{\code{'base64_images'}}{ Any local images linked with the
#' \code{''} tag to the output HTML will automatically be converted to
#' base64 and included along with output. }
#'
#' \item{\code{'mathjax'}}{ includes appropriate Javascript libraries to render
#' math markup.}
#'
#' \item{\code{'highlight_code'}}{ includes appropriate Javascript libraries to
#' highlight code chunks.}
#'
#' }
#'
#' See the EXAMPLES section to see the output of each option turned on or off.
#' @param defaults If \code{TRUE}, then only the default options are returned.
#'   Otherwise all options are returned.
#' @return A \code{character} vector listing either all available options or
#'   just the default options.
#' @seealso \link{markdownToHTML}
#' @export
#' @examples
#' # List all available extensions:
#' markdownHTMLOptions()
#'
#' # To turn on all HTML options globally:
#' options(markdown.HTML.options = markdownHTMLOptions())
#'
#' # To turn off all HTML options globally:
#' options(markdown.HTML.options = NULL)
#'
#' # To turn on package default HTML options globally:
#' options(markdown.HTML.options = markdownHTMLOptions(default = TRUE))
#'
#' @example inst/examples/HTMLOptions.R
markdownHTMLOptions <- function(defaults = FALSE) {
  allOptions <- c(
    'skip_html', 'skip_style', 'skip_images', 'skip_links', 'safelink', 'toc',
    'escape', 'fragment_only', 'hard_wrap', 'use_xhtml', 'smartypants',
    'base64_images', 'mathjax', 'highlight_code'
  )
  if (defaults) allOptions[10:14] else allOptions
}

.onLoad <- function(libname, pkgname) {

  if (is.null(getOption('markdown.extensions')))
    options(markdown.extensions = markdownExtensions())

  if (is.null(getOption('markdown.HTML.options')))
    options(markdown.HTML.options = markdownHTMLOptions(defaults = TRUE))

  if (is.null(getOption('markdown.HTML.stylesheet'))) {
    sheet <- system.file('resources', 'markdown.css', package = 'markdown')
    options(markdown.HTML.stylesheet = sheet)
  }
}
markdown/R/rpubsUpload.R0000644000176200001440000003447112514634366014743 0ustar  liggesusers# Copyright (C) 2009-2014 by RStudio, Inc.
#
# This program is licensed to you under the terms of version 2 of the
# GNU General Public License. This program is distributed WITHOUT ANY
# EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT,
# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the
# GPL (http://www.gnu.org/licenses/gpl-2.0.txt) for more details.
#
#

#' Upload an HTML file to RPubs
#'
#' This function uploads an HTML file to rpubs.com. If the upload succeeds a
#' list that includes an \code{id} and \code{continueUrl} is returned. A browser
#' should be opened to the \code{continueUrl} to complete publishing of the
#' document. If an error occurs then a diagnostic message is returned in the
#' \code{error} element of the list.
#' @param title The title of the document.
#' @param htmlFile The path to the HTML file to upload.
#' @param id If this upload is an update of an existing document then the id
#'   parameter should specify the document id to update. Note that the id is
#'   provided as an element of the list returned by successful calls to
#'   \code{rpubsUpload}.
#' @param properties A named list containing additional document properties
#'   (RPubs doesn't currently expect any additional properties, this parameter
#'   is reserved for future use).
#' @param method Method to be used for uploading. "internal" uses a plain http
#'   socket connection; "curl" uses the curl binary to do an https upload;
#'   "rcurl" uses the RCurl package to do an https upload; and "auto" uses the
#'   best available method searched for in the following order: "curl", "rcurl",
#'   and then "internal". The global default behavior can be configured by
#'   setting the \code{rpubs.upload.method} option (the default is "auto").
#' @return A named list. If the upload was successful then the list contains a
#'   \code{id} element that can be used to subsequently update the document as
#'   well as a \code{continueUrl} element that provides a URL that a browser
#'   should be opened to in order to complete publishing of the document. If the
#'   upload fails then the list contains an \code{error} element which contains
#'   an explanation of the error that occurred.
#' @export
#' @examples
#' \dontrun{
#' # upload a document
#' result <- rpubsUpload("My document title", "Document.html")
#' if (!is.null(result$continueUrl))
#'     browseURL(result$continueUrl) else stop(result$error)
#'
#' # update the same document with a new title
#' updateResult <- rpubsUpload("My updated title", "Document.html", result$id)
#' }
rpubsUpload <- function(title,
                        htmlFile,
                        id = NULL,
                        properties = list(),
                        method = getOption("rpubs.upload.method", "auto")) {

   # validate inputs
   if (!is.character(title))
      stop("title must be specified")
   if (nzchar(title) == FALSE)
      stop("title must be a non-empty string")
   if (!is.character(htmlFile))
      stop("htmlFile parameter must be specified")
   if (!file.exists(htmlFile))
      stop("specified htmlFile does not exist")
   if (!is.list(properties))
      stop("properties paramater must be a named list")

   parseHeader <- function(header) {
      split <- strsplit(header, ": ")[[1]]
      if (length(split) == 2)
         list(name = split[1], value = split[2])
   }

   jsonEscapeString <- function(value) {
      chars <- strsplit(value, "")[[1]]
      chars <- vapply(chars, function(x) {
         if (x %in% c('"', '\\', '/'))
            paste('\\', x, sep='')
         else if (charToRaw(x) < 20)
            paste('\\u', toupper(format(as.hexmode(as.integer(charToRaw(x))),
                                        width=4)),
                  sep='')
         else x
      }, character(1))
      paste(chars, sep="", collapse="")
   }

   jsonProperty <- function(name, value) {
      paste("\"",
            jsonEscapeString(enc2utf8(name)),
            "\" : \"",
            jsonEscapeString(enc2utf8(value)),
            "\"",
            sep="")
   }

   regexExtract <- function(re, input) {
      match <- regexec(re, input)
      matchLoc <- match[1][[1]]
      if (length(matchLoc) > 1) {
         matchLen <-attributes(matchLoc)$match.length
         url <- substr(input, matchLoc[2], matchLoc[2] + matchLen[2]-1)
         url
      }
   }

   # NOTE: we parse the json naively using a regex because:
   #  - We don't want to take a dependency on a json library for just this case
   #  - We know the payload is an ascii url so we don't need a robust parser
   parseContinueUrl <- function(continueUrl) {
      regexExtract("\\{\\s*\"continueUrl\"\\s*:\\s*\"([^\"]+)\"\\s*\\}",
                   continueUrl)
   }

   parseHttpStatusCode <- function(statusLine) {
      statusCode <- regexExtract("HTTP/[0-9]+\\.[0-9]+ ([0-9]+).*", statusLine)
      if (is.null(statusCode)) -1 else as.integer(statusCode)
   }

   pathFromId <- function(id) {
      split <- strsplit(id, "^https?://[^/]+")[[1]]
      if (length(split) == 2) split[2]
   }

   buildPackage <- function(title,
                            htmlFile,
                            properties = list()) {

      # build package.json
      packageJson <- "{"
      packageJson <- paste(packageJson, jsonProperty("title", title), ",")
      for (name in names(properties)) {
         if (nzchar(name) == FALSE)
            stop("all properties must be named")
         value <- properties[[name]]
         packageJson <- paste(packageJson, jsonProperty(name, value), ",")
      }
      packageJson <- substr(packageJson, 1, nchar(packageJson)-1)
      packageJson <- paste(packageJson,"}")

      # create a tempdir to build the package in and copy the files to it
      fileSep <- .Platform$file.sep
      packageDir <- tempfile()
      dir.create(packageDir)
      packageFile <- function(fileName) {
         paste(packageDir,fileName,sep=fileSep)
      }
      writeLines(packageJson, packageFile("package.json"))
      file.copy(htmlFile, packageFile("index.html"))

      # switch to the package dir for building
      oldWd <- getwd()
      setwd(packageDir)
      on.exit(setwd(oldWd))

      # create the tarball
      tarfile <- tempfile("package", fileext = ".tar.gz")
      utils::tar(tarfile, files = ".", compression = "gzip")

      # return the full path to the tarball
      return (tarfile)
   }

   # Use skipDecoding=TRUE if transfer-encoding: chunked but the
   # chunk decoding has already been performed on conn
   readResponse <- function(conn, skipDecoding) {
      # read status code
      resp <- readLines(conn, 1)
      statusCode <- parseHttpStatusCode(resp[1])

      # read response headers
      contentLength <- NULL
      location <- NULL
      transferEncoding <- NULL
      repeat {
         resp <- readLines(conn, 1)
         if (nzchar(resp) == 0)
            break

         header <- parseHeader(resp)
         # Case insensitive header name comparison
         headerName <- tolower(header$name)
         if (!is.null(header)) {
            if (identical(headerName, "content-type"))
               contentType <- header$value
            if (identical(headerName, "content-length"))
               contentLength <- as.integer(header$value)
            if (identical(headerName, "location"))
               location <- header$value
            if (identical(headerName, "transfer-encoding"))
               transferEncoding <- tolower(header$value)
         }
      }

      # read the response content
      content <- if (is.null(transferEncoding) || skipDecoding) {
         if (!is.null(contentLength)) {
            rawToChar(readBin(conn, what = 'raw', n=contentLength))
         }
         else {
            paste(readLines(conn, warn = FALSE), collapse = "\r\n")
         }
      } else if (identical(transferEncoding, "chunked")) {
         accum <- ""
         repeat {
            resp <- readLines(conn, 1)
            resp <- sub(";.*", "", resp) # Ignore chunk extensions
            chunkLen <- as.integer(paste("0x", resp, sep = ""))
            if (is.na(chunkLen)) {
               stop("Unexpected chunk length")
            }
            if (identical(chunkLen, 0L)) {
               break
            }
            accum <- paste0(accum, rawToChar(readBin(conn, what = 'raw', n=chunkLen)))
            # Eat CRLF
            if (!identical("\r\n", rawToChar(readBin(conn, what = 'raw', n=2)))) {
               stop("Invalid chunk encoding: missing CRLF")
            }
         }
         accum
      } else {
         stop("Unexpected transfer encoding")
      }

      # return list
      list(status = statusCode,
           location = location,
           contentType = contentType,
           content = content)
   }

   # internal sockets implementation of upload (supports http-only)
   internalUpload <- function(path,
                              contentType,
                              headers,
                              packageFile) {

      # read file in binary mode
      fileLength <- file.info(packageFile)$size
      fileContents <- readBin(packageFile, what="raw", n=fileLength)

      # build http request
      request <- NULL
      request <- c(request, paste("POST ", path, " HTTP/1.1\r\n", sep=""))
      request <- c(request, "User-Agent: RStudio\r\n")
      request <- c(request, "Host: api.rpubs.com\r\n")
      request <- c(request, "Accept: */*\r\n")
      request <- c(request, paste("Content-Type: ", contentType, "\r\n", sep=""))
      request <- c(request, paste("Content-Length: ", fileLength, "\r\n", sep=""))
      for (name in names(headers)) {
         request <- c(request,
                      paste(name, ": ", headers[[name]], "\r\n", sep=""))
      }
      request <- c(request, "\r\n")

      # open socket connection
      conn <- socketConnection(host="api.rpubs.com",
                               port=80,
                               open="w+b",
                               blocking=TRUE)
      on.exit(close(conn))

      # write the request header and file payload
      writeBin(charToRaw(paste(request,collapse="")), conn, size=1)
      writeBin(fileContents, conn, size=1)

      # read the response
      readResponse(conn, skipDecoding = FALSE)
   }


   rcurlUpload <- function(path,
                           contentType,
                           headers,
                           packageFile) {

      # url to post to
      url <- paste("https://api.rpubs.com", path, sep = "")

      # upload package file
      params <- list(file = RCurl::fileUpload(filename = packageFile,
                                       contentType = contentType))

      # use custom header and text gatherers
      sslpath <- system.file("CurlSSL", "cacert.pem", package = "RCurl")
      options <- RCurl::curlOptions(url, cainfo = sslpath)
      headerGatherer <- RCurl::basicHeaderGatherer()
      options$headerfunction <- headerGatherer$update
      textGatherer <- RCurl::basicTextGatherer()
      options$writefunction <- textGatherer$update

      # add extra headers
      extraHeaders <- as.character(headers)
      names(extraHeaders) <- names(headers)
      options$httpheader <- extraHeaders

      # post the form
      RCurl::postForm(paste("https://api.rpubs.com", path, sep=""),
                           .params = params,
                           .opts = options,
                           useragent = "RStudio")

      # return list
      headers <- headerGatherer$value()
      location <- if ("Location" %in% names(headers)) headers[["Location"]]
      list(status = as.integer(headers[["status"]]),
           location = location,
           contentType <- headers[["Content-Type"]],
           content = textGatherer$value())

   }

   curlUpload <- function(path,
                          contentType,
                          headers,
                          packageFile) {

      fileLength <- file.info(packageFile)$size

      extraHeaders <- character()
      for (header in names(headers)) {
         extraHeaders <- paste(extraHeaders, "--header")
         extraHeaders <- paste(extraHeaders,
                               paste(header,":",headers[[header]], sep=""))
      }

      outputFile <- tempfile()

      command <- paste("curl",
                       "-X",
                       "POST",
                       "--data-binary",
                       shQuote(paste("@", packageFile, sep="")),
                       "-i",
                       "--header", paste("Content-Type:",contentType, sep=""),
                       "--header", paste("Content-Length:", fileLength, sep=""),
                       extraHeaders,
                       "--header", "Expect:",
                       "--silent",
                       "--show-error",
                       "-o", shQuote(outputFile),
                       paste("https://api.rpubs.com", path, sep=""))

      result <- system(command)

      if (result == 0) {
        fileConn <- file(outputFile, "rb")
        on.exit(close(fileConn))
        readResponse(fileConn, skipDecoding = TRUE)
      } else {
        stop(paste("Upload failed (curl error", result, "occurred)"))
      }
   }

   uploadFunction <- if (is.function(method)) {
      method
   } else switch(
     method,
     "auto" = {
       if (nzchar(Sys.which("curl"))) curlUpload else {
         if (suppressWarnings(requireNamespace("RCurl", quietly = TRUE))) {
           rcurlUpload
         } else internalUpload
       }
     },
     "internal" = internalUpload,
     "curl"     = curlUpload,
     "rcurl"    = rcurlUpload,
      stop(paste("Invalid upload method specified:",method))
   )

   # build the package
   packageFile <- buildPackage(title, htmlFile, properties)

   # determine whether this is a new doc or an update
   isUpdate <- FALSE
   path <- "/api/v1/document"
   headers <- list()
   headers$Connection <- "close"
   if (!is.null(id)) {
      isUpdate <- TRUE
      path <- pathFromId(id)
      headers$`X-HTTP-Method-Override` <- "PUT"
   }


   # send the request
   result <- uploadFunction(path,
                            "application/x-compressed",
                            headers,
                            packageFile)

   # check for success
   succeeded <- (isUpdate && (result$status == 200)) || (result$status == 201)

   # mark content as UTF-8
   content <- result$content
   Encoding(content) <- "UTF-8"

   # return either id & continueUrl or error
   if (succeeded) {
     list(id = ifelse(isUpdate, id, result$location),
          continueUrl = parseContinueUrl(content))
   } else list(error = content)
}
markdown/vignettes/0000755000176200001440000000000012515736624014117 5ustar  liggesusersmarkdown/vignettes/markdown-examples.Rmd0000644000176200001440000000133412330062343020203 0ustar  liggesusers

This vignette shows some examples for different Markdown extensions and HTML options.

```{r read-code, include=FALSE}
library(knitr)
opts_chunk$set(tidy = FALSE)  # otherwise \n will cause problems
read_chunk(system.file('examples', 'markdownExtensions.R', package = 'markdown'),
           labels = 'md-extensions')
read_chunk(system.file('examples', 'HTMLOptions.R', package = 'markdown'),
           labels = 'html-options')
```

```{r}
library(markdown)
```

# Markdown Extensions

```{r md-extensions}
```

# HTML Options

```{r html-options}
```


```{r include=FALSE}
options(markdown.HTML.options=markdownHTMLOptions(defaults=TRUE))
```
markdown/vignettes/markdown-output.Rmd0000644000176200001440000000070512330062343017726 0ustar  liggesusers

This vignette shows how the output looks like in HTML from the other vignette `markdown-examples.Rmd`, in which the literal HTML code was shown.

```{r read, include=FALSE}
library(knitr)
opts_chunk$set(results = 'asis')
out = knit_child(text = scan('markdown-examples.Rmd', what = 'character', skip = 7, sep = '\n'))
```

`r paste(out, collapse = '\n')`
markdown/README.md0000644000176200001440000000300412416357710013356 0ustar  liggesusersMarkdown rendering for R
=============================================================================

[![Build Status](https://travis-ci.org/rstudio/markdown.svg)](https://travis-ci.org/rstudio/markdown)

Overview
-----------------------------------------------------------------------------

*Markdown* is a plain-text formatting syntax that can be converted
to XHTML or other formats. This package provides R bindings to the
[Sundown](https://github.com/vmg/sundown) markdown rendering library.

The R function `markdownToHTML` renders a markdown file to HTML. Options
controlling HTML output and supported markdown extensions can be optionally
specified.

The package also exports the underlying Sundown C extension API which
enables creating and calling custom renderers using the `renderMarkdown`
function.

To learn more about markdown syntax see: 

This package is referred to as _R Markdown v1_ when combined with **knitr**. The
primary output format is HTML. Now we have introduced [_R Markdown
v2_](http://blog.rstudio.org/2014/06/18/r-markdown-v2/), which is based on
Pandoc and **knitr**, and supports much more types of output formats. Please see
http://rmarkdown.rstudio.com for details.

License
-----------------------------------------------------------------------------

The markdown package is licensed under the GPLv2. See these files for
additional details:

- inst/COPYING - Markdown package license (GPLv2)
- inst/NOTICE  - Copyright notices for additional included software
markdown/MD50000644000176200001440000000640612516002652012411 0ustar  liggesusers0cd9e494d0146682180186f3d3e2752f *DESCRIPTION
87a89086a2d7d36513a827338f2168bb *NAMESPACE
d62b54718c76c36e0137c30f94776032 *NEWS
0a375621b5466aaa55827331b7a54aba *R/markdown-package.R
7510df407f186198a04e2d4243009501 *R/renderMarkdown.R
9c15b355037cc2e11df80d660e0e6e3f *R/rpubsUpload.R
8d8e54509fc3fe29397a945c23015784 *README.md
115567331f54fe741fd207d8d663b225 *build/vignette.rds
603dd5a44125bb3c7f2595c87c048d93 *inst/COPYING
4907458964894cb1dcc67c4f5690a48b *inst/NOTICE
d19002ff021174b03774124e1caab922 *inst/doc/markdown-examples.R
29668370a07ca593fad4e953674716cc *inst/doc/markdown-examples.Rmd
034d54e06672b954ccb840b33530225d *inst/doc/markdown-examples.html
84ca06dc7b054c074c8bdc795edb4c50 *inst/doc/markdown-output.R
09998ddcbdaa092c32cfedd3d12e11a2 *inst/doc/markdown-output.Rmd
245ad862444209de04c5efa2f5cf57ba *inst/doc/markdown-output.html
97a8de7bcac5a0cfd539d80c098f91a3 *inst/examples/HTMLOptions.R
2c5fc44b771406c4fb7e658e14e63fd7 *inst/examples/markdownExtensions.R
4ba2610d0919031a909bf50306bfc533 *inst/include/autolink.h
510d81c5e25bd88608f06afea594adfa *inst/include/buffer.h
23ed959ea9845e0877d824fdd081b11a *inst/include/markdown.h
9f130bbcd1a33d16d655c5b3bc10917c *inst/include/markdown_rstubs.c
8edae02d2442e7abc13b9118a16c70c7 *inst/include/markdown_rstubs.h
ab9c98860a3e321c58fcb1d75f9f45ba *inst/resources/markdown.css
5ffdc57da02ee2c6a28e4b2d6053c7ac *inst/resources/markdown.html
fdca9d153655c457b619641baf36e1d2 *inst/resources/mathjax.html
e25f1ac72fe309c072cd9aa836c631a6 *inst/resources/r_highlight.html
26cfcdb2d6672ec701d2e9db10650420 *man/markdown.Rd
5caf4643417847ca6e9b3f93f0c9cb24 *man/markdownExtensions.Rd
6e8e61097e6512b33fd527a4dd21903e *man/markdownHTMLOptions.Rd
78039f08f06e5be8e59ad0777758a0ff *man/markdownToHTML.Rd
cbb80c76ae0720b203c2a06fba601f2f *man/registeredRenderers.Rd
a45229de0c3edcdfd229e0d988f2a19a *man/renderMarkdown.Rd
4ea2893c1dd831e40f94ce5d499cf483 *man/rendererExists.Rd
d813f4003d03ce19439d6dc341a4ac27 *man/rendererOutputType.Rd
f7256ce76d880ad4f4cbc5743e89cd2f *man/rpubsUpload.Rd
807692d87b33cf8b7e4810467373fbe0 *man/smartypants.Rd
607ed1ee44e4be0c9a35af6c1686e11f *src/Rbase64.c
e964593e6d13af14ecadea3fe3a7742b *src/Rinit.c
2ea7823363be5db032986e8bb22d2f73 *src/Rmarkdown.c
be6889a7e0acbbc26cebd8b379efae40 *src/Rmarkdown.h
26fcef5aabe22c64142adb48c2a87cf5 *src/autolink.c
4ba2610d0919031a909bf50306bfc533 *src/autolink.h
51bbdc8afb4d77aa10e71e48fa67bd76 *src/buffer.c
468151555424b7d222a1a64d0cbc7a69 *src/buffer.h
6cc1bd118177be4dac56e0e7698470f1 *src/houdini.h
327ac86078b740183d9484bf9b65b719 *src/houdini_href_e.c
ad4e12539e64e6e7685a89b206d2e469 *src/houdini_html_e.c
9b88ce919aa9ec23b4b9dce71696c8da *src/html.c
4500e9bf93a1990f6e504a03d32e7178 *src/html.h
a49ff5141e373322137dd2a8ce07ecf5 *src/html_blocks.h
c437cef296ff77dced3f8dfce7c1fdcc *src/html_smartypants.c
d7c1cac650658c15073aeeecf8117cac *src/markdown.c
8c222ccb74fa0e73f6ba0394bedbe3fc *src/markdown.h
0ac4251d8cb2f229de24efbe501f2a4a *src/stack.c
cd51442c3d728d42342e57467dcd5ad5 *src/stack.h
ecd33756b1689d8da494c69bea7a7ca6 *src/sundown_version.h
44ebcfa56c4b699099a0b74fd32474f7 *tests/tests.R
580cc623b08345531382a3a521f8eb38 *tests/tests.Rout.save
29668370a07ca593fad4e953674716cc *vignettes/markdown-examples.Rmd
09998ddcbdaa092c32cfedd3d12e11a2 *vignettes/markdown-output.Rmd
markdown/build/0000755000176200001440000000000012515736624013206 5ustar  liggesusersmarkdown/build/vignette.rds0000644000176200001440000000036512515736624015551 0ustar  liggesusersuPM@]Z]"A]!f_kⰳ3ͼ}&!L2DRˁPָMp8g_(vGHqUUi*?cAv0.R)΂޷ݢ!!'׳o
q+`%<[=94lO*+hiXXB|X}PjH{V!Ig>ȀM*$C|Emarkdown/DESCRIPTION0000644000176200001440000000147112516002652013604 0ustar  liggesusersPackage: markdown
Type: Package
Title: 'Markdown' Rendering for R
Version: 0.7.7
Date: 2015-04-23
Author: JJ Allaire, Jeffrey Horner, Vicent Marti, and Natacha Porte
Maintainer: Yihui Xie 
Description: Provides R bindings to the 'Sundown' 'Markdown' rendering library
   (https://github.com/vmg/sundown). 'Markdown' is a plain-text formatting
   syntax that can be converted to 'XHTML' or other formats. See
   http://en.wikipedia.org/wiki/Markdown for more information about 'Markdown'.
Depends: R (>= 2.11.1)
Imports: mime (>= 0.3)
Suggests: knitr, RCurl
License: GPL-2
URL: https://github.com/rstudio/markdown
BugReports: https://github.com/rstudio/markdown/issues
VignetteBuilder: knitr
NeedsCompilation: yes
Packaged: 2015-04-22 15:26:12 UTC; yihui
Repository: CRAN
Date/Publication: 2015-04-22 22:33:46
markdown/man/0000755000176200001440000000000012452376510012654 5ustar  liggesusersmarkdown/man/markdownHTMLOptions.Rd0000644000176200001440000001250712515337414017033 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{markdownHTMLOptions}
\alias{markdownHTMLOptions}
\title{Markdown HTML rendering options}
\usage{
markdownHTMLOptions(defaults = FALSE)
}
\arguments{
\item{defaults}{If \code{TRUE}, then only the default options are returned.
Otherwise all options are returned.}
}
\value{
A \code{character} vector listing either all available options or
  just the default options.
}
\description{
\code{markdownHTMLOptions} returns a character vector listing all the options
that are available for the HTML renderer in the \pkg{markdown} package. As a
convenience, the package default options were chosen to render well-formed
stand-alone HTML pages when using \code{\link{markdownToHTML}()}. The default
options are \code{'use_xhtml'}, \code{'smartypants'}, \code{'base64_images'},
\code{'mathjax'}, and \code{'highlight_code'}.
}
\details{
The HTML renderer provides several options described below. To turn these on
globally in the \pkg{markdown} package, simply place some or all of them in a
character vector and assign to the global option \code{markdown.HTML.options}
like so:

\code{options(markdown.HTML.options = markdownHTMLOptions())}

To reset the options to package default, use:

\code{options(markdown.HTML.options = markdownHTMLOptions(default = TRUE))}

To override the global option, pass the \code{options} as an argument:

\code{markdownToHTML(..., options = c('skip_images'))}

Description of all options:

\describe{

\item{\code{'skip_html'}}{ suppress output of all HTML tags in the document.}

\item{\code{'skip_style'}}{ suppress output of HTML style tags.}

\item{\code{'skip_images'}}{ suppress output of HTML image tags.}

\item{\code{'skip_links'}}{ suppress output of HTML anchor tags.}

\item{\code{'safelink'}}{ only create links for known url types, e.g. http,
ftp, http, etc.}

\item{\code{'toc'}}{ assigns an HTML id to each header of the form 'toc_%d'
where '%d' is replaced with the position of the header within the document
(starting at 0), and creates the table of contents.}

\item{\code{'hard_wrap'}}{ adds an HTML br tag for every newline (excluding
trailing) found within a paragraph.}

\item{\code{'use_xhtml'}}{ create XHMTL 1.0 compliant HTML tags.}

\item{\code{'escape'}}{ escape all HTML found within the \emph{markdown}.
Overrides all of the \code{'skip_*'} options mentioned above.}

\item{\code{'smartypants'}}{ translates plain ASCII punctuation characters
into \emph{smart} typographic punctuation HTML entities. }

\item{\code{'fragment_only'}}{ eliminates the inclusion of any HTML header or
body tags, CSS, or Javascript components. }

\item{\code{'base64_images'}}{ Any local images linked with the
\code{''} tag to the output HTML will automatically be converted to
base64 and included along with output. }

\item{\code{'mathjax'}}{ includes appropriate Javascript libraries to render
math markup.}

\item{\code{'highlight_code'}}{ includes appropriate Javascript libraries to
highlight code chunks.}

}

See the EXAMPLES section to see the output of each option turned on or off.
}
\examples{
# List all available extensions:
markdownHTMLOptions()

# To turn on all HTML options globally:
options(markdown.HTML.options = markdownHTMLOptions())

# To turn off all HTML options globally:
options(markdown.HTML.options = NULL)

# To turn on package default HTML options globally:
options(markdown.HTML.options = markdownHTMLOptions(default = TRUE))
# HTML OPTIONS

# The following examples are short, so we allways add the HTML option 'fragment_only'
tOpt <- "fragment_only"

# skip_html example
mkd = 'Hello'
cat(markdownToHTML(text = mkd, options = c(tOpt)))
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))

# skip_style example
cat(markdownToHTML(text = mkd, options = c(tOpt)))
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_style")))

# skip_images example
cat(markdownToHTML(text = mkd, options = c(tOpt)))
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_images")))

# skip_links example
cat(markdownToHTML(text = mkd, options = c(tOpt)))
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_links")))

# safelink example
cat(markdownToHTML(text = '[foo](foo://bar "baz")', options = c(tOpt)))
cat(markdownToHTML(text = '[foo](foo://bar "baz")', options = c(tOpt, "safelink")))

# toc example
mkd <- paste(c("# Header 1", "p1", "## Header 2", "p2"), collapse = "\\n")

cat(markdownToHTML(text = mkd, options = c(tOpt)))
cat(markdownToHTML(text = mkd, options = c(tOpt, "toc")))

# hard_wrap example
cat(markdownToHTML(text = "foo\\nbar\\n", options = c(tOpt)))
cat(markdownToHTML(text = "foo\\nbar\\n", options = c(tOpt, "hard_wrap")))

# use_xhtml example
cat(markdownToHTML(text = "foo\\nbar\\n", options = c(tOpt, "hard_wrap")))
cat(markdownToHTML(text = "foo\\nbar\\n", options = c(tOpt, "hard_wrap", "use_xhtml")))

# escape example
mkd = 'Hello'
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html")))
# overrides all 'skip_*' options
cat(markdownToHTML(text = mkd, options = c(tOpt, "skip_html", "escape")))

# smartypants example
cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt)))
cat(markdownToHTML(text = "1/2 (c)", options = c(tOpt, "smartypants")))

cat(smartypants(text = "1/2 (c)\\n"))
}
\seealso{
\link{markdownToHTML}
}
markdown/man/registeredRenderers.Rd0000644000176200001440000000140212515337414017147 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{registeredRenderers}
\alias{registeredRenderers}
\title{List of Registered Markdown Renderers}
\usage{
registeredRenderers()
}
\value{
A named \code{character} vector listing all available renderers.
  Vector value contain renderer names, and named values contain the renderer
  output type, either \code{character} or \code{raw}.
}
\description{
\code{registeredRenderers} returns a named character vector listing all the
registered renderers known to the \pkg{markdown} package. \pkg{markdown}
allows up to seven renderers to be registered by users; HTML is provided by
the package.
}
\examples{
# List all available renderers
registeredRenderers()
}
\seealso{
\link{markdownToHTML}, \link{rendererOutputType}
}
markdown/man/rendererExists.Rd0000644000176200001440000000070512515337414016153 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{rendererExists}
\alias{rendererExists}
\title{Testing for existence of a markdown renderer}
\usage{
rendererExists(name)
}
\arguments{
\item{name}{name of renderer.}
}
\value{
\code{TRUE} or \code{FALSE} for whether or not the renderer exists.
}
\description{
\code{rendererExists} determines whether or not a certain renderer exists in
the markdown library.
}
\examples{
rendererExists("HTML")
}
markdown/man/markdownToHTML.Rd0000644000176200001440000000756612515337414015773 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{markdownToHTML}
\alias{markdownToHTML}
\title{Render markdown to HTML}
\usage{
markdownToHTML(file, output = NULL, text = NULL,
  options = getOption("markdown.HTML.options"),
  extensions = getOption("markdown.extensions"), title = "",
  stylesheet = getOption("markdown.HTML.stylesheet"),
  header = getOption("markdown.HTML.header"),
  template = getOption("markdown.HTML.template"), fragment.only = FALSE,
  encoding = getOption("encoding"))
}
\arguments{
\item{file}{a character string giving the pathname of the file to read from.
If it is omitted from the argument list, then it is presumed that the
\code{text} argument will be used instead.}

\item{output}{a character string giving the pathname of the file to write to.
If it is omitted (\code{NULL}), then it is presumed that the user expects
the results returned as a \code{character} vector.}

\item{text}{a character vector containing the \emph{markdown} text to
transform (each element of this vector is treated as a line in a file).}

\item{options}{options that are passed to the renderer.  see
\code{\link{markdownHTMLOptions}}.}

\item{extensions}{options that are passed to the \emph{markdown} engine. See
\code{\link{markdownExtensions}}.}

\item{title}{The HTML title.}

\item{stylesheet}{either valid CSS or a file containing CSS. will be included
in the output.}

\item{header}{either valid HTML or a file containing HTML will be included in
the header of the output.}

\item{template}{an HTML file used as template.}

\item{fragment.only}{Whether or not to produce an HTML fragment without the
HTML header and body tags, CSS, and Javascript components.}

\item{encoding}{the encoding of the input file; see \code{\link{file}}}
}
\value{
Invisible \code{NULL} when output is to a file, and a character
  vector otherwise.
}
\description{
\code{markdownToHTML} transforms the \emph{markdown} text provided by the
user in either the \code{file} or \code{text} variable. The HTML
transformation is either written to the \code{output} file or returned to the
user as a \code{character} vector.
}
\details{
Three notable HTML options have been added to support collaborative
reproducible research. They are as follows:

\itemize{

\item Latex math expressions enclosed by one of the block level syntaxes,
$latex ... $ , $$ ... $$, or \[ ... \], or one of the inline syntaxes, $...$,
or \( ... \), will be rendered in real-time by the MathJax Javascript
library.

\item \emph{R} code blocks enclosed between \verb{```r} and \verb{```} will
automatically be syntax highlighted.

\item Any local images linked using the  tag will be base64 encoded and
included in the output HTML.

}

See the DETAILS section below and \code{\link{markdownHTMLOptions}} for more
information.

There are two basic modes to \code{markdownToHTML} determined by the value of
the \code{fragment.only} argument:

When \code{FALSE}, \code{markdownToHTML} creates well-formed stand-alone HTML
pages complete with HTML header, title, and body tags. The default template
used for this mode may be found here:

\code{system.file('resources', 'markdown.html', package = 'markdown')}

Also, \code{markdownToHTML} will automatically determine whether or not
mathjax and R code highlighting are needed and will include the appropriate
Javascript libraries in the output. Thus, there's no need to explicitly set
the \code{'mathjax'} or \code{'highlight_code'} options (see
\code{\link{markdownHTMLOptions}} for more details).

When \code{fragment.only} is TRUE, nothing extra is added.
}
\examples{
(markdownToHTML(text = "Hello World!", fragment.only = TRUE))
(markdownToHTML(file = NULL, text = "_text_ will override _file_", fragment.only = TRUE))
# write HTML to an output file
markdownToHTML(text = "_Hello_, **World**!", output = "test.html")
}
\seealso{
\code{\link{markdownExtensions}}, \code{\link{markdownHTMLOptions}},
  \code{\link{renderMarkdown}}.
}
markdown/man/markdown.Rd0000644000176200001440000000200712515337414014764 0ustar  liggesusers% Please edit documentation in R/markdown-package.R
\docType{package}
\name{markdown}
\alias{markdown}
\alias{markdown-package}
\title{Markdown rendering for R}
\description{
\pkg{Markdown} is a plain-text formatting syntax that can be converted to
XHTML or other formats. This package provides R bindings to the Sundown
(\url{https://github.com/vmg/sundown}) markdown rendering library.
}
\details{
The R function \code{\link{markdownToHTML}} renders a markdown file to HTML
(respecting the specified \code{\link{markdownExtensions}} and
\code{\link{markdownHTMLOptions}}).

The package also exports the underlying Sundown C extension API which enables
creating and calling custom renderers using the \code{\link{renderMarkdown}}
function.

To learn more about markdown syntax see:

\url{http://en.wikipedia.org/wiki/Markdown}
}
\author{
JJ Allaire, Jeffrey Horner, Vicent Marti, and Natacha Porte

  Maintainer: Yihui Xie 
}
\seealso{
\code{\link{markdownToHTML}} \code{\link{renderMarkdown}}
}
\keyword{package}
markdown/man/markdownExtensions.Rd0000644000176200001440000001060112515337413017042 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{markdownExtensions}
\alias{markdownExtensions}
\title{Markdown extensions}
\usage{
markdownExtensions()
}
\value{
A \code{character} vector listing all available extensions.
}
\description{
\code{markdownExtensions} returns a character vector listing all the
extensions that are available in the \pkg{markdown} package.
}
\details{
They are all ON by default.

The \pkg{Sundown} library (upon which \pkg{markdown} is built) has optional
support for several extensions described below. To turn these on globally in
the \pkg{markdown} package, simply place some or all of them in a character
vector and assign to the global option \code{markdown.extensions} like so:

\code{options(markdown.extensions = markdownExtensions())}

To override the global option, pass the \code{extensions} as an argument to
one of the render functions, e.g.:

\code{markdownToHTML(..., extensions = c('no_intra_emphasis'))}

Description of all extensions:

\describe{

\item{\code{'no_intra_emphasis'}}{ skip markdown embedded in words.  }

\item{\code{'tables'}}{ create HTML tables (see Examples). }

\item{\code{'fenced_code'}}{ treat text as verbatim when surrounded with
begin and ending lines with three ~ or \emph{`} characters.  }

\item{\code{'autolink'}}{ create HTML links from urls and email addresses. }

\item{\code{'strikethrough'}}{ create strikethroughs by surrounding text with
~~.  }

\item{\code{'lax_spacing'}}{ allow HTML tags inside paragraphs without being
surrounded by newlines.  }

\item{\code{'space_headers'}}{ add a space between header hashes and the
header itself.  }

\item{\code{'superscript'}}{ translate ^ and subsequent text into HTML
superscript. }

\item{\code{'latex_math'}}{ transforms all math equations into syntactically
correct MathJax equations.  }

}

See the EXAMPLES section to see the output of each extension turned on or
off.
}
\examples{
# List all available extensions:
markdownExtensions()

# To turn on all markdown extensions globally:
options(markdown.extensions = markdownExtensions())

# To turn off all markdown extensions globally:
options(markdown.extensions = NULL)
# The following examples are short, so we set the HTML option 'fragment_only'

options(markdown.HTML.options = "fragment_only")

# no_intra_emphasis example
cat(markdownToHTML(text = "foo_bar_function", extensions = c()))
cat(markdownToHTML(text = "foo_bar_function", extensions = c("no_intra_emphasis")))

# tables example (need 4 spaces at beginning of line here)
cat(markdownToHTML(text = "
    First Header  | Second Header
    ------------- | -------------
    Content Cell  | Content Cell
    Content Cell  | Content Cell
", extensions = c()))

# but not here
cat(markdownToHTML(text = "
First Header  | Second Header
------------- | -------------
Content Cell  | Content Cell
Content Cell  | Content Cell
", extensions = c("tables")))

# fenced_code example (need at least three leading ~ or `)
fenced_block <- function(text, x = "`", n = 3) {
  fence <- paste(rep(x, n), collapse = "")
  paste(fence, text, fence, sep = "")
}
cat(markdownToHTML(text = fenced_block("
preformatted text here without having to indent
first line.
"), extensions = c()))

cat(markdownToHTML(text = fenced_block("
preformatted text here without having to indent
first line.
"), extensions = c("fenced_code")))

# autolink example
cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c()))
cat(markdownToHTML(text = "http://www.r-project.org/", extensions = c("autolink")))

# strikethrough example
cat(markdownToHTML(text = "~~awesome~~", extensions = c()))
cat(markdownToHTML(text = "~~awesome~~", extensions = c("strikethrough")))

# lax_spacing
cat(markdownToHTML(text = "
Embedding html without surrounding with empty newline.

    _markdown_
    
extra text.
", extensions = c("")))
cat(markdownToHTML(text = "
Embedding html without surrounding with empty newline.

    _markdown_
    
extra text.
", extensions = c("lax_spacing")))

# space_headers example
cat(markdownToHTML(text = "#A Header\\neven though there is no space between # and A",
                   extensions = c("")))
cat(markdownToHTML(text = "#Not A Header\\nbecause there is no space between # and N",
                   extensions = c("space_headers")))

# superscript example
cat(markdownToHTML(text = "2^10", extensions = c()))
cat(markdownToHTML(text = "2^10", extensions = c("superscript")))
}
\seealso{
\link{markdownHTMLOptions}
}
markdown/man/renderMarkdown.Rd0000644000176200001440000000464212515337414016133 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{renderMarkdown}
\alias{renderMarkdown}
\title{Render markdown to an HTML fragment}
\usage{
renderMarkdown(file, output = NULL, text = NULL, renderer = "HTML", 
    renderer.options = NULL, extensions = getOption("markdown.extensions"), 
    encoding = getOption("encoding"))
}
\arguments{
\item{file}{a character string giving the pathname of the file to read from.
If it is omitted from the argument list, then it is presumed that the
\code{text} argument will be used instead.}

\item{output}{a character string giving the pathname of the file to write to.
If it is omitted (\code{NULL}), then it is presumed that the user expects
the results returned as a \code{character} vector.}

\item{text}{a character vector containing the \emph{markdown} text to
transform (each element of this vector is treated as a line in a file).}

\item{renderer}{the name of the renderer that will be used to transform the
\code{file} or \code{text}.}

\item{renderer.options}{options that are passed to the renderer.  For
\code{HTML} renderer options see \code{\link{markdownHTMLOptions}}.}

\item{extensions}{options that are passed to the \emph{markdown} engine. See
\code{\link{markdownExtensions}}.}

\item{encoding}{the encoding of the input file; see \code{\link{file}}}
}
\value{
\code{renderMarkdown} returns NULL invisibly when output is to a
  file, and either \code{character} (with the UTF-8 encoding) or \code{raw}
  vector depending on the renderer output type.
}
\description{
\code{renderMarkdown} transforms the \emph{markdown} text provided by the
user in either the \code{file} or \code{text} variable. The transformation is
either written to the \code{output} file or returned to the user. The default
rendering target is "HTML".
}
\details{
\pkg{markdown} uses (and ships with) the popular Sundown library provided by
GitHub. C stubs are available to implement new renderers.
}
\examples{
(renderMarkdown(text = "Hello World!"))
# a few corner cases
(renderMarkdown(text = character(0)))
(renderMarkdown(text = ""))
}
\seealso{
\code{\link{markdownExtensions}}, \code{\link{markdownHTMLOptions}},
  \code{\link{markdownToHTML}}.

  For a description of the original \emph{markdown} version:
  \url{http://daringfireball.net/projects/markdown/}

  The original Sundown library on github:
  \url{https://github.com/vmg/sundown}

  C stubs for writing new renders are in inst/include/markdown_rstubs.[ch].
}
markdown/man/rpubsUpload.Rd0000644000176200001440000000440412515337414015445 0ustar  liggesusers% Please edit documentation in R/rpubsUpload.R
\name{rpubsUpload}
\alias{rpubsUpload}
\title{Upload an HTML file to RPubs}
\usage{
rpubsUpload(title, htmlFile, id = NULL, properties = list(), 
    method = getOption("rpubs.upload.method", "auto"))
}
\arguments{
\item{title}{The title of the document.}

\item{htmlFile}{The path to the HTML file to upload.}

\item{id}{If this upload is an update of an existing document then the id
parameter should specify the document id to update. Note that the id is
provided as an element of the list returned by successful calls to
\code{rpubsUpload}.}

\item{properties}{A named list containing additional document properties
(RPubs doesn't currently expect any additional properties, this parameter
is reserved for future use).}

\item{method}{Method to be used for uploading. "internal" uses a plain http
socket connection; "curl" uses the curl binary to do an https upload;
"rcurl" uses the RCurl package to do an https upload; and "auto" uses the
best available method searched for in the following order: "curl", "rcurl",
and then "internal". The global default behavior can be configured by
setting the \code{rpubs.upload.method} option (the default is "auto").}
}
\value{
A named list. If the upload was successful then the list contains a
  \code{id} element that can be used to subsequently update the document as
  well as a \code{continueUrl} element that provides a URL that a browser
  should be opened to in order to complete publishing of the document. If the
  upload fails then the list contains an \code{error} element which contains
  an explanation of the error that occurred.
}
\description{
This function uploads an HTML file to rpubs.com. If the upload succeeds a
list that includes an \code{id} and \code{continueUrl} is returned. A browser
should be opened to the \code{continueUrl} to complete publishing of the
document. If an error occurs then a diagnostic message is returned in the
\code{error} element of the list.
}
\examples{
\dontrun{
# upload a document
result <- rpubsUpload("My document title", "Document.html")
if (!is.null(result$continueUrl)) 
    browseURL(result$continueUrl) else stop(result$error)

# update the same document with a new title
updateResult <- rpubsUpload("My updated title", "Document.html", result$id)
}
}
markdown/man/rendererOutputType.Rd0000644000176200001440000000132212515337414017032 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{rendererOutputType}
\alias{rendererOutputType}
\title{Fetch the Renderer Output Type}
\usage{
rendererOutputType(name)
}
\arguments{
\item{name}{a character string naming the renderer.}
}
\value{
The character string with a value of either \code{character} or
  \code{raw}.
}
\description{
\pkg{markdown} allows up to seven renderers to be registered by users, and
each must provide the type of output returned, either \code{character} or
\code{raw} for binary output. HTML is provided by the package and outputs
\code{character}.
}
\examples{
# List all available renderers
rendererOutputType("HTML")
}
\seealso{
\link{markdownToHTML}, \link{registeredRenderers}
}
markdown/man/smartypants.Rd0000644000176200001440000000250712515337414015534 0ustar  liggesusers% Please edit documentation in R/renderMarkdown.R
\name{smartypants}
\alias{smartypants}
\title{smartypants: ASCII punctuation to HTML entities}
\usage{
smartypants(file, output, text)
}
\arguments{
\item{file}{a character string giving the pathname of the file to read from.
If it is omitted from the argument list, then it is presumed that the
\code{text} argument will be used instead.}

\item{output}{a character string giving the pathname of the file to write to.
If it is omitted, then it is presumed that the user expects the results
returned as a character string.}

\item{text}{a character vector containing the \emph{markdown} text to
transform.}
}
\value{
\code{smartypants} returns NULL invisibly when output is to a file,
  and a character string otherwise.
}
\description{
\code{smartypants} transforms plain ASCII punctuation characters into
\emph{smart} typographic punctuation HTML entities.
}
\examples{
cat(smartypants(text = "1/2 (c)\\n"))
}
\seealso{
\code{\link{markdownExtensions}}, \code{\link{markdownHTMLOptions}},
  \code{\link{markdownToHTML}}.

  For a description of the original \emph{markdown} version:

  \url{http://daringfireball.net/projects/markdown/}

  The original Sundown library on github:

  \url{https://github.com/vmg/sundown}

  C stubs for writing new renders are in inst/include/markdown_rstubs.[ch].
}