Writeup 2.90 Full Reference Guide

Last updated on 2020-02-07 at 01:23:45 by Andrew Fountain for version 2.90.04 (2020-02-10)

Table of Contents

• 0.1 Philosophy

1. General Syntax

2. Command Line Options

• 2.1 Examples of Command line options
• 2.2 File type detection

3. Markup Language

• 3.1 Inline Character Markup
  • 3.1.1 Links and Images
  • 3.1.2 Special Characters
  • 3.1.3 Escaped characters/sequences
  • 3.1.4 Pre-defined symbols
• 3.2 Line Breaks
• 3.3 Block Markup
  • 3.3.1 Headings
  • 3.3.2 Lists
  • 3.3.3 Tables
  • 3.3.4 Paragraph or other block tags
  • 3.3.5 Switching Block Tags in the middle of lines
• 3.4 Comments
• 3.5 Inline Code and Pre
  • 3.5.1 <code> and <pre>
  • 3.5.2 Inline code (passed through raw)
  • 3.5.3 Header Tags
• 3.6 Easily adding class and id attributes

4. Text Processing Language

• 4.1 Basic variable assignment and function definition
  • 4.1.1 Whole line variable assignment
  • 4.1.2 Inline variable assignment
  • 4.1.3 Inserting the value of variables into the document (i.e. printing)
  • 4.1.4 Block variable assignment
  • 4.1.5 Single Character variables
  • 4.1.6 Parentheses
• 4.2 Function Parameters—passing arguments
  • 4.2.1 The Parameter List
  • 4.2.2 Default Parameters
  • 4.2.3 Missing or empty arguments and default parameters
  • 4.2.4 Named (optional) parameters
  • 4.2.5 Parsing Arguments manually
• 4.3 Flow Control
  • 4.3.1 If
  • 4.3.2 Include
    • 4.3.2.1 Include paths
  • 4.3.3 exit
• 4.4 Pre-defined constants
• 4.5 Pre-defined variables
  • 4.5.1 URL root and base values
• 4.6 Switches
• 4.7 Pre-defined Inline Functions and Methods
  • 4.7.1 Variable handling
  • 4.7.2 Numeric Methods
  • 4.7.3 Text processing Methods
  • 4.7.4 Time/Date processing Functions and Methods
  • 4.7.5 System Functions
  • 4.7.6 Other Functions

5. Defining New Keyword Patterns

• 5.1 Simple replacements
• 5.2 Alternating replacements
• 5.3 Paired replacements
• 5.4 Deleting keywords
• 5.5 Limitations

6. HTML/XML/CSS Attribute Generation

• 6.1 Attribute variables
• 6.2 Setting the colgroup tag
• 6.3 Controlling the HTML generated by Markup
• 6.4 The Tag Stack
• 6.5 Tag Redefinition
  • 6.5.1 Simple tag redefinition (one tag simply replaced by another):
  • 6.5.2 Complex tag redefinition (other text or attributes included):
  • 6.5.3 Example redefining an ordered list as a definition list

7. Supported features in Github GFM and Markdown

• 7.1 Markdown Feature support
• 7.2 Github GFM Feature Support

8. Known limitations

Writeup is a tool for generating content. It takes a plain text file and processes it into HTML, XML and/or CSS. It has three components:

1. A markup language, similar to Markdown or textile.
2. A pre-processing language with variables, functions, conditional compilation and includes.
3. HTML/XML/CSS generation fuctionality for classes, styles and other attributes.

• The program is run from the command line using the syntax: writeup [options] sourcefile
  • There are many command-line options which are documented with the --help option.

0.1 Philosophy

• As simple as possible for the end-user to create complex documents. They need know nothing about Writeup
• The end-user writes semantically and does not have to worry about markup
• Write once, use everwhere. A single source document can be used for web-pages, slide presentations, printed copy etc.
• All the complexities of markup are abstracted into functions contained in include files
• These functions are hidden from the user and are created by Writeup “experts” who have mapped the simple syntax given to end-users into the desired markup for whatever use will be made of the document

1. General Syntax

• A Writeup file is a simple text file.
  • (Can be either in ascii or utf-8. Line endings can be unix or dos style.)
• The first line of the file is usually a heading or a comment. If so, it will be used to generate the title of the document. See File type detection for more details.
• When the --strict option is set, at some point in the file the constant $VER should be set to the version of Writeup that the document was written to.
  • (The purpose of this is that if api changes are made in the future, this will “future-proof” your document.)
• Each line normally generates a block element, so a paragraph is one long line, (propbably wrapping in your text editor).
• Any line can contain a comment using //
  • A valid comment must have whitespace either before or after the //, and not have a : before.
    • e.g. http:// does not count as a comment, nor does path//path/filename.txt
  • To intentionally force // in a line, use the $SLASHES constant.
• All white space is stripped from the end of lines
• A line may be continued (joined with the following line) by ending it with a \
• If the document is stored in a version control system, such as Subversion, then if a line such as:
  $ID=$Id: fullref.txt 604 2020-02-08 03:23:56Z andrewfn $
  is inserted near the top of the document, it will allow Writeup to extract version control metadata for use in the document.
• Tabs are treated as a single white space

2. Command Line Options

• This is the output from the --help option

writeup: allows complex HTML documents to be generated from plain text files

usage: writeup [options] [-o <outfile>] <infile>
  options: -h|?|--help --usage --version -v[v]|--verbose|-q[q]|--quiet --debug

-b    --body       body only (no headers)
-c[c] --close      close open tags quietly at end of document (-cc not just at end)
      --debug      same as -vvvvv
-f    --for        <outputtype> set the $FOR variable, default -f web
-g    --github     enable Markdown with GitHub enhancements
-h    --help       display help
-I    --noinclude  no includes allowed in body (for security)
-k    --strict     striKt checKing for valid syntax
-o    --output     <outfile> output to outfile rather than infile.html
-m    --markdown   enable Markdown compatibility
-p    --process    language processor only, no html rendering (for testing)
-q[q] --quiet      quiet   (-qq very quiet)
-r    --stdout     redirect output to stdout
-s[s] --set        <set> set a variable e.g. -s test=true
      --usage      summary of usage
-v[v] --verbose    verbose (-vv very verbose)
-V    --version    version string
      --versionnum version number
-x    --extract    <varname> extract varible to stdout or to file if -o defined
-X    --export     <[$]pattern> export variables in bash or Writeup format
-y    --yes        answer Yes to any keyboard prompts

Version:  2.90.04 (2020-02-10) by Andrew M Fountain, http://writeup.org
Copyright (c) Andrew M. Fountain,  2019

• Note that the values of --body, --process, --markdown and --github, plus the effects of --quiet, --verbose and --debug can be set within the document using variables. See Pre-defined variables for details.

2.1 Examples of Command line options

• writeup -Iybqq -o myfile-out.html -s include=recipe_inc.txt -s format=Recipe -s VER=2.0 myfile.txt
  • -I No includes allowed in body; -y yes to questions; -b HTML body only; -qq very quiet; -o output file myfile-out.html
  • -s set include file; -s set $format variable; -s set $VER
  • Note that setting VER or --body from the command line has the side-effect of supressing the check for a well-formed title line (to allow for the processing of simple text fragments).

2.2 File type detection

• A well-formed Writeup main document will usually begin with .Title of Document which will start the document with the title as an h1, and also set the document title tag
  • To start with a lower level h-tag, use more dots, e.g. ..Title of Document for h2
  • To supress a heading tag at the top of the document, use the syntax: //.Title of Document (no spaces at the start)
• To mark the document as another $TYPE then place the type name between the
  • e.g. if first line begins with //inc.Title of document then $TYPE will be set to inc if an attempt is made to run the file as the main document
  • The main purpose for this type detection is for document management tools
• If the value of $VER is set from the command line then it will force Writeup to recognize the document as being in Writeup format (to allow, for example, web pages to be processed where $VER is not set, nor is there any top-line title.

3. Markup Language

3.1 Inline Character Markup

• Note that the effect of each markup is completely redefinable

✻Note that if only part of a word is to be italic, then this can be effected using a $NULL to invisibly break the word, e.g. her${NULL}_first_ ➜ herfirst. We have to use ${NULL}_first_ and not $NULL_first_ to stop the _ extending the name $NULL.

3.1.1 Links and Images

Hyperlinks:	[[http://writeup.org]] no link text,↵ or [[http://writeup.org with linking text]]	writeup.org no link text, or with linking text
Autolinks are turned on by default $autolinks=TRUE. Delimited by any non-alphanum at start and whitespace at end:	http://gw.ca/link or https://gw.ca/xx or -http://gw.ca/. or (http://gw.ca/), But not xhttp://gw.ca or [[gw.ca within another link http://gw.ca]]. Note that any .,:;) characters at the end of the url will not be included in the link.	gw.ca/link or gw.ca/xx or -gw.ca. or (gw.ca), But not xhttp://gw.ca or within another link http://gw.ca. Note that any .,:;) characters at the end of the url will not be included in the link.
Links longer than $autolinkslen are displayed abbreviated…:	The link: http://gw.ca/content/long-link.of-meaningless-words is abbreviated.	The link: gw.ca/…nk.of-meaningless-words is abbreviated.
Hyperlinks can span multiple lines, if / used to supress paragraph-per-line:	/[[http://gw.ca ↵ ...Linked heading↵ in multiline link↵ ]]	Linked heading in multiline link
Mailto links are obfuscated by default to deter spammers. (Turn this off with $emailhide=FALSE:	[[mailto:a@gw.ca]]	a@gw.ca
MediaWiki style hyperlinks can be achieved by setting [=${LINK} and ]=</a>:	MediaWiki style link [http://writeup.org with linking text]	MediaWiki style link with linking text
Images:	No alt/title text [[writeup32.png]] or with alt and title text [[writeup32.png Writeup logo]]	No alt/title text or with alt and title text
Autolinks work in exactly the same way with images:	Here is an image http://writeup.org/writeup32.png in the text	Here is an image in the text
To link to an image, override the URL detection by setting $mediatype:	$set $mediatype1=link [[writeup32.png This is a link to the image]]. Use image for an image.	This is a link to the image. Use image for an image.
Using $hrefroot & $imgroot:	See below in URL root and base values to see how url’s can have strings automatically prepended to them.

3.1.2 Special Characters

3.1.3 Escaped characters/sequences

3.1.4 Pre-defined symbols

• Although these are considered constants, they can be re-assigned to a new value if necessary, e.g. a different asterisk character could be used or it could be wrapped in a span

$QUARTER $HALF $THREEQUARTERS↵
$THIRD $TWOTHIRDS

$MDASH $NDASH↵
$LSQUO $RSQUO $LDQUO $RDQUO $LAQUO $RAQUO

$ASTERISK $UNDERSCORE $UNDERLINE↵
$ATSYMBOL $CIRCUMFLEX $PERCENT $HASH $DOLLAR

non-break:($SP)↵
em:($EMSP)↵
regular space: ($SPACE) or (\ )↵
null: ($NULL)↵
zero width space (for allowing word breaks): ($ZWSP)↵
Force trailing space with (SPACE) at end of line: 

3.2 Line Breaks

• Unless within a table (see below), a vertical bar | is identical to starting a new line
  • This is for convenience when it is easier to combine several lines together e.g. $if $test|*testing*|$endif
• To get a vertical bar, use the $VB constant
• To generate a newline within a function, use $VB or \n
• To end a line with an HTML break <br />, simply end it with /
• To insert an HTML break <br />, in the middle use the two characters:/+anywhere/+in the line
  • Alternatively the $BR constant can be used
• A line that begins with just two minus signs -- will create a horizontal rule <hr />

• If it begins with three --- then it will cause a page break. (This is accomplished by adding the css contained in the variable $pagebreakstyle (see below) to the subsequent block tag.

3.3 Block Markup

3.3.1 Headings

• Note that in some situations a document that is included in another might need all its heading levels adjusted. e.g h1→h2 etc. This can be accomplished by setting $headingbase the base value of heading levels to a value other than 1.

...Heading level 3 (h3 tag)↵
.....Heading level 5 (h5 tag)↵
......Heading level 6 (h6 tag)

$set $headingbase=3 ↵
.Heading level 3 (using only 1 dot)

• Note that if $autoclose is set to TRUE any open tags are closed at the end of the block with no error messages.

3.3.2 Lists

1. Can use a number↵
#. or default numbering↵
5. New numbering sequence↵
 A. indent to start nested list↵
 #. and so on↵
  i. upper or lower case or roman numerals↵
  ii. Any depth of list supported↵
 #. Indent one space per level of nesting↵
#. Back to top level

-Simply use minus sign↵
 -and indentations↵
 a. Can be mixed with ordered lists↵
 b. to any depth↵
  -third level↵
  -and again

Plain list↵
 Simply indent↵
  one space per level↵
  and it works as expected.↵
 -It can also be used to add extra paragraphs↵
  to one of the other lists↵
Turn off plainlists $set $plainlists=FALSE ↵
   Indent ignored!

A blank line before a list item puts the "firstline" class on it:↵
↵
-CSS can then be used to create extra space etc. e.g.: .firstline {margin-top: 6px;}↵
 -Sometimes a list level needs to be forcibly ended, and this can be done with a minus exclamation mark:↵
-!↵
-New list started

• Note: Plain lists are implemented with a <div class="plainlist" style="margin-left:40px;". The inline style is included in case no CSS is set, but can be suppressed using $unset $div_plainlist_style.
• $forcelista If TRUE then alphabetic lists do not have to be started at the beginning. (This is usually FALSE to prevent acronyms accidentally starting lists. See Switches for more detail.
• $forcelisti If TRUE then Roman numeral lists do not have to be started at the beginning. (This is usually FALSE to prevent acronyms accidentally starting lists

3.3.3 Tables

----↵
| table cell | table cell |↵
| table cell | table cell |↵
----↵

----t↵
| table head | table head |↵
| table cell | table cell |↵
----↵

----tl↵
| table head | table head | table head |↵
| table head | table cell | table cell |↵
----↵

----t↵
every line↵
is in a cell↵
--cell Then the next cell↵
--cell and↵
a third cell↵
----row A new row↵
implicitly a new cell↵
--cell second column↵
--cell third column↵
----row↵
--cell and↵
--cell one more↵
--cell row↵
----↵

3.3.4 Paragraph or other block tags

• no automatic paragraph/block tag on the line if
  • line begins with /
  • line begins with </endtag>
  • $blocktag is set to “”
  • line begins with <a block tag>
• else if table, list or heading, use its paragraph tag
• else use $blocktag for paragraph tag (defaults to <p>)

3.3.5 Switching Block Tags in the middle of lines

Usually each line creates a single block, according to the above rules. However, it’s possible to:

• end the current block tag and start a new one in the middle of the line:
  The command $newblock blocktagname will end the current block tag and begin a new one.

$set $blocktag1=dt ↵
Def Term $newblock dd Definition Description

• temporarily suspend blocks for subsequent lines, returning to close the original block tag later
  The commands $newblock + and $newblock - will switch off and on block-per-line processing.
  This is used internally for including code segments.
• use the $BR tag with $fakebreak=TRUE to force HTML processing to start a new line but not actually a <br> tag

3.4 Comments

3.5 Inline Code and Pre

3.5.1 <code> and <pre>

• Surrounding inline text with <( and )> will
  • cause all markup to be escaped, e.g. <span>
  • surround the text with <code> ... </code>
• If the <( )> block surrounds the whole line, or multiple lines, then the <pre> tag will be used, e.g.

<p>this block is <em>all</em> a <pre> tag
and can be multiple lines</p>

3.5.2 Inline code (passed through raw)

• Surrounding inline text with <` and `> will cause everything inside to go through raw.
  • This is useful for, say, php or javascript code.
• This can also be used for blocks, as above

3.5.3 Header Tags

By default the document starts with:

Contents-of-$DOCTYPE-variable
<html>
<head>
<style>Contents-of-$style-variable</style>
<title>Contents-of-$TITLE-variable</title>
</head>
<body>

It is possible to redefine <html>, <head> and <body> using tag redefinition so as to create an arbitrary XML document.

If the <html> tag is changed, then both the <head> and <body> tag are supressed.

• For example, an SVG formatted XML document, could be created with the following:

//.Three nested rectangles
$DOCTYPE=<?xml version="1.0" encoding="UTF-8" standalone="no"?>
$html_tag=svg xmlns="http://www.w3.org/2000/svg" width="$MAXX" height="$MAXY"
$MAXX=200
$MAXY=100
$stroke=#000
$pathstyle=fill:$Rfill;stroke:$stroke;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1

$rect($Rx, $Ry, $Rw, $Rh, $Rfill)={
  <path style="$pathstyle" d="M $Rx $Ry L $Rx.plus($Rw) $Ry L $Rx.plus($Rw) $Ry.plus($Rh) L $Rx $Ry.plus($Rh) Z" />
}

$rect 10 10 180 80 #F00
$rect 20 20 160 60 #0F0
$rect 30 30 140 40 #00F

• Which would generate the following XML document:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" width="200" height="100">
<path style="fill:#F00;stroke:#000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" d="M 10 10 L 190 10 L 190 90 L 10 90 Z" />
<path style="fill:#0F0;stroke:#000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" d="M 20 20 L 180 20 L 180 80 L 20 80 Z" />
<path style="fill:#00F;stroke:#000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" d="M 30 30 L 170 30 L 170 70 L 30 70 Z" />
</svg>

• And would look like this:

3.6 Easily adding class and id attributes

• There is a shorthand for generating class and id attributes for tags such as <div> and <span>
  e.g. <div.myclass>, <span.red>, <mark.highlight> will become:
  • <div class="myclass">, <span class="red">, <mark class="highlight">
  e.g. <div#myid>, <span#first>, <mark#pageid> will become:
  • <div id="myid">, <span id="first">, <mark id="pageid">
• The same syntax can be used when closing a tag, but it is ignored, and only used for documentation purposes
  e.g. </div.myclass></div#myid>, will become: </div></div>
• Headings can be given id’s by putting #idname immediately following the periods
  e.g. ..#headid, will become: <h2 id="headid">

4. Text Processing Language

4.1 Basic variable assignment and function definition

• A variable/function name consists of a $ followed by one or more alphanumeric/underscore characters.
• There are three ways of assigning variables: whole line, inline or block
• Important: whole line and block assignments are “lazy” (the assigned string does not get evaluated until it is used), whereas inline assignment evaluates the string before putting it into the variable.
  • inline assignment can be made lazy by putting the string in quotes. (see example below)

4.1.1 Whole line variable assignment

• If the first non-white-space character on a line is a valid variable name, immediately followed by = then the remainder of the line is assigned to the variable/function. e.g.
  $var1=The contents of variable one // whole line assignment
$var1+=, and more content is appended to it
  • resulting in: The contents of variable one, and more content is appended to it
  • Note that all comments and trailing spaces will have been stripped except for a trailing SPACE.
• The main advantage of this method is that the string is only terminated by the end of the line
• A multiline value can be created using $NL or \n
• The line may be continued onto multiple lines by placing \ at the end

4.1.2 Inline variable assignment

• Variables and functions may also be created inline using $set and other functions listed below. e.g.
  $set $var1=newvaluewithnospaces or $set $var1="The contents of variable one"
• Many functions operate on the varible that was modified in the last $set or $modify function. (See Variable handling for more details) e.g.
  $set $x=$y.plus( 2 ) or $modify($name).concat(" B.Sc.") which is equivalent to:
  $set $x=1 $plus 2 or $modify $name $concat " B.Sc."
• The expression $set $x=$variable1 will evaluate $variable1 before putting it into $x
• The expression $set $x="$variable1" will put the literal string $variable1 into $x (i.e. evaluation is lazy).

4.1.3 Inserting the value of variables into the document (i.e. printing)

• Simply including the variable name, e.g. $var will insert it’s value after evaluating it.
• Note that when variable evaluation is “lazy” it will not occur until the variable is actually inserted into the document.
• An exception to this is when an evaluation is forced, explicitly using $eval or $setval, or implicitly when an inline function is used with $set or $modify (see above).
• Methods (functions that operate on the current variable) can be invoked using “dot-notation”, e.g.:
  $myname.uppercase will invoke the $uppercase function and print the result. These may be cascaded as in:
  $date.monthdate.lowercase
• When dot-notation used with methods that take parameters, the parameters must be put in parenthesies, e.g.
  $set $name=Peter
$name.uppercase.concat(" ").repeat(5) ⇒ PETER PETER PETER PETER PETER
• User written methods: This can be used with user-written methods which must be declared as such using the $setmethod function.
  Parameter declaration marks the variable as a function, so to override it, $setmethod must be after $parameters, e.g.

  $parameters $welcome greeting degree     // specify two parameters: greeting & degree
  $setmethod $welcome
  $welcome=\                               // method to add greeting and degree to the current result
    $copy $old_result=$result\
    $set $result="$greeting $old_result $degree!"

  $name=Martin Smith                       // put a value into the name variable
  $name.welcome(Hi "B.Sc. Ph.D.")          // run the method
  $name.welcome(Hello junior)

• ⇒ Hi Martin Smith B.Sc. Ph.D.!
• ⇒ Hello Martin Smith junior!

• dot-notation can also be used on immediate values (as opposed to variables) by using $mkvar, e.g.
  There are $mkvar(60).mult(60).mult(24) seconds in a day.
  ⇒ There are 86400 seconds in a day.

4.1.4 Block variable assignment

• Variables and function may be multi-line using the following syntax:

 $nameofvar={
   multiple lines
 }

• It is possible to use this syntax for a single line, for example when a space must be included at the end of the variable, e.g.:
  [={$li_class1=done }
• Note that block variable assigments should not be used for inline variables/functions since line-end characters will be included.
  • Instead, simply use continuation lines, e.g.:

 $longmonth=\
    $pushset $monthdatefmt="%A %B %-d"\
    $day.monthdate\
    $pop $monthdatefmt

4.1.5 Single Character variables

• One of the strengths of Writeup is the ability to define certain single characters as variables
  • They are the characters: [ ] { } which can be set individually
  • Plus the eight alternating characters: ~ @ # % ^ * _ ` which are used in matching pairs, e.g. *boldly*
• These can be assigned simply by:

(example needed)

• Note that as of Writeup version 2, you can only set the eight alternating characters inline if you use their long form. e.g.
  $set ${:sAT}="Value of first \@" $set ${:eAT}="Value of alternating \@"
  resulting in @--and--@ becoming: Value of first @—and—Value of alternating @
• Here are the long forms of all the single character variables:
  $:sCURL – { $:eCURL – } $::CURL – {}
  $:sSQR – [ $:eSQR – ]); <($::SQR – []
  $:sHASH – # $:eHASH – # $::HASH – #
  $:sCIRC – ^ $:eCIRC – ^ $::CIRC – ^
  $:sPCENT – % – $:ePCENT – % – $::PCENT – %
  $:sTILD – ~ $:eTILD – ~ $::TILD – ~
  $:sAT – @ $:eAT – @ $::AT – @
  $:sTICK – ` $:eTICK – ` $::TICK – `
  $:sASTR – <strong> – $:eASTR – </strong> – $::ASTR – *
  $:sUNDR – <em> – $:eUNDR – </em> – $::UNDR – _

4.1.6 Parentheses

• Parentheses can be used to evaluate an expression, e.g.

$( 1 $plus 1 $)

$set $result=1 $plus 1 $result

$set $greet="Hello world!" $( $greet $whenunset "hi" $uppercase $)

4.2 Function Parameters—passing arguments

• Note that because Writeup uses a single, global namespace, all argument variables are unset before parsing the supplied arguments.
• However they are not cleared at the end of a function.
• But because Writup uses lazy evaluation by default, variables defined within the function should in many cases be evaluated, because a later evaluation might produce different results.
• This would be the case if they depend on values that are valid only in that particular calling of the function.

4.2.1 The Parameter List

Parameters are defined with a comma-separated list in the function definition. E.g.

$myfunction($x, int $y, real $z)=Values supplied were: $x, $y and $z.

example usage:

$myfunction alpha beta gamma

results in:

• defaultvalue any word or quotes words. It can be ““. Special values are:
  • "WARN:words of warning" give warning message if argument missing
  • "" or $NULL will set the default to be an empty string
  • Setting an argument’s value to NOARG will force the default to be used.

$words_and_lines( \
    $worda,  \
    $wordb,  \
    line $line1,  \
    line $line2,  \
    $wordc,  \
    line $line3,  \
    line $line4)={

-*These are the three words:* $worda, $wordb, $wordc
-*line1:* $line1
-*line2:* $line2
-*line3:* $line3
-*line4:* $line4

}  

example usage:

$words_and_lines Alpha Beta Old MacDonald had a farm↵
Eee Eye Eee Eye↵
Gamma Oh↵
!

results in:

Let’s try that again, showing how quote marks are handled, and omitting a line.

• Notice that quotations are always stripped from words (unless escaped) and from lines if they are used to signify an empty line
• However since quotes are not necessary to identify which words are in a line, they are included in the arguments, since they must be intentional.

$words_and_lines "Alpha but no Beta:" "" "Old MacDonald's farm"↵
""↵
'Gamma' 'Eee Eye Eee Eye Oh'↵
""

results in:

More complex example of different types:

• (For clarity, each parameter is put on a separate line by using a line continuation \ at the end of each line.)

$funcdemo( \
    $DEMword,  \
    int $DEMint,  \
    real $DEMreal,  \
    date $DEMdate,  \
    true $DEMtrue,  \
    var $DEMvar,  \
    line $DEMline,  \
    emptyline $placeholder,  \
    multi $DEMmulti)={

-$DEMword, $DEMint, $DEMreal, $DEMdate, $DEMtrue
-LINE: $DEMline
$RED$DEMmulti$eRED
$if $DEMtrue
$floatprecision=10
$setval ${$DEMvar}="Report: On $DEMdate.yeardate the result was: $DEMreal.mult($DEMint)"
$unset $floatprecision
$endif

}  

example usage:

$funcdemo "effectively a word" 12345 -27.123 2020-12-31 YES $report Whatever text to the end of the line↵
↵
And some↵
more↵
lines until ended by empty line↵
↵
-See if function changed variable: $report

results in:

4.2.2 Default Parameters

• If no argument is supplied, then any default will be used.
• If there is no default, then the parameter variable is unset.
• The following code creates a heading and list, with control over the heading level, and the color:
  • Note that

$alert( \
    line $ALtitle=“WARN:Alert needs a title”,  \
    $ALlevel=3,  \
    $color=red,  \
    line $ALsubhead,  \
    line $ALmessage=”More details to be added later”)={

$block_style=color:$color
<h$ALlevel>$ALtitle</h$ALlevel>
$ifdef $ALsubhead
-_*$ALsubhead*_
$endif
-$ALmessage
$unset $block_style

}  

example usage:

$alert Danger from Falling Squirrels↵
2 blue Listen for squeaks↵
If you suspect a rodent is about to fall, place a bag over your head.

results in:

• Running $alert with no arguments will result in the warning message: Warning: Alert needs a title
• If the title is supplied, then all the other arguments default (except for $ALsubhead which does not have a default, but is tested to see if it is defined.)
• For example:

$alert Defaults↵
↵

results in:

• If we want to allow an earlier argument on a line to default, but still set later arguments, then defaut can be forced using a argument value of NOARG
• For example:

$alert Allow default heading level, but set everything else↵
NOARG purple This is the subheading↵
And the warning message

results in:

4.2.3 Missing or empty arguments and default parameters

• Here is a function which will test four possibilities
  • word and line parameters with either a default of “” or no default at all

$testdefaults( \
    $word1,  \
    $word2=””,  \
    line $testtitle,  \
    line $line1,  \
    line $line2=””)={

----row
$testtitle.whenunset("_Arguments missing_")
--cell
$word1.whenunset(_unset_)$NULL
--cell
$word2.whenunset(_unset_)$NULL
--cell
$line1.whenunset(_unset_)$NULL
--cell
$line2.whenunset(_unset_)$NULL

}  

The test is run with four calls to the function within a table:

----tl
$thspan2=$set $th_attr1=colspan="2"
|          | $thspan2 word | $thspan2 line |
| Default: |  none  | ""   | none   | ""   |
$testdefaults argval argval Argument: ‹(argval)›
argval
argval
$testdefaults "" "" Argument: ‹("")›
""
""
$testdefaults


$testdefaults NOARG NOARG Argument: ‹(NOARG)›
NOARG
NOARG
----

resulting in:

4.2.4 Named (optional) parameters

• Named/optional parameters operate exactly like regular parameters, except the arguments are optional and can occur in any position.
• They are identified using a keyword, followed by a colon, and often in CAPS for easy recognition. (Putting keywords in caps also reduces the possibility of falsely identifying them in regular text, and so all caps keywords are spell-checked when parsing.
• Note that if a line contains only named arguments of type word, it will not count as a blank line, or even a line, for the purposes of the other parameters.

Here is the code for the alert function above, updated to make use of named parameters. (note that the body of the function is unchanged):

$alert2( \
    line $ALtitle=“WARN:Alert needs a title”,  \
    $ALlevel=3 LEVEL:,  \
    $color=red COLOR:,  \
    line $ALsubhead SUB:,  \
    line $ALmessage=”More details to be added later”)={

$block_style=color:$color
<h$ALlevel>$ALtitle</h$ALlevel>
$ifdef $ALsubhead
-_*$ALsubhead*_
$endif
-$ALmessage
$unset $block_style

}  

example usage:

$alert2 Danger from Falling Squirrels↵
LEVEL:2 COLOR:blue SUB:Listen for squeaks↵
If you suspect a rodent is about to fall, place a bag over your head.

results in:

• Running $alert with no arguments will result in the warning message: Warning: Alert needs a title
• If the title is supplied, then all the other arguments default (except for $ALsubhead which does not have a default, but is tested to see if it is defined.)
• For example:

$alert2 Defaults↵
↵

results in:

• If we want to allow an earlier argument on a line to default, but still set later arguments, then defaut can be forced using a argument value of NOARG
• For example:

$alert2 Allow default heading level, but set everything else↵
COLOR:purple SUB:This is the subheading↵
And the warning message

results in:

Here is some code which creates an RSS feel for a podcast, plus an example podcast entry:

$autolinks=FALSE // turn off the flags which will mess up pure XML
$timetag=FALSE
$blanklines=
$blocktag=
$FPFEED=21216 // Feedpress basic feed number
[=<`<link>`>||]=<`</link>`>

$talk($SMdate=WARN:, line $talk_title="Talk title coming soon", $SM_short="", $SMdir="", $SMfname="",\
 $SMvimeo=$FALSE, $audioid=$FALSE, line $talk_scripture_line="", multi $talk_descr="",\
 line $speaker SPEAKER:,\  // If not Andrew
 line $series_line SERIES:,\      // optional num + name
 $vidpage VIDPAGE:,\     // omit /video/ if not set, use $SMweb. If NONE then no video
 $blog BLOG:,\           // Optional link to blog article
 $length LENGTH:,\       // File length in bytes
 $minutes=0:00 MINUTES:,\   // Optional time in minutes
 $cdata CDATA:,\         // Optional, set if true
 $feedpressid FPID:,\    // Optional feedpress ID
 $feedpresslink FPLK:,\  // Optional if not ID-1
 $podtime="11:00" PODTIME:,    \   // change the time
 line $keywords=theology KEYWORDS:\   // Optional keywords
)={
  $summary=
  $if $series_line // Prefix the summary with series info
    $setval $sernumbered=$series_line.first.isint // have to do in two steps because of old processing model
    $if $sernumbered||$setval $summary='$series_line.rest Part $series_line.first$SPACE'
    $else||$setval $summary=$series_line$SPACE||$endif
  $endif
  $setval $descprefix=$summary
  $if $talk_scripture_line
    $summary+=($talk_scripture_line)
  $endif
  $if $descprefix||$dspace=$SPACE||$else||$dspace=||$endif
  $if !$VIDPAGE||$copy $SMvideo=$SM_short
  $else||$copy $SMvideo=$VIDPAGE||$endif

  <item>
  $if $speaker
    <title>$speaker: $talk_title</title>
  $else
    <title>$talk_title</title>
    $speaker=Andrew Fountain
  $endif
  $linkurl=$URL/video/$SMvideo
  $linkgif=
  $if $feedpressid
    $if !$feedpresslink||$setval $feedpresslink=$feedpressid.minus(1)||$endif
    $linkurl=https://tracking.feedpress.it/link/$FPFEED/$feedpresslink
    $linkgif=<img src="https://feedpress.me/$FPFEED/$feedpresslink.gif" height="1" width="1"/>
    $if !$cdata||$linkgif=<`<![CDATA[`>$linkgif<`]]>`>||$endif
  $endif
  [$linkurl]
  <pubDate>$SMdate.datefmt("%a, %d %b %Y") $podtime:00 EST</pubDate>
  $if $cdata
    <description><`<![CDATA[`>
    $set $blocktag=p
    $if $series_line
      $descprefix$dspace$talk_descr
    $else
      $talk_descr
      $descprefix
    $endif
    $set $blocktag=
    $linkgif<`]]>`></description>
  $else
    <description>$descprefix$dspace$talk_descr$linkgif</description>
  $endif
  $fullaudio=gwmedia.s3.amazonaws.com/nlife/$SMdate-$SM_short.mp3
  $if $feedpressid
    <enclosure url="https://tracking.feedpress.it/link/$FPFEED/$feedpressid/$SMdate-$SM_short.mp3" length="$length" type="audio/mpeg"/>
  $else
    <enclosure url="https://$fullaudio" length="$length" type="audio/mpeg"/>
  $endif
  <guid isPermaLink="true">https://$fullaudio</guid>
  <itunes:author>$speaker</itunes:author>
  <itunes:duration>$minutes</itunes:duration>
  <itunes:subtitle>$summary</itunes:subtitle>
  $if $cdata
    <itunes:summary><`<![CDATA[`>
    $set $blocktag=p
    $if $series_line
      $descprefix$dspace$talk_descr
    $else
      $talk_descr
      $descprefix
    $endif
    $set $blocktag=
    <`]]>`></itunes:summary>
  $else
    <itunes:summary>$descprefix$dspace$talk_descr</itunes:summary>
  $endif
  <itunes:image href="http://nlife.ca/sites/default/files/$SMdate-$SM_short-poster-1400.jpg"/>
  <itunes:keywords>$keywords</itunes:keywords>
  <itunes:explicit>no</itunes:explicit>
  <itunes:category text="Religion &amp; Spirituality">\n<itunes:category text="Christianity"/>\n</itunes:category>
  </item>
}

$talk 2020-01-12 How the Man Born Blind challenges you and me
john_man_born_blind John/John_09-01 John9_01-man_born_blind 384407570 -1 John 9
FPID:13149409 MINUTES:30:23 LENGTH:12806798 KEYWORDS:Light, Jesus, Blind
SERIES:14 Gospel of John
On the surface this is a simple healing story, but John has beautifully put together a series of events and conversations that build up to a startling revelation from Jesus, that his light can actually lead people to become blind, and we ourselves need to pay close attention.

The resulting XML code is:

<item>
<title>How the Man Born Blind challenges you and me</title>
<link>https://tracking.feedpress.it/link/21216/13149408</link>
<pubDate>Sun, 12 Jan 2020 11:00:00 EST</pubDate>
<description>Gospel of John Part 14  On the surface this is a simple healing story, but John has beautifully put together a series of events and conversations that build up to a startling revelation from Jesus, that his light can actually lead people to become blind, and we ourselves need to pay close attention.<![CDATA[<img src="https://feedpress.me/21216/13149408.gif" height="1" width="1" />]]></description>
<enclosure url="https://tracking.feedpress.it/link/21216/13149409/2020-01-12-john_man_born_blind.mp3" length="12806798" type="audio/mpeg" />
<guid isPermaLink="true">https://gwmedia.s3.amazonaws.com/nlife/2020-01-12-john_man_born_blind.mp3</guid>
<itunes:author>Andrew Fountain</itunes:author>
<itunes:duration>30:23</itunes:duration>
<itunes:subtitle>Gospel of John Part 14 (John 9)</itunes:subtitle>
<itunes:summary>Gospel of John Part 14  On the surface this is a simple healing story, but John has beautifully put together a series of events and conversations that build up to a startling revelation from Jesus, that his light can actually lead people to become blind, and we ourselves need to pay close attention.</itunes:summary>
<itunes:image href="http://nlife.ca/sites/default/files/2020-01-12-john_man_born_blind-poster-1400.jpg" />
<itunes:keywords>Light, Jesus, Blind</itunes:keywords>
<itunes:explicit>no</itunes:explicit>
<itunes:category text="Religion &amp; Spirituality">
<itunes:category text="Christianity" />
</itunes:category>
</item>

4.2.5 Parsing Arguments manually

In some circumstances the usual format of arguments (space separated) might not be desired. In this case the entire argument line can be read as a string and parsed manually by the function. For example, if space comma is the separator:

$parameters $draw draw_line
$draw={
  $set $explodedelim=" ,"
  $explode $arg $draw_line
  $set $explodedelim=" "
Draw a "$( $arg2 $whenunset "thing" $)" at ($arg0, $arg1)
}
$draw 5, 6, office block
$draw 123,   678,    factory and industrial area
$draw 654,908,home
$draw 23,45

• resulting in:

4.3 Flow Control

4.3.1 If

$if <condition>
$elseif //optional elseif clause
$else //optional else clause
$endif

• There are three other variants:
  • $ifdef <variable_name> tests to see if variable is defined
  • $ifndef <variable_name> converse of above
  • $ifexists <file_name> the file name can be contained in a variable and can be absolute or relative to the directory of the current document.
• No looping is currently provided (although it can be effected using recursion)
• There is a conditional statement: $iftrue <testvariable> <true-result> <false-result>. See Pre-defined Inline Functions

4.3.2 Include

• Files may be included using the $include <filename> function
  • If the file is not found in the current directory, and not an absolute path, then its parent is searched, and so on, up to the root
    • (This enables include files to be stored in one place)
    • To prevent this search, use $includex (include exact) instead
  • If the filename includes a relative path, e.g. includes/my_inc.txt then a search will be performed in the order:
    • includes/my_inc.txt, ../includes/my_inc.txt, ../../includes/my_inc.txt etc.
• If there are no includes in the document, then Writeup will automatically add $include top.txt at the top of the document
  • To prevent this happening, the line $include NONE can be added
• The constant $INCLUDED is set to the current inclusion depth, where 0=top level. See Pre-defined constants.

4.3.2.1 Include paths

In order to help functions within include files to set up paths for other includes, css, javascript etc, the functions can find out information about how the file system is set up through the following variables:

• $INCLUDEPATH contains the absolute path of the current file, including the final ‘/’
  • So if an included file is not contained in the current directory, the value of $INCLUDEPATH will be different to its value within the main document.
  • If you need to include a file from somewhere else in the file structure, This value can be set to a search base (i.e. the bottom of the tree, and search is upwards, however in most cases it would be better to use an absolute path.)
• From within an include file, $RELPATH gives the relative address of the main document (not including the final ‘/’)
• From within an include file, $REVERSEPATH gives the relative address the main document would need to use to access the directory containing the include file
  • e.g. within an include file that is in the directory above the main file, $REVERSEPATH would be ../
  • The values of $RELPATH or $REVERSEPATH from the most recent include will still be availabe in the main document.
    • But if their values need to persist past other includes, they should be $copy’ed into another variable.
  • In Writeup 2.x $RELPATH and $REVERSEPATH are set to FALSE if the included file is not in a directory that is a direct ancestor of the current directory. (This may change in future versions.)

4.3.3 exit

• $exit will immediately abort. It can be in the middle of a line.
  • Writeup will attempt to close any open tags with no error messages.
  • If a warning message should be generated, then use $warningmsg before $exit.

4.4 Pre-defined constants

$OS 

($DIRSEP)

4.5 Pre-defined variables

default value: $author 

4.5.1 URL root and base values

There are three kinds of URL:

• Relative, as in mylink
• Root-relative, as in /home/mylink where the url starts with /
• Absolute, as in http://writeup.org/home/mylink where the url starts with a scheme, e.g. http://

It is common to test a page on one site, but move in into production on another. To facilitate this, the variables $hrefroot or $imgroot are automatically prepended to root-relative url’s.

• This effect may be supressed and the url fixed by putting a : at the start of the url

• Image urls can be controlled in the same way using $imgroot
• Often images are stored in an images folder and this can be specified using $imgbase which will be prepended to relative url’s only.
  • If after adding $imgbase the url becomes root-relative, then as expected, $imgroot will also be prepended.

• Notes:
  • $hrefbase works similarly to $imgbase but there are very few use cases for it
  • $hrefroot and $imgroot should never end in a /
    -$hrefbase and $imgbase will always end in a /

4.6 Switches

Note that all of these switches except $noerrors can have a “1” suffixed to them to make them one time only.

• e.g. $tableclasses1=TRUE will only affect the next table. The variable will then self-delete.

----t↵
$set $tableclasses=TRUE ↵
| tr.row1 th.col1 | tr.row1 th.col2 |↵
| tr.row2 td.col1 | tr.row2 td.col2 |↵
----↵

$set $listclasses=TRUE ↵
-ul.ul1 li.ul1↵
 -ul.ul2 li.ul2↵
 a. ol.ol2 li.ol2↵
 b. li.ol2↵
  -ul.ul3 li.ul3↵
   cl3↵
 c. li.ol2↵
   ul.pl3 li.pl3

$set $noerrors=TRUE ↵
unchecked code↵
$set $noerrors=FALSE

$set $compacttables=TRUE ↵
----↵
cell has no paragraph tag ↵
----

Converted to link: http://gw.ca↵
$set $autolinks=FALSE ↵
not converted: http://gw.ca

The link: http://gw.ca/content/long-link/goes-on?q=with%20arguments is abbreviated.

$set $forcelista1=TRUE ↵
H. G. Wells is now an alphabetic list item "H."↵
#. List continues.

$set $forcelisti1=TRUE ↵
MCMXCIX. This is list item 1999.↵
#. Next list value is 2000.

$set $autoclose1=TRUE opened <mark>but not closed

$set $timetag1=TRUE $( $TODAY $yeardate $)

4.7 Pre-defined Inline Functions and Methods

4.7.1 Variable handling

• These functions can be placed inline anywhere.
• All values can be delimited by spaces, ", ', : or /
• The first six functions, marked § have the following side effect:
  • They set their first parameter to be the “current variable”, for use with functions like $plus
• The functions marked ‡ have the side effect of triggering a constructor if one has been defined
• In the examples below, the result of the operation is often shown in (parenthesis). They have no function apart from clearly marking out the result.

4.7.2 Numeric Methods

4.7.3 Text processing Methods

4.7.4 Time/Date processing Functions and Methods

These functions allow variables of the date type “date” to be manipulated and displayed.

• A date variable is simply a string of the form yyyy-mm-dd (ISO standard format) and may be created displayed with no special functions.
• The date can be converted to another format using the C++ strftime specification of which a simplified summary is:

• Note that Unix defines %E as available for alternative formats, so Writeup defines:
  • %Eb as an alternative form of %b where June, July & Sept are 4 letters instead of three to conform with popular usage.
  • %Ea as an alternative form of %a where Tues & Thurs are the short days instead of Tue and Thu to conform with popular usage.
  • Note that the %- prefix removes leading zeros or spacing
• The conversion format is stored in the following variables:
  • $monthdatefmt is used by $monthdate and has the default value: %Eb %-d.
  • $yeardatefmt is used by $yeardate and has the default value: %Eb %-d, %Y.
  • $customdatefmt is used by $customdate and has the default value: %Ea %Eb %-d, %Y.
    • note that as usual you can append “1” to the name to override the value for the next conversion. e.g. $monthdatefmt1.
  • The .datefmt() method is the best way to do one-off date formatting.
• The date is displayed using the HTML5 <time> tag if $timetag is TRUE. (Default value is TRUE)
• The time tag below is made more visible using the CSS:
  • time {border-bottom: 1px dotted #0A0; cursor:help;} time:hover {border:none;}
• The <time> tag by default will have it’s title attribute set to the date, formatted using $timetag_title.
  • Unset $timetag_title to prevent this.

4.7.5 System Functions

4.7.6 Other Functions

5. Defining New Keyword Patterns

5.1 Simple replacements

Short character sequences such as [ or * are pre-defined to map to variables, but new ones can be defined.

E.g. to define @@ as a new pattern:

• $keywordset @@ ${ATAT} ANY will cause every occurrance of @@ to be replaced by the variable ${ATAT}, anywhere in the line
• $keywordset @@ ${ATl} LEFT will cause @@ at the left end of lines to be replaced by ${ATl}
• $keywordset @@ ${ATr} RIGHT will cause @@ at the right end of lines to be replaced by ${ATr}
• $keywordset @@ ${AT} BOTH will cause lines that contain only @@ to be replaced by ${AT}
• It is recommeded that variable include the {} characters so they don’t accidentally combine with any characters following.
• So if we define the following (just as an illustration):

$ATAT=<img src="i.jpg"/>
$ATl=<img src="l.jpg"/>
$ATr=<img src="r.jpg"/>
$AT=<img src="b.jpg"/>

• Then it will replace this line:
  @@a line with an image at each end@@and one in the middle@@
• with:
  

  <img src="l.jpg" />a line with an image at each end<img src="i.jpg" />and one in the middle<img src="r.jpg" />

• and a line containing just @@ will become:
  

  <img src="b.jpg"/>

5.2 Alternating replacements

• If a new keyword is intended to alternate between start and end values, like * does, then this may be accomplished with:

$keywordset "::" ${mark} ANY     // register the keyword pattern in the normal way
$keywordalt $mark $smark $emark // convert to an alternating pair by registering start and end varables
$smark=<mark>                   //assign values
$emark=</mark>

• Then it will replace this line:
  

  This is a way to ::highlight:: a word

• With this:
  

  <p>This is a way to <mark>highlight</mark> a word</p>

5.3 Paired replacements

• Sometimes Keyword patterns are used in pairs. If Writeup is informed of this, more intelligent error messages can be generated if a pair is not closed. E.g.

$keywordset "((" ${RED} ANY  // register the keyword patterns in the normal way
$keywordset "))" ${eRED} ANY //
$keywordpair $RED $eRED     // register them as paired
$RED=<span class="red">     //assign values
$eRED=</span>

• Then it will replace this line:
  

  The values will work as a ((pair)) with an intelligent error if the closing )'s are missing.

• With this:
  

  <p>The values will work as a <span class="red">pair</span> with an intelligent error if the closing )‘s are missing.</p>

5.4 Deleting keywords

• Keywords can be deleted using $keyworddel pattern

5.5 Limitations

1. Care must be taken with single character keywords to prevent circular references
2. At present, there are limits to the evaluation of variables that are used in non-inline text, such as attributes and styles.
   • Such variables cannot at present contain built-in functions

6. HTML/XML/CSS Attribute Generation

6.1 Attribute variables

These varibles can be set to modify the attributes of tags that follow. Most of these variables can have a “1” suffixed to them which means they are cleared after one use, which will be the next occurrence of the tag:

• $tagname_class sets the class on following tags of that type.
  • e.g. $li_class=menu will make list items of class “menu”
  • e.g. $li_class1=menu will make the next list item of class “menu”
• $tagname_style sets the style on following tags of that type.
  • e.g. $li_style=font-weight:bold; will make list items bold
  • e.g. $li_style1=font-weight:bold; will make the next list item bold
• $tagname_attr sets the attribute on following tags of that type.
  • e.g. $td_attr=colspan="2" will set colspan=“2” on all td’s
  • e.g. $td_attr1=colspan="2" will set colspan=“2” on the next td
• $tagname_title sets the title attribute on following tags of that type.
  • e.g. $h3_title=Conclusions will set title=“Conclusions” on all h3 tags
  • e.g. $h3_title1=Conclusions will set title=“Conclusions” on the next h3 tag
• $tagname_id sets the id on the following tags of that type (a “1’ is assumed since id’s must be unique)
  • e.g. $li_id=firstitem will set id=“firstitem” on the next list items
  • e.g. $li_id1=firstitem identical to $li_id
• The attribute can be applied only to tags of a particular class using the syntax:
  • $tagname_tagclass_xxxx —Note that as of Writeup 2.0 this will only apply if the class is generated automatically, i.e. in tables and lists where Writeup can created numbered classes for row/col or list-indent.
  • e.g. $li_row3_class=red will add the class “red” to the third row of tables (if $tableclasses=TRUE)
  • Note that this selector will take precedence over $li_class if it can be matched.
• There are two “wildcard” tags: block and inline. These will only be matched if no other variable match.
  • e.g. $inline_style1=display:none; will hide the next inline element

6.2 Setting the colgroup tag

• The colgroup tag can simply be controlled from a variable
  • $colgroup will set the columngroup tag for all following tables
  • $colgroup1 will set the columngroup tag for one table only
• e.g.
  • $colgroup1=<col /><col class="c2" /><col class="c3" />
  • and set up styles:
  • $bodystyle=col.c2 {width:400px; background-color:yellow;} col.c3 {background-color:blue;}

6.3 Controlling the HTML generated by Markup

6.4 The Tag Stack

6.5 Tag Redefinition

• Tags may be redefined, either to another tag, or to something totally different.
• If the new value starts with '<' then the string is not parsed but taken literally, and the end tag is not changed.
• If the new value begins with a letter, then the tag name is used to set the end tag. This must be overridden if this is not what is desired.

6.5.1 Simple tag redefinition (one tag simply replaced by another):

$p_tag=blockquote // simply replace paragraph tags with a blockquote
$p_etag=/blockquote // Do not need to do this, it is done automatically when setting _tag

$p_tag1=blockquote // or use tag1 to apply only to the next paragraph
$p_etag1=/blockquote // and the end tag which is not set automatically for _tag1

resulting in:

This is a paragraph redefined as a blockquote.

Back to normal paragraphs.

• Note that attribute variables will be applied to simple redefinitions, but not to complex redefinitions.

6.5.2 Complex tag redefinition (other text or attributes included):

$li_tag=<li class=item>Item:$SP // adds a class and some characters. Don’t need to change li_etag.

• Item: backpack
• Item: boots
• Item: food
• Item: water

This will have to be explicitly ended with $unset $li_tag

6.5.3 Example redefining an ordered list as a definition list

• Use a combination of simple and complex redefinitions

$ul1_tag=dl    // start and end the definition list
$ul1_etag=/dl
$li1_tag=dt    // a level one list item will start a definintion term
$li1_etag=
$ul2_tag=</dt>
$ul2_etag=
$li2_tag=dd
$li2_etag=/dd
$dlind=12 // in em units
$dt_style=width:${dlind}em;
$dd_style=margin-left:$dlind.5em;

• e.g. $li_tag=<li><span class="listitem">
  • $li_etag=</span></li>

7. Supported features in Github GFM and Markdown

• Markdown reference: daringfireball.net/…own/syntax
• Github GFM reference: help.github.com/…ored-markdown

7.1 Markdown Feature support

• ‡ Default support of feature can be turned off by setting $OPT_markdown_default=FALSE

7.2 Github GFM Feature Support

8. Known limitations

• Varibles defined using the single line method cannot have trailing underscores in the name, nor can curly brackets be used to delimit the variable name
• Special characters, (_*{}[]~`@%^) have to be escaped if they occur in an “autolinks” URL
• Most of the built in functions, such as $plus cannot be used within styles/attributes etc without first doing an $eval
• A multi-line definition cannot appear within another multi-line definition.

It is anticipated that all the above limitations will be lifted in a future release.