Output parameters

[tribals]

Hi there!

I'm trying to use GLFW library.

First off, it is not clear for me, which should I use - include or c_include? According to documentation:

Name mangling is an important difference between C and C++ code. The use of c_include instead of include prevents mangling.

This is a C library, not C++, as well as Zlib, so I decided to use c_include. But when I'm trying it, it doesn't find attributes on imported library (adapting from doc's Zlib example):

cppyy.c_include('GLFW/glfw3.h')
cppyy.load_library('libglfw')

cppyy.gbl.glfwGetVersion
Traceback (most recent call last):
  File "<python-input-7>", line 1, in <module>
    cppyy.gbl.glfwGetVersion
AttributeError: <namespace cppyy.gbl at 0xa468180> has no attribute 'glfwGetVersion'. Full details:
  type object '' has no attribute 'glfwGetVersion'
  'glfwGetVersion' is not a known C++ class
  'glfwGetVersion' is not a known C++ template
  'glfwGetVersion' is not a known C++ enum

Why this is so?

But even when I'm using include instead, there's a problem still:

cppyy.include('GLFW/glfw3.h')
cppyy.load_library('libglfw')

cppyy.gbl.glfwGetVersion()
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    cppyy.gbl.glfwGetVersion()
    ~~~~~~~~~~~~~~~~~~~~~~~~^^
TypeError: void glfwGetVersion(int* major, int* minor, int* rev) =>
    TypeError: takes at least 3 arguments (0 given)

It is not clear, though, how to pass them? As they are defined as pointers:

void glfwGetVersion(int* major, int* minor, int* rev);

I've tried to do something like a, b, c = 0, 0, 0 then passing it to glfwGetVersion or even abc = [0, 0, 0] and glfwGetVersion(*abc) with no luck.

Although there is glfwGetVersionString() so zlib example could be easily replicated, there is other functions expecting output parameters like glfwGetCursorPos, as well it is common in C code to do that.

How output parameters could be supplied?

[wlav]

For the first, although GLFW is written in C, it's meant to be usable from C++; c_include is only for pure C libraries that have no such provision.

For the second, yes that function requires arguments, no way around that. You can not pass Python integers as you need a C++ int-sized patch of memory each for the function to scribble in and the Python int internals don't look anything like that. Easiest would be the use of ctypes:

>>> from ctypes import c_int
>>> major, minor, rev = c_int(0), c_int(0), c_int(0)
>>> cppyy.gbl.glfwGetVersion(major, minor, rev)
>>> print(major, minor, rev)
c_int(3) c_int(3) c_int(2)

Or if you use numpy already and are okay with that as a dependency:

>>> import numpy as np
>>> major, minor, rev = np.int32(0), np.int32(0), np.int32(0)
>>> cppyy.gbl.glfwGetVersion(major, minor, rev)
>>> print(major, minor, rev)
3 3 2

[tribals]

Than you a lot! 😊

I didn't expect such a quick response.

[wlav]

It's Friday afternoon. :)

[tribals]

it's meant to be usable from C++; c_include is only for pure C libraries that have no such provision

Cold you please elaborate a little on this?

What does it mean for C library to "be usable from C++"? Sorry, I'm neither C nor C++ expert.

[wlav]

Top of glfw.h looks like this:

#ifndef _glfw3_h_
#define _glfw3_h_

#ifdef __cplusplus
extern "C" {
#endif

which prevents name-mangling when #includeed in C++.

[tribals]

Good to know. Thanks!

[tribals]

Okay, I've just read Doc's "Features > Basic types > Pointers" for "how to pass pointers" question:

When the C++ code takes a pointer or reference type to a specific builtin type (such as an unsigned int for example), then types need to match exactly.

Here is the code (for convenience):

import cppyy
from cppyy import gbl as g

cppyy.include('GLFW/glfw3.h')
cppyy.load_library('libglfw')

from ctypes import c_int, byref

major, minor, rev = c_int(), c_int(), c_int()

g.glfwGetVersion(major, minor, rev)

print(major, minor, rev)
# c_int(3) c_int(4) c_int(0)

One even don't need to byref them as it is handled automatically:

m, n, r = c_int(), c_int(), c_int()

g.glfwGetVersion(byref(m), n, byref(r))

print(m, n, r)
# c_int(3) c_int(4) c_int(0)

[wlav]

Jinxed. :)

[tribals]

One more question, if you don't mind.

Trying to pass callback function:

GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun callback);  // 1
typedef void (* GLFWerrorfun)(int error_code, const char* description);  // 2

1. https://github.com/glfw/glfw/blob/master/include/GLFW/glfw3.h#L2504
2. https://github.com/glfw/glfw/blob/master/include/GLFW/glfw3.h#L1591

def error_callback(error, description):
    print(f'GLFW: {error}, {description}', file=sys.stderr)

g.glfwSetErrorCallback(error_callback)

Traceback (most recent call last):
  File "/tmp/tmp.8JvAxnXFe6/getting_started.py", line 53, in <module>
    c.glfwSetErrorCallback(error_callback)
    ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^
TypeError: void(*)(int,const char*) glfwSetErrorCallback(GLFWerrorfun callback) =>
    TypeError: can not convert null function pointer

At this time I first read the docs about callbacks, but still doesn't understand the reason for this error.

[wlav]

Does this work:

def error_callback(error: int, description: 'const char*'):
    print(f'GLFW: {error}, {description}', file=sys.stderr)

I forget when annotation support was added; may not have been released yet.

[tribals]

No, unfortunately not.

$ python3 -V
Python 3.13.5
$ uv pip list
Package             Version
------------------- -----------
cppyy               3.5.0
cppyy-backend       1.15.3
cppyy-cling         6.32.8
cpycppyy            1.13.0

[wlav]

Oh, I'm mistaken. It's not the annotations that makes it work, it's something more subtle. Kindof funny, really.

What's going on is that glfwSetErrorCallback returns the previously installed callback. The first time, that one is nullptr. The second time, it's the prior installed handler. Hence I thought the first call failed and that the subsequent call to install the annotated version succeeded. They both succeed, just that cppyy is erroneously interpreting that nullptr return as an error (as it can't wrap nullptr into a callback pointer).

Call it in a try: / except: block and ignore the exception. See whether the callback gets called back?

[tribals]

Will try it later.

[tribals]

Well, wrapped in try/except, it actually works, in both variants:

try:
    g.glfwSetErrorCallback(error_callback)
except TypeError:
    pass

$ DISPLAY=:42 WAYLAND_DISPLAY=wayland-42 uv run python getting_started.py
GLFW: 65550, Failed to detect any supported platform

try:
    g.glfwSetErrorCallback(error_callback)
except TypeError:
    print(g.glfwSetErrorCallback(error_callback))

This will print:

$ DISPLAY=:42 WAYLAND_DISPLAY=wayland-42 uv run python getting_started.py
<cppyy.gbl.std.function<void(int,const char*)> object at 0x19cc04b0>
GLFW: 65550, Failed to detect any supported platform

[wlav]

Yes, I removed the error checking and returned None instead on nullptr return (also not great, but not sure what a nullptr function pointer is otherwise): wlav/CPyCppyy@3d903f1

[tribals]

Wow! That's... great, I suppose. Thanks for following up!