support automatic GIL grabbing inside a function by addign 'withGIL' to its signature

Type check after (not before) operation on inplace assignment.

enable attribute access of cdef functions

Check return values before PyErr_Occurred() for coercion nodes.

incref_local_binop option for SAGE

This is so mutating inplace operations can be detected safely.

Better error for ** on integer types.

do not use __builtin_expect with GCC < 2.96

rewrote Python 2.5-ism

fixed typo

fix for property functions

extract FQ module name from distutils

version number 0.9.6.5

avoid argument parsing (via meth_o, meth_noargs) for non-python-object arguments, upgrade version number to 0.9.6.4

compiles and runs SAGE fine

remove pointer warning for generic arguments

meth_o and meth_noargs for module-level functions

previous patch was just for classes

Avoid call to PyArg_ParseTupleAndKeywords for zero- and single-argument functions.

PyObject -> Py_ssize_t now uses __index__ rather than __int__ (even in function signatures)

Correct flags on special methods so one can call their python functions directly.

Docstrings for special methods

version number

Raise error when declaring reserved names.

Fixed some typos reported by Helmut Jarausch

remove gcc dependance for inline, branch prediction

More Pyrex --> Cython conversions.

A few more Pyrex --> Cython changes.

Changing Python. to Cython.

Changing from pyrex/sagex to cython -- snapshot.

Merge in lxml-pyrex enum patch.

Merge in C/API patch from lxml-pyrex.

Added pre-import option, which assumes all undeclared names come from the given module.

Emulates behavior of

from <module> import *

gcc branch prediction
For some reason, it actually makes it slower in some of the most common cases (now commented out). Why? It does help in others.

fix incompatable tmp release between 0.9.5.1a and fast tuple unpacking

latest 0.9.4 changes into 0.9.5 branch

finish merging, fix weakref segfault, all SAGE doctests pass

Jim Kleckner patch to allow trailing commas in function argument lists

sagex_multi_file.patch from Joel Mohler (sane cross-file type cmp)

Fast tuple unpacking

fix inplace operators for 0.9.5.1a

copy ModuleNode changes to new file

initial merge

Pyrex Official version 0.9.5.1a

type narrowing for pxd files

type narrowing for cdef methods

Now if you inherit cdef methods from another class, you may re-declare the
arguments and return variables to be sub-types of the original declared type.
This will be especially convenient for the SAGE arithmetic architecture.
Type-checking is performed if necessary.

fix semantics of cmp() -- should not be a bint

Added warning about infinite loops in for-from-by statement.

One rarely, if ever, wants the [step] argument to be negative.

Compile-time checking for builtin names, cast TypeObjects to PyObject* so c compiler won't complain.

comments, builtin objects

Added for i from ... ['by' step] syntax.

E.g.

for i from 0 <= i < 10 by 2:
    print i

0
2
4
6
8

Old for-from loops remain exactly the same (using the ++ or --). If step is specified, the increment operator will be += step or -= step, depending on the orientation of the inequalities (as before).

NOTE: 'by' is now a keyword

Added a bint c type, which is a c int that coerces to and from python objects via the boolean routines.

The purpose of this type is to free the coder from having to use
bool() when retrieving and returning semantically "boolean" values
(e.g. the result of a compare).

The bint type is a subclass of the int type, and the only difference
is that it uses PyBool_FromLong and PyObject_IsTrue rather than
PyInt_FromLong and PyInt_AsLong. Arithmatic on bints will return ints.

Where it makes sense, several builtin functions have been re-declared
to return bints, as well as comparisons and the boolean operations
or, and, and not.

Cache __builtin__ name lookups so they are performed on module load rather than at every use.

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.

Inline keyword for cdef functions, variable assignment on declaration (+optimization)

"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.

disable builtin functions that conflict with type names
add dummy py_index for cdef arrays so subexprs valid

Fix sizeof for dotted (cimported) types

modify sizeof() operator to return size of extension type struct

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

Conditional expressions

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

fast cdef type indexing into lists/tuples via runtime type checking

- 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

Disable a**b for cdef int's. (Return result was a double.)

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.

fix temp allocation order, remove straggling comment output

FloorDiv operation

Implemented inplace arithmetic

Get rid of this sort of error: "Cannot assign type 'gsl_complex' to 'gsl_complex'"

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

List comprehension

Peter Johnson (peter@tortall.net) weakref patch

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.

Eric Huss's readonly variable patch:

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.

Modified usage banner.

Had to also put the type code in for the signed case.

Made some error output more verbose.

Added support for automatic conversion of input types to Py_ssize_t.

Made annoted C files easier to read.

Fix one warning was too high a level

Made the output generated by Pyrex much more verbose with better context information.

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 (;;) {

Changed that error to a warning.

Fixed an error in a call to the error function.

Fix a Py_ssize_t build problem.

Add a new option "-e" or "--embed-positions" to Pyrex.

  -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.

Change so that warning for multiple declarations are printed by default.

Delete spurious print statement (that was used for debugging).

Add correct setting of tp_name to the full module name in Nodes.py.

  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).

Print out the usage message if pyrexc is called with no options and no input source files.

Don't list experimental macosx only options.  Never needed in context of SAGE.

Add to help that multiple include directories are allowed.

Added nice error messages with context information.

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

Print "warning: " before warnings, so they look different than errors.

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.

Version of Pyrex distributed with SAGE on October 19, 2006

Official Pyrex version 0.9.4.1