Skip to content

HTTPS clone URL

Subversion checkout URL

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

    authored
  2. Add Sequence Protocol

    authored
Commits on Aug 10, 2013
  1. Add missing decref

    authored
  2. Add a few more String methods

    authored
  3. Add Unicode type

    authored
    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

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

    authored
    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

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

    authored
    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

    authored
Commits on Jul 6, 2013
  1. Fix import

    authored
  2. @quarnster

    Added SetInterrupt + test

    quarnster authored committed
  3. Remove log from test

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

    Fixed method calling

    quarnster authored committed
    Conflicts:
    	lib/class.go
    
    Only the test changes are now relevant ...
  5. Remove Finalize from the tests

    authored
    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

    authored
    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

    authored
  9. Fix import path

    authored
  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

    authored
    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

    authored
  15. Hopefully cope with Go 1.0 and Go 1.1

    authored
    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

    authored
    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

    authored
    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

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

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

    authored
    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

    authored
    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

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