Move the docs in the parent folder as in clang.

Adjust a few options to make the docs locally buildable.

docs/ReadTheDocs/conf.py

@@ -1,36 +0,0 @@
-# Configuration file for the Sphinx documentation builder.
-
-# -- Project information
-
-project = 'Cling'
-copyright = '2022, Cling'
-author = 'Sara Bellei'
-
-release = '0.1'
-version = '0.1.0'
-
-# -- General configuration
-
-extensions = [
-    'sphinx.ext.duration',
-    'sphinx.ext.doctest',
-    'sphinx.ext.autodoc',
-    'sphinx.ext.autosummary',
-    'sphinx.ext.intersphinx',
-]
-
-intersphinx_mapping = {
-    'python': ('https://docs.python.org/3/', None),
-    'sphinx': ('https://www.sphinx-doc.org/en/master/', None),
-}
-intersphinx_disabled_domains = ['std']
-
-templates_path = ['_templates']
-
-# -- Options for HTML output
-
-html_theme = 'sphinx_rtd_theme'
-
-# -- Options for EPUB output
-epub_show_urls = 'footnote'
-

docs/ReadTheDocs/index.rst

@@ -1,42 +0,0 @@
-Cling interprets C++
-=======================================
-
-.. figure:: images/fig1.jpeg
-
-**Cling** is an interactive C++ interpreter built on top of `Clang
-<https://clang.llvm.org/>`_ and `LLVM <https://llvm.org/>`_.  It uses LLVM's
-*Just-In-Time* (`JIT <https://en.wikipedia.org/wiki/Just-in-time_compilation>`_)
-compiler to provide a fast and optimized compilation pipeline. Cling uses the
-`read-eval-print-loop
-<https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop>`_
-(**REPL**) approach, making rapid application development in C++ possible,
-avoiding the classic edit-compile-run-debug cycle approach.
-
-
-Cling's last release, download instructions, dependencies, and any other useful
-information for developers can be found on `Cling's GitHub webpage
-<https://github.com/vgvassilev/cling>`_.
-
-Find out more about **Interpreting C++** on the `Compiler Research Group
-<https://compiler-research.org/>`_'s webpage.
-   
-
-Table of Contents
---------
-
- .. toctree::
-    :numbered:
-   
-    chapters/background
-    chapters/interactivity
-    chapters/implementation
-    chapters/REPL
-    chapters/XEUS
-    chapters/cudaC++
-    chapters/grammar
-    chapters/references
-
-.. note::
-
-  This project is under active development.
-  Cling has its documentation hosted on Read the Docs.

docs/chapters/XEUS.rst

@@ -1,5 +1,5 @@
 C++ in Jupyter Notebook - Xeus Cling
------------------------------------
+------------------------------------
 
 The Jupyter Notebook technology allows users to create and share documents that
 contain live code, equations, visualizations and narrative text. It enables data

docs/chapters/conclusion.rst

@@ -1,5 +1,5 @@
 Conclusion
------------------------------------
+----------
 
 Cling is not just a REPL, it is an embeddable and extensible execution system
 for efficient incremental execution of C++. Cling allows us to decide how much

docs/chapters/grammar.rst

@@ -1,5 +1,5 @@
 Command Line
-=====
+============
 
 Cling has its own command line, which looks like any other Unix shell. The
 emacs-like command line editor is what we call interactive command line or
@@ -11,13 +11,13 @@ runtime universe. Thus it creates the minimal environment for the user to start.
 
 
 Grammar
-------------
+-------
 
 Cling is capable to parse everything that `Clang <https://clang.llvm.org/>`_ can
 do. In addition, Cling can parse some interpreter-specific C++ extensions.
 
 Metaprocessor
-------------
+-------------
 
 Cling Metaprocessor provides convenient and easy to use interface for changing
 the interpreter’s internal state or for executing handy commands. Cling provides

docs/chapters/references.rst

@@ -1,54 +1,47 @@
 Literature
-=====
+==========
 
 
 What is Cling?
-------------
+--------------
 
 `Relaxing the One Definition Rule in Interpreted C++
 <https://dl.acm.org/doi/10.1145/3377555.3377901>`_
-
 *Javier Lopez Gomez et al.*, 29th International Conference on Compiler
- Construction, 2020
+Construction, 2020
 
 *This paper discusses how Cling enables redefinitions of C++ entities at the
- prompt, and the implications of interpreting C++ and the One Definition Rule
- (ODR) in C++*
-
+prompt, and the implications of interpreting C++ and the One Definition Rule
+(ODR) in C++*
 `Cling – The New Interactive Interpreter for ROOT 6
 <https://iopscience.iop.org/article/10.1088/1742-6596/396/5/052071>`_
 
 *V Vasilev et al* 2012 J. Phys.: Conf. Ser. 396 052071
 
 *This paper describes the link between Cling and ROOT. The concepts of REPL and
- JIT compilation. Cling’s methods for handling errors, expression evaluation,
- streaming out of execution results, runtime dynamism.*
-
+JIT compilation. Cling’s methods for handling errors, expression evaluation,
+streaming out of execution results, runtime dynamism.*
 `Interactive, Introspected C++ at CERN
 <https://www.youtube.com/watch?v=K2KqEV866Ro>`_
 
 *V Vasilev*, CERN PH-SFT, 2013
 
 *Vassil Vasilev (Princeton University) explains how Cling enables interactivity
- in C++, and illustrates the type introspection mechanism provided by the
- interpreter.*
-
+in C++, and illustrates the type introspection mechanism provided by the
+interpreter.*
 `Introducing Cling, a C++ Interpreter Based on Clang/LLVM
 <https://www.youtube.com/watch?v=f9Xfh8pv3Fs>`_
 
 *Axel Naumann* 2012  Googletechtalks
-
 *Axel Naumann (CERN) discusses Cling’s most relevant features: abstract syntax
- tree (AST) production, wrapped functions, global initialization of a function,
- delay expression evaluation at runtime, and dynamic scopes.*
-
+tree (AST) production, wrapped functions, global initialization of a function,
+delay expression evaluation at runtime, and dynamic scopes.*
 `Creating Cling, an interactive interpreter interface
 <https://www.youtube.com/watch?v=BjmGOMJWeAo>`_
 
 *Axel Naumann* 2010 LLVM Developers’ meeting
-
 *This presentation introduces Cling, an ahead-of-time compiler that extends C++
- for ease of use as an interpreter.*
+for ease of use as an interpreter.*
 
 .. list-table:: Title
    :widths: 25 25 50
@@ -57,49 +50,44 @@ What is Cling?
    * - Link
      - Info 
      - Description
-   * - `Relaxing the One Definition Rule in Interpreted C++
-     <https://dl.acm.org/doi/10.1145/3377555.3377901>`_
+   * - `Relaxing the One Definition Rule in Interpreted C++ <https://dl.acm.org/doi/10.1145/3377555.3377901>`_
      - *Javier Lopez Gomez et al.*
        
        29th International Conference on Compiler Construction 2020
      - This paper discusses how Cling enables redefinitions of C++ entities at the prompt, and the implications of interpreting C++ and the One Definition Rule (ODR) in C++
-   * - `Cling – The New Interactive Interpreter for ROOT 6
-     <https://iopscience.iop.org/article/10.1088/1742-6596/396/5/052071>`_
+   * - `Cling – The New Interactive Interpreter for ROOT 6 <https://iopscience.iop.org/article/10.1088/1742-6596/396/5/052071>`_
      - *V Vasilev et al* 2012 J. Phys.: Conf. Ser. 396 052071
      - This paper describes the link between Cling and ROOT. The concepts of
        REPL and JIT compilation. Cling’s methods for handling errors, expression
        evaluation, streaming out of execution results, runtime dynamism.
-   * - `Interactive, Introspected C++ at CERN
-     <https://www.youtube.com/watch?v=K2KqEV866Ro>`_
+   * - `Interactive, Introspected C++ at CERN <https://www.youtube.com/watch?v=K2KqEV866Ro>`_
      - *V Vasilev*, CERN PH-SFT, 2013
      - Vassil Vasilev (Princeton University) explains how Cling enables
        interactivity in C++, and illustrates the type introspection mechanism
        provided by the interpreter.
-   * - `Introducing Cling, a C++ Interpreter Based on Clang/LLVM
-     <https://www.youtube.com/watch?v=f9Xfh8pv3Fs>`_
+   * - `Introducing Cling, a C++ Interpreter Based on Clang/LLVM <https://www.youtube.com/watch?v=f9Xfh8pv3Fs>`_
      - *Axel Naumann* 2012  Googletechtalks
      - Axel Naumann (CERN) discusses Cling’s most relevant features: abstract
        syntax tree (AST) production, wrapped functions, global initialization of
        a function, delay expression evaluation at runtime, and dynamic scopes.
-   * - `Creating Cling, an interactive interpreter interface
-     <https://www.youtube.com/watch?v=BjmGOMJWeAo>`_
+   * - `Creating Cling, an interactive interpreter interface <https://www.youtube.com/watch?v=BjmGOMJWeAo>`_
      - *Axel Naumann* 2010 LLVM Developers’ meeting
      - This presentation introduces Cling, an ahead-of-time compiler that
        extends C++ for ease of use as an interpreter.
 
 
 Demos, tutorials, Cling’s ecosystem:
-------------
+------------------------------------
 
 
 Language Interoperability with Cling:
-------------
+-------------------------------------
 
 Cling for interactive CUDA C++:
-------------
+-------------------------------
 
 Cling on Jupyter:
-------------
+-----------------
 
 Clad:
-------------
+-----

docs/conf.py

@@ -50,9 +50,15 @@ copyright = u'2007-%d, The Cling Team' % date.today().year
 # built documents.
 #
 # The short version.
-version = '9'
+
+current_file_dir = os.path.dirname(os.path.realpath(__file__))
+CLING_ROOT = current_file_dir + "/.."
+
+with open(CLING_ROOT + "/VERSION", "r") as f:
+    version = f.read()
+
 # The full version, including alpha/beta/rc tags.
-release = '9'
+release = version
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/index.rst

@@ -1,13 +1,44 @@
-.. Cling documentation master file, created by
-   sphinx-quickstart on Sun Sep 14 20:01:55 2022.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
+Cling interprets C++
+====================
 
-.. title:: Welcome to Cling's documentation!
+.. figure:: images/fig1.jpeg
 
-.. toctree::
-   :maxdepth: 1
+**Cling** is an interactive C++ interpreter built on top of `Clang
+<https://clang.llvm.org/>`_ and `LLVM <https://llvm.org/>`_.  It uses LLVM's
+*Just-In-Time* (`JIT <https://en.wikipedia.org/wiki/Just-in-time_compilation>`_)
+compiler to provide a fast and optimized compilation pipeline. Cling uses the
+`read-eval-print-loop
+<https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop>`_
+(**REPL**) approach, making rapid application development in C++ possible,
+avoiding the classic edit-compile-run-debug cycle approach.
 
-Using Cling
-===========
 
+Cling's last release, download instructions, dependencies, and any other useful
+information for developers can be found on `Cling's GitHub webpage
+<https://github.com/vgvassilev/cling>`_.
+
+Find out more about **Interpreting C++** on the `Compiler Research Group
+<https://compiler-research.org/>`_'s webpage.
+   
+
+Table of Contents
+-----------------
+
+ .. toctree::
+    :numbered:
+   
+    chapters/background
+    chapters/interactivity
+    chapters/implementation
+    chapters/REPL
+    chapters/XEUS
+    chapters/cudaC++
+    chapters/grammar
+    chapters/references
+    chapters/conclusion
+    chapters/why_interpreting
+
+.. note::
+
+  This project is under active development.
+  Cling has its documentation hosted on Read the Docs.