[pypy-dev] planning the 0.6.2 PyPy release

Armin Rigo arigo at tunes.org
Fri Jun 10 12:54:19 CEST 2005


Here is our status.  The translation is progressing, a lot remains to be
done.  At this point, given the immediate goals, we can say that:

* The low-level types' model is supposedly stable, but actually still
  undergoes small changes.  For example, we added arrays of primitive
  types, because it makes the ll_ functions saner (e.g. we can implement
  strings as arrays of characters instead of arrays of structures that
  each contain a single character).  We plan another update soon: the
  possibility to attach custom deallocators to GcStructs.  And maybe --
  possibly -- later it would be convenient to have arrays of fixed size
  (e.g. arrays of 4 integers).

* The 'translator/c/' code is mostly finished.  It accepts all the
  low-level types and operations and produces rather inefficient C code
  out of it, but that's fine for the time being.

* The focus is on the rtyper (pypy/rpython/r*.py).  A low-level flow
  graph interpreter would be very useful for debugging at this point,
  and it is the kind of thing that neither Samuele nor myself should do
  because it is a good and easy introduction to lltypes.  So let me push
  this forward again.

  We're working on framework things like being able to call ll_
  functions from other ll_ functions.  For the status of what's there
  and missing, try running the test file
  pypy/translator/genc/test/inprogress_test_typed.py shows some
  limitations of the rtyper that we are working on.  In general, we

  - int, float, bool (thanks Eric)
  - the basics of lists including slices, ranges, iterators
  - tuples
  - the basics of strings and characters
  - very few built-in functions
  - a good enough class and instance model
  - very preliminary support for function pointers

  We need everything else that the annotator supports, e.g.:

  - (easy) unicode characters
  - (hard) prebuilt constants -- PBCs -- and dicts with PBC keys
  - (medium) dicts with string keys, and iterators over them
  - (easy) iterators over strings
  - (medium) iterators over tuples
  - (varying) all built-in functions listed in annotation/builtin.py
  - (mostly easy) a few more operations: id, issubtype, str(?), is
  - (easy) add_ovf --> int_add_ovf
  - (easy) list methods reverse, pop, insert, index(?)
  - (easy) tuple concatenation
  - (easy) string methods startswith(1-arg), endswith(1-arg),
           join (possibly only on the empty string ''), string slices
  - (easy) equality and non-equality are generally missing
  - (medium) limited form of string formatting: 'constant template' only
             which should only generate a sequence of simple operations
             like concatenation and str() on integers

A bientot,


More information about the Pypy-dev mailing list