The code "__Pyx_GetName(__pyx_b, __pyx_n_[string])" is performed in several
thousand places throughout the sage library, and can be quite expensive
(a dictionary lookup, possibly raising an error, etc.) This is redundant
as the result will always be the same. I perform the lookup once
(on loading the module), then have a pointer to the result for all subsequent use.

The most common examples are bool/str/int (both as function calls and
in isinstance), True/False, and raisign errors.

A side feature is that on loading a module with an illegal __builtin__ name,
it will complain at load time rather than at run time.

"cdef inline foo()" now valid, and will place inline in the resulting c code

"cdef o = expr" and "cdef type x = expr" now valid.
This may not seem like a huge change, but it ended up requiring
quite a bit of work. The variables are still all declared at the
top, but the assignment takes place at the specified line in the
code.

If an assignment is made at declaration, the variable is initalized to
0 rather than None (also skipping an INCREF) and Py_XDECREF is used on
exiting the function (in case an error occured before the actual value
was calculated). Hence these variables MUST NOT be used before they are
defined or it will probably segfault.

add dummy py_index for cdef arrays so subexprs valid

Figured out how to use the Python/C API for some builtin functions (such as len) to avoid python calling conventions.

Changes in grammar required change for this, see http://www.python.org/dev/peps/pep-0308/
Most noteably for list comprehensions (dissambiguate the if)

- 5 times as fast for L[i], list/tuple L, cdef integer type i, 0 <= i < len(L)
- no change for L[a], python object a
- 1-1.5% slowdown for L[i], i negative or out of range

De-allocate function temp variables _after_ computing return value, in case an exception is thrown, caught, and said temp variables still need to be accessed.

The solution in this patch is somewhat hackish, but should be OK.

I recently ran into this problem myself (as the current code causes
Python to crash), so I whipped up a quick patch that fixes it for me.
I think it follows all of the weakref guidelines now.

The patch is against the LXML svn pyrex
(http://codespeak.net/svn/lxml/pyrex/).  Is there a different SVN I
should be pointing to?  It patches functions generate_new_function,
generate_dealloc_function, generate_traverse_function, and
generate_clear_function.

The patch just compares the entry.name against "__weakref__"; this
could probably be centralized in the Entry object if so desired.

Apply Nick Alexander's patch so that Sagex that embeds positions in module, cdef class, and def class docstrings.

There's a minor bug, if you try to cdef a readonly variable at the module
scope, the compiler raises an UnboundLocalError exception.  The attached
patch seems to clear up the problem and gets the compiler to report the
correct error.

For example:

  /* "/Volumes/HOME/s/devel/sage-1/sage/matrix/matrix_generic_sparse.pyx":581
    x = set(v.keys()).intersection(set(w.keys()))
    a = 0
    for k in x:             # <<<<<<<<<<<<<<
        a = a + v[k]*w[k]
    return a
 */
  __pyx_3 = PyObject_GetIter(__pyx_v_x); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 581; goto __pyx_L1;}
  for (;;) {

  -p, --embed-positions          If specified, the positions in Pyrex files of each
                                 function definition is embedded in its docstring.

This is very useful to support interactive viewing of *Pyrex* source
code in, e.g, IPython.

  This required a number of changes to a few files.  Basically, the
  full module name is determined in Main.py. It is then passed around
  a bit until it is used when generating tp_name.

  This change was needed because otherwise pickling of extension classes
  with full module names like sage.rings.integer.Integer would fail
  (since Python would look for integer.Integer instead).  NOTE: This is
  pickling of the extension class itself, not of instances (which could
  also fail, because the class doesn't pickle).

Finally, you can see the line itself where the error occured,
instead of just the line number!!

Added a "Warning" class, and changed it so redeclaring or re-importing is a warning rather than an error.

    Because Pyrex has no #ifndef macro, it is impossibly painful to use
    pxi files for declarations in a large project.  SAGE is a large project.
    Also, in Python it is not an error to import a module twice.  Thus
    more in line with Python's behavior, multiple declarations of the same
    symbol is no longer an error.