Commits

Maciej Fijalkowski  committed d526611

update docs to mention new dir layout

  • Participants
  • Parent commits 7182610

Comments (0)

Files changed (7)

File pypy/doc/arm.rst

 
 ::
 
-  pypy ~/path_to_pypy_checkout/pypy/translator/goal/translate.py -O1 --platform=arm target.py
+  pypy ~/path_to_pypy_checkout/rpython/translator/goal/translate.py -O1 --platform=arm target.py
 
 If everything worked correctly this should yield an ARM binary. Running this binary in the ARM chroot or on an ARM device should produce the output ``"Hello World"``.
 

File pypy/doc/cppyy.rst

     $ hg clone https://bitbucket.org/pypy/pypy
     $ cd pypy
     $ hg up reflex-support         # optional
-    $ cd pypy/translator/goal
+    $ cd pypy/goal
     
     # This example shows python, but using pypy-c is faster and uses less memory
-    $ python translate.py -O jit --gcrootfinder=shadowstack targetpypystandalone.py --withmod-cppyy
+    $ python ../../rpython/bin/rpython.py -O jit --gcrootfinder=shadowstack targetpypystandalone.py --withmod-cppyy
 
 This will build a ``pypy-c`` that includes the cppyy module, and through that,
 Reflex support.

File pypy/doc/ctypes-implementation.rst

 The pypy-c translated to run the ctypes tests can be used to run the pyglet examples as well. They can be run like e.g.::
 
     $ cd pyglet/
-    $ PYTHONPATH=. ../ctypes-stable/pypy/translator/goal/pypy-c examples/opengl.py
+    $ PYTHONPATH=. ../ctypes-stable/pypy/goal/pypy-c examples/opengl.py
 
 
 they usually should be terminated with ctrl-c. Refer to the their doc strings for details about how they should behave.

File pypy/doc/getting-started-dev.rst

     python bin/translatorshell.py
 
 Test snippets of translatable code are provided in the file
-``pypy/translator/test/snippet.py``, which is imported under the name
+``rpython/translator/test/snippet.py``, which is imported under the name
 ``snippet``.  For example::
 
     >>> t = Translation(snippet.is_perfect_number, [int])
 The graph can be turned into C code::
 
    >>> t.rtype()
-   >>> f = t.compile_c()
+   >>> lib = t.compile_c()
 
 The first command replaces the operations with other low level versions that
-only use low level types that are available in C (e.g. int). To try out the
-compiled version::
+only use low level types that are available in C (e.g. int). The compiled
+version is now in a ``.so`` library. You can run it say using ctypes:
 
+   >>> from ctypes import CDLL
+   >>> f = CDLL(lib)
    >>> f(5)
-   False
+   0
    >>> f(6)
-   True
+   1
 
 Translating the flow graph to CLI or JVM code
 +++++++++++++++++++++++++++++++++++++++++++++
 There is a small-to-medium demo showing the translator and the annotator::
 
     cd demo
-    ../pypy/translator/goal/translate.py --view --annotate bpnn.py
+    ../rpython/translator/goal/translate.py --view --annotate bpnn.py
 
 This causes ``bpnn.py`` to display itself as a call graph and class
 hierarchy.  Clicking on functions shows the flow graph of the particular
 To turn this example to C code (compiled to the executable ``bpnn-c``),
 type simply::
 
-    ../pypy/translator/goal/translate.py bpnn.py
+    ../rpython/translator/goal/translate.py bpnn.py
 
 
 Translating Full Programs
 +++++++++++++++++++++++++
 
 To translate full RPython programs, there is the script ``translate.py`` in
-``translator/goal``. Examples for this are a slightly changed version of
+``rpython/translator/goal``. Examples for this are a slightly changed version of
 Pystone::
 
-    cd pypy/translator/goal
+    cd rpython/translator/goal
     python translate.py targetrpystonedalone
 
 This will produce the executable "targetrpystonedalone-c".

File pypy/doc/index.rst

 ================================   =========================================== 
 Directory                          explanation/links
 ================================   =========================================== 
-`pypy/annotation/`_                `type inferencing code`_ for `RPython`_ programs 
 
-`pypy/bin/`_                       command-line scripts, mainly `py.py`_ and `translatorshell.py`_
+`pypy/bin/`_                       command-line scripts, mainly `pyinteractive.py`_
 
 `pypy/config/`_                    handles the numerous options for building and running PyPy
 
 
 `pypy/objspace/`_                  `object space`_ implementations
 
-`pypy/objspace/flow/`_             the FlowObjSpace_ implementing `abstract interpretation`_
-
 `pypy/objspace/std/`_              the StdObjSpace_ implementing CPython's objects and types
 
-`pypy/rlib/`_                      a `"standard library"`_ for RPython_ programs
-
-`pypy/rpython/`_                   the `RPython Typer`_ 
-
-`pypy/rpython/lltypesystem/`_      the `low-level type system`_ for C-like backends
-
-`pypy/rpython/ootypesystem/`_      the `object-oriented type system`_ for OO backends
-
-`pypy/rpython/memory/`_            the `garbage collector`_ construction framework
-
 `pypy/tool/`_                      various utilities and hacks used from various places 
 
 `pypy/tool/algo/`_                 general-purpose algorithmic and mathematic
 
 `pypy/tool/pytest/`_               support code for our `testing methods`_
 
-`pypy/translator/`_                translation_ backends and support code
 
-`pypy/translator/backendopt/`_     general optimizations that run before a backend generates code
+`rpython/annotator/`_              `type inferencing code`_ for `RPython`_ programs 
 
-`pypy/translator/c/`_              the `GenC backend`_, producing C code from an
+`rpython/config/`_                 handles the numerous options for RPython
+
+
+`rpython/flowspace/`_              the FlowObjSpace_ implementing `abstract interpretation`_
+
+
+`rpython/rlib/`_                   a `"standard library"`_ for RPython_ programs
+
+`rpython/rtyper/`_                 the `RPython Typer`_ 
+
+`rpython/rtyper/lltypesystem/`_    the `low-level type system`_ for C-like backends
+
+`rpython/rtyper/ootypesystem/`_    the `object-oriented type system`_ for OO backends
+
+`rpython/rtyper/memory/`_          the `garbage collector`_ construction framework
+
+`rpython/translator/`_             translation_ backends and support code
+
+`rpython/translator/backendopt/`_  general optimizations that run before a backend generates code
+
+`rpython/translator/c/`_           the `GenC backend`_, producing C code from an
                                    RPython program (generally via the rtyper_)
 
-`pypy/translator/cli/`_            the `CLI backend`_ for `.NET`_ (Microsoft CLR or Mono_)
+`rpython/translator/cli/`_         the `CLI backend`_ for `.NET`_ (Microsoft CLR or Mono_)
 
-`pypy/translator/goal/`_           our `main PyPy-translation scripts`_ live here
+`pypy/goal/`_                      our `main PyPy-translation scripts`_ live here
 
-`pypy/translator/jvm/`_            the Java backend
+`rpython/translator/jvm/`_         the Java backend
 
-`pypy/translator/tool/`_           helper tools for translation, including the Pygame
+`rpython/translator/tool/`_        helper tools for translation, including the Pygame
                                    `graph viewer`_
 
 ``*/test/``                        many directories have a test subdirectory containing test 

File pypy/doc/sandbox.rst

 -----
 
 
-In pypy/translator/goal::
+In pypy/goal::
 
-   ./translate.py -O2 --sandbox targetpypystandalone.py
+   ../../rpython/bin/rpython -O2 --sandbox targetpypystandalone.py
 
 If you don't have a regular PyPy installed, you should, because it's
 faster to translate, but you can also run ``python translate.py`` instead.
 
 
-To run it, use the tools in the pypy/translator/sandbox directory::
+To run it, use the tools in the pypy/sandbox directory::
 
    ./pypy_interact.py /some/path/pypy-c-sandbox [args...]
 

File pypy/doc/whatsnew-head.rst

 .. branch: inline-virtualref-2
 Better optimized certain types of frame accesses in the JIT, particularly
 around exceptions that escape the function they were raised in.
+
+.. branch: missing-ndarray-attributes
+Some missing attributes from ndarrays