feat: support ParserConfig, use a handle

Author: bfabio

go-src/publiccode-parser-wrapper.go

@@ -1,10 +1,11 @@
 package main
 
 /*
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdbool.h>
 
-struct ParseOptions {
+struct ParserConfig {
         bool DisableNetwork;
         char *Branch;
         char *BaseURL;
@@ -16,33 +17,54 @@ struct ParseResult {
         int ErrorCount;
         char **Errors;
 };
+
+typedef uintptr_t ParserHandle;
 */
 import "C"
 import (
 	"encoding/json"
+	"errors"
+	"runtime/cgo"
 	"strings"
 	"unsafe"
 
 	"github.com/italia/publiccode-parser-go/v4"
 )
 
-//export ParseString
-func ParseString(content *C.char) *C.struct_ParseResult {
-	parser, err := publiccode.NewDefaultParser()
-	if err != nil {
-		// TODO: proper return
-		panic("err on NewDefaultParser()")
+//export NewParser
+func NewParser(disableNetwork C.bool, branch *C.char, baseURL *C.char) C.ParserHandle {
+	config := publiccode.ParserConfig{
+		DisableNetwork: bool(disableNetwork),
+		Branch:         C.GoString(branch),
+		BaseURL:        C.GoString(baseURL),
 	}
 
-	goString := C.GoString(content)
+	p, err := publiccode.NewParser(config)
+	if err != nil {
+		return 0
+	}
 
-	pc, err := parser.ParseStream(strings.NewReader(goString))
+	return C.ParserHandle(cgo.NewHandle(p))
+}
 
+//export ParseString
+func ParseString(handle C.ParserHandle, content *C.char) *C.struct_ParseResult {
 	result := (*C.struct_ParseResult)(C.calloc(1, C.size_t(C.sizeof_struct_ParseResult)))
 	result.Error = nil
 	result.Errors = nil
 	result.ErrorCount = 0
 
+	parser, err := toGoParser(handle)
+	if err != nil {
+		result.Error = C.CString("Failed create a Parser: " + err.Error())
+
+		return result
+	}
+
+	goString := C.GoString(content)
+
+	pc, err := parser.ParseStream(strings.NewReader(goString))
+
 	if err != nil {
 		if validationRes, ok := err.(publiccode.ValidationResults); ok {
 			var ve []publiccode.ValidationError
@@ -112,6 +134,20 @@ func FreeResult(result *C.struct_ParseResult) {
 	}
 }
 
+func toGoParser(handle C.ParserHandle) (*publiccode.Parser, error) {
+	if handle == 0 {
+		return nil, errors.New("nil handle")
+	}
+
+	v := cgo.Handle(handle).Value()
+	p, ok := v.(*publiccode.Parser)
+	if !ok || p == nil {
+		return nil, errors.New("invalid handle")
+	}
+
+	return p, nil
+}
+
 func main() {
 	// Required for building shared library
 }