2015-10-24 18:18:24 +03:00
|
|
|
package templater
|
|
|
|
|
|
|
|
import (
|
2016-04-28 20:43:44 +03:00
|
|
|
"bytes"
|
2017-01-29 20:43:19 +03:00
|
|
|
"crypto/sha1"
|
|
|
|
"encoding/hex"
|
2015-10-24 18:18:24 +03:00
|
|
|
"fmt"
|
2018-11-06 20:16:33 +03:00
|
|
|
"math"
|
2018-06-09 03:31:50 +03:00
|
|
|
"math/rand"
|
2019-11-28 19:53:39 +03:00
|
|
|
"path/filepath"
|
2015-12-06 02:56:16 +03:00
|
|
|
"sort"
|
2015-10-24 18:18:24 +03:00
|
|
|
"strings"
|
2018-06-09 03:31:50 +03:00
|
|
|
"time"
|
2015-10-24 18:18:24 +03:00
|
|
|
|
2017-07-19 19:45:25 +03:00
|
|
|
"github.com/therecipe/qt/internal/binding/converter"
|
2015-10-24 18:18:24 +03:00
|
|
|
"github.com/therecipe/qt/internal/binding/parser"
|
2017-01-27 22:22:58 +03:00
|
|
|
"github.com/therecipe/qt/internal/utils"
|
2015-10-24 18:18:24 +03:00
|
|
|
)
|
|
|
|
|
2018-06-09 03:31:50 +03:00
|
|
|
var exportedFunctions []string
|
2018-10-23 22:04:38 +03:00
|
|
|
var CleanupDepsForCI = func() {}
|
2018-06-09 03:31:50 +03:00
|
|
|
|
2017-05-16 01:06:35 +03:00
|
|
|
func CppTemplate(module string, mode int, target, tags string) []byte {
|
2017-03-28 18:41:57 +03:00
|
|
|
utils.Log.WithField("module", module).Debug("generating cpp")
|
2018-06-09 03:31:50 +03:00
|
|
|
exportedFunctions = make([]string, 0)
|
2017-03-21 00:27:56 +03:00
|
|
|
parser.State.Target = target
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
var bb = new(bytes.Buffer)
|
|
|
|
defer bb.Reset()
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode != MOC {
|
2016-12-31 01:37:32 +03:00
|
|
|
module = "Qt" + module
|
2017-01-29 20:43:19 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
for _, c := range parser.SortedClassNamesForModule(module, true) {
|
2017-01-29 20:43:19 +03:00
|
|
|
var class, e = parser.State.ClassMap[c]
|
|
|
|
if !e {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
var typeMap = make(map[string]string)
|
|
|
|
for _, f := range class.Functions {
|
|
|
|
if parser.IsPackedMap(f.Output) {
|
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(f.Output))
|
|
|
|
typeMap[f.Output] = hex.EncodeToString(tHash.Sum(nil)[:3])
|
|
|
|
}
|
|
|
|
for _, p := range f.Parameters {
|
|
|
|
if parser.IsPackedMap(p.Value) {
|
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(p.Value))
|
|
|
|
typeMap[p.Value] = hex.EncodeToString(tHash.Sum(nil)[:3])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-03 01:01:46 +03:00
|
|
|
for _, p := range class.Properties {
|
|
|
|
if parser.IsPackedMap(p.Output) {
|
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(p.Output))
|
|
|
|
typeMap[p.Output] = hex.EncodeToString(tHash.Sum(nil)[:3])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-29 20:43:19 +03:00
|
|
|
for typ, hash := range typeMap {
|
|
|
|
fmt.Fprintf(bb, "typedef %v type%v;\n", typ, hash)
|
|
|
|
}
|
|
|
|
}
|
2016-12-31 01:37:32 +03:00
|
|
|
}
|
|
|
|
|
2016-12-17 03:18:44 +03:00
|
|
|
if module == "QtCharts" || module == "QtDataVisualization" {
|
2017-02-15 19:48:35 +03:00
|
|
|
for _, classname := range parser.SortedClassNamesForModule(module, true) {
|
2016-12-17 03:18:44 +03:00
|
|
|
fmt.Fprintf(bb, "typedef %v::%v %v;\n", module, classname, classname)
|
|
|
|
}
|
|
|
|
fmt.Fprint(bb, "\n")
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
for _, className := range parser.SortedClassNamesForModule(module, true) {
|
2017-01-02 19:01:18 +03:00
|
|
|
var class = parser.State.ClassMap[className]
|
2016-04-16 19:48:26 +03:00
|
|
|
|
2017-01-02 19:01:18 +03:00
|
|
|
if class.IsSupported() {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-04 21:01:53 +03:00
|
|
|
if class.HasCallbackFunctions() || mode == MOC {
|
2015-12-15 04:01:51 +03:00
|
|
|
|
2017-01-13 22:14:08 +03:00
|
|
|
//TODO: split
|
2016-04-28 20:43:44 +03:00
|
|
|
fmt.Fprintf(bb,
|
|
|
|
`class %v%v: public %v
|
|
|
|
{
|
|
|
|
%vpublic:
|
|
|
|
`,
|
|
|
|
func() string {
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2016-04-28 20:43:44 +03:00
|
|
|
return ""
|
2016-01-04 04:05:31 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return "My"
|
|
|
|
}(),
|
|
|
|
|
|
|
|
class.Name,
|
|
|
|
|
|
|
|
func() string {
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2016-04-28 20:43:44 +03:00
|
|
|
return class.GetBases()[0]
|
|
|
|
}
|
|
|
|
return class.Name
|
|
|
|
}(),
|
|
|
|
|
|
|
|
func() string {
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2018-10-23 22:04:38 +03:00
|
|
|
bb := new(bytes.Buffer)
|
2017-01-13 22:14:08 +03:00
|
|
|
defer bb.Reset()
|
|
|
|
fmt.Fprintln(bb, "Q_OBJECT")
|
|
|
|
|
|
|
|
for _, p := range class.Properties {
|
2017-02-03 01:01:46 +03:00
|
|
|
|
2018-10-23 22:04:38 +03:00
|
|
|
ty := p.Output
|
2017-02-03 01:01:46 +03:00
|
|
|
if parser.IsPackedMap(p.Output) {
|
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(p.Output))
|
|
|
|
ty = fmt.Sprintf("type%v", hex.EncodeToString(tHash.Sum(nil)[:3]))
|
|
|
|
}
|
|
|
|
|
2018-04-12 22:42:26 +03:00
|
|
|
fmt.Fprintf(bb, "Q_PROPERTY(%v PREPRO%v READ %v WRITE set%v NOTIFY %vChanged)\n", ty, p.Name,
|
2017-01-13 22:14:08 +03:00
|
|
|
func() string {
|
2017-06-21 23:05:59 +03:00
|
|
|
if p.Output == "bool" && !strings.HasPrefix(strings.ToLower(p.Name), "is") {
|
2017-01-13 22:14:08 +03:00
|
|
|
return "is" + strings.Title(p.Name)
|
|
|
|
}
|
|
|
|
return p.Name
|
|
|
|
}(), strings.Title(p.Name), p.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
return bb.String()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}())
|
|
|
|
|
|
|
|
if !hasUnimplementedPureVirtualFunctions(class.Name) {
|
|
|
|
for _, function := range class.Functions {
|
2017-01-18 21:28:40 +03:00
|
|
|
if function.Meta != parser.CONSTRUCTOR || !function.IsSupported() {
|
|
|
|
continue
|
|
|
|
}
|
2016-01-04 04:05:31 +03:00
|
|
|
|
2018-10-23 22:04:38 +03:00
|
|
|
out := fmt.Sprintf("\t%v%v(%v) : %v(%v) {%v};\n",
|
2017-01-18 21:28:40 +03:00
|
|
|
func() string {
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2017-01-18 21:28:40 +03:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return "My"
|
|
|
|
}(),
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
function.ClassName(),
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-04-05 18:13:51 +03:00
|
|
|
func() string {
|
|
|
|
var input []string
|
|
|
|
for _, p := range function.OgParameters {
|
2017-08-01 20:43:48 +03:00
|
|
|
name := parser.CleanName(p.Name, p.Value)
|
2017-04-05 18:13:51 +03:00
|
|
|
if p.Default != "" {
|
|
|
|
if strings.HasSuffix(p.Value, "*") || strings.HasSuffix(p.Value, "&") {
|
2017-08-01 20:43:48 +03:00
|
|
|
input = append(input, p.Value+name+" = "+p.Default)
|
2017-04-05 18:13:51 +03:00
|
|
|
} else {
|
2017-08-01 20:43:48 +03:00
|
|
|
input = append(input, p.Value+" "+name+" = "+p.Default)
|
2017-04-05 18:13:51 +03:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if strings.HasSuffix(p.Value, "*") || strings.HasSuffix(p.Value, "&") {
|
2017-08-01 20:43:48 +03:00
|
|
|
input = append(input, p.Value+name)
|
2017-04-05 18:13:51 +03:00
|
|
|
} else {
|
2017-08-01 20:43:48 +03:00
|
|
|
input = append(input, p.Value+" "+name)
|
2017-04-05 18:13:51 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return strings.Join(input, ", ")
|
|
|
|
}(),
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func() string {
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2017-01-18 21:28:40 +03:00
|
|
|
return class.GetBases()[0]
|
|
|
|
}
|
|
|
|
return function.ClassName()
|
|
|
|
}(),
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-08-01 20:43:48 +03:00
|
|
|
func() string {
|
|
|
|
input := make([]string, len(function.Parameters))
|
|
|
|
for i, p := range function.Parameters {
|
|
|
|
input[i] = parser.CleanName(p.Name, p.Value)
|
|
|
|
}
|
|
|
|
return strings.Join(input, ", ")
|
|
|
|
}(),
|
2017-05-31 16:05:10 +03:00
|
|
|
|
|
|
|
func() string {
|
2017-06-10 22:37:03 +03:00
|
|
|
var pre string
|
2019-10-14 21:30:44 +03:00
|
|
|
if class.IsSubClassOfQObject() || class.HasCallbackFunctions() {
|
2017-06-14 17:12:17 +03:00
|
|
|
pre = fmt.Sprintf("%[1]v_%[1]v_QRegisterMetaType();", className)
|
2017-06-10 22:37:03 +03:00
|
|
|
}
|
2017-05-31 16:05:10 +03:00
|
|
|
if mode != MOC {
|
2017-06-10 22:37:03 +03:00
|
|
|
return pre
|
2017-05-31 16:05:10 +03:00
|
|
|
}
|
2018-06-09 03:31:50 +03:00
|
|
|
if UseJs() {
|
|
|
|
return fmt.Sprintf("qRegisterMetaType<quintptr>(\"quintptr\");%[1]v%[2]v_%[2]v_QRegisterMetaTypes();emscripten::val::global(\"Module\").call<void>(\"_callback%[2]v_Constructor\", reinterpret_cast<uintptr_t>(this));", pre, className)
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("qRegisterMetaType<quintptr>(\"quintptr\");%[1]v%[2]v_%[2]v_QRegisterMetaTypes();callback%[2]v_Constructor(this);", pre, className)
|
2017-05-31 16:05:10 +03:00
|
|
|
}(),
|
2017-01-18 21:28:40 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
fmt.Fprint(bb, out)
|
2015-12-15 04:01:51 +03:00
|
|
|
}
|
2016-01-04 04:05:31 +03:00
|
|
|
}
|
2015-12-15 04:01:51 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//callback functions
|
2018-10-23 22:04:38 +03:00
|
|
|
implementedVirtuals := make(map[string]struct{})
|
2017-02-15 19:48:35 +03:00
|
|
|
for i, parentClassName := range append([]string{class.Name}, class.GetAllBases()...) {
|
|
|
|
var parentClass, e = parser.State.ClassMap[parentClassName]
|
|
|
|
if !e || !parentClass.IsSupported() {
|
|
|
|
continue
|
2015-12-23 18:22:00 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
for _, f := range parentClass.Functions {
|
|
|
|
var _, e = implementedVirtuals[f.Name+f.OverloadNumber]
|
|
|
|
if e || !f.IsSupported() {
|
|
|
|
continue
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-23 02:45:45 +03:00
|
|
|
if (parentClass.Module == parser.MOC || parentClass.Pkg != "") && f.Meta == parser.SLOT {
|
2017-02-15 19:48:35 +03:00
|
|
|
continue
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
if i > 0 && (f.Meta == parser.CONSTRUCTOR || f.Meta == parser.DESTRUCTOR) {
|
|
|
|
continue
|
2015-12-06 02:56:16 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-05-10 17:29:50 +03:00
|
|
|
implementedVirtuals[f.Name+f.OverloadNumber] = struct{}{}
|
|
|
|
|
2019-11-28 19:53:39 +03:00
|
|
|
fOld := f
|
2017-02-15 19:48:35 +03:00
|
|
|
var f = *f
|
|
|
|
f.SignalMode = parser.CALLBACK
|
|
|
|
f.Fullname = fmt.Sprintf("%v::%v", class.Name, f.Name)
|
|
|
|
f.Fullname = fmt.Sprintf("%v::%v", f.FindDeepestImplementation(), f.Name)
|
|
|
|
|
|
|
|
if f.Meta == parser.SLOT || f.Meta == parser.SIGNAL || f.Virtual == parser.IMPURE || f.Virtual == parser.PURE {
|
2018-10-23 22:04:38 +03:00
|
|
|
if fb := cppFunctionCallback(&f); len(fb) != 0 {
|
|
|
|
fmt.Fprintf(bb, "\t%v\n", fb)
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2019-11-28 19:53:39 +03:00
|
|
|
if f.NeedsFinalizer {
|
|
|
|
fOld.NeedsFinalizer = true
|
|
|
|
fOld.NeedsFinalizerFor = f.NeedsFinalizerFor
|
|
|
|
}
|
2015-10-24 18:18:24 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-04 04:05:31 +03:00
|
|
|
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2017-01-13 22:14:08 +03:00
|
|
|
for _, p := range class.Properties {
|
2017-02-03 01:01:46 +03:00
|
|
|
|
|
|
|
var ty = p.Output
|
|
|
|
if parser.IsPackedMap(p.Output) {
|
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(p.Output))
|
|
|
|
ty = fmt.Sprintf("type%v", hex.EncodeToString(tHash.Sum(nil)[:3]))
|
|
|
|
}
|
|
|
|
|
2017-06-12 20:52:01 +03:00
|
|
|
fmt.Fprintf(bb, "\t%v %v%v() { return _%v; };\n",
|
|
|
|
ty,
|
|
|
|
func() string {
|
2017-06-21 23:05:59 +03:00
|
|
|
if p.Output == "bool" && !strings.HasPrefix(strings.ToLower(p.Name), "is") {
|
2017-06-12 20:52:01 +03:00
|
|
|
return "is" + strings.Title(p.Name)
|
|
|
|
}
|
|
|
|
return p.Name
|
|
|
|
}(),
|
|
|
|
func() string {
|
|
|
|
if p.IsMocSynthetic {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return "Default"
|
|
|
|
}(),
|
|
|
|
p.Name,
|
|
|
|
)
|
|
|
|
fmt.Fprintf(bb, "\tvoid set%v%v(%v p) { if (p != _%v) { _%v = p; %vChanged(_%v); } };\n",
|
|
|
|
strings.Title(p.Name),
|
|
|
|
func() string {
|
|
|
|
if p.IsMocSynthetic {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return "Default"
|
|
|
|
}(),
|
|
|
|
ty,
|
|
|
|
p.Name,
|
|
|
|
p.Name,
|
|
|
|
p.Name,
|
|
|
|
p.Name,
|
|
|
|
)
|
2017-01-13 22:14:08 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
fmt.Fprintln(bb, "signals:")
|
|
|
|
for _, function := range class.Functions {
|
|
|
|
if function.Meta == parser.SIGNAL {
|
|
|
|
var function = *function
|
|
|
|
function.Meta = parser.SLOT
|
2018-10-23 22:04:38 +03:00
|
|
|
if fb := cppFunctionCallbackHeader(&function); len(fb) != 0 {
|
|
|
|
fmt.Fprintf(bb, "\t%v;\n", fb)
|
|
|
|
}
|
2016-04-16 19:48:26 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
fmt.Fprintln(bb, "public slots:")
|
|
|
|
for _, function := range class.Functions {
|
|
|
|
if function.Meta == parser.SLOT {
|
2019-11-28 19:53:39 +03:00
|
|
|
osm := function.SignalMode
|
|
|
|
function.SignalMode = parser.CALLBACK
|
2018-10-23 22:04:38 +03:00
|
|
|
if fb := cppFunctionCallback(function); len(fb) != 0 {
|
|
|
|
fmt.Fprintf(bb, "\t%v\n", fb)
|
|
|
|
}
|
2019-11-28 19:53:39 +03:00
|
|
|
function.SignalMode = osm
|
2016-04-16 19:48:26 +03:00
|
|
|
}
|
|
|
|
}
|
2017-01-13 22:14:08 +03:00
|
|
|
|
|
|
|
fmt.Fprintln(bb, "private:")
|
|
|
|
for _, p := range class.Properties {
|
2017-02-03 01:01:46 +03:00
|
|
|
var ty = p.Output
|
|
|
|
if parser.IsPackedMap(p.Output) {
|
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(p.Output))
|
|
|
|
ty = fmt.Sprintf("type%v", hex.EncodeToString(tHash.Sum(nil)[:3]))
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprintf(bb, "\t%v _%v;\n", ty, p.Name)
|
2017-01-13 22:14:08 +03:00
|
|
|
}
|
2016-04-16 19:48:26 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
fmt.Fprint(bb, "};\n\n")
|
2015-10-24 18:18:24 +03:00
|
|
|
}
|
2019-10-14 21:30:44 +03:00
|
|
|
if class.IsSubClassOfQObject() || class.HasCallbackFunctions() {
|
|
|
|
if mode != MOC {
|
|
|
|
switch class.Name {
|
|
|
|
case "QSurface", "QGraphicsItem", "QObject", "QMacToolBar", "QQmlComponent", "QQmlWebChannel",
|
|
|
|
"QAbstractVideoSurface", "QScxmlDataModel", "QScxmlInvokableService", "QScxmlStateMachine",
|
|
|
|
"QGamepad", "QQuickItem", "QQuickTextDocument", "QQuickTransform", "QQuickWindow", "QWebEngineCookieStore":
|
|
|
|
//re-definition
|
|
|
|
default:
|
2019-11-28 19:53:39 +03:00
|
|
|
if class.Module != "QtQuickControls2" || (class.Module == "QtQuickControls2" && !strings.HasPrefix(class.Name, "QQuick")) {
|
|
|
|
fmt.Fprintf(bb, "Q_DECLARE_METATYPE(%v*)\n", class.Name)
|
|
|
|
}
|
2019-10-14 21:30:44 +03:00
|
|
|
}
|
|
|
|
}
|
2017-06-10 22:37:03 +03:00
|
|
|
fmt.Fprintf(bb, "Q_DECLARE_METATYPE(%v%v*)\n\n",
|
|
|
|
func() string {
|
|
|
|
if mode != MOC {
|
|
|
|
return "My"
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}(), class.Name)
|
|
|
|
|
|
|
|
if mode != MOC {
|
2017-06-12 17:32:15 +03:00
|
|
|
if strings.HasPrefix(class.Name, "QMac") && !strings.HasPrefix(parser.State.ClassMap[class.Name].Module, "QtMac") {
|
2017-07-12 00:33:08 +03:00
|
|
|
fmt.Fprintf(bb, "int %[1]v_%[1]v_QRegisterMetaType(){\n\t#ifdef Q_OS_OSX\n\t\tqRegisterMetaType<%[1]v*>(); return qRegisterMetaType<My%[1]v*>();\n\t#else\n\t\treturn 0;\n\t#endif\n}\n\n", class.Name)
|
2017-06-12 17:32:15 +03:00
|
|
|
} else {
|
2019-11-28 19:53:39 +03:00
|
|
|
if class.Module == "QtQuickControls2" && strings.HasPrefix(class.Name, "QQuick") {
|
|
|
|
fmt.Fprintf(bb, "int %[1]v_%[1]v_QRegisterMetaType(){return qRegisterMetaType<My%[1]v*>();}\n\n", class.Name)
|
|
|
|
} else {
|
|
|
|
fmt.Fprintf(bb, "int %[1]v_%[1]v_QRegisterMetaType(){qRegisterMetaType<%[1]v*>(); return qRegisterMetaType<My%[1]v*>();}\n\n", class.Name)
|
|
|
|
}
|
2017-06-12 17:32:15 +03:00
|
|
|
}
|
2017-06-14 17:12:17 +03:00
|
|
|
} else {
|
2019-05-16 06:31:11 +03:00
|
|
|
typeMap := make(map[string]string)
|
2017-06-14 17:12:17 +03:00
|
|
|
for _, f := range class.Functions {
|
2017-06-23 23:07:09 +03:00
|
|
|
if parser.IsPackedMap(f.Output) {
|
2017-06-14 17:12:17 +03:00
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(f.Output))
|
|
|
|
typeMap[f.Output] = hex.EncodeToString(tHash.Sum(nil)[:3])
|
|
|
|
}
|
2019-05-16 06:31:11 +03:00
|
|
|
if parser.IsPackedList(f.Output) {
|
|
|
|
typeMap[f.Output] = "QList<QObject*>"
|
|
|
|
}
|
2017-06-14 17:12:17 +03:00
|
|
|
for _, p := range f.Parameters {
|
2017-06-23 23:07:09 +03:00
|
|
|
if parser.IsPackedMap(p.Value) {
|
2017-06-14 17:12:17 +03:00
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(p.Value))
|
|
|
|
typeMap[p.Value] = hex.EncodeToString(tHash.Sum(nil)[:3])
|
|
|
|
}
|
2019-05-16 06:31:11 +03:00
|
|
|
if parser.IsPackedList(p.Value) {
|
|
|
|
typeMap[p.Value] = "QList<QObject*>"
|
|
|
|
}
|
2017-06-14 17:12:17 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 19:45:25 +03:00
|
|
|
propTypes := make(map[string]struct{})
|
2017-06-14 17:12:17 +03:00
|
|
|
for _, p := range class.Properties {
|
2017-06-23 23:07:09 +03:00
|
|
|
if parser.IsPackedMap(p.Output) {
|
2017-06-14 17:12:17 +03:00
|
|
|
var tHash = sha1.New()
|
|
|
|
tHash.Write([]byte(p.Output))
|
|
|
|
typeMap[p.Output] = hex.EncodeToString(tHash.Sum(nil)[:3])
|
|
|
|
}
|
2019-05-16 06:31:11 +03:00
|
|
|
if parser.IsPackedList(p.Output) {
|
|
|
|
typeMap[p.Output] = "QList<QObject*>"
|
|
|
|
}
|
2017-07-19 19:45:25 +03:00
|
|
|
if o := converter.CppRegisterMetaTypeProp(p); o != "" {
|
|
|
|
propTypes[o] = struct{}{}
|
|
|
|
}
|
2017-06-14 17:12:17 +03:00
|
|
|
}
|
|
|
|
|
2017-06-23 23:07:09 +03:00
|
|
|
for _, hash := range typeMap {
|
2017-06-28 20:58:42 +03:00
|
|
|
if hash == "30021d" || //QHash<quintptr, quintptr>
|
|
|
|
hash == "95ad14" || //QHash<qint32, quintptr>
|
2018-04-27 19:58:50 +03:00
|
|
|
hash == "d01680" || //QHash<qint32, QByteArray>
|
|
|
|
hash == "d15f9e" || //QMap<quintptr, quintptr>
|
|
|
|
hash == "cc064b" || //QMap<qint32, quintptr>
|
2019-05-16 06:31:11 +03:00
|
|
|
hash == "378cdd" || //QMap<qint32, QByteArray>
|
|
|
|
hash == "424d06" || //QMap<QString, QVariant>
|
|
|
|
hash == "QList<QObject*>" {
|
2017-06-23 23:07:09 +03:00
|
|
|
continue
|
2017-06-14 17:12:17 +03:00
|
|
|
}
|
2017-06-23 23:07:09 +03:00
|
|
|
fmt.Fprintf(bb, "Q_DECLARE_METATYPE(type%v)\n", hash)
|
2017-06-14 17:12:17 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprintf(bb, "\nvoid %[1]v_%[1]v_QRegisterMetaTypes() {\n", class.Name)
|
2019-05-16 06:31:11 +03:00
|
|
|
for out, hash := range typeMap {
|
|
|
|
if parser.IsPackedList(out) {
|
|
|
|
if up := parser.UnpackedList(out); parser.State.ClassMap[up].IsSubClassOfQObject() && up != "QObject" {
|
|
|
|
fmt.Fprintf(bb, "\tqRegisterMetaType<%v>(\"%v\");\n", hash, out)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fmt.Fprintf(bb, "\tqRegisterMetaType<type%[1]v>(\"type%[1]v\");\n", hash)
|
|
|
|
}
|
2017-06-14 17:12:17 +03:00
|
|
|
}
|
2017-07-19 19:45:25 +03:00
|
|
|
for t := range propTypes {
|
|
|
|
fmt.Fprintf(bb, "\tqRegisterMetaType<%v>();\n", t)
|
|
|
|
}
|
2017-06-14 17:12:17 +03:00
|
|
|
fmt.Fprint(bb, "}\n\n")
|
2017-06-10 22:37:03 +03:00
|
|
|
}
|
2019-10-14 21:30:44 +03:00
|
|
|
} else if strings.HasPrefix(class.Name, "Q") {
|
|
|
|
if f := class.GetFunction(class.Name); f != nil {
|
|
|
|
if cppFunction(f); f.IsSupported() {
|
|
|
|
switch class.Name {
|
|
|
|
case "QFileInfo", "QItemSelection", "QItemSelectionRange", "QStorageInfo",
|
|
|
|
"QVariant", "QVersionNumber", "QOpenGLDebugMessage", "QPageLayout",
|
|
|
|
"QPageSize", "QStaticText", "QNetworkAddressEntry", "QNetworkConfiguration",
|
|
|
|
"QNetworkDatagram", "QNetworkInterface", "QNetworkProxy", "QOcspResponse",
|
|
|
|
"QSslConfiguration", "QSslEllipticCurve", "QSslPreSharedKeyAuthenticator",
|
|
|
|
"QDBusArgument", "QDBusMessage", "QDBusObjectPath", "QDBusSignature", "QDBusUnixFileDescriptor",
|
|
|
|
"QDBusVariant", "QNdefMessage", "QGeoAddress", "QGeoCircle", "QGeoCoordinate", "QGeoPath", "QGeoPolygon",
|
|
|
|
"QGeoPositionInfo", "QGeoRectangle", "QGeoShape", "QQmlListReference", "QQmlScriptString",
|
|
|
|
"QSourceLocation", "QXmlItem", "QXmlName", "QBluetoothAddress", "QBluetoothDeviceInfo", "QBluetoothHostInfo",
|
|
|
|
"QBluetoothServiceInfo", "QBluetoothUuid", "QLowEnergyCharacteristic", "QLowEnergyConnectionParameters",
|
|
|
|
"QLowEnergyDescriptor", "QAudioBuffer", "QAudioDeviceInfo", "QAudioEncoderSettings", "QAudioFormat", "QCameraViewfinderSettings",
|
|
|
|
"QImageEncoderSettings", "QMediaContent", "QMediaResource", "QVideoEncoderSettings", "QVideoFrame",
|
2019-10-23 02:27:33 +03:00
|
|
|
"QVideoSurfaceFormat", "QTestEventList", "QModbusDeviceIdentification", "QScxmlError", "QScxmlEvent",
|
2019-11-20 17:58:34 +03:00
|
|
|
"QNetworkRequest", "QWebElement":
|
2019-10-14 21:30:44 +03:00
|
|
|
//re-definition
|
|
|
|
case "QCommandLineParser", "QDataStream", "QEventLoopLocker", "QMessageLogger", "QMimeDatabase",
|
|
|
|
"QSemaphoreReleaser", "QTemporaryDir", "QWaitCondition", "QXmlStreamReader", "QXmlStreamWriter",
|
|
|
|
"QImageReader", "QImageWriter", "QOpenGLTextureBlitter", "QPainter", "QPainterPathStroker",
|
|
|
|
"QPictureIO", "QTextDocumentWriter", "QTextLayout", "QXmlNamespaceSupport", "QStylePainter",
|
2019-10-23 02:27:33 +03:00
|
|
|
"QXmlSchemaValidator", "QAndroidJniEnvironment", "QMutex", "QRecursiveMutex":
|
2019-10-14 21:30:44 +03:00
|
|
|
//constructor issue
|
|
|
|
default:
|
|
|
|
if len(f.Parameters) == 0 {
|
|
|
|
fmt.Fprintf(bb, "Q_DECLARE_METATYPE(%v)\n", class.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if class.Name != "QSslPreSharedKeyAuthenticator" {
|
|
|
|
fmt.Fprintf(bb, "Q_DECLARE_METATYPE(%v*)\n", class.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-11-18 22:10:11 +03:00
|
|
|
}
|
2015-10-24 18:18:24 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode != MOC {
|
2017-02-15 19:48:35 +03:00
|
|
|
cTemplate(bb, class, cppEnum, cppFunction, "\n\n", false)
|
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
}
|
2016-12-14 23:12:51 +03:00
|
|
|
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2017-02-15 19:48:35 +03:00
|
|
|
for _, className := range parser.SortedClassNamesForModule(module, true) {
|
|
|
|
var class = parser.State.ClassMap[className]
|
|
|
|
|
|
|
|
if class.IsSupported() {
|
|
|
|
cTemplate(bb, class, cppEnum, cppFunction, "\n\n", false)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-09 03:31:50 +03:00
|
|
|
if !UseJs() {
|
|
|
|
fmt.Fprintln(bb, "#include \"moc_moc.h\"")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if UseJs() {
|
|
|
|
for _, df := range deferredFunctions {
|
|
|
|
bb.WriteString(df)
|
|
|
|
}
|
|
|
|
deferredFunctions = nil
|
|
|
|
|
|
|
|
rand.Seed(time.Now().UTC().UnixNano())
|
2018-11-06 20:16:33 +03:00
|
|
|
fmt.Fprintf(bb, "EMSCRIPTEN_BINDINGS(r%v) {\n", rand.Intn(math.MaxInt32)) //TODO: use deterministic hash instead
|
2018-06-09 03:31:50 +03:00
|
|
|
|
|
|
|
sort.Stable(sort.StringSlice(exportedFunctions))
|
|
|
|
|
|
|
|
for _, f := range exportedFunctions {
|
|
|
|
if strings.Contains(bb.String(), f+"(") && !strings.Contains(bb.String(), "_KEEPALIVE_"+f+"(") && !strings.Contains(bb.String(), "_"+f+"\"") {
|
|
|
|
fmt.Fprintf(bb, "\temscripten::function(\"_%[1]v\", &%[1]v);\n", f)
|
|
|
|
}
|
|
|
|
|
|
|
|
if strings.Contains(bb.String(), f+"Default(") && !strings.Contains(bb.String(), "_KEEPALIVE_"+f+"Default(") && !strings.Contains(bb.String(), "_"+f+"Default\"") {
|
|
|
|
fmt.Fprintf(bb, "\temscripten::function(\"_%[1]vDefault\", &%[1]vDefault);\n", f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprintln(bb, "}\n")
|
|
|
|
|
|
|
|
if mode == MOC {
|
|
|
|
fmt.Fprintln(bb, "#include \"moc_moc.h\"")
|
|
|
|
}
|
2015-10-24 18:18:24 +03:00
|
|
|
}
|
|
|
|
|
2018-06-09 03:31:50 +03:00
|
|
|
return preambleCpp(module, bb.Bytes(), mode, target, tags)
|
2015-10-24 18:18:24 +03:00
|
|
|
}
|
|
|
|
|
2018-06-09 03:31:50 +03:00
|
|
|
func preambleCpp(module string, input []byte, mode int, target, tags string) []byte {
|
2016-04-28 20:43:44 +03:00
|
|
|
var bb = new(bytes.Buffer)
|
|
|
|
defer bb.Reset()
|
2015-10-24 18:18:24 +03:00
|
|
|
|
2017-04-17 22:13:53 +03:00
|
|
|
if mode == MOC {
|
2019-04-28 03:44:55 +03:00
|
|
|
libsm := make(map[string]struct{})
|
2017-04-17 22:13:53 +03:00
|
|
|
for _, c := range parser.State.ClassMap {
|
|
|
|
if c.Pkg != "" && c.IsSubClassOfQObject() {
|
|
|
|
libsm[c.Module] = struct{}{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
var libs []string
|
|
|
|
for k := range libsm {
|
|
|
|
libs = append(libs, k)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, c := range parser.SortedClassesForModule(strings.Join(libs, ","), true) {
|
|
|
|
if c.Pkg == "" || !strings.Contains(string(input), c.Name) /*|| !c.HasConstructor()*/ {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprintf(bb, "class %v: public %v{\npublic:\n", c.Name, c.GetBases()[0])
|
|
|
|
|
|
|
|
for _, function := range c.Functions {
|
|
|
|
if function.Meta != parser.CONSTRUCTOR || !function.IsSupported() {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
var input = make([]string, len(function.Parameters))
|
|
|
|
for i, p := range function.Parameters {
|
|
|
|
input[i] = p.Name
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprintf(bb, "\t%v%v(%v) : %v(%v) {};\n",
|
|
|
|
func() string {
|
|
|
|
if mode == MOC {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return "My"
|
|
|
|
}(),
|
|
|
|
|
|
|
|
function.ClassName(),
|
|
|
|
|
|
|
|
strings.Split(strings.Split(function.Signature, "(")[1], ")")[0],
|
|
|
|
|
|
|
|
func() string {
|
|
|
|
if mode == MOC {
|
|
|
|
return c.GetBases()[0]
|
|
|
|
}
|
|
|
|
return function.ClassName()
|
|
|
|
}(),
|
|
|
|
|
|
|
|
strings.Join(input, ", "),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
fmt.Fprint(bb, "\n};\n")
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprint(bb, "\n")
|
|
|
|
|
|
|
|
bb.Write(input)
|
|
|
|
input = []byte(bb.String())
|
|
|
|
bb.Reset()
|
|
|
|
}
|
|
|
|
|
2016-05-28 19:18:42 +03:00
|
|
|
fmt.Fprintf(bb, `%v
|
|
|
|
|
|
|
|
#define protected public
|
2016-04-28 20:43:44 +03:00
|
|
|
#define private public
|
2019-12-21 19:42:05 +03:00
|
|
|
%v
|
2016-04-28 20:43:44 +03:00
|
|
|
#include "%v.h"
|
2019-04-20 20:34:45 +03:00
|
|
|
%v%v
|
2019-08-28 00:09:01 +03:00
|
|
|
%v
|
2016-04-28 20:43:44 +03:00
|
|
|
`,
|
2017-05-16 01:06:35 +03:00
|
|
|
buildTags(module, false, mode, tags),
|
2016-05-28 19:18:42 +03:00
|
|
|
|
2019-12-21 19:42:05 +03:00
|
|
|
func() string {
|
|
|
|
if target == "darwin" && utils.QT_STATIC() && utils.QT_DOCKER() && module == "QtCore" {
|
|
|
|
return `
|
|
|
|
#include <QOperatingSystemVersion>
|
2019-12-23 03:02:14 +03:00
|
|
|
extern "C" int32_t __isOSVersionAtLeast(int32_t Major, int32_t Minor, int32_t Subminor) {
|
2019-12-21 19:42:05 +03:00
|
|
|
const auto current = QOperatingSystemVersion::current();
|
|
|
|
if (Major < current.majorVersion()) return 1;
|
|
|
|
if (Major > current.majorVersion()) return 0;
|
|
|
|
if (Minor < current.minorVersion()) return 1;
|
|
|
|
if (Minor > current.minorVersion()) return 0;
|
|
|
|
return Subminor <= current.microVersion();
|
|
|
|
}
|
2019-12-23 03:02:14 +03:00
|
|
|
extern "C" int32_t __isPlatformVersionAtLeast(int32_t Platform, int32_t Major, int32_t Minor, int32_t Subminor) { return __isOSVersionAtLeast(Major, Minor, Subminor); }
|
2019-12-21 19:42:05 +03:00
|
|
|
`
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}(),
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func() string {
|
|
|
|
switch module {
|
|
|
|
case "QtAndroidExtras":
|
|
|
|
{
|
2017-01-02 19:01:18 +03:00
|
|
|
return fmt.Sprintf("%v_android", goModule(module))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-04 04:05:31 +03:00
|
|
|
|
2016-06-19 05:24:38 +03:00
|
|
|
case "QtSailfish":
|
|
|
|
{
|
2017-01-02 19:01:18 +03:00
|
|
|
return fmt.Sprintf("%v_sailfish", goModule(module))
|
2016-06-19 05:24:38 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
default:
|
|
|
|
{
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MINIMAL {
|
2017-01-02 19:01:18 +03:00
|
|
|
return fmt.Sprintf("%v-minimal", goModule(module))
|
2016-10-14 20:06:35 +03:00
|
|
|
}
|
2017-01-02 19:01:18 +03:00
|
|
|
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MOC {
|
2017-01-02 19:01:18 +03:00
|
|
|
return "moc"
|
|
|
|
}
|
|
|
|
|
|
|
|
return goModule(module)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}(),
|
2018-04-07 22:05:41 +03:00
|
|
|
|
|
|
|
func() string {
|
2018-06-09 03:31:50 +03:00
|
|
|
if UseJs() {
|
2018-07-11 17:42:34 +03:00
|
|
|
return "\n#include <string>\n#include <emscripten.h>\n#include <emscripten/bind.h>\n#include <emscripten/val.h>"
|
2018-06-09 03:31:50 +03:00
|
|
|
}
|
2018-04-07 22:05:41 +03:00
|
|
|
switch module {
|
|
|
|
case "QtAndroidExtras", "QtSailfish":
|
|
|
|
return "#include \"_cgo_export.h\""
|
|
|
|
default:
|
|
|
|
if utils.QT_DYNAMIC_SETUP() {
|
|
|
|
return "#include \"_obj/_cgo_export.h\""
|
|
|
|
}
|
|
|
|
return "#include \"_cgo_export.h\""
|
|
|
|
}
|
|
|
|
}(),
|
2019-04-20 20:34:45 +03:00
|
|
|
|
|
|
|
func() string {
|
|
|
|
if utils.QT_DEBUG_CPP() {
|
|
|
|
return "\n#include <QDebug>\n"
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}(),
|
2019-08-28 00:09:01 +03:00
|
|
|
|
|
|
|
func() string {
|
|
|
|
if module == "QtCore" {
|
|
|
|
return `
|
|
|
|
#ifndef QT_CORE_LIB
|
|
|
|
#error ------------------------------------------------------------------
|
|
|
|
#error please run: '$(go env GOPATH)/bin/qtsetup'
|
|
|
|
#error more info here: https://github.com/therecipe/qt/wiki/Installation
|
|
|
|
#error ------------------------------------------------------------------
|
|
|
|
#endif`
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}(),
|
2016-04-28 20:43:44 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
var classes = make([]string, 0)
|
2017-01-02 19:01:18 +03:00
|
|
|
for _, class := range parser.State.ClassMap {
|
2019-05-01 03:39:02 +03:00
|
|
|
if (bytes.Contains(input, []byte(class.Name+";")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+":")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+"*")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+" ")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+"<")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+">")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+"(")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+")")) ||
|
|
|
|
bytes.Contains(input, []byte(class.Name+"_"))) && class.Module != parser.MOC {
|
2016-04-28 20:43:44 +03:00
|
|
|
classes = append(classes, class.Name)
|
2016-04-16 19:48:26 +03:00
|
|
|
}
|
2015-12-06 02:56:16 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
sort.Stable(sort.StringSlice(classes))
|
2015-12-06 02:56:16 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
for _, class := range classes {
|
2016-06-19 05:24:38 +03:00
|
|
|
if class == "SailfishApp" {
|
2017-01-22 20:34:39 +03:00
|
|
|
fmt.Fprint(bb, "#include <sailfishapp.h>\n")
|
2016-06-19 05:24:38 +03:00
|
|
|
} else {
|
2017-02-17 20:55:39 +03:00
|
|
|
var c, _ = parser.State.ClassMap[class]
|
2019-05-13 21:37:59 +03:00
|
|
|
if strings.HasPrefix(c.Module, "custom_") ||
|
|
|
|
strings.ToLower(c.Module) == c.Module ||
|
2019-09-28 19:21:38 +03:00
|
|
|
!strings.HasPrefix(class, "Q") && !(class == "FelgoApplication" || class == "FelgoLiveClient") {
|
2017-03-23 02:45:45 +03:00
|
|
|
continue
|
|
|
|
}
|
2017-02-17 20:55:39 +03:00
|
|
|
switch c.Name {
|
|
|
|
case
|
|
|
|
"Qt",
|
|
|
|
"QPdf",
|
|
|
|
"QDBus",
|
|
|
|
"QAudio",
|
|
|
|
"QMultimedia",
|
|
|
|
"QSsl",
|
|
|
|
"QPrint",
|
|
|
|
"QScript",
|
|
|
|
"QSql",
|
|
|
|
"QTest",
|
|
|
|
"QWebSocketProtocol",
|
|
|
|
"QBluetooth",
|
|
|
|
"QPlatformGraphicsBuffer",
|
2017-06-10 22:37:03 +03:00
|
|
|
"QDBusPendingReplyTypes",
|
|
|
|
"QRemoteObjectPackets",
|
2017-12-30 15:32:06 +03:00
|
|
|
"QRemoteObjectStringLiterals",
|
2018-06-25 19:32:27 +03:00
|
|
|
"QStringList",
|
2018-07-11 17:42:34 +03:00
|
|
|
"QtDwmApiDll",
|
|
|
|
"QStringView":
|
2017-02-17 20:55:39 +03:00
|
|
|
{
|
|
|
|
continue
|
|
|
|
}
|
2016-12-01 20:35:01 +03:00
|
|
|
}
|
2018-03-26 10:59:04 +03:00
|
|
|
|
|
|
|
if utils.QT_VERSION_NUM() <= 5042 {
|
|
|
|
switch c.Name {
|
|
|
|
case
|
|
|
|
"QQmlAbstractProfilerAdapter",
|
|
|
|
"QQuickAsyncImageProvider",
|
|
|
|
"QQuickImageResponse":
|
|
|
|
{
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-29 13:09:04 +03:00
|
|
|
if strings.HasPrefix(parser.State.Target, "sailfish") {
|
|
|
|
if !parser.IsWhiteListedSailfishLib(strings.TrimPrefix(c.Module, "Qt")) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-15 22:40:07 +03:00
|
|
|
if strings.HasPrefix(parser.State.Target, "rpi") && utils.QT_RPI() {
|
|
|
|
if !parser.IsWhiteListedRaspberryLib(strings.TrimPrefix(c.Module, "Qt")) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-03 17:14:05 +03:00
|
|
|
if c, ok := parser.State.ClassMap[class]; ok {
|
|
|
|
if strings.Contains(c.Pkg, "/vendor/") {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-28 19:53:39 +03:00
|
|
|
if c.Module == "QtQuickControls2" && strings.HasPrefix(c.Name, "QQuick") && c.Name != "QQuickStyle" {
|
|
|
|
dir, fn := filepath.Split(c.Filepath)
|
|
|
|
if filepath.Base(dir) == "quickcontrols2" {
|
|
|
|
fmt.Fprintf(bb, "#include <QtQuickControls2/private/%v>\n", fn)
|
|
|
|
} else {
|
|
|
|
fmt.Fprintf(bb, "#include <QtQuickTemplates2/private/%v>\n", fn)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fmt.Fprintf(bb, "#include <%v>\n", class)
|
|
|
|
}
|
2018-03-29 13:09:04 +03:00
|
|
|
|
2018-10-30 18:53:05 +03:00
|
|
|
if (strings.HasPrefix(target, "ios") || target == "js" || target == "wasm") && mode == MINIMAL {
|
2018-06-09 03:31:50 +03:00
|
|
|
oldModuleGo := strings.TrimPrefix(c.Module, "Qt")
|
|
|
|
|
|
|
|
var containsSelf bool
|
2018-10-30 18:53:05 +03:00
|
|
|
for _, l := range parser.LibDeps["build_static"] {
|
2018-06-09 03:31:50 +03:00
|
|
|
if l == oldModuleGo {
|
|
|
|
containsSelf = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !containsSelf {
|
2018-10-30 18:53:05 +03:00
|
|
|
parser.LibDeps["build_static"] = append(parser.LibDeps["build_static"], oldModuleGo)
|
2018-06-09 03:31:50 +03:00
|
|
|
|
|
|
|
switch oldModuleGo {
|
|
|
|
case "Multimedia":
|
2018-10-30 18:53:05 +03:00
|
|
|
parser.LibDeps["build_static"] = append(parser.LibDeps["build_static"], "MultimediaWidgets")
|
2018-06-09 03:31:50 +03:00
|
|
|
case "Quick":
|
2018-10-30 18:53:05 +03:00
|
|
|
parser.LibDeps["build_static"] = append(parser.LibDeps["build_static"], "QuickWidgets")
|
2018-06-09 03:31:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-29 13:09:04 +03:00
|
|
|
if mode == MOC {
|
|
|
|
var found bool
|
2018-11-27 03:26:11 +03:00
|
|
|
parser.LibDepsMutex.Lock()
|
2018-03-29 13:09:04 +03:00
|
|
|
for _, m := range parser.LibDeps[parser.MOC] {
|
|
|
|
if m == strings.TrimPrefix(c.Module, "Qt") {
|
|
|
|
found = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !found {
|
|
|
|
parser.LibDeps[parser.MOC] = append(parser.LibDeps[parser.MOC], strings.TrimPrefix(c.Module, "Qt"))
|
|
|
|
}
|
2018-11-27 03:26:11 +03:00
|
|
|
parser.LibDepsMutex.Unlock()
|
2018-06-09 03:31:50 +03:00
|
|
|
|
2018-10-30 18:53:05 +03:00
|
|
|
if target == "js" || target == "wasm" {
|
2018-06-09 03:31:50 +03:00
|
|
|
|
|
|
|
found = false
|
2018-10-30 18:53:05 +03:00
|
|
|
for _, m := range parser.LibDeps["build_static"] {
|
2018-06-09 03:31:50 +03:00
|
|
|
if m == strings.TrimPrefix(c.Module, "Qt") {
|
|
|
|
found = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !found {
|
2018-10-30 18:53:05 +03:00
|
|
|
parser.LibDeps["build_static"] = append(parser.LibDeps["build_static"], strings.TrimPrefix(c.Module, "Qt"))
|
2018-06-09 03:31:50 +03:00
|
|
|
|
|
|
|
switch strings.TrimPrefix(c.Module, "Qt") {
|
|
|
|
case "Multimedia":
|
2018-10-30 18:53:05 +03:00
|
|
|
parser.LibDeps["build_static"] = append(parser.LibDeps["build_static"], "MultimediaWidgets")
|
2018-06-09 03:31:50 +03:00
|
|
|
case "Quick":
|
2018-10-30 18:53:05 +03:00
|
|
|
parser.LibDeps["build_static"] = append(parser.LibDeps["build_static"], "QuickWidgets")
|
2018-06-09 03:31:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-03-29 13:09:04 +03:00
|
|
|
}
|
2017-02-17 20:55:39 +03:00
|
|
|
}
|
2017-03-20 20:33:55 +03:00
|
|
|
|
|
|
|
c, ok := parser.State.ClassMap[class]
|
|
|
|
if ok && !strings.Contains(strings.Join(parser.LibDeps[strings.TrimPrefix(module, "Qt")], " "), strings.TrimPrefix(c.Module, "Qt")) {
|
2017-03-23 02:45:45 +03:00
|
|
|
if strings.HasPrefix(c.Module, "custom_") {
|
|
|
|
continue
|
|
|
|
}
|
2017-03-20 20:33:55 +03:00
|
|
|
|
2017-03-23 02:45:45 +03:00
|
|
|
utils.Log.Debugf("%v add dependency: %v", module, c.Module)
|
2017-03-20 20:33:55 +03:00
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = append(parser.LibDeps[strings.TrimPrefix(module, "Qt")], strings.TrimPrefix(c.Module, "Qt"))
|
2018-10-23 22:04:38 +03:00
|
|
|
old := CleanupDepsForCI
|
|
|
|
CleanupDepsForCI = func() {
|
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = parser.LibDeps[strings.TrimPrefix(module, "Qt")][:len(parser.LibDeps[strings.TrimPrefix(module, "Qt")])-1]
|
|
|
|
old()
|
|
|
|
}
|
2017-03-20 20:33:55 +03:00
|
|
|
switch c.Module {
|
|
|
|
case "QtMultimedia":
|
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = append(parser.LibDeps[strings.TrimPrefix(module, "Qt")], "MultimediaWidgets")
|
2018-10-23 22:04:38 +03:00
|
|
|
old := CleanupDepsForCI
|
|
|
|
CleanupDepsForCI = func() {
|
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = parser.LibDeps[strings.TrimPrefix(module, "Qt")][:len(parser.LibDeps[strings.TrimPrefix(module, "Qt")])-1]
|
|
|
|
old()
|
|
|
|
}
|
2017-03-20 20:33:55 +03:00
|
|
|
case "QtWebEngine":
|
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = append(parser.LibDeps[strings.TrimPrefix(module, "Qt")], "WebEngineWidgets")
|
2018-10-23 22:04:38 +03:00
|
|
|
old := CleanupDepsForCI
|
|
|
|
CleanupDepsForCI = func() {
|
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = parser.LibDeps[strings.TrimPrefix(module, "Qt")][:len(parser.LibDeps[strings.TrimPrefix(module, "Qt")])-1]
|
|
|
|
old()
|
|
|
|
}
|
2017-03-20 20:33:55 +03:00
|
|
|
case "QtQuick":
|
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = append(parser.LibDeps[strings.TrimPrefix(module, "Qt")], "QuickWidgets")
|
2018-10-23 22:04:38 +03:00
|
|
|
old := CleanupDepsForCI
|
|
|
|
CleanupDepsForCI = func() {
|
|
|
|
parser.LibDeps[strings.TrimPrefix(module, "Qt")] = parser.LibDeps[strings.TrimPrefix(module, "Qt")][:len(parser.LibDeps[strings.TrimPrefix(module, "Qt")])-1]
|
|
|
|
old()
|
|
|
|
}
|
2017-03-20 20:33:55 +03:00
|
|
|
}
|
|
|
|
}
|
2017-02-17 20:55:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if module == "QtCore" {
|
|
|
|
if !strings.Contains(bb.String(), "QTextDocument") {
|
|
|
|
fmt.Fprint(bb, "#include <QTextDocument>\n")
|
2016-06-19 05:24:38 +03:00
|
|
|
}
|
2015-10-24 18:18:24 +03:00
|
|
|
}
|
2017-02-16 18:38:33 +03:00
|
|
|
|
2017-03-04 21:01:53 +03:00
|
|
|
if mode == MINIMAL {
|
2017-02-16 18:38:33 +03:00
|
|
|
if module == "QtCore" {
|
|
|
|
fmt.Fprint(bb, "#include <QObject>\n")
|
|
|
|
} else if module == "QtNetwork" {
|
2017-02-19 23:11:49 +03:00
|
|
|
fmt.Fprint(bb, "#include <QSsl>\n")
|
2017-02-16 18:38:33 +03:00
|
|
|
}
|
2017-02-21 16:13:05 +03:00
|
|
|
|
|
|
|
if !strings.Contains(bb.String(), "QStringList") {
|
|
|
|
fmt.Fprint(bb, "#include <QStringList>\n")
|
|
|
|
}
|
2017-02-16 18:38:33 +03:00
|
|
|
}
|
|
|
|
|
2019-05-01 03:39:02 +03:00
|
|
|
if mode == MOC {
|
2019-11-18 05:07:49 +03:00
|
|
|
if utils.QT_VERSION_NUM() < 5070 {
|
|
|
|
fmt.Fprint(bb, "\n#ifdef QT_QML_LIB\n\t#include <QtQml>\n#endif\n")
|
|
|
|
} else {
|
|
|
|
fmt.Fprint(bb, "\n#ifdef QT_QML_LIB\n\t#include <QQmlEngine>\n#endif\n")
|
|
|
|
}
|
2019-05-01 03:39:02 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
fmt.Fprint(bb, "\n")
|
|
|
|
|
2018-10-31 20:12:08 +03:00
|
|
|
for _, class := range parser.State.ClassMap {
|
|
|
|
if class.Fullname != "" && bytes.Contains(input, []byte("<"+class.Name)) {
|
|
|
|
fmt.Fprintf(bb, "typedef %v %v;\n", class.Fullname, class.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
bb.Write(input)
|
2015-10-24 18:18:24 +03:00
|
|
|
|
2018-04-03 17:14:05 +03:00
|
|
|
//TODO: regexp
|
|
|
|
if mode == MOC {
|
|
|
|
pre := bb.String()
|
|
|
|
bb.Reset()
|
2019-04-28 03:44:55 +03:00
|
|
|
libsm := make(map[string]struct{})
|
2018-04-12 22:42:26 +03:00
|
|
|
for _, c := range parser.State.ClassMap {
|
|
|
|
if c.Pkg != "" && c.IsSubClassOfQObject() {
|
|
|
|
libsm[c.Module] = struct{}{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
var libs []string
|
|
|
|
for k := range libsm {
|
|
|
|
libs = append(libs, k)
|
|
|
|
}
|
|
|
|
libs = append(libs, module)
|
|
|
|
|
|
|
|
for _, c := range parser.SortedClassesForModule(strings.Join(libs, ","), true) {
|
2018-04-03 17:14:05 +03:00
|
|
|
hName := c.Hash()
|
2018-06-09 03:31:50 +03:00
|
|
|
sep := []string{"\"_", "LIVE_", " ", "\t", "\n", "\r", "(", ")", ":", ";", "*", "<", ">", "&", "~", "{", "}", "[", "]", "_", "callback"}
|
2018-04-03 17:14:05 +03:00
|
|
|
for _, p := range sep {
|
2019-10-10 20:49:05 +03:00
|
|
|
if p == ":" {
|
|
|
|
continue
|
|
|
|
}
|
2018-04-03 17:14:05 +03:00
|
|
|
for _, s := range sep {
|
2019-10-10 20:49:05 +03:00
|
|
|
if s == "callback" ||
|
|
|
|
(p == "(" && s == ")") ||
|
|
|
|
(p == " " && s == " ") ||
|
|
|
|
(p == ">" && s != ":") {
|
2018-04-03 17:14:05 +03:00
|
|
|
continue
|
|
|
|
}
|
2019-10-10 20:49:05 +03:00
|
|
|
if p == " " && (s == "(" || s == ")") {
|
|
|
|
p = "new "
|
|
|
|
pre = strings.Replace(pre, p+c.Name+s, p+c.Name+hName+s, -1)
|
|
|
|
p = ": "
|
|
|
|
pre = strings.Replace(pre, p+c.Name+s, p+c.Name+hName+s, -1)
|
|
|
|
p = " "
|
|
|
|
} else {
|
|
|
|
pre = strings.Replace(pre, p+c.Name+s, p+c.Name+hName+s, -1)
|
|
|
|
}
|
2018-04-03 17:14:05 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-04-12 22:42:26 +03:00
|
|
|
pre = strings.Replace(pre, "PREPRO", "", -1)
|
2018-04-03 17:14:05 +03:00
|
|
|
bb.WriteString(pre)
|
|
|
|
}
|
|
|
|
|
2018-06-09 03:31:50 +03:00
|
|
|
if UseJs() {
|
|
|
|
pre := bb.String()
|
|
|
|
bb.Reset()
|
|
|
|
pre = strings.Replace(pre, "_KEEPALIVE_", "", -1)
|
|
|
|
bb.WriteString(pre)
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
return bb.Bytes()
|
2015-10-24 18:18:24 +03:00
|
|
|
}
|