From 2dfd24bf4abced11e533f2971a8d2d45aba9eaeb Mon Sep 17 00:00:00 2001 From: Andy Williams Date: Fri, 29 May 2020 10:10:24 +0100 Subject: [PATCH] Latest mobile fork has fix for GL deadlock issue Fixes #950 --- go.mod | 2 +- go.sum | 4 +- .../fyne-io/mobile/app/GoNativeActivity.java | 8 +- .../github.com/fyne-io/mobile/app/android.c | 8 +- .../github.com/fyne-io/mobile/app/android.go | 39 +- vendor/github.com/fyne-io/mobile/app/app.go | 15 +- .../fyne-io/mobile/app/darwin_desktop.go | 2 +- .../fyne-io/mobile/app/darwin_ios.go | 22 +- .../fyne-io/mobile/app/darwin_ios.m | 28 +- vendor/github.com/fyne-io/mobile/app/shiny.go | 2 +- vendor/github.com/fyne-io/mobile/app/x11.go | 2 +- .../github.com/fyne-io/mobile/exp/f32/gen.go | 48 + .../github.com/fyne-io/mobile/gl/gendebug.go | 996 ++++++++++++++++++ vendor/github.com/fyne-io/mobile/gl/work.go | 2 +- vendor/modules.txt | 2 +- 15 files changed, 1145 insertions(+), 35 deletions(-) create mode 100644 vendor/github.com/fyne-io/mobile/exp/f32/gen.go create mode 100644 vendor/github.com/fyne-io/mobile/gl/gendebug.go diff --git a/go.mod b/go.mod index a8e4ef716e..1a450d1186 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,7 @@ require ( github.com/akavel/rsrc v0.8.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/fsnotify/fsnotify v1.4.9 - github.com/fyne-io/mobile v0.0.2-0.20200525115341-f642c98357ec + github.com/fyne-io/mobile v0.0.2-0.20200528163636-261ce6a40089 github.com/go-gl/gl v0.0.0-20190320180904-bf2b1f2f34d7 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4 github.com/godbus/dbus/v5 v5.0.3 diff --git a/go.sum b/go.sum index 41055a1261..c2fc2ffc5e 100644 --- a/go.sum +++ b/go.sum @@ -8,8 +8,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= -github.com/fyne-io/mobile v0.0.2-0.20200525115341-f642c98357ec h1:x135rzm7aZ+UTktiR+s55JO5W6T98BB8CyvozYEX8Ew= -github.com/fyne-io/mobile v0.0.2-0.20200525115341-f642c98357ec/go.mod h1:/kOrWrZB6sasLbEy2JIvr4arEzQTXBTZGb3Y96yWbHY= +github.com/fyne-io/mobile v0.0.2-0.20200528163636-261ce6a40089 h1:giC0Df/BJU+OM0BqPCd/dvf1E2188HX2Fp7EKaqTFqE= +github.com/fyne-io/mobile v0.0.2-0.20200528163636-261ce6a40089/go.mod h1:/kOrWrZB6sasLbEy2JIvr4arEzQTXBTZGb3Y96yWbHY= github.com/go-gl/gl v0.0.0-20190320180904-bf2b1f2f34d7 h1:SCYMcCJ89LjRGwEa0tRluNRiMjZHalQZrVrvTbPh+qw= github.com/go-gl/gl v0.0.0-20190320180904-bf2b1f2f34d7/go.mod h1:482civXOzJJCPzJ4ZOX/pwvXBWSnzD4OKMdH4ClKGbk= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4 h1:WtGNWLvXpe6ZudgnXrq0barxBImvnnJoMEhXAzcbM0I= diff --git a/vendor/github.com/fyne-io/mobile/app/GoNativeActivity.java b/vendor/github.com/fyne-io/mobile/app/GoNativeActivity.java index 0d5629829b..beebe94753 100644 --- a/vendor/github.com/fyne-io/mobile/app/GoNativeActivity.java +++ b/vendor/github.com/fyne-io/mobile/app/GoNativeActivity.java @@ -99,13 +99,13 @@ public void run() { }); } - static void showFileOpen() { - goNativeActivity.doShowFileOpen(); + static void showFileOpen(String mimes) { + goNativeActivity.doShowFileOpen(mimes); } - void doShowFileOpen() { + void doShowFileOpen(String mimes) { Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT); - intent.setType("*/*"); + intent.setType(mimes); intent.addCategory(Intent.CATEGORY_OPENABLE); startActivityForResult(Intent.createChooser(intent, "Open File"), FILE_OPEN_CODE); } diff --git a/vendor/github.com/fyne-io/mobile/app/android.c b/vendor/github.com/fyne-io/mobile/app/android.c index be743d0887..d1b49aaefa 100644 --- a/vendor/github.com/fyne-io/mobile/app/android.c +++ b/vendor/github.com/fyne-io/mobile/app/android.c @@ -81,7 +81,7 @@ void ANativeActivity_onCreate(ANativeActivity *activity, void* savedState, size_ key_rune_method = find_static_method(env, current_class, "getRune", "(III)I"); show_keyboard_method = find_static_method(env, current_class, "showKeyboard", "()V"); hide_keyboard_method = find_static_method(env, current_class, "hideKeyboard", "()V"); - show_file_open_method = find_static_method(env, current_class, "showFileOpen", "()V"); + show_file_open_method = find_static_method(env, current_class, "showFileOpen", "(Ljava/lang/String;)V"); setCurrentContext(activity->vm, (*env)->NewGlobalRef(env, activity->clazz)); @@ -228,11 +228,13 @@ void hideKeyboard(JNIEnv* env) { ); } -void showFileOpen(JNIEnv* env) { +void showFileOpen(JNIEnv* env, char* mimes) { + jstring mimesJString = (*env)->NewStringUTF(env, mimes); (*env)->CallStaticVoidMethod( env, current_class, - show_file_open_method + show_file_open_method, + mimesJString ); } diff --git a/vendor/github.com/fyne-io/mobile/app/android.go b/vendor/github.com/fyne-io/mobile/app/android.go index ad91b1dea4..0a278e1947 100644 --- a/vendor/github.com/fyne-io/mobile/app/android.go +++ b/vendor/github.com/fyne-io/mobile/app/android.go @@ -44,7 +44,7 @@ int32_t getKeyRune(JNIEnv* env, AInputEvent* e); void showKeyboard(JNIEnv* env); void hideKeyboard(JNIEnv* env); -void showFileOpen(JNIEnv* env); +void showFileOpen(JNIEnv* env, char* mimes); void Java_org_golang_app_GoNativeActivity_filePickerReturned(JNIEnv *env, jclass clazz, jstring str); */ @@ -52,7 +52,9 @@ import "C" import ( "fmt" "log" + "mime" "os" + "strings" "time" "unsafe" @@ -331,18 +333,37 @@ func insetsChanged(top, bottom, left, right int) { screenInsetTop, screenInsetBottom, screenInsetLeft, screenInsetRight = top, bottom, left, right } -func driverShowFileOpenPicker(callback func(string, func())) { +func driverShowFileOpenPicker(callback func(string, func()), filter *FileFilter) { fileCallback = callback - if err := mobileinit.RunOnJVM(showFileOpenPicker); err != nil { - log.Fatalf("app: %v", err) + mimes := "*/*" + if filter.MimeTypes != nil { + mimes = strings.Join(filter.MimeTypes, ",") + } else if filter.Extensions != nil { + var mimeTypes []string + for _, ext := range filter.Extensions { + mimeType := mime.TypeByExtension(ext) + if mimeType == "" { + continue + } + + mimeTypes = append(mimeTypes, mimeType) + } + mimes = strings.Join(mimeTypes, ",") + } + mimeStr := C.CString(mimes) + defer C.free(unsafe.Pointer(mimeStr)) + + open := func(vm, jniEnv, ctx uintptr) error { + // TODO pass in filter... + env := (*C.JNIEnv)(unsafe.Pointer(jniEnv)) // not a Go heap pointer + C.showFileOpen(env, mimeStr) + return nil } -} -func showFileOpenPicker(vm, jniEnv, ctx uintptr) error { - env := (*C.JNIEnv)(unsafe.Pointer(jniEnv)) // not a Go heap pointer - C.showFileOpen(env) - return nil + if err := mobileinit.RunOnJVM(open); err != nil { + log.Fatalf("app: %v", err) + } } var mainUserFn func(App) diff --git a/vendor/github.com/fyne-io/mobile/app/app.go b/vendor/github.com/fyne-io/mobile/app/app.go index 2dba4ea8bc..d5272ffe5e 100644 --- a/vendor/github.com/fyne-io/mobile/app/app.go +++ b/vendor/github.com/fyne-io/mobile/app/app.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build linux darwin openbsd freebsd windows +// +build linux darwin windows package app @@ -54,7 +54,12 @@ type App interface { ShowVirtualKeyboard() HideVirtualKeyboard() - ShowFileOpenPicker(func(string, func())) + ShowFileOpenPicker(func(string, func()), *FileFilter) +} + +type FileFilter struct { + Extensions []string + MimeTypes []string } // PublishResult is the result of an App.Publish call. @@ -141,8 +146,8 @@ func (a *app) HideVirtualKeyboard() { driverHideVirtualKeyboard() } -func (a *app) ShowFileOpenPicker(callback func(string, func())) { - driverShowFileOpenPicker(callback) +func (a *app) ShowFileOpenPicker(callback func(string, func()), filter *FileFilter) { + driverShowFileOpenPicker(callback, filter) } type stopPumping struct{} @@ -234,4 +239,4 @@ func screenOrientation(width, height int) size.Orientation { } return size.OrientationPortrait -} +} \ No newline at end of file diff --git a/vendor/github.com/fyne-io/mobile/app/darwin_desktop.go b/vendor/github.com/fyne-io/mobile/app/darwin_desktop.go index 3304a686c9..a7b0b6c758 100644 --- a/vendor/github.com/fyne-io/mobile/app/darwin_desktop.go +++ b/vendor/github.com/fyne-io/mobile/app/darwin_desktop.go @@ -236,7 +236,7 @@ func driverHideVirtualKeyboard() { } // driverShowFileOpenPicker does nothing on desktop -func driverShowFileOpenPicker(func(string, func())) { +func driverShowFileOpenPicker(func(string, func()), *FileFilter) { } // convRune marks the Carbon/Cocoa private-range unicode rune representing diff --git a/vendor/github.com/fyne-io/mobile/app/darwin_ios.go b/vendor/github.com/fyne-io/mobile/app/darwin_ios.go index d8a5c35e70..98e7d28997 100644 --- a/vendor/github.com/fyne-io/mobile/app/darwin_ios.go +++ b/vendor/github.com/fyne-io/mobile/app/darwin_ios.go @@ -9,7 +9,7 @@ package app /* #cgo CFLAGS: -x objective-c -DGL_SILENCE_DEPRECATION -#cgo LDFLAGS: -framework Foundation -framework UIKit -framework GLKit -framework OpenGLES -framework QuartzCore -framework UserNotifications +#cgo LDFLAGS: -framework Foundation -framework UIKit -framework MobileCoreServices -framework GLKit -framework OpenGLES -framework QuartzCore -framework UserNotifications #include #include #include @@ -27,7 +27,7 @@ UIEdgeInsets getDevicePadding(); void showKeyboard(); void hideKeyboard(); -void showFileOpenPicker(); +void showFileOpenPicker(char* mimes, char *exts); void closeFileResource(void* urlPtr); */ import "C" @@ -283,8 +283,22 @@ func filePickerReturned(str *C.char, urlPtr unsafe.Pointer) { fileCallback = nil } -func driverShowFileOpenPicker(callback func(string, func())) { +func driverShowFileOpenPicker(callback func(string, func()), filter *FileFilter) { fileCallback = callback - C.showFileOpenPicker() + mimes := strings.Join(filter.MimeTypes, "|") + + // extensions must have the '.' removed for UTI lookups on iOS + extList := []string{} + for _, ext := range filter.Extensions { + extList = append(extList, ext[1:]) + } + exts := strings.Join(extList, "|") + + mimeStr := C.CString(mimes) + defer C.free(unsafe.Pointer(mimeStr)) + extStr := C.CString(exts) + defer C.free(unsafe.Pointer(extStr)) + + C.showFileOpenPicker(mimeStr, extStr) } diff --git a/vendor/github.com/fyne-io/mobile/app/darwin_ios.m b/vendor/github.com/fyne-io/mobile/app/darwin_ios.m index d1aa255031..4d4e102908 100644 --- a/vendor/github.com/fyne-io/mobile/app/darwin_ios.m +++ b/vendor/github.com/fyne-io/mobile/app/darwin_ios.m @@ -11,6 +11,7 @@ #include #import +#import #import #import @@ -265,11 +266,34 @@ void hideKeyboard() { }); } -void showFileOpenPicker() { +void showFileOpenPicker(char* mimes, char *exts) { GoAppAppDelegate *appDelegate = (GoAppAppDelegate *)[[UIApplication sharedApplication] delegate]; + NSMutableArray *docTypes = [NSMutableArray array]; + if (mimes != NULL && strlen(mimes) > 0) { + NSString *mimeList = [NSString stringWithUTF8String:mimes]; + NSArray *mimeItems = [mimeList componentsSeparatedByString:@"|"]; + + for (NSString *mime in mimeItems) { + CFStringRef UTI = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, mime, NULL); + + [docTypes addObject:UTI]; + } + } else if (exts != NULL && strlen(exts) > 0) { + NSString *extList = [NSString stringWithUTF8String:exts]; + NSArray *extItems = [extList componentsSeparatedByString:@"|"]; + + for (NSString *ext in extItems) { + CFStringRef UTI = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, ext, NULL); + + [docTypes addObject:UTI]; + } + } else { + [docTypes addObject:@"public.data"]; + } + UIDocumentPickerViewController *documentPicker = [[UIDocumentPickerViewController alloc] - initWithDocumentTypes:@[@"public.data"] inMode:UIDocumentPickerModeOpen]; + initWithDocumentTypes:docTypes inMode:UIDocumentPickerModeOpen]; documentPicker.delegate = appDelegate; documentPicker.modalPresentationStyle = UIModalPresentationPopover; diff --git a/vendor/github.com/fyne-io/mobile/app/shiny.go b/vendor/github.com/fyne-io/mobile/app/shiny.go index 8ffd4c3599..f5dbbb15f6 100644 --- a/vendor/github.com/fyne-io/mobile/app/shiny.go +++ b/vendor/github.com/fyne-io/mobile/app/shiny.go @@ -23,5 +23,5 @@ func driverHideVirtualKeyboard() { } // driverShowFileOpenPicker does nothing on desktop -func driverShowFileOpenPicker(func(string, func())) { +func driverShowFileOpenPicker(func(string, func()), *FileFilter) { } diff --git a/vendor/github.com/fyne-io/mobile/app/x11.go b/vendor/github.com/fyne-io/mobile/app/x11.go index ce3ea4dc62..170f3d9f11 100644 --- a/vendor/github.com/fyne-io/mobile/app/x11.go +++ b/vendor/github.com/fyne-io/mobile/app/x11.go @@ -133,5 +133,5 @@ func driverHideVirtualKeyboard() { } // driverShowFileOpenPicker does nothing on desktop -func driverShowFileOpenPicker(func(string, func())) { +func driverShowFileOpenPicker(func(string, func()), *FileFilter) { } \ No newline at end of file diff --git a/vendor/github.com/fyne-io/mobile/exp/f32/gen.go b/vendor/github.com/fyne-io/mobile/exp/f32/gen.go new file mode 100644 index 0000000000..a8438bbd33 --- /dev/null +++ b/vendor/github.com/fyne-io/mobile/exp/f32/gen.go @@ -0,0 +1,48 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build ignore + +package main + +/* +This program generates table.go. Invoke it as: +go run gen.go -output table.go +*/ + +import ( + "bytes" + "flag" + "fmt" + "go/format" + "io/ioutil" + "log" + "math" +) + +// N is the number of entries in the sin look-up table. It must be a power of 2. +const N = 4096 + +var filename = flag.String("output", "table.go", "output file name") + +func main() { + b := new(bytes.Buffer) + fmt.Fprintf(b, "// Code generated by go run gen.go; DO NOT EDIT\n\npackage f32\n\n") + fmt.Fprintf(b, "const sinTableLen = %d\n\n", N) + fmt.Fprintf(b, "// sinTable[i] equals sin(i * π / sinTableLen).\n") + fmt.Fprintf(b, "var sinTable = [sinTableLen]float32{\n") + for i := 0; i < N; i++ { + radians := float64(i) * (math.Pi / N) + fmt.Fprintf(b, "%v,\n", float32(math.Sin(radians))) + } + fmt.Fprintf(b, "}\n") + + data, err := format.Source(b.Bytes()) + if err != nil { + log.Fatal(err) + } + if err := ioutil.WriteFile(*filename, data, 0644); err != nil { + log.Fatal(err) + } +} diff --git a/vendor/github.com/fyne-io/mobile/gl/gendebug.go b/vendor/github.com/fyne-io/mobile/gl/gendebug.go new file mode 100644 index 0000000000..ef3287f319 --- /dev/null +++ b/vendor/github.com/fyne-io/mobile/gl/gendebug.go @@ -0,0 +1,996 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build ignore + +// The gendebug program takes gl.go and generates a version of it +// where each function includes tracing code that writes its arguments +// to the standard log. +package main + +import ( + "bytes" + "flag" + "fmt" + "go/ast" + "go/format" + "go/parser" + "go/printer" + "go/token" + "io/ioutil" + "log" + "os" + "strconv" +) + +var enumWhitelist = []string{ + "POINTS", + "LINES", + "LINE_LOOP", + "LINE_STRIP", + "TRIANGLES", + "TRIANGLE_STRIP", + "TRIANGLE_FAN", + "SRC_COLOR", + "ONE_MINUS_SRC_COLOR", + "SRC_ALPHA", + "ONE_MINUS_SRC_ALPHA", + "DST_ALPHA", + "ONE_MINUS_DST_ALPHA", + "DST_COLOR", + "ONE_MINUS_DST_COLOR", + "SRC_ALPHA_SATURATE", + "FUNC_ADD", + "BLEND_EQUATION", + "BLEND_EQUATION_RGB", + "BLEND_EQUATION_ALPHA", + "FUNC_SUBTRACT", + "FUNC_REVERSE_SUBTRACT", + "BLEND_DST_RGB", + "BLEND_SRC_RGB", + "BLEND_DST_ALPHA", + "BLEND_SRC_ALPHA", + "CONSTANT_COLOR", + "ONE_MINUS_CONSTANT_COLOR", + "CONSTANT_ALPHA", + "ONE_MINUS_CONSTANT_ALPHA", + "BLEND_COLOR", + "ARRAY_BUFFER", + "ELEMENT_ARRAY_BUFFER", + "ARRAY_BUFFER_BINDING", + "ELEMENT_ARRAY_BUFFER_BINDING", + "STREAM_DRAW", + "STATIC_DRAW", + "DYNAMIC_DRAW", + "BUFFER_SIZE", + "BUFFER_USAGE", + "CURRENT_VERTEX_ATTRIB", + "FRONT", + "BACK", + "FRONT_AND_BACK", + "TEXTURE_2D", + "CULL_FACE", + "BLEND", + "DITHER", + "STENCIL_TEST", + "DEPTH_TEST", + "SCISSOR_TEST", + "POLYGON_OFFSET_FILL", + "SAMPLE_ALPHA_TO_COVERAGE", + "SAMPLE_COVERAGE", + "INVALID_ENUM", + "INVALID_VALUE", + "INVALID_OPERATION", + "OUT_OF_MEMORY", + "CW", + "CCW", + "LINE_WIDTH", + "ALIASED_POINT_SIZE_RANGE", + "ALIASED_LINE_WIDTH_RANGE", + "CULL_FACE_MODE", + "FRONT_FACE", + "DEPTH_RANGE", + "DEPTH_WRITEMASK", + "DEPTH_CLEAR_VALUE", + "DEPTH_FUNC", + "STENCIL_CLEAR_VALUE", + "STENCIL_FUNC", + "STENCIL_FAIL", + "STENCIL_PASS_DEPTH_FAIL", + "STENCIL_PASS_DEPTH_PASS", + "STENCIL_REF", + "STENCIL_VALUE_MASK", + "STENCIL_WRITEMASK", + "STENCIL_BACK_FUNC", + "STENCIL_BACK_FAIL", + "STENCIL_BACK_PASS_DEPTH_FAIL", + "STENCIL_BACK_PASS_DEPTH_PASS", + "STENCIL_BACK_REF", + "STENCIL_BACK_VALUE_MASK", + "STENCIL_BACK_WRITEMASK", + "VIEWPORT", + "SCISSOR_BOX", + "COLOR_CLEAR_VALUE", + "COLOR_WRITEMASK", + "UNPACK_ALIGNMENT", + "PACK_ALIGNMENT", + "MAX_TEXTURE_SIZE", + "MAX_VIEWPORT_DIMS", + "SUBPIXEL_BITS", + "RED_BITS", + "GREEN_BITS", + "BLUE_BITS", + "ALPHA_BITS", + "DEPTH_BITS", + "STENCIL_BITS", + "POLYGON_OFFSET_UNITS", + "POLYGON_OFFSET_FACTOR", + "TEXTURE_BINDING_2D", + "SAMPLE_BUFFERS", + "SAMPLES", + "SAMPLE_COVERAGE_VALUE", + "SAMPLE_COVERAGE_INVERT", + "NUM_COMPRESSED_TEXTURE_FORMATS", + "COMPRESSED_TEXTURE_FORMATS", + "DONT_CARE", + "FASTEST", + "NICEST", + "GENERATE_MIPMAP_HINT", + "BYTE", + "UNSIGNED_BYTE", + "SHORT", + "UNSIGNED_SHORT", + "INT", + "UNSIGNED_INT", + "FLOAT", + "FIXED", + "DEPTH_COMPONENT", + "ALPHA", + "RGB", + "RGBA", + "LUMINANCE", + "LUMINANCE_ALPHA", + "UNSIGNED_SHORT_4_4_4_4", + "UNSIGNED_SHORT_5_5_5_1", + "UNSIGNED_SHORT_5_6_5", + "MAX_VERTEX_ATTRIBS", + "MAX_VERTEX_UNIFORM_VECTORS", + "MAX_VARYING_VECTORS", + "MAX_COMBINED_TEXTURE_IMAGE_UNITS", + "MAX_VERTEX_TEXTURE_IMAGE_UNITS", + "MAX_TEXTURE_IMAGE_UNITS", + "MAX_FRAGMENT_UNIFORM_VECTORS", + "SHADER_TYPE", + "DELETE_STATUS", + "LINK_STATUS", + "VALIDATE_STATUS", + "ATTACHED_SHADERS", + "ACTIVE_UNIFORMS", + "ACTIVE_UNIFORM_MAX_LENGTH", + "ACTIVE_ATTRIBUTES", + "ACTIVE_ATTRIBUTE_MAX_LENGTH", + "SHADING_LANGUAGE_VERSION", + "CURRENT_PROGRAM", + "NEVER", + "LESS", + "EQUAL", + "LEQUAL", + "GREATER", + "NOTEQUAL", + "GEQUAL", + "ALWAYS", + "KEEP", + "REPLACE", + "INCR", + "DECR", + "INVERT", + "INCR_WRAP", + "DECR_WRAP", + "VENDOR", + "RENDERER", + "VERSION", + "EXTENSIONS", + "NEAREST", + "LINEAR", + "NEAREST_MIPMAP_NEAREST", + "LINEAR_MIPMAP_NEAREST", + "NEAREST_MIPMAP_LINEAR", + "LINEAR_MIPMAP_LINEAR", + "TEXTURE_MAG_FILTER", + "TEXTURE_MIN_FILTER", + "TEXTURE_WRAP_S", + "TEXTURE_WRAP_T", + "TEXTURE", + "TEXTURE_CUBE_MAP", + "TEXTURE_BINDING_CUBE_MAP", + "TEXTURE_CUBE_MAP_POSITIVE_X", + "TEXTURE_CUBE_MAP_NEGATIVE_X", + "TEXTURE_CUBE_MAP_POSITIVE_Y", + "TEXTURE_CUBE_MAP_NEGATIVE_Y", + "TEXTURE_CUBE_MAP_POSITIVE_Z", + "TEXTURE_CUBE_MAP_NEGATIVE_Z", + "MAX_CUBE_MAP_TEXTURE_SIZE", + "TEXTURE0", + "TEXTURE1", + "TEXTURE2", + "TEXTURE3", + "TEXTURE4", + "TEXTURE5", + "TEXTURE6", + "TEXTURE7", + "TEXTURE8", + "TEXTURE9", + "TEXTURE10", + "TEXTURE11", + "TEXTURE12", + "TEXTURE13", + "TEXTURE14", + "TEXTURE15", + "TEXTURE16", + "TEXTURE17", + "TEXTURE18", + "TEXTURE19", + "TEXTURE20", + "TEXTURE21", + "TEXTURE22", + "TEXTURE23", + "TEXTURE24", + "TEXTURE25", + "TEXTURE26", + "TEXTURE27", + "TEXTURE28", + "TEXTURE29", + "TEXTURE30", + "TEXTURE31", + "ACTIVE_TEXTURE", + "REPEAT", + "CLAMP_TO_EDGE", + "MIRRORED_REPEAT", + "VERTEX_ATTRIB_ARRAY_ENABLED", + "VERTEX_ATTRIB_ARRAY_SIZE", + "VERTEX_ATTRIB_ARRAY_STRIDE", + "VERTEX_ATTRIB_ARRAY_TYPE", + "VERTEX_ATTRIB_ARRAY_NORMALIZED", + "VERTEX_ATTRIB_ARRAY_POINTER", + "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", + "IMPLEMENTATION_COLOR_READ_TYPE", + "IMPLEMENTATION_COLOR_READ_FORMAT", + "COMPILE_STATUS", + "INFO_LOG_LENGTH", + "SHADER_SOURCE_LENGTH", + "SHADER_COMPILER", + "SHADER_BINARY_FORMATS", + "NUM_SHADER_BINARY_FORMATS", + "LOW_FLOAT", + "MEDIUM_FLOAT", + "HIGH_FLOAT", + "LOW_INT", + "MEDIUM_INT", + "HIGH_INT", + "FRAMEBUFFER", + "RENDERBUFFER", + "RGBA4", + "RGB5_A1", + "RGB565", + "DEPTH_COMPONENT16", + "STENCIL_INDEX8", + "RENDERBUFFER_WIDTH", + "RENDERBUFFER_HEIGHT", + "RENDERBUFFER_INTERNAL_FORMAT", + "RENDERBUFFER_RED_SIZE", + "RENDERBUFFER_GREEN_SIZE", + "RENDERBUFFER_BLUE_SIZE", + "RENDERBUFFER_ALPHA_SIZE", + "RENDERBUFFER_DEPTH_SIZE", + "RENDERBUFFER_STENCIL_SIZE", + "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", + "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", + "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", + "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", + "COLOR_ATTACHMENT0", + "DEPTH_ATTACHMENT", + "STENCIL_ATTACHMENT", + "FRAMEBUFFER_COMPLETE", + "FRAMEBUFFER_INCOMPLETE_ATTACHMENT", + "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", + "FRAMEBUFFER_INCOMPLETE_DIMENSIONS", + "FRAMEBUFFER_UNSUPPORTED", + "FRAMEBUFFER_BINDING", + "RENDERBUFFER_BINDING", + "MAX_RENDERBUFFER_SIZE", + "INVALID_FRAMEBUFFER_OPERATION", + "DEPTH_BUFFER_BIT", + "STENCIL_BUFFER_BIT", + "COLOR_BUFFER_BIT", + "FLOAT_VEC2", + "FLOAT_VEC3", + "FLOAT_VEC4", + "INT_VEC2", + "INT_VEC3", + "INT_VEC4", + "BOOL", + "BOOL_VEC2", + "BOOL_VEC3", + "BOOL_VEC4", + "FLOAT_MAT2", + "FLOAT_MAT3", + "FLOAT_MAT4", + "SAMPLER_2D", + "SAMPLER_CUBE", + "FRAGMENT_SHADER", + "VERTEX_SHADER", + "FALSE", + "TRUE", + "ZERO", + "ONE", + "NO_ERROR", + "NONE", + "ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH", + "ACTIVE_UNIFORM_BLOCKS", + "ALREADY_SIGNALED", + "ANY_SAMPLES_PASSED", + "ANY_SAMPLES_PASSED_CONSERVATIVE", + "BLUE", + "BUFFER_ACCESS_FLAGS", + "BUFFER_MAP_LENGTH", + "BUFFER_MAP_OFFSET", + "BUFFER_MAPPED", + "BUFFER_MAP_POINTER", + "COLOR", + "COLOR_ATTACHMENT10", + "COLOR_ATTACHMENT1", + "COLOR_ATTACHMENT11", + "COLOR_ATTACHMENT12", + "COLOR_ATTACHMENT13", + "COLOR_ATTACHMENT14", + "COLOR_ATTACHMENT15", + "COLOR_ATTACHMENT2", + "COLOR_ATTACHMENT3", + "COLOR_ATTACHMENT4", + "COLOR_ATTACHMENT5", + "COLOR_ATTACHMENT6", + "COLOR_ATTACHMENT7", + "COLOR_ATTACHMENT8", + "COLOR_ATTACHMENT9", + "COMPARE_REF_TO_TEXTURE", + "COMPRESSED_R11_EAC", + "COMPRESSED_RG11_EAC", + "COMPRESSED_RGB8_ETC2", + "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", + "COMPRESSED_RGBA8_ETC2_EAC", + "COMPRESSED_SIGNED_R11_EAC", + "COMPRESSED_SIGNED_RG11_EAC", + "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", + "COMPRESSED_SRGB8_ETC2", + "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", + "CONDITION_SATISFIED", + "COPY_READ_BUFFER", + "COPY_READ_BUFFER_BINDING", + "COPY_WRITE_BUFFER", + "COPY_WRITE_BUFFER_BINDING", + "CURRENT_QUERY", + "DEPTH", + "DEPTH24_STENCIL8", + "DEPTH32F_STENCIL8", + "DEPTH_COMPONENT24", + "DEPTH_COMPONENT32F", + "DEPTH_STENCIL", + "DEPTH_STENCIL_ATTACHMENT", + "DRAW_BUFFER0", + "DRAW_BUFFER10", + "DRAW_BUFFER1", + "DRAW_BUFFER11", + "DRAW_BUFFER12", + "DRAW_BUFFER13", + "DRAW_BUFFER14", + "DRAW_BUFFER15", + "DRAW_BUFFER2", + "DRAW_BUFFER3", + "DRAW_BUFFER4", + "DRAW_BUFFER5", + "DRAW_BUFFER6", + "DRAW_BUFFER7", + "DRAW_BUFFER8", + "DRAW_BUFFER9", + "DRAW_FRAMEBUFFER", + "DRAW_FRAMEBUFFER_BINDING", + "DYNAMIC_COPY", + "DYNAMIC_READ", + "FLOAT_32_UNSIGNED_INT_24_8_REV", + "FLOAT_MAT2x3", + "FLOAT_MAT2x4", + "FLOAT_MAT3x2", + "FLOAT_MAT3x4", + "FLOAT_MAT4x2", + "FLOAT_MAT4x3", + "FRAGMENT_SHADER_DERIVATIVE_HINT", + "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", + "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", + "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING", + "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE", + "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", + "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", + "FRAMEBUFFER_ATTACHMENT_RED_SIZE", + "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", + "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER", + "FRAMEBUFFER_DEFAULT", + "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE", + "FRAMEBUFFER_UNDEFINED", + "GREEN", + "HALF_FLOAT", + "INT_2_10_10_10_REV", + "INTERLEAVED_ATTRIBS", + "INT_SAMPLER_2D", + "INT_SAMPLER_2D_ARRAY", + "INT_SAMPLER_3D", + "INT_SAMPLER_CUBE", + "INVALID_INDEX", + "MAJOR_VERSION", + "MAP_FLUSH_EXPLICIT_BIT", + "MAP_INVALIDATE_BUFFER_BIT", + "MAP_INVALIDATE_RANGE_BIT", + "MAP_READ_BIT", + "MAP_UNSYNCHRONIZED_BIT", + "MAP_WRITE_BIT", + "MAX", + "MAX_3D_TEXTURE_SIZE", + "MAX_ARRAY_TEXTURE_LAYERS", + "MAX_COLOR_ATTACHMENTS", + "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", + "MAX_COMBINED_UNIFORM_BLOCKS", + "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", + "MAX_DRAW_BUFFERS", + "MAX_ELEMENT_INDEX", + "MAX_ELEMENTS_INDICES", + "MAX_ELEMENTS_VERTICES", + "MAX_FRAGMENT_INPUT_COMPONENTS", + "MAX_FRAGMENT_UNIFORM_BLOCKS", + "MAX_FRAGMENT_UNIFORM_COMPONENTS", + "MAX_PROGRAM_TEXEL_OFFSET", + "MAX_SAMPLES", + "MAX_SERVER_WAIT_TIMEOUT", + "MAX_TEXTURE_LOD_BIAS", + "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", + "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", + "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", + "MAX_UNIFORM_BLOCK_SIZE", + "MAX_UNIFORM_BUFFER_BINDINGS", + "MAX_VARYING_COMPONENTS", + "MAX_VERTEX_OUTPUT_COMPONENTS", + "MAX_VERTEX_UNIFORM_BLOCKS", + "MAX_VERTEX_UNIFORM_COMPONENTS", + "MIN", + "MINOR_VERSION", + "MIN_PROGRAM_TEXEL_OFFSET", + "NUM_EXTENSIONS", + "NUM_PROGRAM_BINARY_FORMATS", + "NUM_SAMPLE_COUNTS", + "OBJECT_TYPE", + "PACK_ROW_LENGTH", + "PACK_SKIP_PIXELS", + "PACK_SKIP_ROWS", + "PIXEL_PACK_BUFFER", + "PIXEL_PACK_BUFFER_BINDING", + "PIXEL_UNPACK_BUFFER", + "PIXEL_UNPACK_BUFFER_BINDING", + "PRIMITIVE_RESTART_FIXED_INDEX", + "PROGRAM_BINARY_FORMATS", + "PROGRAM_BINARY_LENGTH", + "PROGRAM_BINARY_RETRIEVABLE_HINT", + "QUERY_RESULT", + "QUERY_RESULT_AVAILABLE", + "R11F_G11F_B10F", + "R16F", + "R16I", + "R16UI", + "R32F", + "R32I", + "R32UI", + "R8", + "R8I", + "R8_SNORM", + "R8UI", + "RASTERIZER_DISCARD", + "READ_BUFFER", + "READ_FRAMEBUFFER", + "READ_FRAMEBUFFER_BINDING", + "RED", + "RED_INTEGER", + "RENDERBUFFER_SAMPLES", + "RG", + "RG16F", + "RG16I", + "RG16UI", + "RG32F", + "RG32I", + "RG32UI", + "RG8", + "RG8I", + "RG8_SNORM", + "RG8UI", + "RGB10_A2", + "RGB10_A2UI", + "RGB16F", + "RGB16I", + "RGB16UI", + "RGB32F", + "RGB32I", + "RGB32UI", + "RGB8", + "RGB8I", + "RGB8_SNORM", + "RGB8UI", + "RGB9_E5", + "RGBA16F", + "RGBA16I", + "RGBA16UI", + "RGBA32F", + "RGBA32I", + "RGBA32UI", + "RGBA8", + "RGBA8I", + "RGBA8_SNORM", + "RGBA8UI", + "RGBA_INTEGER", + "RGB_INTEGER", + "RG_INTEGER", + "SAMPLER_2D_ARRAY", + "SAMPLER_2D_ARRAY_SHADOW", + "SAMPLER_2D_SHADOW", + "SAMPLER_3D", + "SAMPLER_BINDING", + "SAMPLER_CUBE_SHADOW", + "SEPARATE_ATTRIBS", + "SIGNALED", + "SIGNED_NORMALIZED", + "SRGB", + "SRGB8", + "SRGB8_ALPHA8", + "STATIC_COPY", + "STATIC_READ", + "STENCIL", + "STREAM_COPY", + "STREAM_READ", + "SYNC_CONDITION", + "SYNC_FENCE", + "SYNC_FLAGS", + "SYNC_FLUSH_COMMANDS_BIT", + "SYNC_GPU_COMMANDS_COMPLETE", + "SYNC_STATUS", + "TEXTURE_2D_ARRAY", + "TEXTURE_3D", + "TEXTURE_BASE_LEVEL", + "TEXTURE_BINDING_2D_ARRAY", + "TEXTURE_BINDING_3D", + "TEXTURE_COMPARE_FUNC", + "TEXTURE_COMPARE_MODE", + "TEXTURE_IMMUTABLE_FORMAT", + "TEXTURE_IMMUTABLE_LEVELS", + "TEXTURE_MAX_LEVEL", + "TEXTURE_MAX_LOD", + "TEXTURE_MIN_LOD", + "TEXTURE_SWIZZLE_A", + "TEXTURE_SWIZZLE_B", + "TEXTURE_SWIZZLE_G", + "TEXTURE_SWIZZLE_R", + "TEXTURE_WRAP_R", + "TIMEOUT_EXPIRED", + "TRANSFORM_FEEDBACK", + "TRANSFORM_FEEDBACK_ACTIVE", + "TRANSFORM_FEEDBACK_BINDING", + "TRANSFORM_FEEDBACK_BUFFER", + "TRANSFORM_FEEDBACK_BUFFER_BINDING", + "TRANSFORM_FEEDBACK_BUFFER_MODE", + "TRANSFORM_FEEDBACK_BUFFER_SIZE", + "TRANSFORM_FEEDBACK_BUFFER_START", + "TRANSFORM_FEEDBACK_PAUSED", + "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", + "TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH", + "TRANSFORM_FEEDBACK_VARYINGS", + "UNIFORM_ARRAY_STRIDE", + "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", + "UNIFORM_BLOCK_ACTIVE_UNIFORMS", + "UNIFORM_BLOCK_BINDING", + "UNIFORM_BLOCK_DATA_SIZE", + "UNIFORM_BLOCK_INDEX", + "UNIFORM_BLOCK_NAME_LENGTH", + "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", + "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", + "UNIFORM_BUFFER", + "UNIFORM_BUFFER_BINDING", + "UNIFORM_BUFFER_OFFSET_ALIGNMENT", + "UNIFORM_BUFFER_SIZE", + "UNIFORM_BUFFER_START", + "UNIFORM_IS_ROW_MAJOR", + "UNIFORM_MATRIX_STRIDE", + "UNIFORM_NAME_LENGTH", + "UNIFORM_OFFSET", + "UNIFORM_SIZE", + "UNIFORM_TYPE", + "UNPACK_IMAGE_HEIGHT", + "UNPACK_ROW_LENGTH", + "UNPACK_SKIP_IMAGES", + "UNPACK_SKIP_PIXELS", + "UNPACK_SKIP_ROWS", + "UNSIGNALED", + "UNSIGNED_INT_10F_11F_11F_REV", + "UNSIGNED_INT_2_10_10_10_REV", + "UNSIGNED_INT_24_8", + "UNSIGNED_INT_5_9_9_9_REV", + "UNSIGNED_INT_SAMPLER_2D", + "UNSIGNED_INT_SAMPLER_2D_ARRAY", + "UNSIGNED_INT_SAMPLER_3D", + "UNSIGNED_INT_SAMPLER_CUBE", + "UNSIGNED_INT_VEC2", + "UNSIGNED_INT_VEC3", + "UNSIGNED_INT_VEC4", + "UNSIGNED_NORMALIZED", + "VERTEX_ARRAY_BINDING", + "VERTEX_ATTRIB_ARRAY_DIVISOR", + "VERTEX_ATTRIB_ARRAY_INTEGER", + "WAIT_FAILED", +} + +var outfile = flag.String("o", "", "result will be written to the file instead of stdout.") + +var fset = new(token.FileSet) + +func typeString(t ast.Expr) string { + buf := new(bytes.Buffer) + printer.Fprint(buf, fset, t) + return buf.String() +} + +func typePrinter(t string) string { + switch t { + case "[]float32", "[]byte": + return "len(%d)" + } + return "%v" +} + +func typePrinterArg(t, name string) string { + switch t { + case "[]float32", "[]byte": + return "len(" + name + ")" + } + return name +} + +func die(err error) { + fmt.Fprintf(os.Stderr, err.Error()) + os.Exit(1) +} + +func main() { + flag.Parse() + + f, err := parser.ParseFile(fset, "consts.go", nil, parser.ParseComments) + if err != nil { + die(err) + } + entries := enum(f) + + f, err = parser.ParseFile(fset, "gl.go", nil, parser.ParseComments) + if err != nil { + die(err) + } + + buf := new(bytes.Buffer) + + fmt.Fprint(buf, preamble) + + fmt.Fprintf(buf, "func (v Enum) String() string {\n") + fmt.Fprintf(buf, "\tswitch v {\n") + for _, e := range dedup(entries) { + fmt.Fprintf(buf, "\tcase 0x%x: return %q\n", e.value, e.name) + } + fmt.Fprintf(buf, "\t%s\n", `default: return fmt.Sprintf("gl.Enum(0x%x)", uint32(v))`) + fmt.Fprintf(buf, "\t}\n") + fmt.Fprintf(buf, "}\n\n") + + for _, d := range f.Decls { + // Before: + // func (ctx *context) StencilMask(mask uint32) { + // C.glStencilMask(C.GLuint(mask)) + // } + // + // After: + // func (ctx *context) StencilMask(mask uint32) { + // defer func() { + // errstr := ctx.errDrain() + // log.Printf("gl.StencilMask(%v) %v", mask, errstr) + // }() + // C.glStencilMask(C.GLuint(mask)) + // } + fn, ok := d.(*ast.FuncDecl) + if !ok { + continue + } + if fn.Recv == nil || fn.Recv.List[0].Names[0].Name != "ctx" { + continue + } + tname := "" + t := fn.Recv.List[0].Type + if star, ok := t.(*ast.StarExpr); ok { + tname = "*" + star.X.(*ast.Ident).Name + } else if t, ok := t.(*ast.Ident); ok { + tname = t.Name + } + + var ( + params []string + paramTypes []string + results []string + resultTypes []string + ) + + // Print function signature. + fmt.Fprintf(buf, "func (ctx %s) %s(", tname, fn.Name.Name) + for i, p := range fn.Type.Params.List { + if i > 0 { + fmt.Fprint(buf, ", ") + } + ty := typeString(p.Type) + for i, n := range p.Names { + if i > 0 { + fmt.Fprint(buf, ", ") + } + fmt.Fprintf(buf, "%s ", n.Name) + params = append(params, n.Name) + paramTypes = append(paramTypes, ty) + } + fmt.Fprint(buf, ty) + } + fmt.Fprintf(buf, ") (") + if fn.Type.Results != nil { + for i, r := range fn.Type.Results.List { + if i > 0 { + fmt.Fprint(buf, ", ") + } + ty := typeString(r.Type) + if len(r.Names) == 0 { + name := fmt.Sprintf("r%d", i) + fmt.Fprintf(buf, "%s ", name) + results = append(results, name) + resultTypes = append(resultTypes, ty) + } + for i, n := range r.Names { + if i > 0 { + fmt.Fprint(buf, ", ") + } + fmt.Fprintf(buf, "%s ", n.Name) + results = append(results, n.Name) + resultTypes = append(resultTypes, ty) + } + fmt.Fprint(buf, ty) + } + } + fmt.Fprintf(buf, ") {\n") + + // gl.GetError is used by errDrain, which will be made part of + // all functions. So do not apply it to gl.GetError to avoid + // infinite recursion. + skip := fn.Name.Name == "GetError" + + if !skip { + // Insert a defer block for tracing. + fmt.Fprintf(buf, "defer func() {\n") + fmt.Fprintf(buf, "\terrstr := ctx.errDrain()\n") + switch fn.Name.Name { + case "GetUniformLocation", "GetAttribLocation": + fmt.Fprintf(buf, "\tr0.name = name\n") + } + fmt.Fprintf(buf, "\tlog.Printf(\"gl.%s(", fn.Name.Name) + for i, p := range paramTypes { + if i > 0 { + fmt.Fprint(buf, ", ") + } + fmt.Fprint(buf, typePrinter(p)) + } + fmt.Fprintf(buf, ") ") + if len(resultTypes) > 1 { + fmt.Fprint(buf, "(") + } + for i, r := range resultTypes { + if i > 0 { + fmt.Fprint(buf, ", ") + } + fmt.Fprint(buf, typePrinter(r)) + } + if len(resultTypes) > 1 { + fmt.Fprint(buf, ") ") + } + fmt.Fprintf(buf, "%%v\"") + for i, p := range paramTypes { + fmt.Fprintf(buf, ", %s", typePrinterArg(p, params[i])) + } + for i, r := range resultTypes { + fmt.Fprintf(buf, ", %s", typePrinterArg(r, results[i])) + } + fmt.Fprintf(buf, ", errstr)\n") + fmt.Fprintf(buf, "}()\n") + } + + // Print original body of function. + for _, s := range fn.Body.List { + if c := enqueueCall(s); c != nil { + c.Fun.(*ast.SelectorExpr).Sel.Name = "enqueueDebug" + setEnqueueBlocking(c) + } + printer.Fprint(buf, fset, s) + fmt.Fprintf(buf, "\n") + } + fmt.Fprintf(buf, "}\n\n") + } + + b, err := format.Source(buf.Bytes()) + if err != nil { + os.Stdout.Write(buf.Bytes()) + die(err) + } + + if *outfile == "" { + os.Stdout.Write(b) + return + } + if err := ioutil.WriteFile(*outfile, b, 0666); err != nil { + die(err) + } +} + +func enqueueCall(stmt ast.Stmt) *ast.CallExpr { + exprStmt, ok := stmt.(*ast.ExprStmt) + if !ok { + return nil + } + call, ok := exprStmt.X.(*ast.CallExpr) + if !ok { + return nil + } + fun, ok := call.Fun.(*ast.SelectorExpr) + if !ok { + return nil + } + if fun.Sel.Name != "enqueue" { + return nil + } + return call +} + +func setEnqueueBlocking(c *ast.CallExpr) { + lit := c.Args[0].(*ast.CompositeLit) + for _, elt := range lit.Elts { + kv := elt.(*ast.KeyValueExpr) + if kv.Key.(*ast.Ident).Name == "blocking" { + kv.Value = &ast.Ident{Name: "true"} + return + } + } + lit.Elts = append(lit.Elts, &ast.KeyValueExpr{ + Key: &ast.Ident{ + NamePos: lit.Rbrace, + Name: "blocking", + }, + Value: &ast.Ident{Name: "true"}, + }) +} + +const preamble = `// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Code generated from gl.go using go generate. DO NOT EDIT. +// See doc.go for details. + +// +build darwin linux openbsd freebsd windows +// +build gldebug + +package gl + +import ( + "fmt" + "log" + "math" + "sync/atomic" + "unsafe" +) + +func (ctx *context) errDrain() string { + var errs []Enum + for { + e := ctx.GetError() + if e == 0 { + break + } + errs = append(errs, e) + } + if len(errs) > 0 { + return fmt.Sprintf(" error: %v", errs) + } + return "" +} + +func (ctx *context) enqueueDebug(c call) uintptr { + numCalls := atomic.AddInt32(&ctx.debug, 1) + if numCalls > 1 { + panic("concurrent calls made to the same GL context") + } + defer func() { + if atomic.AddInt32(&ctx.debug, -1) > 0 { + select {} // block so you see us in the panic + } + }() + + return ctx.enqueue(c) +} + +` + +type entry struct { + name string + value uint64 +} + +func genWhitelistMap(whitelist []string) map[string]bool { + m := make(map[string]bool) + for _, v := range enumWhitelist { + m[v] = true + } + return m +} + +// enum builds a list of all GL constants that make up the gl.Enum type. +func enum(f *ast.File) []entry { + var entries []entry + whitelist := genWhitelistMap(enumWhitelist) + for _, d := range f.Decls { + gendecl, ok := d.(*ast.GenDecl) + if !ok { + continue + } + if gendecl.Tok != token.CONST { + continue + } + for _, s := range gendecl.Specs { + v, ok := s.(*ast.ValueSpec) + if !ok { + continue + } + if len(v.Names) != 1 || len(v.Values) != 1 { + continue + } + if _, ok := whitelist[v.Names[0].Name]; !ok { + continue + } + val, err := strconv.ParseUint(v.Values[0].(*ast.BasicLit).Value, 0, 64) + if err != nil { + log.Fatalf("enum %s: %v", v.Names[0].Name, err) + } + entries = append(entries, entry{v.Names[0].Name, val}) + } + } + return entries +} + +func dedup(entries []entry) []entry { + // Find all duplicates. Use "%d" as the name of any value with duplicates. + seen := make(map[uint64]int) + for _, e := range entries { + seen[e.value]++ + } + var dedup []entry + for _, e := range entries { + switch seen[e.value] { + case 0: // skip, already here + case 1: + dedup = append(dedup, e) + default: + // value is duplicated + dedup = append(dedup, entry{fmt.Sprintf("%d", e.value), e.value}) + seen[e.value] = 0 + } + } + return dedup +} diff --git a/vendor/github.com/fyne-io/mobile/gl/work.go b/vendor/github.com/fyne-io/mobile/gl/work.go index 81b06e5cda..3e5338dfed 100644 --- a/vendor/github.com/fyne-io/mobile/gl/work.go +++ b/vendor/github.com/fyne-io/mobile/gl/work.go @@ -87,7 +87,7 @@ type context3 struct { func NewContext() (Context, Worker) { glctx := &context{ workAvailable: make(chan struct{}, 1), - work: make(chan call, workbufLen), + work: make(chan call, workbufLen*4), retvalue: make(chan C.uintptr_t), } if C.GLES_VERSION == "GL_ES_2_0" { diff --git a/vendor/modules.txt b/vendor/modules.txt index 00a8a39f47..0662319f0b 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -8,7 +8,7 @@ github.com/akavel/rsrc/ico github.com/davecgh/go-spew/spew # github.com/fsnotify/fsnotify v1.4.9 github.com/fsnotify/fsnotify -# github.com/fyne-io/mobile v0.0.2-0.20200525115341-f642c98357ec +# github.com/fyne-io/mobile v0.0.2-0.20200528163636-261ce6a40089 github.com/fyne-io/mobile/app github.com/fyne-io/mobile/app/internal/callfn github.com/fyne-io/mobile/event/key