Permalink
Commits on Aug 11, 2013
  1. Add Mapping Protocol

    qur committed Aug 11, 2013
  2. Add Sequence Protocol

    qur committed Aug 11, 2013
Commits on Aug 10, 2013
  1. Add missing decref

    qur committed Aug 10, 2013
  2. Add a few more String methods

    qur committed Aug 10, 2013
  3. Add Unicode type

    qur committed Aug 10, 2013
    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

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

    qur committed Jul 7, 2013
    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

    qur committed Jul 7, 2013
    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.

    qur committed Jul 7, 2013
    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

    qur committed Jul 7, 2013
Commits on Jul 6, 2013
  1. Fix import

    qur committed Jul 6, 2013
  2. Added SetInterrupt + test

    quarnster committed with qur Apr 10, 2013
  3. Remove log from test

    qur committed Jul 6, 2013
    Didn't really add anything useful ...
  4. Fixed method calling

    quarnster committed with qur Mar 31, 2013
    Conflicts:
    	lib/class.go
    
    Only the test changes are now relevant ...
  5. Remove Finalize from the tests

    qur committed Jul 6, 2013
    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

    qur committed Jul 6, 2013
    Refactor the code to be easier to read whilst we're at it.
    
    Also fix a typo in a comment.
  7. Add Finalize

    qur committed Jul 6, 2013
  8. Fix import path

    qur committed Jul 6, 2013
  9. Count how many times the goroutine has been locked to the os thread.

    quarnster committed with qur Apr 17, 2013
    Otherwise we prematurely release the goroutine from the os thread
    resulting in a crash, as the GIL locking mechanisms allow reentrance.
  10. Unit testing wip

    quarnster committed with qur Mar 31, 2013
  11. Make sure that the runtime knows about indirections

    qur committed Jul 6, 2013
    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.
  12. go fmt

    qur committed Jul 6, 2013
  13. Hopefully cope with Go 1.0 and Go 1.1

    qur committed Jul 6, 2013
    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

    qur committed Jun 4, 2012
    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

    qur committed Jun 4, 2012
    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

    qur committed Jun 2, 2012
    Protect goModule from multiple simultaneous initialisations.
  2. Add lock to object.go

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

    qur committed Jun 2, 2012
    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

    qur committed Jun 2, 2012
    Both module.go and cfunction.go had code for creating a Python
    CFunction from a go function.  Refactor so they share an
    implementation.
  5. Start locking global state

    qur committed Jun 2, 2012
    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 ...