Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Commits on Aug 11, 2013
  1. Add Mapping Protocol

  2. Add Sequence Protocol

Commits on Aug 10, 2013
  1. Add missing decref

  2. Add a few more String methods

  3. Add Unicode type

    The Unicode type represents the Python unicode type, this is actually
    quite an involved type, as it deals with encodings.  Haven't quite
    figured out how to map the underlying Py_UNICODE to Go yet - so those
    parts are not implemented yet.
  4. Add a bunch more methods

    These are essentially at random, from browsing through the API
    documentation ...
Commits on Jul 7, 2013
  1. Update documentation to mention ext branch

    The ext branch has been around for a while.  It would make sense to
    mention it, rather than keeping the flat statement that extensions are
    not possible.
  2. Make exported functions private again

    I really don't remember why I made all the exported functions public.
    There is no need to call these from Go - only from Python, and
    exporting allows that whilst keeping the functions private.
  3. Be more consistent in naming.

    All the other ...Check functions only change the case of the first
    letter.  This one changes the first two.  Well, now it only changes
    the first ...
  4. Fix typo

Commits on Jul 6, 2013
  1. Fix import

  2. @quarnster

    Added SetInterrupt + test

    quarnster authored committed
  3. Remove log from test

    Didn't really add anything useful ...
  4. @quarnster

    Fixed method calling

    quarnster authored committed
    Only the test changes are now relevant ...
  5. Remove Finalize from the tests

    Running Finalize in the tests means that sometimes the Initialize
    takes forever ... so let's not do that.
  6. Fix lock.go to compile with Go 1.0

    Refactor the code to be easier to read whilst we're at it.
    Also fix a typo in a comment.
  7. @adzenith

    Fixes for "function declaration isn't a prototype"

    adzenith authored committed
  8. Add Finalize

  9. Fix import path

  10. @quarnster

    Count how many times the goroutine has been locked to the os thread.

    quarnster authored committed
    Otherwise we prematurely release the goroutine from the os thread
    resulting in a crash, as the GIL locking mechanisms allow reentrance.
  11. @quarnster
  12. @quarnster

    Unit testing wip

    quarnster authored committed
  13. Make sure that the runtime knows about indirections

    We want to keep these indirections, which means that the Go runtime
    needs to know that we are holding references to them.  It won't look
    at the contexts structs, because they are C types and so opaque to the
    runtime - so we need to store them separately in a way the runtime
    will see them.
  14. go fmt

  15. Hopefully cope with Go 1.0 and Go 1.1

    Go 1.1 has changed the way that functions work - basically, we have to
    point at a pointer to the actual code.  Since we don't really want to
    maintain different versions of the code for 1.0 & 1.1 - we use runtime
    detection to figure out whether the indirection is needed.
Commits on Jun 4, 2012
  1. Don't lock memLock twice

    Since goGcMalloc already locks memLock, we should call the _goMalloc
    helper function.  We were calling goMalloc before, which would
    immediately try to lock memLock again.
  2. Change some locks to RWMutex

    Some of the locks recently introduced make more sense as RWMutex than
    as Mutex.  They are all protecting state that is likely to be accessed
    a lot more than it is modified.  There is no need to serialise
    accesses, only to make sure that there is no access in parallel with a
    modify - which is exactly the protection a RWMutex gives us.
Commits on Jun 2, 2012
  1. Add lock to gomod.go

    Protect goModule from multiple simultaneous initialisations.
  2. Add lock to object.go

    object.go is another place that global state is maintained, and needs
    to be protected.
  3. Add lock to cfunction.go

    cfunction.go is one of the places that we maintain some global state,
    so we need to add a lock to protect from concurrent modification.
  4. Simplify code a bit

    Both module.go and cfunction.go had code for creating a Python
    CFunction from a go function.  Refactor so they share an
  5. Start locking global state

    There are some global variables that are used to maintain global
    state.  These variables need to be protected if we are going to be
    accessing them from multiple goroutines (which we may well be).
    Not all of the variables are locked by this change.  Hopefully those
    that aren't have at least got a TODO now though ...
Something went wrong with that request. Please try again.