cutego/internal/binding/converter/output.go

package converter

import (
	"fmt"
	"strings"

	"github.com/therecipe/qt/internal/binding/parser"
)

func goOutput(name, value string, f *parser.Function) string {
	var vOld = value

	name = cleanName(name, value)
	value = CleanValue(value)

	switch value {
	case "char", "qint8", "uchar", "quint8", "QString":
		{
			return fmt.Sprintf("C.GoString(%v)", name)
		}

	case "QByteArray":
		{
			return fmt.Sprintf("qt.HexDecodeToString(C.GoString(%v))", name)
		}

	case "QStringList":
		{
			return fmt.Sprintf("strings.Split(C.GoString(%v), \"|\")", name)
		}

	case "void", "":
		{
			if strings.Contains(vOld, "*") {
				return fmt.Sprintf("unsafe.Pointer(%v)", name)
			}

			return name
		}

	case "bool":
		{
			return fmt.Sprintf("%v != 0", name)
		}

	case "short", "qint16":
		{
			return fmt.Sprintf("int16(%v)", name)
		}

	case "ushort", "unsigned short", "quint16":
		{
			return fmt.Sprintf("uint16(%v)", name)
		}

	case "int", "qint32":
		{
			return fmt.Sprintf("int(int32(%v))", name)
		}

	case "uint", "unsigned int", "quint32":
		{
			return fmt.Sprintf("uint(uint32(%v))", name)
		}

	case "long":
		{
			return fmt.Sprintf("int(int32(%v))", name)
		}

	case "ulong", "unsigned long":
		{
			return fmt.Sprintf("uint(uint32(%v))", name)
		}

	case "longlong", "long long", "qlonglong", "qint64":
		{
			return fmt.Sprintf("int64(%v)", name)
		}

	case "ulonglong", "unsigned long long", "qulonglong", "quint64":
		{
			return fmt.Sprintf("uint64(%v)", name)
		}

	case "float":
		{
			return fmt.Sprintf("float32(%v)", name)
		}

	case "double", "qreal":
		{
			return fmt.Sprintf("float64(%v)", name)
		}

	case "uintptr_t", "uintptr", "quintptr", "WId":
		{
			return fmt.Sprintf("uintptr(%v)", name)
		}

		//non std types

	case "T", "JavaVM", "jclass", "jobject":
		{
			switch f.TemplateMode {
			case "Boolean":
				{
					return fmt.Sprintf("int8(%v) != 0", name)
				}

			case "Int":
				{
					return fmt.Sprintf("int(int32(%v))", name)
				}

			case "Void":
				{
					return name
				}
			}

			return fmt.Sprintf("unsafe.Pointer(%v)", name)
		}
	}

	switch {
	case isEnum(f.Class(), value):
		{
			if c, exists := parser.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
				if parser.ClassMap[f.Class()].WeakLink[c.Module] {
					return fmt.Sprintf("int64(%v)", name)
				}
				return fmt.Sprintf("%v.%v(%v)", module(c.Module), goEnum(f, value), name)
			}
			return fmt.Sprintf("%v(%v)", goEnum(f, value), name)
		}

	case isClass(value):
		{
			if m := module(parser.ClassMap[value].Module); m != module(f) {
				if parser.ClassMap[f.Class()].WeakLink[parser.ClassMap[value].Module] {
					return fmt.Sprintf("unsafe.Pointer(%v)", name)
				}
				return fmt.Sprintf("%v.New%vFromPointer(%v)", m, strings.Title(value), name)
			}

			return fmt.Sprintf("New%vFromPointer(%v)", strings.Title(value), name)
		}
	}

	f.Access = fmt.Sprintf("unsupported_goOutput(%v)", value)
	return f.Access
}

func goOutputFailed(value string, f *parser.Function) string {
	var vOld = value

	value = CleanValue(value)

	switch value {
	case "char", "qint8", "uchar", "quint8", "QString", "QByteArray":
		{
			return "\"\""
		}

	case "QStringList":
		{
			return "make([]string, 0)"
		}

	case "void", "":
		{
			if strings.Contains(vOld, "*") {
				return "nil"
			}

			return ""
		}

	case "bool":
		{
			return "false"
		}

	case
		"short", "qint16",
		"ushort", "unsigned short", "quint16",

		"int", "qint32",
		"uint", "unsigned int", "quint32",

		"long",
		"ulong", "unsigned long",

		"longlong", "long long", "qlonglong", "qint64",
		"ulonglong", "unsigned long long", "qulonglong", "quint64",

		"float",
		"double", "qreal",

		"uintptr_t", "uintptr", "quintptr", "WId":
		{
			return "0"
		}

		//non std types

	case "T", "JavaVM", "jclass", "jobject":
		{
			switch f.TemplateMode {
			case "Boolean":
				{
					return "false"
				}

			case "Int":
				{
					return "0"
				}

			case "Void":
				{
					return ""
				}
			}

			return "nil"
		}
	}

	switch {
	case isEnum(f.Class(), value):
		{
			return "0"
		}

	case isClass(value):
		{
			if f.TemplateMode == "String" {
				return "\"\""
			}

			return "nil"
		}
	}

	f.Access = fmt.Sprintf("unsupported_goOutputFailed(%v)", value)
	return f.Access
}

func cgoOutput(name, value string, f *parser.Function) string {

	var vOld = value

	name = cleanName(name, value)
	value = CleanValue(value)

	switch value {
	case "char", "qint8", "uchar", "quint8", "QString":
		{
			return fmt.Sprintf("C.GoString(%v)", name)
		}

	case "QByteArray":
		{
			return fmt.Sprintf("qt.HexDecodeToString(C.GoString(%v))", name)
		}

	case "QStringList":
		{
			return fmt.Sprintf("strings.Split(C.GoString(%v), \"|\")", name)
		}

	case "void", "":
		{
			if strings.Contains(vOld, "*") {
				return name
			}

			return ""
		}

	case "bool":
		{
			return fmt.Sprintf("int8(%v) != 0", name)
		}

	case "short", "qint16":
		{
			return fmt.Sprintf("int16(%v)", name)
		}

	case "ushort", "unsigned short", "quint16":
		{
			return fmt.Sprintf("uint16(%v)", name)
		}

	case "int", "qint32":
		{
			return fmt.Sprintf("int(int32(%v))", name)
		}

	case "uint", "unsigned int", "quint32":
		{
			return fmt.Sprintf("uint(uint32(%v))", name)
		}

	case "long":
		{
			return fmt.Sprintf("int(int32(%v))", name)
		}

	case "ulong", "unsigned long":
		{
			return fmt.Sprintf("uint(uint32(%v))", name)
		}

	case "longlong", "long long", "qlonglong", "qint64":
		{
			return fmt.Sprintf("int64(%v)", name)
		}

	case "ulonglong", "unsigned long long", "qulonglong", "quint64":
		{
			return fmt.Sprintf("uint64(%v)", name)
		}

	case "float":
		{
			return fmt.Sprintf("float32(%v)", name)
		}

	case "double", "qreal":
		{
			return fmt.Sprintf("float64(%v)", name)
		}

	case "uintptr_t", "uintptr", "quintptr", "WId":
		{
			return fmt.Sprintf("uintptr(%v)", name)
		}
	}

	switch {
	case isEnum(f.Class(), value):
		{
			if c, exists := parser.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
				if parser.ClassMap[f.Class()].WeakLink[c.Module] {
					return fmt.Sprintf("int64%v)", name)
				}
				return fmt.Sprintf("%v.%v(%v)", module(c.Module), goEnum(f, value), name)
			}
			return fmt.Sprintf("%v(%v)", goEnum(f, value), name)
		}

	case isClass(value):
		{
			if m := module(parser.ClassMap[value].Module); m != module(f) {
				if parser.ClassMap[f.Class()].WeakLink[parser.ClassMap[value].Module] {
					return fmt.Sprintf("unsafe.Pointer(%v)", name)
				}
				return fmt.Sprintf("%v.New%vFromPointer(%v)", m, strings.Title(value), name)
			}
			return fmt.Sprintf("New%vFromPointer(%v)", strings.Title(value), name)
		}
	}

	f.Access = fmt.Sprintf("unsupported_cgoOutput(%v)", value)
	return f.Access
}

func CppOutput(name, value string, f *parser.Function) string {
	return cppOutput(name, value, f)
}

func cppOutput(name, value string, f *parser.Function) string {
	var vOld = value

	name = cleanName(name, value)
	value = CleanValue(value)

	switch value {
	case "char", "qint8":
		{
			return cppOutput(fmt.Sprintf("QString(%v)", name), "QString", f)
		}

	case "uchar", "quint8":
		{
			if strings.Contains(vOld, "*") {
				return cppOutput(fmt.Sprintf("QString(QChar(*%v))", name), "QString", f)
			}

			return cppOutput(fmt.Sprintf("QString(QChar(%v))", name), "QString", f)
		}

	case "QString":
		{
			if strings.Contains(vOld, "*") {
				return fmt.Sprintf("const_cast<char*>(%v->toUtf8().prepend(\"WHITESPACE\").constData()+10)", name)
			}

			return fmt.Sprintf("const_cast<char*>(%v.toUtf8().prepend(\"WHITESPACE\").constData()+10)", name)
		}

	case "QByteArray":
		{
			return fmt.Sprintf("const_cast<char*>(%v.toHex().prepend(\"WHITESPACE\").constData()+10)", name)
		}

	case "QStringList":
		{
			return cppOutput(fmt.Sprintf("%v.join(\"|\")", name), "QString", f)
		}

	case
		"bool",

		"short", "qint16",
		"ushort", "unsigned short", "quint16",

		"int", "qint32",
		"uint", "unsigned int", "quint32",

		"long",
		"ulong", "unsigned long",

		"longlong", "long long", "qlonglong", "qint64",
		"ulonglong", "unsigned long long", "qulonglong", "quint64",

		"float",
		"double", "qreal",

		"uintptr_t", "uintptr", "quintptr", "WId":
		{
			if strings.Contains(vOld, "*") {
				return fmt.Sprintf("*%v", name)
			}

			return name
		}

		//non std types

	case "void", "", "T", "JavaVM", "jclass", "jobject":
		{
			if f.Fullname == "QMimeData::imageData" {
				return fmt.Sprintf("new QImage(qvariant_cast<QImage>(%v))", name)
			}

			if value == "void" || value == "T" {
				if strings.Contains(vOld, "*") && strings.Contains(vOld, "const") {
					return fmt.Sprintf("const_cast<void*>(%v)", name)
				}
			}

			return name
		}
	}

	switch {
	case isEnum(f.Class(), value):
		{
			return name
		}

	case isClass(value):
		{
			if strings.Contains(vOld, "*") {
				if strings.Contains(vOld, "const") {
					return fmt.Sprintf("const_cast<%v*>(%v)", value, name)
				}
				return name
			}

			if strings.Contains(vOld, "&") {
				if strings.Contains(vOld, "const") {
					return fmt.Sprintf("const_cast<%v*>(&%v)", value, name)
				}
			}

			f.NeedsFinalizer = true

			switch value {
			case "QModelIndex", "QMetaMethod", "QItemSelection":
				{
					return fmt.Sprintf("new %v(%v)", value, name)
				}

			case "QAndroidJniObject":
				{
					return fmt.Sprintf("new %v(%v.object())", value, name)
				}

			case "QPoint", "QPointF":
				{
					return fmt.Sprintf("({ %v tmpValue = %v; new %v(tmpValue.x(), tmpValue.y()); })", value, name, value)
				}

			case "QSize", "QSizeF":
				{
					return fmt.Sprintf("({ %v tmpValue = %v; new %v(tmpValue.width(), tmpValue.height()); })", value, name, value)
				}

			case "QRect", "QRectF":
				{
					return fmt.Sprintf("({ %v tmpValue = %v; new %v(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); })", value, name, value)
				}

			case "QLine", "QLineF":
				{
					return fmt.Sprintf("({ %v tmpValue = %v; new %v(tmpValue.p1(), tmpValue.p2()); })", value, name, value)
				}

			case "QMargins", "QMarginsF":
				{
					return fmt.Sprintf("({ %v tmpValue = %v; new %v(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); })", value, name, value)
				}
			}

			for _, f := range parser.ClassMap[value].Functions {
				if f.Meta == parser.CONSTRUCTOR {
					if len(f.Parameters) == 1 {
						if CleanValue(f.Parameters[0].Value) == value {
							return fmt.Sprintf("new %v(%v)", value, name)
						}
					}
				}
			}
		}
	}

	f.Access = fmt.Sprintf("unsupported_cppOutput(%v)", value)
	return f.Access
}