The MIT License

Copyright (c) 2010 Timothy Farrell

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 MIT License

Copyright (c) 2013 Hasan Karahan

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

* field lists (:duref:`ref <field-lists>`)

* option lists (:duref:`ref <option-lists>`)

* quoted literal blocks (:duref:`ref <quoted-literal-blocks>`)

* doctest blocks (:duref:`ref <doctest-blocks>`)

Source Code

-----------

Literal code blocks (:duref:`ref <literal-blocks>`) are introduced by ending a

paragraph with the special marker ``::``.  The literal block must be indented

(and, like all paragraphs, separated from the surrounding ones by blank lines)::

   This is a normal text paragraph. The next paragraph is a code sample::

      It is not processed in any way, except

      that the indentation is removed.

      It can span multiple lines.

   This is a normal text paragraph again.

The handling of the ``::`` marker is smart:

* If it occurs as a paragraph of its own, that paragraph is completely left

  out of the document.

* If it is preceded by whitespace, the marker is removed.

* If it is preceded by non-whitespace, the marker is replaced by a single

  colon.

That way, the second sentence in the above example's first paragraph would be

rendered as "The next paragraph is a code sample:".

.. _rst-tables:

Tables

------

Two forms of tables are supported.  For *grid tables* (:duref:`ref

<grid-tables>`), you have to "paint" the cell grid yourself.  They look like

this::

   +------------------------+------------+----------+----------+

   | Header row, column 1   | Header 2   | Header 3 | Header 4 |

   | (header rows optional) |            |          |          |

   +========================+============+==========+==========+

   | body row 1, column 1   | column 2   | column 3 | column 4 |

   +------------------------+------------+----------+----------+

   | body row 2             | ...        | ...      |          |

   +------------------------+------------+----------+----------+

*Simple tables* (:duref:`ref <simple-tables>`) are easier to write, but

limited: they must contain more than one row, and the first column cannot

contain multiple lines.  They look like this::

   =====  =====  =======

   A      B      A and B

   =====  =====  =======

   False  False  False

   True   False  False

   False  True   False

   True   True   True

   =====  =====  =======

Hyperlinks

----------

External links

^^^^^^^^^^^^^^

Use ```Link text <http://example.com/>`_`` for inline web links.  If the link

text should be the web address, you don't need special markup at all, the parser

finds links and mail addresses in ordinary text.

You can also separate the link and the target definition (:duref:`ref

<hyperlink-targets>`), like this::

   This is a paragraph that contains `a link`_.

   .. _a link: http://example.com/

Internal links

^^^^^^^^^^^^^^

Internal linking is done via a special reST role provided by Sphinx, see the

section on specific markup, :ref:`ref-role`.

Sections

--------

Section headers (:duref:`ref <sections>`) are created by underlining (and

optionally overlining) the section title with a punctuation character, at least

as long as the text::

   =================

   This is a heading

   =================

Normally, there are no heading levels assigned to certain characters as the

structure is determined from the succession of headings.  However, for the

Python documentation, this convention is used which you may follow:

* ``#`` with overline, for parts

* ``*`` with overline, for chapters

* ``=``, for sections

* ``-``, for subsections

* ``^``, for subsubsections

* ``"``, for paragraphs

Of course, you are free to use your own marker characters (see the reST

documentation), and use a deeper nesting level, but keep in mind that most

target formats (HTML, LaTeX) have a limited supported nesting depth.

Explicit Markup

---------------

"Explicit markup" (:duref:`ref <explicit-markup-blocks>`) is used in reST for

most constructs that need special handling, such as footnotes,

specially-highlighted paragraphs, comments, and generic directives.

An explicit markup block begins with a line starting with ``..`` followed by

whitespace and is terminated by the next paragraph at the same level of

indentation.  (There needs to be a blank line between explicit markup and normal

paragraphs.  This may all sound a bit complicated, but it is intuitive enough

when you write it.)

.. _directives:

Directives

----------

A directive (:duref:`ref <directives>`) is a generic block of explicit markup.

Besides roles, it is one of the extension mechanisms of reST, and Sphinx makes

heavy use of it.

Docutils supports the following directives:

* Admonitions: :dudir:`attention`, :dudir:`caution`, :dudir:`danger`,

  :dudir:`error`, :dudir:`hint`, :dudir:`important`, :dudir:`note`,

  :dudir:`tip`, :dudir:`warning` and the generic :dudir:`admonition`.

  (Most themes style only "note" and "warning" specially.)

* Images:

  - :dudir:`image` (see also Images_ below)

  - :dudir:`figure` (an image with caption and optional legend)

* Additional body elements:

  - :dudir:`contents` (a local, i.e. for the current file only, table of

    contents)

  - :dudir:`container` (a container with a custom class, useful to generate an

    outer ``<div>`` in HTML)

  - :dudir:`rubric` (a heading without relation to the document sectioning)

  - :dudir:`topic`, :dudir:`sidebar` (special highlighted body elements)

  - :dudir:`parsed-literal` (literal block that supports inline markup)

  - :dudir:`epigraph` (a block quote with optional attribution line)

  - :dudir:`highlights`, :dudir:`pull-quote` (block quotes with their own

    class attribute)

  - :dudir:`compound` (a compound paragraph)

* Special tables:

  - :dudir:`table` (a table with title)

  - :dudir:`csv-table` (a table generated from comma-separated values)

  - :dudir:`list-table` (a table generated from a list of lists)

* Special directives:

  - :dudir:`raw` (include raw target-format markup)

  - :dudir:`include` (include reStructuredText from another file)

    -- in Sphinx, when given an absolute include file path, this directive takes

    it as relative to the source directory

  - :dudir:`class` (assign a class attribute to the next element) [1]_

* HTML specifics:

  - :dudir:`meta` (generation of HTML ``<meta>`` tags)

  - :dudir:`title` (override document title)

* Influencing markup:

  - :dudir:`default-role` (set a new default role)

  - :dudir:`role` (create a new role)

  Since these are only per-file, better use Sphinx' facilities for setting the

  :confval:`default_role`.

Do *not* use the directives :dudir:`sectnum`, :dudir:`header` and

:dudir:`footer`.

Directives added by Sphinx are described in :ref:`sphinxmarkup`.

Basically, a directive consists of a name, arguments, options and content. (Keep

this terminology in mind, it is used in the next chapter describing custom

directives.)  Looking at this example, ::

   .. function:: foo(x)

                 foo(y, z)

      :module: some.module.name

      Return a line of text input from the user.

``function`` is the directive name.  It is given two arguments here, the

remainder of the first line and the second line, as well as one option

``module`` (as you can see, options are given in the lines immediately following

the arguments and indicated by the colons).  Options must be indented to the

same level as the directive content.

The directive content follows after a blank line and is indented relative to the

directive start.

Images

------

reST supports an image directive (:dudir:`ref <image>`), used like so::

   .. image:: gnu.png

      (options)

When used within Sphinx, the file name given (here ``gnu.png``) must either be

relative to the source file, or absolute which means that they are relative to

the top source directory.  For example, the file ``sketch/spam.rst`` could refer

to the image ``images/spam.png`` as ``../images/spam.png`` or

``/images/spam.png``.

Sphinx will automatically copy image files over to a subdirectory of the output

directory on building (e.g. the ``_static`` directory for HTML output.)

Interpretation of image size options (``width`` and ``height``) is as follows:

if the size has no unit or the unit is pixels, the given size will only be

respected for output channels that support pixels (i.e. not in LaTeX output).

Other units (like ``pt`` for points) will be used for HTML and LaTeX output.

Sphinx extends the standard docutils behavior by allowing an asterisk for the

extension::

   .. image:: gnu.*

Sphinx then searches for all images matching the provided pattern and determines

their type.  Each builder then chooses the best image out of these candidates.

For instance, if the file name ``gnu.*`` was given and two files :file:`gnu.pdf`

and :file:`gnu.png` existed in the source tree, the LaTeX builder would choose

the former, while the HTML builder would prefer the latter.

.. versionchanged:: 0.4

   Added the support for file names ending in an asterisk.

.. versionchanged:: 0.6

   Image paths can now be absolute.

Footnotes

---------

For footnotes (:duref:`ref <footnotes>`), use ``[#name]_`` to mark the footnote

location, and add the footnote body at the bottom of the document after a

"Footnotes" rubric heading, like so::

   Lorem ipsum [#f1]_ dolor sit amet ... [#f2]_

   .. rubric:: Footnotes

   .. [#f1] Text of the first footnote.

   .. [#f2] Text of the second footnote.

You can also explicitly number the footnotes (``[1]_``) or use auto-numbered

footnotes without names (``[#]_``).

Citations

---------

Standard reST citations (:duref:`ref <citations>`) are supported, with the

additional feature that they are "global", i.e. all citations can be referenced

from all files.  Use them like so::

   Lorem ipsum [Ref]_ dolor sit amet.

   .. [Ref] Book or article reference, URL or whatever.

Citation usage is similar to footnote usage, but with a label that is not

numeric or begins with ``#``.

Substitutions

-------------

reST supports "substitutions" (:duref:`ref <substitution-definitions>`), which

are pieces of text and/or markup referred to in the text by ``|name|``.  They

are defined like footnotes with explicit markup blocks, like this::

   .. |name| replace:: replacement *text*

or this::

   .. |caution| image:: warning.png

                :alt: Warning!

See the :duref:`reST reference for substitutions <substitution-definitions>`

for details.

If you want to use some substitutions for all documents, put them into

:confval:`rst_prolog` or put them into a separate file and include it into all

documents you want to use them in, using the :rst:dir:`include` directive.  (Be

sure to give the include file a file name extension differing from that of other

source files, to avoid Sphinx finding it as a standalone document.)

Sphinx defines some default substitutions, see :ref:`default-substitutions`.

Comments

--------

Every explicit markup block which isn't a valid markup construct (like the

footnotes above) is regarded as a comment (:duref:`ref <comments>`).  For

example::

   .. This is a comment.

You can indent text after a comment start to form multiline comments::

   ..

      This whole indented block

      is a comment.

      Still in the comment.

Source encoding

---------------

Since the easiest way to include special characters like em dashes or copyright

signs in reST is to directly write them as Unicode characters, one has to

specify an encoding.  Sphinx assumes source files to be encoded in UTF-8 by

default; you can change this with the :confval:`source_encoding` config value.

Gotchas

-------

There are some problems one commonly runs into while authoring reST documents:

* **Separation of inline markup:** As said above, inline markup spans must be

  separated from the surrounding text by non-word characters, you have to use a

  backslash-escaped space to get around that.  See `the reference

  <http://docutils.sf.net/docs/ref/rst/restructuredtext.html#inline-markup>`_

  for the details.

* **No nested inline markup:** Something like ``*see :func:`foo`*`` is not

  possible.

.. rubric:: Footnotes

.. [1] When the default domain contains a :rst:dir:`class` directive, this directive

       will be shadowed.  Therefore, Sphinx re-exports it as :rst:dir:`rst-class`.

</textarea></form>

    <script>

      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {

        lineNumbers: true,

      });

    </script>

    <p>

        The <code>python</code> mode will be used for highlighting blocks

        containing Python/IPython terminal sessions: blocks starting with

        <code>&gt;&gt;&gt;</code> (for Python) or <code>In [num]:</code> (for

        IPython).

        Further, the <code>stex</code> mode will be used for highlighting

        blocks containing LaTex code.

    </p>

    <p><strong>MIME types defined:</strong> <code>text/x-rst</code>.</p>

  </body>

</html>

.cm-tw-syntaxerror {

	color: #FFF;

	background-color: #900;

}

.cm-tw-deleted {

	text-decoration: line-through;

}

.cm-tw-header5 {

	font-weight: bold;

}

.cm-tw-listitem:first-child { /*Added first child to fix duplicate padding when highlighting*/

	padding-left: 10px;

}

.cm-tw-box {

	border-top-width: 0px ! important;

	border-style: solid;

	border-width: 1px;

	border-color: inherit;

}

.cm-tw-underline {

	text-decoration: underline;

<!doctype html>

<html>

  <head>

    <meta charset="utf-8">

    <title>CodeMirror: VBScript mode</title>

    <link rel="stylesheet" href="../../lib/codemirror.css">

    <script src="../../lib/codemirror.js"></script>

    <script src="vbscript.js"></script>

    <link rel="stylesheet" href="../../doc/docs.css">

    <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>

  </head>

  <body>

    <h1>CodeMirror: VBScript mode</h1>

<div><textarea id="code" name="code">

' Pete Guhl

' 03-04-2012

'

' Basic VBScript support for codemirror2

Const ForReading = 1, ForWriting = 2, ForAppending = 8

Call Sub020_PostBroadcastToUrbanAirship(strUserName, strPassword, intTransmitID, strResponse)

If Not IsNull(strResponse) AND Len(strResponse) = 0 Then

	boolTransmitOkYN = False

Else

	' WScript.Echo "Oh Happy Day! Oh Happy DAY!"

	boolTransmitOkYN = True

End If

</textarea></div>

    <script>

      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {

        lineNumbers: true

      });

    </script>

    <p><strong>MIME types defined:</strong> <code>text/vbscript</code>.</p>

  </body>

</html>