From 8ae84a553b7fca03d708bb1ccbf2b0ecc473a9ee Mon Sep 17 00:00:00 2001 From: "ggellner@basestar" Date: Sat, 3 May 2008 13:24:10 -0400 Subject: [PATCH] Applied patches to fix typos. Also added an hgignore, and the .static files needed to generate output. --- .hgignore | 8 +++++++ docs/extension_types.rst | 42 ++++++++++++++++++----------------- docs/external_C_code.rst | 10 ++++----- docs/language_basics.rst | 4 ++-- docs/pyrex_differences.rst | 8 +++---- docs/sharing_declarations.rst | 28 +++++++++++++++-------- 6 files changed, 59 insertions(+), 41 deletions(-) create mode 100644 .hgignore diff --git a/.hgignore b/.hgignore new file mode 100644 index 00000000..51e174eb --- /dev/null +++ b/.hgignore @@ -0,0 +1,8 @@ +syntax: glob + +*.pyc +*~ +.*.swp + +syntax: regexp +^build/ diff --git a/docs/extension_types.rst b/docs/extension_types.rst index 55afae4d..2be5f895 100644 --- a/docs/extension_types.rst +++ b/docs/extension_types.rst @@ -209,25 +209,26 @@ Here's a complete example. It defines a property which adds to a list each time it is written to, returns the list when it is read, and empties the list when it is deleted.:: - #cheesy.pyx Test input + # cheesy.pyx cdef class CheeseShop: - cdef object cheeses + cdef object cheeses - def __cinit__(self): - self.cheeses = [] + def __cinit__(self): + self.cheeses = [] - property cheese: + property cheese: - def __get__(self): - return "We don't have: %s" % self.cheeses + def __get__(self): + return "We don't have: %s" % self.cheeses - def __set__(self, value): - self.cheeses.append(value) + def __set__(self, value): + self.cheeses.append(value) - def __del__(self): - del self.cheeses[:] + def __del__(self): + del self.cheeses[:] + # Test input from cheesy import CheeseShop shop = CheeseShop() @@ -242,7 +243,7 @@ when it is deleted.:: del shop.cheese print shop.cheese - #Test output + # Test output We don't have: [] We don't have: ['camembert'] We don't have: ['camembert', 'cheddar'] @@ -280,18 +281,17 @@ functions, C methods are declared using :keyword:`cdef` instead of :keyword:`def`. C methods are "virtual", and may be overridden in derived extension types.:: - pets.pyx - Output + # pets.pyx cdef class Parrot: - cdef void describe(self): - print "This parrot is resting." + cdef void describe(self): + print "This parrot is resting." cdef class Norwegian(Parrot): - cdef void describe(self): - Parrot.describe(self) - print "Lovely plumage!" + cdef void describe(self): + Parrot.describe(self) + print "Lovely plumage!" cdef Parrot p1, p2 @@ -301,7 +301,9 @@ extension types.:: p1.describe() print "p2:" p2.describe() - p1: + + # Output + p1: This parrot is resting. p2: This parrot is resting. diff --git a/docs/external_C_code.rst b/docs/external_C_code.rst index 3e1a5c59..f4dc7334 100644 --- a/docs/external_C_code.rst +++ b/docs/external_C_code.rst @@ -293,18 +293,16 @@ can then be called and the extension types used as usual. Any public C type or extension type declarations in the Cython module are also made available when you include :file:`modulename_api.h`.:: - delorean.pyx - - marty.c - + # delorean.pyx cdef public struct Vehicle: - int speed - float power + int speed + float power cdef api void activate(Vehicle *v): if v.speed >= 88 and v.power >= 1.21: print "Time travel achieved" + # marty.c #include "delorean_api.h" Vehicle car; diff --git a/docs/language_basics.rst b/docs/language_basics.rst index 249b0a4b..d77cc999 100644 --- a/docs/language_basics.rst +++ b/docs/language_basics.rst @@ -327,7 +327,7 @@ body, and the loop may have an else clause. Error return values ------------------- -If you don't do anything special, a function declared with :keyword`cdef` that +If you don't do anything special, a function declared with :keyword:`cdef` that does not return a Python object has no way of reporting Python exceptions to its caller. If an exception is detected in such a function, a warning message is printed and the exception is ignored. @@ -520,7 +520,7 @@ Such expressions are made up of literal values and names defined using ``DEF`` statements, combined using any of the Python expression syntax. The following compile-time names are predefined, corresponding to the values -returned by :func:``os.uname``. +returned by :func:`os.uname`. UNAME_SYSNAME, UNAME_NODENAME, UNAME_RELEASE, UNAME_VERSION, UNAME_MACHINE diff --git a/docs/pyrex_differences.rst b/docs/pyrex_differences.rst index 24d0fe1f..decd761d 100644 --- a/docs/pyrex_differences.rst +++ b/docs/pyrex_differences.rst @@ -108,7 +108,7 @@ python. One can declare variables and return values for functions to be of the :ctype:`bint` type. For example:: cdef int i = x - Cdef bint b = x + cdef bint b = x The first conversion would happen via ``x.__int__()`` whereas the second would happen via ``x.__nonzero__()``. (Actually, if ``x`` is the python object @@ -156,7 +156,7 @@ method on the class directly, e.g.:: cdef class A: cpdef foo(self): - pass + pass x = A() x.foo() # will check to see if overridden @@ -197,10 +197,10 @@ In Cython ``x`` will try and do a coercion (as would happen on assignment It does not stop one from casting where there is no conversion (though it will emit a warning). If one really wants the address, cast to a ``void *`` first. -As in Pyrex ``x`` will cast ``x`` to type `MyExtensionType` without any +As in Pyrex ``x`` will cast ``x`` to type :ctype:`MyExtensionType` without any type checking. Cython supports the syntax ```` to do the cast with type checking (i.e. it will throw an error if ``x`` is not a (subclass of) -`MyExtensionType`. +:ctype:`MyExtensionType`. Optional arguments in cdef/cpdef functions ------------------------------------------ diff --git a/docs/sharing_declarations.rst b/docs/sharing_declarations.rst index a9fdc5de..61e08ee1 100644 --- a/docs/sharing_declarations.rst +++ b/docs/sharing_declarations.rst @@ -16,7 +16,12 @@ suffix, containing C declarations that are to be available to other Cython modules, and an implementation file with a ``.pyx`` suffix, containing everything else. When a module wants to use something declared in another module's definition file, it imports it using the :keyword:`cimport` -statement. What a Definition File contains A definition file can contain: +statement. + +What a Definition File contains +------------------------------- + +A definition file can contain: * Any kind of C type declaration. * extern C function or variable declarations. @@ -77,9 +82,9 @@ uses it. d.filler = dishes.sausage def serve(): - spamdish d + cdef spamdish d prepare(&d) - print "%d oz spam, filler no. %d" % (d->oz_of_spam, d->otherstuff) + print "%d oz spam, filler no. %d" % (d.oz_of_spam, d.otherstuff) It is important to understand that the :keyword:`cimport` statement can only be used to import C data types, C functions and variables, and extension @@ -139,12 +144,12 @@ C functions defined at the top level of a module can be made available via :keyword:`cimport` by putting headers for them in the ``.pxd`` file, for example,: -:file:`volume.pxd`: - -:file:`spammery.pyx`:: +:file:`volume.pxd`:: cdef float cube(float) +:file:`spammery.pyx`:: + from volume cimport cube def menu(description, size): @@ -185,17 +190,22 @@ Python methods. Here is an example of a module which defines and exports an extension type, and another module which uses it.:: - Shrubbing.pxd Shrubbing.pyx + # Shrubbing.pxd cdef class Shrubbery: cdef int width - cdef int length cdef class Shrubbery: + cdef int length + + # Shrubbing.pyx + cdef class Shrubbery: def __new__(self, int w, int l): self.width = w self.length = l def standard_shrubbery(): return Shrubbery(3, 7) - Landscaping.pyx + + + # Landscaping.pyx cimport Shrubbing import Shrubbing -- 2.26.2