nswrap/types/convert.go

378 lines
7.6 KiB
Go
Raw Normal View History

package types
import (
"fmt"
"regexp"
"strings"
)
//super is a map recording which class is the parent of each other class
var super map[string]string
//wrapped is a map recording whether a given GoType is to be "wrapped" in a
//go struct.
var wrapped map[string]bool
func shouldWrap(gt string) bool {
return gt != "" && gt[0] == '*' && wrapped[gt[1:]]
}
//goInterfaces records the names of top level Go interfaces. Pointers to these
//are dereferenced to bare interface names.
var goInterfaces map[string]bool
func IsGoInterface(gt string) bool {
return goInterfaces[gt]
}
//TypeParameters maps, for each class, a TypedefName to a type, representing
//the Objective-C type parameters for that class
var TypeParameters map[string]map[string]string
//Typedefs maps from C types to the Type of a typedef with that name.
var typedefs map[string]*Type
func (t *Type) Typedef() *Type {
//return typedefs[t.BaseType().CType()]
return typedefs[t.CType()]
}
var (
r_id *regexp.Regexp
r_instancename *regexp.Regexp
r_instancetype *regexp.Regexp
)
func init() {
super = make(map[string]string)
wrapped = make(map[string]bool)
goInterfaces = make(map[string]bool)
TypeParameters = make(map[string]map[string]string)
typedefs = make(map[string]*Type)
r_id = regexp.MustCompile("\bid\b")
r_instancename = regexp.MustCompile(`\binstancename\b`)
r_instancetype = regexp.MustCompile(`\binstancetype\b`)
}
func Super(c string) string {
return super[c]
}
func SetSuper(c, p string) {
super[c] = p
}
func SetTypeParam(c, n, t string) {
if TypeParameters[c] == nil {
TypeParameters[c] = make(map[string]string)
}
TypeParameters[c][n] = t
}
func AddTypedef(n,t string) {
//fmt.Printf("AddTypedef(): %s -> %s\n",n,t)
typedefs[n] = NewTypeFromString(t,"")
}
type Type struct {
Node *Node
Class string
ctype string
Variadic bool
}
func (t *Type) CloneToClass(c string) *Type {
return &Type{
Node: t.Node,
Class: c,
Variadic: t.Variadic,
}
}
func clean(n *Node,c string) (*Node,bool) {
if n == nil {
return nil,false
}
ret := NewNode(n.Kind,n.Content)
ret.Children = n.Children
//fmt.Printf("clean(%s,%s)\n",n.Ctype(),c)
recur := false
if TypeParameters[c] != nil {
for k,v := range TypeParameters[c] {
recur = ret.renameTypedefs(k,v)
}
}
// recur = recur || ret.renameTypedefs("instancename",c)
// recur = recur || ret.renameTypedefs("instancetype",c + "*")
if recur {
clean(n, c)
return ret,true
}
return n,false
}
func NewType(n *Node, c string) *Type {
n2,_ := clean(n, c)
return &Type{
Node: n2,
Class: c,
//ctype: "",
}
}
func NewTypeFromString(t,c string) *Type {
//fmt.Printf("t/c: %s/%s\n",t,c)
n,err := Parse(t)
//fmt.Printf("%p %s",n,n.String())
if n.IsId() {
n,err = Parse("NSObject*")
}
if err != nil {
return &Type{}
}
if n2,ok := clean(n, c); ok {
return NewTypeFromString(n2.Ctype(),c)
}
return &Type{
Node: n,
Class: c,
//ctype: "",
}
}
func (t *Type) String() string {
return t.Node.String()
}
func (t *Type) PointsTo() *Type {
if td := t.Typedef(); td != nil {
return td.PointsTo()
}
if pt := t.Node.PointsTo(); pt != nil {
return NewType(t.Node.PointsTo(), t.Class)
} else {
return nil
}
}
func Wrap(s string) {
// it is the pointers to this type that get wrapped
wrapped[s] = true
}
func (t *Type) BaseType() *Type {
if t == nil {
return nil
}
ret := NewType(
t.Node.BaseType(),
t.Class,
)
return ret
}
func swapstars(s string) string {
for i := len(s) - 1; i > 0 && s[i] == '*'; {
s = "*" + s[:i]
}
return strings.TrimSpace(s)
}
func (t *Type) CGoType() string {
ct := swapstars("C." + t.CType())
ct = strings.ReplaceAll(ct,"unsigned ","u")
ct = strings.ReplaceAll(ct,"signed ","u")
ct = strings.ReplaceAll(ct,"long ","long")
ct = strings.ReplaceAll(ct,"complex ","complex")
ct = strings.ReplaceAll(ct," ","_")
return ct
}
func (t *Type) GoType() string {
return _goType(t.CType())
}
func _goType(ct string) string {
ct = swapstars(ct)
ct = strings.Title(ct)
ct = strings.ReplaceAll(ct," ","")
ct = strings.ReplaceAll(ct,"Struct","")
if len(ct) > 0 && ct[0] == '*' && IsGoInterface(ct[1:]) {
return ct[1:]
}
if ct == "Id" {
ct = "*Id"
}
return ct
}
func (t *Type) CType() string {
return t._CType(false)
}
func (t *Type) CTypeAttrib() string {
return t._CType(true)
}
func (t *Type) _CType(attrib bool) string {
if t == nil {
//fmt.Println("nil sent to _CType()")
return ""
}
if !attrib && t.ctype != "" { // cache
return t.ctype
}
var ct string
if attrib {
ignore := map[string]bool { "GenericList": true }
ct = t.Node._Ctype(ignore)
} else {
ct = t.Node.CtypeSimplified()
}
ct = r_id.ReplaceAllString(ct,"NSObject*")
ct = r_instancename.ReplaceAllString(ct,t.Class)
ct = r_instancetype.ReplaceAllString(ct,t.Class + "*")
if attrib {
t._CType(false)
} else {
t.ctype = ct
}
return ct
}
func (t *Type) GoTypeDecl() string {
if wrapped[t.GoType()] {
return t.GoInterfaceDecl()
}
tp := t.BaseType()
if tp.Node.IsId() {
return ""
}
gt := tp.GoType()
switch gt {
case "", "Void":
return ""
default:
extra := t.Node.CtypeSimplified()
var cgt string
if td := tp.Typedef(); td != nil {
cgt = td.CGoType()
extra = "typedef " + td.Node.Ctype()
} else {
cgt = tp.CGoType()
}
return fmt.Sprintf(`
//%s (%s)
type %s %s
`,t.Node.Ctype(),extra,gt,cgt)
}
}
func (t *Type) GoInterfaceDecl() string {
gt := t.GoType()
if gt[0] == '*' {
gt = gt[1:] // dereference wrapped types
}
super := Super(gt)
if super == "" {
goInterfaces[gt] = true
return fmt.Sprintf(`
//%s (%s)
type %s interface {
Ptr() unsafe.Pointer
}
`,t.Node.Ctype(),t.BaseType().GoType(),gt)
}
if IsGoInterface(super) {
super = "Id"
}
return fmt.Sprintf(`
//%s (%s)
type %s struct { %s }
func (o *%s) Ptr() unsafe.Pointer { return unsafe.Pointer(o) }
func (o *Id) %s() *%s { return (*%s)(unsafe.Pointer(o)) }
`,t.Node.Ctype(),t.BaseType().GoType(),gt,super,gt,gt,gt,gt)
}
func (t *Type) IsFunction() bool {
if t == nil {
fmt.Println("nil sent to IsFunction()")
return false
}
if td := t.Typedef(); td != nil {
return td.IsFunction()
}
return t.Node.IsFunction()
}
func (t *Type) ReturnType() *Type {
if rt := t.Node.ReturnType(); rt != nil {
return NewType(rt,t.Class)
}
return nil
}
func (t *Type) IsPointer() bool {
if td := t.Typedef(); td != nil {
return td.IsPointer()
}
return t.Node.IsPointer()
}
func (t *Type) CToGo(cval string) string { // cast C value to CGo
if t.IsPointer() {
cval = "unsafe.Pointer(" + cval + ")"
}
return fmt.Sprintf("(%s)(%s)",t.GoType(),cval)
}
// Call a C function from Go with a given return type and parameter types
func GoToC(name string, pnames []string, rtype *Type, ptypes []*Type) string {
if rtype == nil {
fmt.Println("nil sent to GoToC")
return ""
}
var ret strings.Builder
rt := rtype.CType()
if rt != "void" {
rtgt := rtype.GoType()
if IsGoInterface(rtgt) {
rtgt = "*Id"
}
ret.WriteString("return (" + rtgt + ")(")
if rtype.IsPointer() {
ret.WriteString("unsafe.Pointer(")
}
}
ret.WriteString("C." + name + "(")
parms := []string{}
for i := 0; i < len(pnames); i++ {
pn,pt := pnames[i],ptypes[i]
p := pn
if (shouldWrap(pt.GoType()) || IsGoInterface(pt.GoType())) && !pt.Variadic {
p = pn + ".Ptr()"
} else {
switch {
case pt.Variadic:
p = "unsafe.Pointer(&" + p + ")"
case pt.IsPointer():
p = "unsafe.Pointer(" + pn + ")"
default:
p = "(" + pt.CGoType() + ")(" + pn + ")"
}
}
parms = append(parms,p)
}
ret.WriteString(strings.Join(parms,", "))
ret.WriteString(")")
if rt != "void" {
ret.WriteString(")")
if rtype.IsPointer() {
ret.WriteString(")")
}
}
return ret.String()
}