Adjust to Go tip changes

carlosmn · carlosmn · commit a06f4a030a90 · 2014-04-01T12:36:44.000+02:00
It does not like breaking aliasing rules, so let's keep a casted pointer
for when libgit2 wants that.
diff --git a/blob.go b/blob.go
@@ -20,15 +20,16 @@ import (
 
 type Blob struct {
 	gitObject
+	cast_ptr *C.git_blob
 }
 
 func (v *Blob) Size() int64 {
-	return int64(C.git_blob_rawsize(v.ptr))
+	return int64(C.git_blob_rawsize(v.cast_ptr))
 }
 
 func (v *Blob) Contents() []byte {
-	size := C.int(C.git_blob_rawsize(v.ptr))
-	buffer := unsafe.Pointer(C.git_blob_rawcontent(v.ptr))
+	size := C.int(C.git_blob_rawsize(v.cast_ptr))
+	buffer := unsafe.Pointer(C.git_blob_rawcontent(v.cast_ptr))
 	return C.GoBytes(buffer, size)
 }
 
diff --git a/branch.go b/branch.go
@@ -43,7 +43,7 @@ func (repo *Repository) CreateBranch(branchName string, target *Commit, force bo
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.ptr, cForce, cSignature, cmsg)
+	ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.cast_ptr, cForce, cSignature, cmsg)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
diff --git a/commit.go b/commit.go
@@ -17,56 +17,57 @@ import (
 // Commit
 type Commit struct {
 	gitObject
+	cast_ptr *C.git_commit
 }
 
 func (c Commit) Message() string {
-	return C.GoString(C.git_commit_message(c.ptr))
+	return C.GoString(C.git_commit_message(c.cast_ptr))
 }
 
 func (c Commit) Tree() (*Tree, error) {
-	var ptr *C.git_object
+	var ptr *C.git_tree
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	err := C.git_commit_tree(&ptr, c.ptr)
+	err := C.git_commit_tree(&ptr, c.cast_ptr)
 	if err < 0 {
 		return nil, MakeGitError(err)
 	}
 
-	return allocObject(ptr).(*Tree), nil
+	return allocObject((*C.git_object)(ptr)).(*Tree), nil
 }
 
 func (c Commit) TreeId() *Oid {
-	return newOidFromC(C.git_commit_tree_id(c.ptr))
+	return newOidFromC(C.git_commit_tree_id(c.cast_ptr))
 }
 
 func (c Commit) Author() *Signature {
-	ptr := C.git_commit_author(c.ptr)
-	return newSignatureFromC(ptr)
+	cast_ptr := C.git_commit_author(c.cast_ptr)
+	return newSignatureFromC(cast_ptr)
 }
 
 func (c Commit) Committer() *Signature {
-	ptr := C.git_commit_committer(c.ptr)
-	return newSignatureFromC(ptr)
+	cast_ptr := C.git_commit_committer(c.cast_ptr)
+	return newSignatureFromC(cast_ptr)
 }
 
 func (c *Commit) Parent(n uint) *Commit {
-	var cobj *C.git_object
-	ret := C.git_commit_parent(&cobj, c.ptr, C.uint(n))
+	var cobj *C.git_commit
+	ret := C.git_commit_parent(&cobj, c.cast_ptr, C.uint(n))
 	if ret != 0 {
 		return nil
 	}
 
-	return allocObject(cobj).(*Commit)
+	return allocObject((*C.git_object)(cobj)).(*Commit)
 }
 
 func (c *Commit) ParentId(n uint) *Oid {
-	return newOidFromC(C.git_commit_parent_id(c.ptr, C.uint(n)))
+	return newOidFromC(C.git_commit_parent_id(c.cast_ptr, C.uint(n)))
 }
 
 func (c *Commit) ParentCount() uint {
-	return uint(C.git_commit_parentcount(c.ptr))
+	return uint(C.git_commit_parentcount(c.cast_ptr))
 }
 
 // Signature
diff --git a/object.go b/object.go
@@ -48,7 +48,7 @@ func (t ObjectType) String() (string) {
 }
 
 func (o gitObject) Id() *Oid {
-	return newOidFromC(C.git_commit_id(o.ptr))
+	return newOidFromC(C.git_object_id(o.ptr))
 }
 
 func (o gitObject) Type() ObjectType {
@@ -57,24 +57,33 @@ func (o gitObject) Type() ObjectType {
 
 func (o *gitObject) Free() {
 	runtime.SetFinalizer(o, nil)
-	C.git_commit_free(o.ptr)
+	C.git_object_free(o.ptr)
 }
 
 func allocObject(cobj *C.git_object) Object {
 
 	switch ObjectType(C.git_object_type(cobj)) {
 	case ObjectCommit:
-		commit := &Commit{gitObject{cobj}}
+		commit := &Commit{
+			gitObject: gitObject{cobj},
+			cast_ptr:  (*C.git_commit)(cobj),
+		}
 		runtime.SetFinalizer(commit, (*Commit).Free)
 		return commit
 
 	case ObjectTree:
-		tree := &Tree{gitObject{cobj}}
+		tree := &Tree{
+			gitObject: gitObject{cobj},
+			cast_ptr:  (*C.git_tree)(cobj),
+		}
 		runtime.SetFinalizer(tree, (*Tree).Free)
 		return tree
 
 	case ObjectBlob:
-		blob := &Blob{gitObject{cobj}}
+		blob := &Blob{
+			gitObject: gitObject{cobj},
+			cast_ptr:  (*C.git_blob)(cobj),
+		}
 		runtime.SetFinalizer(blob, (*Blob).Free)
 		return blob
 	}
diff --git a/repository.go b/repository.go
@@ -239,7 +239,7 @@ func (v *Repository) CreateCommit(
 	if nparents > 0 {
 		cparents = make([]*C.git_commit, nparents)
 		for i, v := range parents {
-			cparents[i] = v.ptr
+			cparents[i] = v.cast_ptr
 		}
 		parentsarg = &cparents[0]
 	}
@@ -256,7 +256,7 @@ func (v *Repository) CreateCommit(
 	ret := C.git_commit_create(
 		oid.toC(), v.ptr, cref,
 		authorSig, committerSig,
-		nil, cmsg, tree.ptr, C.size_t(nparents), parentsarg)
+		nil, cmsg, tree.cast_ptr, C.size_t(nparents), parentsarg)
 
 	if ret < 0 {
 		return nil, MakeGitError(ret)
@@ -331,7 +331,7 @@ func (v *Repository) TreeBuilderFromTree(tree *Tree) (*TreeBuilder, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	if ret := C.git_treebuilder_create(&bld.ptr, tree.ptr); ret < 0 {
+	if ret := C.git_treebuilder_create(&bld.ptr, tree.cast_ptr); ret < 0 {
 		return nil, MakeGitError(ret)
 	}
 	runtime.SetFinalizer(bld, (*TreeBuilder).Free)
diff --git a/tree.go b/tree.go
@@ -26,6 +26,7 @@ const (
 
 type Tree struct {
 	gitObject
+	cast_ptr *C.git_tree
 }
 
 type TreeEntry struct {
@@ -48,7 +49,7 @@ func (t Tree) EntryByName(filename string) *TreeEntry {
 	cname := C.CString(filename)
 	defer C.free(unsafe.Pointer(cname))
 
-	entry := C.git_tree_entry_byname(t.ptr, cname)
+	entry := C.git_tree_entry_byname(t.cast_ptr, cname)
 	if entry == nil {
 		return nil
 	}
@@ -66,7 +67,7 @@ func (t Tree) EntryByPath(path string) (*TreeEntry, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	ret := C.git_tree_entry_bypath(&entry, t.ptr, cpath)
+	ret := C.git_tree_entry_bypath(&entry, t.cast_ptr, cpath)
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -75,7 +76,7 @@ func (t Tree) EntryByPath(path string) (*TreeEntry, error) {
 }
 
 func (t Tree) EntryByIndex(index uint64) *TreeEntry {
-	entry := C.git_tree_entry_byindex(t.ptr, C.size_t(index))
+	entry := C.git_tree_entry_byindex(t.cast_ptr, C.size_t(index))
 	if entry == nil {
 		return nil
 	}
@@ -84,7 +85,7 @@ func (t Tree) EntryByIndex(index uint64) *TreeEntry {
 }
 
 func (t Tree) EntryCount() uint64 {
-	num := C.git_tree_entrycount(t.ptr)
+	num := C.git_tree_entrycount(t.cast_ptr)
 	return uint64(num)
 }
 
@@ -104,7 +105,7 @@ func (t Tree) Walk(callback TreeWalkCallback) error {
 	defer runtime.UnlockOSThread()
 
 	err := C._go_git_treewalk(
-		t.ptr,
+		t.cast_ptr,
 		C.GIT_TREEWALK_PRE,
 		unsafe.Pointer(&callback),
 	)

Original file line number	Diff line number	Diff line change
`@@ -20,15 +20,16 @@ import (`
`20`	`20`
`21`	`21`	`type Blob struct {`
`22`	`22`	`gitObject`
	`23`	`+ cast_ptr *C.git_blob`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`func (v *Blob) Size() int64 {`
`26`		`- return int64(C.git_blob_rawsize(v.ptr))`
	`27`	`+ return int64(C.git_blob_rawsize(v.cast_ptr))`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`func (v *Blob) Contents() []byte {`
`30`		`- size := C.int(C.git_blob_rawsize(v.ptr))`
`31`		`- buffer := unsafe.Pointer(C.git_blob_rawcontent(v.ptr))`
	`31`	`+ size := C.int(C.git_blob_rawsize(v.cast_ptr))`
	`32`	`+ buffer := unsafe.Pointer(C.git_blob_rawcontent(v.cast_ptr))`
`32`	`33`	`return C.GoBytes(buffer, size)`
`33`	`34`	`}`
`34`	`35`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ func (repo Repository) CreateBranch(branchName string, target Commit, force bo`
`43`	`43`	`runtime.LockOSThread()`
`44`	`44`	`defer runtime.UnlockOSThread()`
`45`	`45`
`46`		`- ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.ptr, cForce, cSignature, cmsg)`
	`46`	`+ ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.cast_ptr, cForce, cSignature, cmsg)`
`47`	`47`	`if ret < 0 {`
`48`	`48`	`return nil, MakeGitError(ret)`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,56 +17,57 @@ import (`
`17`	`17`	`// Commit`
`18`	`18`	`type Commit struct {`
`19`	`19`	`gitObject`
	`20`	`+ cast_ptr *C.git_commit`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`func (c Commit) Message() string {`
`23`		`- return C.GoString(C.git_commit_message(c.ptr))`
	`24`	`+ return C.GoString(C.git_commit_message(c.cast_ptr))`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`func (c Commit) Tree() (*Tree, error) {`
`27`		`- var ptr *C.git_object`
	`28`	`+ var ptr *C.git_tree`
`28`	`29`
`29`	`30`	`runtime.LockOSThread()`
`30`	`31`	`defer runtime.UnlockOSThread()`
`31`	`32`
`32`		`- err := C.git_commit_tree(&ptr, c.ptr)`
	`33`	`+ err := C.git_commit_tree(&ptr, c.cast_ptr)`
`33`	`34`	`if err < 0 {`
`34`	`35`	`return nil, MakeGitError(err)`
`35`	`36`	`}`
`36`	`37`
`37`		`- return allocObject(ptr).(*Tree), nil`
	`38`	`+ return allocObject((C.git_object)(ptr)).(Tree), nil`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`func (c Commit) TreeId() *Oid {`
`41`		`- return newOidFromC(C.git_commit_tree_id(c.ptr))`
	`42`	`+ return newOidFromC(C.git_commit_tree_id(c.cast_ptr))`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`func (c Commit) Author() *Signature {`
`45`		`- ptr := C.git_commit_author(c.ptr)`
`46`		`- return newSignatureFromC(ptr)`
	`46`	`+ cast_ptr := C.git_commit_author(c.cast_ptr)`
	`47`	`+ return newSignatureFromC(cast_ptr)`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`func (c Commit) Committer() *Signature {`
`50`		`- ptr := C.git_commit_committer(c.ptr)`
`51`		`- return newSignatureFromC(ptr)`
	`51`	`+ cast_ptr := C.git_commit_committer(c.cast_ptr)`
	`52`	`+ return newSignatureFromC(cast_ptr)`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`func (c Commit) Parent(n uint) Commit {`
`55`		`- var cobj *C.git_object`
`56`		`- ret := C.git_commit_parent(&cobj, c.ptr, C.uint(n))`
	`56`	`+ var cobj *C.git_commit`
	`57`	`+ ret := C.git_commit_parent(&cobj, c.cast_ptr, C.uint(n))`
`57`	`58`	`if ret != 0 {`
`58`	`59`	`return nil`
`59`	`60`	`}`
`60`	`61`
`61`		`- return allocObject(cobj).(*Commit)`
	`62`	`+ return allocObject((C.git_object)(cobj)).(Commit)`
`62`	`63`	`}`
`63`	`64`
`64`	`65`	`func (c Commit) ParentId(n uint) Oid {`
`65`		`- return newOidFromC(C.git_commit_parent_id(c.ptr, C.uint(n)))`
	`66`	`+ return newOidFromC(C.git_commit_parent_id(c.cast_ptr, C.uint(n)))`
`66`	`67`	`}`
`67`	`68`
`68`	`69`	`func (c *Commit) ParentCount() uint {`
`69`		`- return uint(C.git_commit_parentcount(c.ptr))`
	`70`	`+ return uint(C.git_commit_parentcount(c.cast_ptr))`
`70`	`71`	`}`
`71`	`72`
`72`	`73`	`// Signature`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ const (`
`26`	`26`
`27`	`27`	`type Tree struct {`
`28`	`28`	`gitObject`
	`29`	`+ cast_ptr *C.git_tree`
`29`	`30`	`}`
`30`	`31`
`31`	`32`	`type TreeEntry struct {`
`@@ -48,7 +49,7 @@ func (t Tree) EntryByName(filename string) *TreeEntry {`
`48`	`49`	`cname := C.CString(filename)`
`49`	`50`	`defer C.free(unsafe.Pointer(cname))`
`50`	`51`
`51`		`- entry := C.git_tree_entry_byname(t.ptr, cname)`
	`52`	`+ entry := C.git_tree_entry_byname(t.cast_ptr, cname)`
`52`	`53`	`if entry == nil {`
`53`	`54`	`return nil`
`54`	`55`	`}`
`@@ -66,7 +67,7 @@ func (t Tree) EntryByPath(path string) (*TreeEntry, error) {`
`66`	`67`	`runtime.LockOSThread()`
`67`	`68`	`defer runtime.UnlockOSThread()`
`68`	`69`
`69`		`- ret := C.git_tree_entry_bypath(&entry, t.ptr, cpath)`
	`70`	`+ ret := C.git_tree_entry_bypath(&entry, t.cast_ptr, cpath)`
`70`	`71`	`if ret < 0 {`
`71`	`72`	`return nil, MakeGitError(ret)`
`72`	`73`	`}`
`@@ -75,7 +76,7 @@ func (t Tree) EntryByPath(path string) (*TreeEntry, error) {`
`75`	`76`	`}`
`76`	`77`
`77`	`78`	`func (t Tree) EntryByIndex(index uint64) *TreeEntry {`
`78`		`- entry := C.git_tree_entry_byindex(t.ptr, C.size_t(index))`
	`79`	`+ entry := C.git_tree_entry_byindex(t.cast_ptr, C.size_t(index))`
`79`	`80`	`if entry == nil {`
`80`	`81`	`return nil`
`81`	`82`	`}`
`@@ -84,7 +85,7 @@ func (t Tree) EntryByIndex(index uint64) *TreeEntry {`
`84`	`85`	`}`
`85`	`86`
`86`	`87`	`func (t Tree) EntryCount() uint64 {`
`87`		`- num := C.git_tree_entrycount(t.ptr)`
	`88`	`+ num := C.git_tree_entrycount(t.cast_ptr)`
`88`	`89`	`return uint64(num)`
`89`	`90`	`}`
`90`	`91`
`@@ -104,7 +105,7 @@ func (t Tree) Walk(callback TreeWalkCallback) error {`
`104`	`105`	`defer runtime.UnlockOSThread()`
`105`	`106`
`106`	`107`	`err := C._go_git_treewalk(`
`107`		`- t.ptr,`
	`108`	`+ t.cast_ptr,`
`108`	`109`	`C.GIT_TREEWALK_PRE,`
`109`	`110`	`unsafe.Pointer(&callback),`
`110`	`111`	`)`