template.qtpl

{% package main %}
{% import (
	"strings"

	"github.com/turutcrane/gencefingo/parser"
	"github.com/turutcrane/gencefingo/internal/log"
)%}

Generate parameter name for Go func.
{% func goParamName(p parser.Param) -%}
{% switch p.Name() -%}
{% case "type", "string", "map", "time", "range" -%}
	{%-s "c" + p.Name() -%}
{% default -%}
	{%-s p.Name() -%}
{% endswitch -%}
{% endfunc %}

Generate parameter name for Go func.
{% func goParamNameOut(p parser.Param) -%}
{%= goParamName(p) -%}
{% if p.IsInOutParam() %}Out{% endif -%}
{% endfunc %}

{% func goTempName(p parser.Param) -%}
goTmp{%s p.Name() -%}
{% endfunc %}

{% func goTempNameOut(p parser.Param) -%}
{%s goTempName(p) + "Out" -%}
{% endfunc %}

Statemens to convert from C.param to Go type.
{% func convToGoTypeStmts(p parser.Param, lt *LogTag) -%}
{% if p.IsInOutParam() -%}
		// p.IsInOutParam
	{%- if p.Type().Ty == parser.TyStringT -%}
		{%= goTempName(p) %} := string_from_cef_string({%s goParamName(p) %})
	{%- elseif p.Type().Pointer == 2 && p.Type().Deref().IsRefCountedClass() -%}
		{%= goTempName(p) %} := {%s ConvToGoTypeExp(p.Type().Deref(), "*" + goParamName(p), "byApi") %}
		cefp := {%s goTempName(p) %}.pc_{%s p.Type().BaseName() %}
	{%- elseif p.IsBoolParam() -%}
		{%= goTempName(p) %} := (*{%s p.Name() %}) != 0
	{%- elseif p.Type().Ty == parser.TyStructSimple || p.Type().Ty ==  parser.TyInt -%}
		{%= goTempName(p) %} := {%s p.Type().Deref().GoType() %}(*{%s p.Name() %})
	{%- else -%}
	{%- code log.Panicf("E43: %s::%s::%s", p.CalleeName(), p.Name(), p.Type()) -%}
	{%- endif -%}
{% elseif !p.IsOutParam() -%}
		// !p.IsOutParam
	{%- if bs, maxLenArg := p.IsByteSliceParam(); bs -%}
		{%= goTempName(p) %} := (*[1 << 30]byte)({%s p.Name() %})[:{%s maxLenArg %}:{%s maxLenArg %}]
	{%- elseif s, maxLenArg := p.IsSliceParam(); s -%}
		// p.IsSliceParam
		slice := (*[1 << 30]({%s p.Type().Deref().GoCType() %}))(unsafe.Pointer({%s p.Name() %}))[:{%s maxLenArg %}:{%s maxLenArg %}]
		{%= goTempName(p) %} := make({%s p.GoType() %}, {%s maxLenArg %})
		for i, v := range slice {
			{%= goTempName(p) %}[i] = {%s ConvToGoTypeExp(p.Type().Deref(), "v", "byApi") %}
		}
	{%- else -%}
		{%- if p.IsBoolParam() -%}
		{%= goTempName(p) %} := {%s= goParamName(p) %} != 0
		{%- elseif !p.IsSliceLengthParam() -%}
		{%= goTempName(p) %} := {%s ConvToGoTypeExp(p.Type(), goParamName(p), "byApi") %}
		{%- endif -%}
	{%- endif -%}
{% endif -%}
{% endfunc %}

Set returned Go value to C.param and cleanup
{% func postProcess(p parser.Param, lt *LogTag) -%}
{% if p.IsOutParam() -%}
	// IsOutParam
	{%- if p.Type().Ty == parser.TyStringT -%}
		set_cef_string({%= goParamName(p) %}, {%= goTempNameOut(p) %})
	{%- elseif p.Type().Deref().IsRefCountedClass() -%}
		if {%s goTempNameOut(p) %} != nil {
			if {%s goTempNameOut(p) %}.beUnrefed != byCef {
				BaseAddRef({%s goTempNameOut(p) %}.pc_{%s p.Type().BaseName() %}) // Out Param
			}
			*{%s goParamName(p) %} = ({%s p.Type().Deref().GoCType() %})({%s goTempNameOut(p) %}.pc_{%s p.Type().BaseName() %})
		}
	{%- elseif isSlice, sliceLen := p.IsByteSliceParam(); isSlice -%}
		*{%s sliceLen %} = C.size_t(len({%s goTempNameOut(p) %}))
		*{%s goParamName(p) %} = ({%s p.Type().Deref().GoCType() %})(c_calloc(*{%s sliceLen %}, 1, "{%s lt.NextTag() %}:{%s p.CalleeName() + "::" + p.Name() %}"))
		target := (*[1<<30]byte)(unsafe.Pointer(*{%s goParamName(p) %}))[:*{%s sliceLen %}:*{%s sliceLen %}]
		copy(target, {%s goTempNameOut(p) %})
	{%- elseif isSlice, _ := p.IsSliceParam(); isSlice -%}
		{% code log.Panicf("T76: Not implemented %v", p) %}
	{%- elseif p.IsBoolParam() -%}
		*{%s goParamName(p) %} = 0
		if {%s goTempNameOut(p) %} {
			*{%s goParamName(p) %} = 1
		}
	{%- else -%}
		*{%s goParamName(p) %} = ({%s p.Type().Deref().GoCType() %})({%s goTempNameOut(p) %})
	{%- endif -%}
{% elseif p.IsInOutParam() -%}
	{%- if p.Type().Ty == parser.TyStringT -%}
		set_cef_string({%s goParamName(p) %},{%s goTempNameOut(p) %})
	{%- elseif p.IsBoolParam() -%}
		*{%s goParamName(p) %} = 0
		if {%s goTempNameOut(p) %} {
			*{%s goParamName(p) %} = 1
		}
	{%- elseif p.Type().Ty == parser.TyStructSimple  || p.Type().Ty ==  parser.TyInt -%}
		*{%s p.Name() %} = {%s p.Type().Deref().GoCType() %}({%s goTempNameOut(p) %})
	{%- elseif p.Type().Pointer == 2 -%}
		if cefp != {%= goTempNameOut(p) %}.pc_{%s p.Type().BaseName() %} {
			if {%= goTempNameOut(p) %}.beUnrefed != byCef {
				BaseAddRef({%= goTempNameOut(p) %}.pc_{%s p.Type().BaseName() %}) // InOut Param
				// BaseAddRef({%= goTempNameOut(p) %}.pc_{%s p.Type().BaseName() %}) // for Last byApi
			}
			BaseRelease(cefp) // for byApi
			*{%s goParamName(p) %} = ({%s p.Type().Deref().GoCType() %})({%= goTempNameOut(p) %}.pc_{%s p.Type().BaseName() %})
		}
	{%- else -%}
	{%- code log.Panicf("E88: %s::%s::%s", p.CalleeName(), p.Name(), p.Type()) -%}
	{%- endif -%}
{% endif -%}
{% endfunc %}

{% func MethodComments(m *parser.MethodDecl) -%}
{% for _, c := range m.Comment -%}
{%s c %}
{% endfor -%}
{% endfunc -%}

{% func goRecieveValue(m *parser.MethodDecl) -%}
{% code first := true -%}
{% if m.HasReturnValue() %}goRet{% code first = false %}{% endif -%}
{%- for _, p := range m.Params() -%}
	{%- if p.IsOutParam() || p.IsInOutParam() -%}
		{%- if !first %}, {% endif -%}
		{%-s goTempNameOut(p) %}{% code first = false -%}
	{%- endif -%}
{%- endfor -%}
{%- if m.HasReturnValue() || m.HasOutParam() -%}:= {% endif -%}
{% endfunc %}

{% func GoCallback(m *parser.MethodDecl, st *parser.CefClassDecl, lt *LogTag) %}
{% code
	var retCtype string
	retCtype = m.ReturnType().GoCType()
	baseName := st.BaseName()
-%}
{%= MethodComments(m) -%}
//export cefingo_{%s baseName %}_{%s m.Funcname.Name() %}
func cefingo_{%s baseName %}_{%s m.Funcname.Name() %}(
{%- for _, p := range m.Params() -%}
	{%s goParamName(p) %} {%s p.GoCType() %},
{%- endfor -%}
) {% if retCtype != "" %}(cRet {%s retCtype %}){% endif %} {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	Tracef(unsafe.Pointer(self), "{%s lt.NextTag() %}:")
	cefingoIfaceAccess.Lock()
	{%- if st.GoCType() == m.Params()[0].GoCType() -%}
	f := {%s baseName %}_handlers.{%= memberName(m) %}[({%s st.CgoType() %})(self)]
	{%- else -%}
	f := {%s baseName %}_handlers.{%= memberName(m) %}[({%s st.CgoType() %})(unsafe.Pointer(self))]
	{%- endif -%}
	cefingoIfaceAccess.Unlock()

	if f != nil {
		{%- for _, p := range m.Params() -%}
			{%- if exp := convToGoTypeStmts(p, lt); exp != "" && !p.IsByteSliceLengthParam() -%}
				{%-s= exp -%}
			{%- endif -%}
		{%- endfor %}
		{%= goRecieveValue(m) %}f.{%s m.Funcname.TitleCase()%}{%s "(" -%}
		{%- for _, p := range m.Params() -%}
		{%- if !(p.IsSliceLengthParam() || p.IsByteSliceLengthParam() || p.IsOutParam()) %}{%= goTempName(p) %},{% endif -%}
		{%- endfor %})
		{%- for _, p := range m.Params() -%}
			{%- if exp := postProcess(p, lt); exp != "" -%}
				{%-s= exp -%}
			{%- endif -%}
		{%- endfor %}
		{%- if m.IsBoolValueMethod() %}
		if goRet {cRet = 1}
		{%- elseif m.ReturnType().IsRefCountedClass() %}
		if goRet != nil {
			if goRet.beUnrefed != byCef {
				BaseAddRef(goRet.pc_{%s m.ReturnType().BaseName() %}) // return GoObj
			}
			cRet = ({%s retCtype %})(goRet.pc_{%s m.ReturnType().BaseName() %})
		}
		{%- elseif retCtype != "" %}
		cRet = ({%s retCtype %})(goRet)
		{%- endif -%}
	} else {
		Logf("{%s lt.NextTag() %}: {%s m.Funcname.Name() %}: Noo!")
	}
	{%- for _, p := range m.Params() -%}
		{%- if p.Name() != "self" && p.IsRefCountedClass() -%}
			BaseRelease(({%s p.CgoType() %})({%s goParamName(p) %})) // byApi
		{%- elseif p.IsInOutParam() && p.Type().Deref().IsRefCountedClass() -%}
			// BaseRelease(({%s p.Type().Deref().CgoType() %})(*{%s goParamName(p) %})) // byApi
		{%- endif -%}
	{%- endfor %}
	{% if retCtype !="" %}return cRet{% endif %}
}
{% endfunc %}

{% func GoBindFunc(st *parser.CefClassDecl, lt *LogTag) %}
{% code baseName := st.BaseName()
	self := baseName -%}
func ({%s self %} {%s st.GoType() %}) bind(a interface{}) {%s st.GoType() %} {
	cefingoIfaceAccess.Lock()
	defer cefingoIfaceAccess.Unlock()
	noBind := true
	{%- code funcnum := 0 -%}
	{%- for c := st; c != nil; c = c.GetBase() -%}
	{%- for _, m := range c.Methods %}
	{%- if funcnum == 0 -%}
	cp := {%s self %}.pc_{%s baseName %}
	{%s baseName %}_handlers.handler[cp] = a

	{%- endif -%}
	{%- code funcnum += 1 -%}
	if h, ok := a.({%s m.IfName() %}); ok {
		{%s baseName %}_handlers.{%= memberName(m) %}[cp] = h
		noBind = false
	} else {
		delete({%s baseName %}_handlers.{%= memberName(m) %}, cp)
	}
	{%- endfor -%}
	{%- endfor %}
	if noBind {
		Panicln("F229: {%s st.GoType() %} No bind")
	}
	return {%s self %}
}

func unbindAll{%s st.GoName() %}(cp {%s st.CgoType() %}) {
	cefingoIfaceAccess.Lock()
	defer cefingoIfaceAccess.Unlock()

	// cp := {%s self %}.pc_{%s baseName %}
	delete({%s baseName %}_handlers.handler, cp)

	{%- for c := st; c != nil; c = c.GetBase() -%}
	{%- for _, m := range c.Methods -%}
	delete({%s baseName %}_handlers.{%= memberName(m) %}, cp)
	{%- endfor -%}
	{%- endfor -%}
}

func ({%s self %} {%s st.GoType() %}) UnbindAll() {
	unbindAll{%s st.GoName() %}({%s self %}.pc_{%s baseName %})
	{%s self %}.Unref()
}

func ({%s self %} {%s st.GoType() %}) Handler() interface{} {
	cefingoIfaceAccess.Lock()
	defer cefingoIfaceAccess.Unlock()

	cp := {%s self %}.pc_{%s baseName %}
	return {%s baseName %}_handlers.handler[cp]
}
{% endfunc %}

{% func GoHead(imports []string, defIfMutex, winOnly bool) %}
// Code generated by "gen-cefingo.go" DO NOT EDIT.
{% if winOnly -%}
// +build windows
{% endif -%}

package capi

{% if len(imports) > 0 -%}
import (
{% for _, p := range imports -%}
	"{%s p %}"
{% endfor -%}
)
{% endif -%}
// #include "cefingo.h"
import "C"
{% if defIfMutex %}var cefingoIfaceAccess sync.Mutex
{% endif -%}
{% endfunc %}

{% func GoIface(m *parser.MethodDecl) %}
{%= MethodComments(m) -%}
type {%s m.IfName() %} interface {
	{%s m.Funcname.TitleCase() %} (
		{%- for _, p := range m.Params() -%}
		{%- if !(p.IsSliceLengthParam() || p.IsByteSliceLengthParam() || p.IsOutParam()) -%}
		{%s goParamName(p) %} {%s p.GoTypeIn() %},
		{%- endif -%}
		{%- endfor -%}
	) {%s retTypes(m) %}
}
{% endfunc %}

{% func memberName(m *parser.MethodDecl) -%}
{%-s m.Funcname.Name() %}_handler{%s "" -%}
{% endfunc %}

{% func memberGoType(m *parser.MethodDecl) -%}
{%-s m.IfName() -%}
{% endfunc %}

{% func IfaceStruct(st *parser.CefClassDecl) %}
var {%s st.BaseName() %}_handlers = struct {
	handler map[{%s st.CgoType() %}]interface{}
{% for c := st; c != nil; c = c.GetBase() -%}
	{%- for _, m := range c.Methods -%}
	{%= memberName(m) %} map[{%s st.CgoType() %}]{%= memberGoType(m) %}
	{%- endfor -%}
{% endfor -%}
}{
	map[{%s st.CgoType() %}]interface{}{},
{% for c := st; c != nil; c = c.GetBase() -%}
	{%- for _, m := range c.Methods -%}
	map[{%s st.CgoType() %}]{%= memberGoType(m) %}{},
	{%- endfor -%}
{% endfor -%}
}
{% endfunc %}

{% func GoAllocFunc(st *parser.CefClassDecl, lt *LogTag) %}
// alloc{%s st.GoName()%} allocates {%s st.GoName() %} and construct it
func alloc{%s st.GoName()%}() {%s st.GoType()%} {
	up := c_calloc(1, C.sizeof_cefingo_{%s st.BaseName() %}_wrapper_t, "{%s lt.NextTag() %}:")
	cefp := C.cefingo_construct_{%s st.BaseName() %}((*C.cefingo_{%s st.BaseName() %}_wrapper_t)(up))
	cgop := ({%s st.CgoType() %})(cefp)

	registerDeassocer(up, DeassocFunc(func() {
		// Do not have reference to {%s st.CefName() %} itself in DeassocFunc,
		// or {%s st.CefName() %} is never GCed.
		Tracef(up, "{%s lt.NextTag() %}:")
		unbindAll{%s st.GoName() %}(cgop)
	}))

	BaseAddRef(cgop)
	return new{%s st.GoName() %}(cefp, byApp)
}

// New{%s st.GoName()%} allocates {%s st.GoName() %}, construct and bind it
func New{%s st.GoName()%}(a interface{}) {%s st.GoType()%} {
	return alloc{%s st.GoName()%}().bind(a)
}
{% endfunc %}

{% func methodCTypeName(m *parser.MethodDecl) -%}
{% code callee := strings.Replace(m.CalleeName(), "::", "_", 1) -%}
T_{%s strings.ToUpper(callee) -%}
{% endfunc %}

{% func constructorName(st *parser.CefClassDecl) -%}
{%s st.CefName() + " *cefingo_construct_" + st.BaseName() + "(cefingo_" + st.BaseName() + "_wrapper_t* " + st.BaseName() + ")" -%}
{% endfunc %}

{% func CConstruct(st *parser.CefClassDecl, lt *LogTag) %}
{% for _, m := range st.Methods -%}
{% if m.HasConstParams() -%}
typedef {%s m.ReturnType().CType() -%}
 (*{%s methodCTypeName(m) %})(
{% for i, p := range m.Params() -%}
{% if i > 0 %},
{% endif %}	{%s p.CType() -%}
{% endfor%}
);
{% endif -%}
{% endfor -%}

{%s constructorName(st) %}
{
	initialize_cefingo_base_ref_counted(
		offsetof(__typeof__(*{%s st.BaseName() %}), counter),
		(cef_base_ref_counted_t*) {%s st.BaseName() %});

	// callbacks
	{%- code base := "" -%}
	{%- for c := st; c != nil; c = c.GetBase() -%}
	{%- for _, m := range c.Methods -%}
	{%s st.BaseName() %}->body{%s base %}.{%s m.Funcname.Name() %} =
		{% if m.HasConstParams() %}(/* {%s methodCTypeName(m) %} */ void *){% endif %}cefingo_{%s st.BaseName() %}_{%s m.Funcname.Name() %};
	{%- endfor -%}
	{%- code base = base + ".base"-%}
	{%- endfor -%}

	return ({%s st.CefName() %}*){%s st.BaseName() %};
}
{% endfunc %}

{% func HCallback(st *parser.CefClassDecl, lt *LogTag) %}
CEFINGO_REF_COUNTER_WRAPPER(cef_{%s st.BaseName() %}_t, cefingo_{%s st.BaseName() %}_wrapper_t);
extern {%s constructorName(st) %};
{% endfunc %}

{% func preConvToC(p parser.Param, lt *LogTag) -%}
{% if p.IsOutParam() -%}
	// IsOutParam
	{%- if ok, argLen := p.IsByteSliceParam(); ok -%}
	{%s argLen %} := len({%s goParamName(p) %})
	{%s cTempName(p) %} := c_calloc(C.size_t({%s argLen %}), 1, "{%s lt.NextTag() %}:{%s p.CalleeName() + "::" + p.Name() %}")
	{%- elseif isSlice, argLen := p.IsSliceParam(); isSlice -%}
	_{%s argLen %} := C.size_t({%s p.SliceSizeExp() %}) // =SizeFunc {%s p.CalleeName() %}:{%s p.Name() %}
	if _{%s argLen %} == 0 {
		return
	}
	{%s argLen %} := &_{%s argLen %}
	{%s cTempName(p) %} := unsafe.Pointer(c_calloc(_{%s argLen %}, 8, "{%s lt.NextTag() %}"))
	defer C.free({%s cTempName(p) %})
	{%- elseif p.Type().Ty == parser.TyStringT -%}
	{%s cTempName(p) %} := create_cef_string("")
	{%- else -%}
	var {%s cTempName(p) %} {%s p.Type().Deref().GoCType() %}
	{%- endif -%}
{% elseif ok, argLen := p.IsByteSliceParam(); ok && !p.IsInOutParam() -%}
	{%s argLen %} := len({%s goParamName(p) %})
	{%s cTempName(p) %} := C.CBytes({%s goParamName(p) %})
	defer C.free({%s cTempName(p) %})
{% elseif ok, argLen := p.IsSliceParam(); ok -%}
	{%s argLen %} := len({%s goParamName(p) %})
	{%s cTempName(p) %} := c_calloc(C.size_t({%s argLen %}), (C.size_t)(unsafe.Sizeof({%= goParamName(p) %}[0])), "{%s lt.NextTag() %}:{%s p.CalleeName() + "::" + p.Name() %}")
	slice := (*[1 << 30]{%s p.Type().Deref().GoCType() %})({%s cTempName(p) %})[:{%s argLen %}:{%s argLen %}]
	for i, v := range {%s goParamName(p) %} {
		cefp := v.pc_{%s p.Type().BaseName() %}
		if cefp != nil {
			BaseAddRef(cefp)
		}
		slice[i] = ({%s p.Type().Deref().GoCType() %})(cefp)
	}
{% elseif p.Type().IsRefCountedClass() -%}
	var {%= goTempName(p) %} {%s p.GoCType() %} 
	if {%= goParamName(p) %} != nil {
		BaseAddRef({%s goParamName(p) %}.pc_{%s p.Type().BaseName() %})
		{%= goTempName(p) %} = ({%s p.GoCType() %})({%s goParamName(p) %}.pc_{%s p.Type().BaseName() %})
	}
{% else -%}
{% switch p.GoType() -%}
{% case "bool" -%}
	var {%s cTempName(p) %} int
	if {%s goParamName(p) %} {
		{%s cTempName(p) %} = 1
	}
{% case "string" -%}
	{%s cName(p) %} := create_cef_string({%s goParamName(p) %})
{% case "time.Time" -%}
	{%s cName(p) %} := {%s goParamName(p) %}.Unix()
{% endswitch -%}
{% endif -%}
{% endfunc %}

{% func cName(p parser.Param) -%}
{% switch p.Type().GoType() -%}
{% case "string", "*time.Time", "time.Time" -%}
c_{% endswitch %}{%s goParamName(p) -%}
{% endfunc %}

{% func cTempName(p parser.Param) -%}
tmp{%= cName(p) -%}
{% endfunc %}

{% func convToC(p parser.Param, lt *LogTag) -%}
{% if p.IsOutParam() -%}
	{%- if ok, _ := p.IsByteSliceParam(); ok -%}
	{%-= cTempName(p) -%}
	{%- elseif p.Type().Ty == parser.TyStringT -%}
	{%-= cTempName(p) %}.{%s "p_cef_string_t" -%}
	{%- elseif ok, _ := p.IsSliceParam(); ok -%}
	{%-s= "(*" + p.Type().Deref().GoCType() + ")(" + cTempName(p) + ")"  -%}
	{%- else -%}
	{%-s= "&" + cTempName(p) -%}
	{%- endif -%}
	{%-s "/* IsOutParam */" -%}
{% elseif p.IsRefCountedClass() -%}
	{%- if p.Name() == "self" -%}({%s p.GoCType() %})(self.pc_{%s p.Type().BaseName() -%}{%s ")" -%}
	{%- else %}{%s goTempName(p) %}{% endif -%}
{% elseif p.IsScopedClass() -%}
	({%s p.GoCType() %})({%-s cName(p) %}.pc_{%s p.Type().BaseName() -%}{%s ")" -%}
{% elseif ok, _ := p.IsByteSliceParam(); ok && !p.IsInOutParam() -%}
	{%-s= cTempName(p) -%}
{% elseif ok, _ := p.IsSliceParam(); ok -%}
	({%s p.GoCType() %})({%-= cTempName(p) -%}{%s ")" -%}
{% else -%}
	{%- switch p.GoType() -%}
	{%- case "bool" -%}
		{%-s p.GoCType() %}({%-s cTempName(p) + ")" -%}
	{%- case "*time.Time" -%}
		{%-s= "&" + cName(p) -%}
	{%- case "time.Time" -%}
		{%-s "C.time_t(" + cName(p) + ")" -%}
	{%- case "unsafe.Pointer" -%}{% code log.Tracef("T335: %s::%s\n", p.CalleeName(), p.Name()) -%}
		{%-s cName(p) -%}
	{%- case "string" -%}
		{%-s cName(p) -%}.{%s "p_cef_string_t" -%}
	{%- default -%}
		{%-s "(" + p.GoCType() + ")(" %}{%s cName(p) %}{%s ")" -%}
	{%- endswitch -%}
{% endif -%}
{% endfunc %}

{% func postConvFromC(p parser.Param, lt *LogTag) -%}
{% if p.IsOutParam() -%}
	// IsOutParam
	{%- if isSlice, argLen := p.IsByteSliceParam(); isSlice -%}
	{%s goParamName(p) %} = C.GoBytes({%s cTempName(p) %}, C.int({%s argLen %}))
	C.free({%s cTempName(p) %})
	{%- elseif isSlice, argLen := p.IsSliceParam(); isSlice -%}
	{%s goParamName(p) %} = make([]{%s p.Type().Deref().GoType() %}, *{%s argLen %})
	_{%s cTempName(p) %} := (*[1 << 30]({%s p.Type().Deref().GoCType() %}))(unsafe.Pointer({%s cTempName(p) %}))[:*{%s argLen %}:*{%s argLen %}]
	for i := C.size_t(0); i {%s= "<" %} *{%s argLen %}; i++ {
		{%s goParamName(p) %}[i] = new{%s p.Type().Deref().Deref().GoType() %}(_{%s cTempName(p) %}[i], byApp) // Out Slice Param
	}
	{%- elseif p.Type().Ty == parser.TyStringT -%}
	{%s goParamName(p) %} = string_from_cef_string({%s cTempName(p) %}.p_cef_string_t)
	{%- elseif p.Type().Deref().IsRefCountedClass() -%}
	{%s goParamName(p) %} = new{%s p.Type().Deref().Deref().GoType() %}({%s cTempName(p) %}, byApp) // Out Param
	{%- elseif p.Type().Ty == parser.TyTimeT %}
	{%s goParamName(p) %} = time.Unix(int64({%= cTempName(p) %}), 0)
	{%- else -%}
	{%s goParamName(p) %} = ({%s p.Type().Deref().GoType() %})({%s cTempName(p) %})
	{%- endif -%}
{% endif -%}
{% endfunc %}

{% func GoFunction(f *parser.FuncDecl, lt *LogTag) -%}
func {%s f.Funcname.TitleCase() %}(
	{%- for _, p := range f.Params() -%}
	{%- if !p.IsByteSliceLengthParam() && !p.IsSliceLengthParam() && !p.IsOutParam() -%}
	{%s goParamName(p) %} {%s p.GoType() %},
	{%- endif -%}
	{%- endfor -%}
) {%= retTypes(f) %}{
	{%- for _, p := range f.Params() -%}
		{%- if exp := preConvToC(p, lt); exp != "" -%}
			{%-s= exp -%}
		{%- endif -%}
	{%- endfor %}
	{% if f.HasReturnValue() %}cRet := {% endif %}C.{%s f.CefName() %}({% for i, p := range f.Params() -%}
	{%- if i > 0 %}, {% endif %}{%= convToC(p, lt) -%}
	{%- endfor %})

	{%- for _, p := range f.Params() -%}{%= postConvFromC(p, lt) %}{%endfor -%}
	{%= goReturnStmt(f) %}
}
{% endfunc %}

Generate Go func Return Types
{% func retTypes(m parser.Callable) -%}
{% if m.HasReturnValue() || m.HasOutParam() -%}
({% if m.HasReturnValue() -%}ret {%s m.ReturnGoType() -%},{%- endif -%}
{% for _, p := range m.Params() -%}
{% if p.IsOutParam() || p.IsInOutParam() -%}
{%s goParamNameOut(p) + " " -%}
{% if p.Type().Ty == parser.TyStringT && p.Type().Pointer == 1 -%}
	{%-s p.Type().GoType() -%}
{% elseif isSlice, _ := p.IsSliceParam(); isSlice -%}
	{%-s "[]" + p.Type().Deref().GoType() -%}
{% elseif isSlice, _ := p.IsByteSliceParam(); isSlice -%}
	{%-s "[]byte" -%}
{% elseif p.IsBoolParam() -%}
	{%-s "bool" -%}
{% else -%}
	{%-s p.Type().Deref().GoType() -%}
{% endif -%}
, {% endif -%}
{% endfor -%}
{%s ")" -%}
{% endif -%}
{% endfunc %}

Generate Go method call to object method (self->method(...))
{% func CefObjectMethod(m *parser.MethodDecl, lt *LogTag) %}
{% for _, c := range m.Comment -%}
{%s c %}
{% endfor -%}
func  ({%s goParamName(m.Params()[0]) %} {%s m.Params()[0].GoType() %}) {%s m.Funcname.TitleCase() %}(
{% for i, p := range m.Params() -%}
	{%- if i > 0 && !p.IsOutParam() -%}
	{%- if !p.IsByteSliceLengthParam() && !p.IsSliceLengthParam() -%}
	{%s goParamName(p) %} {%s p.GoType() %},
	{%- endif -%}
	{%- endif -%}
{% endfor -%}
) {%= retTypes(m) %}{
	{%- for i, p := range m.Params() -%}
	{%- if !(i == 0 && p.Name() == "self") -%}
		{%- if stmts := preConvToC(p, lt); stmts != "" -%}
			{%-s= stmts -%}
		{%- endif -%}
	{%- endif -%}
	{%- endfor %}
	{% if m.HasReturnValue() %}cRet := {% endif %}C.{%s methodCName(m) %}({% for i, p := range m.Params() -%}
	{%- if i > 0 %}, {% endif %}{%= convToC(p, lt) -%}
	{%- endfor %})

	{%- for _, p := range m.Params() -%}{%= postConvFromC(p, lt) %}{%endfor -%}
	{%-= goReturnStmt(m) %}
}
{% endfunc %}

{% func goReturnStmt(m parser.Callable) -%}
	{%- if m.HasReturnValue() -%}
	{%- if m.IsBoolValueMethod() %}
	ret = cRet == 1
	{%- elseif m.ReturnType().Ty == parser.TyStringUserfreeT %}
	s := string_from_cef_string(cRet)
	if cRet != nil {
		C.cef_string_userfree_free(cRet)
	}
	ret = s
	{%- else %}
	ret = {%s ConvToGoTypeExp(m.ReturnType(), "cRet", "byApp") %} // return GoObj
	{%- endif -%}
	{%- endif -%}
	{%- if m.HasReturnValue() || m.HasOutParam() -%}{% code first := true -%}
	return {%if m.HasReturnValue() %}ret{%code first = false %}{% endif -%}
	{%- for _, p := range m.Params() -%}
		{%- if p.IsOutParam() || p.IsInOutParam() -%}
			{%- if !first %}, {% endif %}{%s goParamName(p) %}{%code first = false -%}
		{%- endif -%}
	{%- endfor -%}
	{%- endif -%}
{% endfunc %}

{% func methodCName(m *parser.MethodDecl) -%}
{%s "cefingo_" + m.ClassBaseName() + "_" + m.Funcname.Name() -%}
{% endfunc %}

{% func methodCSig(m *parser.MethodDecl) -%}
{%s m.ReturnType().CType() %} {%s methodCName(m) %}(
{% for i, p := range m.Params() -%}
{% if i > 0 %},
{% endif -%}
	{%s p.CType() %} {%s p.Name() -%}
{% endfor %}
{%s ")" -%}
{% endfunc %}

{% func CefObjectMethodH(m *parser.MethodDecl) %}
extern {%s methodCSig(m) %};
{% endfunc %}

{% func CefObjectMethodC(m *parser.MethodDecl) %}
{% code withRet := m.ReturnGoType() != "" -%}
{%s methodCSig(m) %}
{
	{% if withRet %}return	{% endif %}self->{%s m.Funcname.Name() %}(
		{%- for i, p := range m.Params() -%}
		{%- if i > 0 %},
		{%- endif -%}
	{% if withRet %}	{% endif %}	{%s p.Name() -%}
		{%- endfor %}
	{% if withRet %}	{% endif %});
}
{% endfunc %}

// newCXxxxT()
{% func GoType(d *parser.CefClassDecl, lt *LogTag) %}
type {%s d.CgoName() %} C.{%s d.CefName() %}
// Go type for {%s d.CefName() %}
type {%s d.GoName() %} struct {
	noCopy                 noCopy
	pc_{%s d.BaseName() %} {%s d.CgoType() %}
	{%- if d.St == parser.StRefCounted -%}
	beUnrefed              unrefedBy
	{%- endif -%}
}

func (p {%s d.GoType() %}) Pass() (ret {%s d.GoType() %}) {
	{%- if d.St == parser.StRefCounted -%}
	switch p.beUnrefed {
	case byApp:
		p.beUnrefed = unrefed
		ret = new{%s d.GoName() %}(({%s d.GoCType() %})(p.pc_{%s d.BaseName() %}), byCef)
	case byApi, byCef:
		ret = p
	default:
		Panicln("F725: Unsupported Ref Passed", p.beUnrefed)
	}
	{%- else -%}
	ret = p
	{%- endif %}
	return ret
}

func (self {%s d.GoType() %}) NewRef() (newP {%s d.GoType() %}) {
	if self == nil {
		return newP
	}
	{%- if d.St == parser.StRefCounted -%}
	gop := self.pc_{%s d.BaseName() %}
	BaseAddRef(gop)
	newP = new{%s d.GoName() %}(({%s d.GoCType() %})(gop), byApp)
	{%- else -%}
	newP = self
	{%- endif -%}
	return newP
}

// Go type {%s d.GoName() %} wraps cef type {%s d.GoCType() %}
func new{%s d.GoName() %}(p {%s d.GoCType() %}{%- if d.St == parser.StRefCounted -%}, unrefedBy unrefedBy{% endif %}) {%s d.GoType() %} {
	if p == nil {
		return nil
	}
	Tracef(unsafe.Pointer(p), "{%s lt.NextTag() %}:")
	pc := ({%s d.CgoType() %})(p)
	{%- if d.St == parser.StRefCounted -%}
	go_{%s d.BaseName() %} := &{%s d.GoName() %}{noCopy{}, pc, unrefedBy}
	// BaseAddRef(pc)
	runtime.SetFinalizer(go_{%s d.BaseName() %}, func(g {%s d.GoType() %}) {
		// same as g.Unref()
		if (g.beUnrefed == byApp && g.pc_{%s d.BaseName() %} != nil) {
			Tracef(unsafe.Pointer(g.pc_{%s d.BaseName() %}), "{%s lt.NextTag() %}:")
			BaseRelease(g.pc_{%s d.BaseName() %})
		}
	})

	{%- else -%}
	go_{%s d.BaseName() %} := &{%s d.GoName() %}{noCopy{}, pc}
	{%- endif -%}
	return go_{%s d.BaseName() %}
}
{% if d.St == parser.StRefCounted -%}
// {%s d.GoCType() %} has refCounted interface
func ({%s d.BaseName() %} {%s d.GoType() %}) HasOneRef() bool {
	return BaseHasOneRef({%s d.BaseName() %}.pc_{%s d.BaseName() %})
}

func (p {%s d.CgoType() %}) cast_to_p_base_ref_counted_t() *C.cef_base_ref_counted_t {
	return (*C.cef_base_ref_counted_t)(unsafe.Pointer(p))
}

func ({%s d.BaseName() %} {%s d.GoType() %}) Unref() (ret bool) {
	if {%s d.BaseName() %} == nil {
		return
	}
	if {%s d.BaseName() %}.beUnrefed == byApp {
		ret = BaseRelease({%s d.BaseName() %}.pc_{%s d.BaseName() %})
		{%s d.BaseName() %}.beUnrefed = unrefed
	}
	{%s d.BaseName() %}.pc_{%s d.BaseName() %} = nil
	return ret
}
{% endif -%}
{% if p := d.GetBase(); p != nil %}
// Convert to Base Class Pointer {%s p.GoType() %}
func ({%s d.BaseName() %} {%s d.GoType() %}) To{%s p.GoName() %}() {%s p.GoType() %}{
	p := ({%s p.GoCType() %})(unsafe.Pointer({%s d.BaseName() %}.pc_{%s d.BaseName() %}))
	BaseAddRef({%s d.BaseName() %}.pc_{%s d.BaseName() %})
	return new{%s p.GoName() %}(p, byApp)
}
{% endif -%}
{% endfunc %}

{% func cField(f string) -%}
{% if f == "type" || f == "range" %}_{%s f %}{% else %}{%s f %}{% endif -%}
{% endfunc %}

{% func castGoType(s string) -%}
{% if s == "C.VOIDP" -%}unsafe.Pointer{% else %}{%s s %}{% endif %}{% endfunc %}

{% func MemberAccessor(d *parser.StructDecl, m parser.Member) -%}
func (st {%s d.GoType() %}) {%s m.GoName() %}() {%s m.GoType() %} {
{% if m.Type().Ty == parser.TyStringT && m.Type().Pointer == 0 -%}
	return string_from_cef_string(&st.{%s cField(m.Name()) %})
{% elseif m.IsBoolMember() -%}
	return st.{%s cField(m.Name()) %} != 0
{% else -%}
	return {%s m.GoType() %}(st.{%s cField(m.Name()) %})
{% endif -%}
}

func (st {%s d.GoType() %}) Set{%s m.GoName() %}(v {%s m.GoType() %}) {
{% if m.Type().Ty == parser.TyStringT && m.Type().Pointer == 0 -%}
	set_cef_string(&st.{%s cField(m.Name()) %}, v)
{% elseif m.IsBoolMember() -%}
	if v {
		st.{%s cField(m.Name()) %} = 1
	} else {
		st.{%s cField(m.Name()) %} = 0
	}
{% else -%}
	st.{%s cField(m.Name()) %} = ({%s castGoType(m.Type().GoCType()) %})(v)
{% endif -%}
}

{% endfunc %}

{% func NewStruct(d *parser.StructDecl) -%}
func New{%s d.GoName() %}() {%s d.GoType() %} {
	s := &{%s d.GoName() %}{}
	{%- if d.Members[0].Type().Ty == parser.TySizeT && d.Members[0].Name() == "size" -%}
	s.size = C.sizeof_{%s d.CefName() %}
	{%- endif -%}
	return s
}

{% endfunc %}