Commits

Manuel Jacob committed cf91e4a

Replace remaining internal URLs by rst roles.

  • Participants
  • Parent commits 88eabe1
  • Branches improve-docs

Comments (0)

Files changed (12)

pypy/doc/coding-guide.rst

 .. _official wiki: http://mercurial.selenic.com/wiki/Branch
 
 
+.. _using-development-tracker:
+
 Using the development bug/feature tracker
 -----------------------------------------
 

pypy/doc/cpython_differences.rst

 PyPy.
 
 
+.. _extension-modules:
+
 Extension modules
 -----------------
 

pypy/doc/extending.rst

 * Write them in pure python and use ctypes, see CTypes_ section
 
 * Write them in pure python and use direct libffi low-level bindings, See
-  `\_ffi <LibFFI>`_ module description.
+  `\_ffi`_ module description.
 
-* Write them in RPython as `mixedmodule <Mixed Modules>`_, using *rffi* as bindings.
+* Write them in RPython as `mixedmodule <#Mixed Modules>`_, using *rffi* as bindings.
 
 * Write them in C++ and bind them through Reflex_
 
 present.  The slow-path is very slow.
 
 
-LibFFI
-------
+_ffi
+----
 
 Mostly in order to be able to write a ctypes module, we developed a very
 low-level libffi bindings called ``_ffi``. (libffi is a C-level library for dynamic calling,

pypy/doc/extradoc.rst

 * `Automatic generation of JIT compilers for dynamic languages in .NET`_,
   D. Ancona, C.F. Bolz, A. Cuni and A. Rigo
 
-* `EU Reports`_: a list of all the reports we produced until 2007 for the
+* :doc:`EU Reports <index-report>`: a list of all the reports we produced until 2007 for the
   European Union sponsored part of PyPy.  Notably, it includes:
 
 * `Core Object Optimization Results`_, PyPy Team
 .. _Faster than C#\: Efficient Implementation of Dynamic Languages on .NET: https://bitbucket.org/pypy/extradoc/raw/tip/talk/icooolps2009-dotnet/cli-jit.pdf
 .. _Automatic JIT Compiler Generation with Runtime Partial Evaluation:  http://www.stups.uni-duesseldorf.de/thesis/final-master.pdf
 .. _RPython\: A Step towards Reconciling Dynamically and Statically Typed OO Languages: http://www.disi.unige.it/person/AnconaD/papers/Recent_abstracts.html#AACM-DLS07
-.. _EU Reports: index-report.html
 .. _Hardware Transactional Memory Support for Lightweight Dynamic Language Evolution: http://sabi.net/nriley/pubs/dls6-riley.pdf
 .. _PyGirl\: Generating Whole-System VMs from High-Level Prototypes using PyPy: http://scg.unibe.ch/archive/papers/Brun09cPyGirl.pdf
 .. _Representation-Based Just-in-Time Specialization and the Psyco Prototype for Python: http://psyco.sourceforge.net/psyco-pepm-a.ps.gz
 Almost!
 
 The mostly likely stumbling block for any given project is support for
-`extension modules`_.  PyPy supports a continually growing
+:ref:`extension modules <extension-modules>`.  PyPy supports a continually growing
 number of extension modules, but so far mostly only those found in the
 standard library.
 
 complete and well tested, so if your project does not use many
 extension modules there is a good chance that it will work with PyPy.
 
-We list the differences we know about in `cpython differences`_.
+We list the differences we know about in :doc:`cpython differences <cpython_differences>`.
 
 
 Do CPython Extension modules work with PyPy?
 For information on which third party extensions work (or do not work)
 with PyPy see the `compatibility wiki`_.
 
-.. _extension modules: cpython_differences.html#extension-modules
-.. _cpython differences: cpython_differences.html
 .. _compatibility wiki: https://bitbucket.org/pypy/compatibility/wiki/Home
 .. _cffi: http://cffi.readthedocs.org/
 

pypy/doc/getting-started.rst

 --------------
 
 In common parlance, PyPy has been used to mean two things.  The first is the
-`RPython translation toolchain`_, which is a framework for generating
+:doc:`RPython translation toolchain <rpython:translation>`, which is a framework for generating
 dynamic programming language implementations.  And the second is one
 particular implementation that is so generated --
 an implementation of the Python_ programming language written in
 This double usage has proven to be confusing, and we are trying to move
 away from using the word PyPy to mean both things.  From now on we will
 try to use PyPy to only mean the Python implementation, and say the
-`RPython translation toolchain`_ when we mean the framework.  Some older
+:doc:`RPython translation toolchain <rpython:translation>` when we mean the framework.  Some older
 documents, presentations, papers and videos will still have the old
 usage.  You are hereby warned.
 
 language implementation itself. :doc:`more... <architecture>`
 
 .. _Python: http://docs.python.org/reference/
-.. _RPython translation toolchain: translation.html
-.. _more...: architecture.html
 
 
 Just the facts
 Clone the repository
 ~~~~~~~~~~~~~~~~~~~~
 
-If you prefer to `compile PyPy by yourself`_, or if you want to modify it, you
+If you prefer to :doc:`compile PyPy by yourself <getting-started-python>`, or if you want to modify it, you
 will need to obtain a copy of the sources.  This can be done either by
 `downloading them from the download page`_ or by checking them out from the
 repository using mercurial.  We suggest using mercurial if one wants to access
 
 where XXXXX is the revision id.
 
-.. _compile PyPy by yourself: getting-started-python.html
 .. _our nightly tests: http://buildbot.pypy.org/summary?branch=<trunk>
 
 
 
 You may file `bug reports`_ on our issue tracker which is
 also accessible through the 'issues' top menu of
-the PyPy website.  `Using the development tracker`_ has
+the PyPy website.  :ref:`Using the development tracker <using-development-tracker>` has
 more detailed information on specific features of the tracker.
 
-.. _Using the development tracker: coding-guide.html#using-development-tracker
 .. _bug reports: https://bugs.pypy.org/

pypy/doc/objspace-proxies.rst

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 If you are using the `--objspace-std-withtproxy`_ option
-the `__pypy__`_ module provides the following builtins:
+the :doc:`__pypy__ <__pypy__-module>` module provides the following builtins:
 
 * ``tproxy(type, controller)``: returns a proxy object
   representing the given type and forwarding all operations
   controller for a given object.  For non-proxied objects
   ``None`` is returned.
 
-.. _`__pypy__`:  __pypy__-module.html
 .. _--objspace-std-withtproxy: config/objspace.std.withtproxy.html
 
 

rpython/doc/cli-backend.rst

+.. _gencli:
+
 The CLI backend
 ===============
 

rpython/doc/faq.rst

 that a program will manipulate by doing a static analysis.  It should be
 clear if you are familiar with Python, but if in doubt see [BRETT]_.
 
-If you want a fast Python program, please use the PyPy JIT_ instead.
-
-.. _JIT: jit/index.html
+If you want a fast Python program, please use the PyPy :doc:`JIT <jit/index>` instead.
 
 .. [BRETT] Brett Cannon,
            Localized Type Inference of Atomic Types in Python,
 No.  `Zope's RestrictedPython`_ aims to provide a sandboxed
 execution environment for CPython.   `PyPy's RPython`_ is the implementation
 language for dynamic language interpreters.  However, PyPy also provides
-a robust `sandboxed Python Interpreter`_.
+a robust :doc:`sandboxed Python Interpreter <pypy:sandbox>`.
 
-.. _sandboxed Python Interpreter: sandbox.html
 .. _Zope's RestrictedPython: http://pypi.python.org/pypi/RestrictedPython
 
 
 Which backends are there for the RPython toolchain?
 ---------------------------------------------------
 
-Currently, there are backends for C_, the CLI_, and the JVM_.
+Currently, there are backends for :ref:`C <genc>`, the :ref:`CLI <gencli>`, and the :ref:`JVM <genjvm>`.
 All of these can translate the entire PyPy interpreter.
-To learn more about backends take a look at the `translation document`_.
-
-.. _C: translation.html#the-c-back-end
-.. _CLI: cli-backend.html
-.. _JVM: translation.html#genjvm
-.. _translation document: translation.html
+To learn more about backends take a look at the :doc:`translation document <translation>`.
 
 
 Could we use LLVM?

rpython/doc/getting-started.rst

 Translating the flow graph to CLI or JVM code
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-PyPy also contains a `CLI backend`_ and JVM backend which
+PyPy also contains a :ref:`CLI backend <gencli>` and :ref:`JVM backend <genjvm>` which
 can translate flow graphs into .NET executables or a JVM jar
 file respectively.  Both are able to translate the entire
 interpreter.  You can try out the CLI and JVM backends
    there is a file rxxxx.py that contains the low level functions needed for
    this type.
 
-*  :source:`rpython/rlib` contains the `RPython standard library`_, things that you can
+*  :source:`rpython/rlib` contains the :doc:`RPython standard library <rlib>`, things that you can
    use from rpython.
 
 
 .. _full Python interpreter: http://pypy.readthedocs.org/en/latest/getting-started-python.html
-.. _RPython standard library: rlib.html

rpython/doc/glossary.rst

       Typer.
 
    lltypesystem
-      A `C-like type model <rtyper.html#low-level-types>`__ that contains
+      A :ref:`C-like type model <low-level-types>` that contains
       structs and pointers.  A :term:`backend` that uses this type system is also
       called a low-level backend.  The C backend uses this
       typesystem.
       some operation in terms of the target :term:`type system`.
 
    ootypesystem
-      An `object oriented type model <rtyper.html#object-oriented-types>`__
+      An :ref:`object oriented type model <oo-type>`
       containing classes and instances.  A :term:`backend` that uses this type system
       is also called a high-level backend.  The JVM and CLI backends
       all use this typesystem.

rpython/doc/translation.rst

    which insert explicit exception handling and memory management
    operations.
 
-6. The `C backend`_ (colloquially known as "GenC") produces a number of C
+6. `The C backend`_ (colloquially known as "GenC") produces a number of C
    source files (as noted above, we are ignoring the other backends for
    now).
 
 :config:`translation.gc`.
 
 
-.. _C:
-.. _GenC:
-.. _c backend:
+.. _genc:
 
-The C Back-End
+The C Backend
 --------------
 
 :source:`rpython/translator/c/`
 .. _Master's thesis: http://buildbot.pypy.org/misc/Implementing%20Python%20in%20.NET.pdf
 
 
+.. _genjvm:
+
 GenJVM
 ++++++