Remove reST documentation, attendant updates.

The documentation covers topics not specifically relevant to libmaple,
so it doesn't make sense for it to be part of the libmaple source
distribution.

Delete the docs/ tree, and prepare libmaple for use with the new
leaflabs-docs repo, which will contain the docs from now on.

* README: update to reflect this change

* support/doxygen/Doxyfile: This is the old docs/Doxyfile

* Makefile: Add a doxygen target

* wirish/comm/HardwareSerial.h: fix reference to docs/.  The comment
  informing maintainers that the HardwareSerial interface is
  documented by hand refers to the docs/ tree, which no longer exists.
  Update it to refer to the separate leaflabs-docs repository.

* support/scripts/copy-to-ide: No longer build the documentation

1 files changed, 0 insertions, 129 deletions

diff --git a/docs/source/lang/cpp/goto.rst b/docs/source/lang/cpp/goto.rst
deleted file mode 100644
index 2c0b3b0..0000000
--- a/docs/source/lang/cpp/goto.rst
+++ /dev/null
@@ -1,129 +0,0 @@
-.. highlight:: cpp
-
-.. _lang-goto:
-
-Labels and ``goto``
-===================
-
-A *label* gives a name to a line of code within a function.  You can
-label a line by writing a name for it, then a colon (``:``), before
-the line starts.  The ``goto`` keyword allows program flow to transfer
-to a labeled line from anywhere within the same function.
-
-.. warning:: The use of ``goto`` is discouraged in C and C++
-   programming.  It is *never necessary* to use ``goto`` to write a
-   program.
-
-   Unless you know what you're doing, using ``goto`` tends to
-   encourage code which is harder to debug and understand than
-   programs without ``goto`` that do the same thing.  That said,
-   however, it's sometimes useful; :ref:`see below <goto-when-to-use>`
-   for a concrete example.
-
-Using Labels and goto
----------------------
-
-Labels and ``goto`` are probably best explained through example.
-Let's start with an example of how to label lines.  The first line
-(``int x = analogRead(some_pin);``) in the :ref:`loop <lang-loop>`
-function below has label ``readpin``.  The third line (``delay(x);``)
-has label ``startdelay``.  The second line (``SerialUSB.println(x);``)
-does not have a label::
-
-       void loop() {
-       readpin:
-              int x = analogRead(some_pin);
-              SerialUSB.println(x); // for debugging
-       startdelay:
-              delay(x);
-              // ... more code ...
-       }
-
-Anything which can be a :ref:`variable <lang-variables>` name can
-be a label.
-
-Let's say that we wanted to print ``x`` only if it was very large, say
-at least 2000.  We might want to do this just so anybody watching on a
-:ref:`serial monitor <ide-serial-monitor>` would know they were in for
-a longer wait than usual.  We can accomplish this through the use of a
-``goto`` statement that skips the printing if ``x`` is less than
-2000::
-
-       void loop() {
-       readpin:
-              int x = analogRead(some_pin);
-              if (x < 2000) {
-                  goto startdelay;
-              }
-              SerialUSB.println(x); // for debugging
-       startdelay:
-              delay(x);
-              // ... more code ...
-       }
-
-In this modified program, whenever ``x`` is less than 2000, the body
-of the :ref:`if <lang-if>` statement in the second line is
-executed.  The ``goto`` statement inside the ``if`` body skips
-straight to the line labeled ``startdelay``, passing over the line
-doing the printing.
-
-A ``goto`` does not have to "move forwards"; it can go "backwards",
-too.  For example, the following program prints "5" forever (why?)::
-
-    void loop() {
-    printfive:
-        SerialUSB.println(5);
-        goto printfive;
-        SerialUSB.println(6);
-    }
-
-.. _goto-when-to-use:
-
-When to Use goto
-----------------
-
-As mentioned above, use of ``goto`` is `generally discouraged
-<http://en.wikipedia.org/wiki/Goto#Criticism_and_decline>`_.  However,
-when used with care, ``goto`` can simplify certain programs.  One
-important use case for ``goto`` is breaking out of deeply nested
-:ref:`for <lang-for>` loops or :ref:`if <lang-if>` logic blocks.
-Here's an example::
-
-    for(int r = 0; r < 255; r++) {
-        for(int g = 255; g > -1; g--) {
-            for(int b = 0; b < 255; b++) {
-                if (analogRead(0) > 250) {
-                    goto bailout;
-                }
-                // more statements ...
-            }
-            // innermost loop ends here
-        }
-    }
-    bailout:
-    // more code here
-
-In the above example, whenever the :ref:`analog reading
-<lang-analogread>` on pin 0 was greater than 250, the program would
-jump to the line labeled ``bailout``, exiting all three loops at once.
-
-While there is already a :ref:`break <lang-break>` keyword for
-breaking out of a loop, it will only break out of the *innermost*
-loop.  So, if instead of saying "``goto bailout;``", there was a
-"``break;``" instead, the program would only exit from the loop with
-header "``for(int b = 0; b < 255; b++)``".  The program would continue
-at the line which reads "``// innermost loop ends here``", which is
-clearly undesirable if you wanted to leave all three loops at once.
-
-More examples of when ``goto`` is a good choice are given in Donald
-Knuth's paper, "Structured Programming with go to Statements"; see
-below for a link.
-
-See Also
---------
-
-- Dijkstra, Edsger W. `Go To Statement Considered Harmful <http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.92.4846&rep=rep1&type=pdf>`_ (PDF)
-
-- Knuth, Donald. `Structured Programming with go to Statements <http://pplab.snu.ac.kr/courses/adv_pl05/papers/p261-knuth.pdf>`_ (PDF)
-
-.. include:: /arduino-cc-attribution.txt