OpenEuphoria

1. sdl2 and ffi

• Posted by ChrisB (moderator) Nov 14, 2022
• 2967 views

Hi Andy

SimpleWin

What are you doing here?

18 object event = allocate_struct(event)

Cheers

Chris

3. Re: sdl2 and ffi

• Posted by ghaberek (admin) Nov 14, 2022
• 2899 views

I'm not sure that going to work. I had discussed the current "correct" approach here: https://openeuphoria.org/forum/137153.wc

The prototype currently works like this:

-- RECT structure (windef.h) 
-- https://learn.microsoft.com/en-us/windows/win32/api/windef/ns-windef-rect 
constant C_RECT = define_c_type({ 
    C_LONG, -- left 
    C_LONG, -- top 
    C_LONG, -- right 
    C_LONG  -- bottom 
}) 
 
atom rect = allocate_struct( C_RECT ) 
poke_type( rect, C_RECT, {50,50,100,100} ) 

But I'd like to rename define_c_type() to define_c_struct() and then add define_c_union(), and then re-implement define_c_type() for "raw" types (like C_STRING as a copy of C_POINTER).

-- RECT structure (windef.h) 
-- https://learn.microsoft.com/en-us/windows/win32/api/windef/ns-windef-rect 
constant C_RECT = define_c_struct({ 
    {C_LONG,"left"}, 
    {C_LONG,"top"}, 
    {C_LONG,"right"}, 
    {C_LONG,"bottom"} 
}, "RECT") 
 
atom rect = allocate_struct( C_RECT, {50,50,100,100} ) 
? peek_member( rect, "RECT.left" ) -- prints 50 
? peek_member( rect, "RECT" ) -- prints {50,50,100,100} 

Thoughts/opinions on this design are welcome.

-Greg

5. Re: sdl2 and ffi

• Posted by ghaberek (admin) Nov 14, 2022
• 2842 views

rect = allocate(16) allocates a block of memory of 16 bytes 
poke4(rect,{50,50,100,100}) - poke 4 4-byte integers into memory whose location begins at rect 

constant C_RECT = define_c_type({ 
    C_LONG, -- left 
    C_LONG, -- top 
    C_LONG, -- right 
    C_LONG  -- bottom 
})\\ 

atom rect = allocate_struct( C_RECT ) --allocate a memory block of the size required to hold the c_type C_RECT 
poke_type( rect, C_RECT, {50,50,100,100} ) 
poke type( rect - pointer to where the memory is located 
           C_RECT - the definition of the structure elements 
           {50,50,100,100} - what to poke into each of those memory elements. 

Yes that's what I'm going for. I originally called it define_c_type() because that's basically what I want: to define additional C types, be they "int" or "float" or structures and unions. That way we're extending the existing design of define_c_func/proc() and the new structure/union "types" will work there as well, almost transparently.

peek4u(rect) (= 50) 
peek4u(rect + 12) (= 100) 
peek4u({rect,4}) (= {50,50,100,100}  ) 

You're not wrong; you can certainly do that. But there's a lot of potential for error here, especially with the addition of 64-bit Euphoria and many more peek/poke routines like peek8u() and peek_pointer(). IMHO the ethos of Euphoria is to help reduce this kind of confusion. Why should you have to worry about the size of those structure members?

That's where peek_type() and poke_type() come in: these routines will handle the nonsense of "is it four or eight bytes? signed? floating-point?" and just dispatch to the correct peek/poke for you, and it will do so correctly based on the platform (not all C_LONG are four bytes).

constant C_RECT = define_c_struct({ 
    {C_LONG,"left"}, 
    {C_LONG,"top"}, 
    {C_LONG,"right"}, 
    {C_LONG,"bottom"} 
}, "RECT") 

atom rect = allocate_struct( C_RECT, {50,50,100,100} ) 

peek4u(rect + 12) (= 100) 
peek4u({rect,4}) (= {50,50,100,100}  ) 

That's the gist of it. Although minding all of those "+ 12" offsets gets very messy when we have to support 32-bit and 64-bit Intel/AMD architecture, let alone that ARM processors are more common and those could introduce differences as well. Using libffi to help do some of this heavy lifting means we're building on literal decades of experience.

? peek_member( rect, "RECT.left" ) -- prints 50 
? peek_member( rect, "RECT" ) -- prints {50,50,100,100} 

This is where feedback helps the most. I'm trying to reduce complexity, not add to it. Is peek_type( ptr, C_TYPE ) or peek_member( ptr, "TYPE.name" ) really more complex than peek4u( ptr + 12 )? and what does 12 mean? it might have to be 16 or 20 on 64-bit, right? who knows! So I'm basically going back to the drawing board on what Matt had original mostly-built for memstruct. He was doing all of these sizes-and-offsets by hand. Plus it seems a bit out of order to implement memstruct now with out a better plan for how classes will work later, since they might utilize a lot of the same type-sniffing code.

C_RECT already defined as above 
 
constant C_THING = define_c_union { 
    C_LONG, 
    C_LONG, 
    C_POINTER, 
    C_RECT,                         --pointer to the C_RECT structure 
} 
thing = allocate_union(C_THING) 

This is probably where having named members helps the most. Otherwise you're really shooting in the dark with magic numbers. Basically a union lets you perform bit-twiddling by converting a chunk of memory into different types. I don't know about you but to me, remembering what something like peek_type( ptr, C_THING, 1 ) does is going to be hard if not impossible.

I think you're doing great, Chris.

-Greg

7. Re: sdl2 and ffi

• Posted by ChrisB (moderator) Nov 14, 2022
• 2844 views

Includes missing in sdl.e

public include SDL_keyboard.e
public include SDL_scancode.e

Cheers

Chris

9. Re: sdl2 and ffi

• Posted by SDPringle Nov 16, 2022
• 2608 views

You guys are making cool stuff! The data structures that must exist could open the door to making validating data as well.

-- you could write a function like this: 
is_struct(RECT, x) -- returns true iff x has four members and each member falls within the range of the respective c types 
 
type rect(object x) 
  return is_struct(RECT, x) 
end type 
 

11. Re: sdl2 and ffi

• Posted by ChrisB (moderator) Nov 17, 2022
• 2387 views

FAO Andy

Hi

You've defined SDL_surface in SDL_surface.e as a define_c_type, and then

export constant xSDL_GetWindowSurface = define_c_func(sdl,"+SDL_GetWindowSurface",{C_POINTER},SDL_Surface) 
 
public function SDL_GetWindowSurface(atom win) 
	return c_func(xSDL_GetWindowSurface,{win}) 
end function 

the function SDL_GetWindowSurface returns a pointer to the SDL_surface, not the actual structure itself, so eu is throwing type errors.

atom surf = SDL_GetWindowSurface(win) 

D:\EuProgramming\Euphoria4_1\SDL2Wrapper\Examples\WinImage.exw:28 
type_check failure, surf is {7195552,{36'$',{1952061344,{298874067,2684419766,...  

So, am I missing a step somewhere?

Cheers

Chris

13. Re: sdl2 and ffi

• Posted by Icy_Viking Nov 17, 2022
• 2313 views

export constant xSDL_GetWindowSurface = define_c_func(sdl,"+SDL_GetWindowSurface",{C_POINTER},SDL_Surface) 
 
public function SDL_GetWindowSurface(atom win) 
	return c_func(xSDL_GetWindowSurface,{win}) 
end function 

atom surf = SDL_GetWindowSurface(win) 

D:\EuProgramming\Euphoria4_1\SDL2Wrapper\Examples\WinImage.exw:28 
type_check failure, surf is {7195552,{36'$',{1952061344,{298874067,2684419766,...  

I've changed it from SDL_Surface to C_POINTER. I've uploaded the change to github. I also like the allocate_mem feature that could be added to the FFI wrapper/library.

15. Re: sdl2 and ffi

• Posted by ChrisB (moderator) Nov 17, 2022
• 2300 views

SDL_render.e
line 116
public function SDL_CreateTextureFromSurface(atom ren, sequence surf)
->
public function SDL_CreateTextureFromSurface(atom ren, atom surf)

Cheers Chris

17. Re: sdl2 and ffi

• Posted by ChrisB (moderator) Nov 18, 2022
• 2210 views

Hi Andy

Did you just replace that one instance? There are quite a few others. All surf s and rect s need to be atoms, not sequences, because all of the sdl C functions, afaict, need to have pointers sent to them, and you are trying to send a type. I may be missing something of course.

I've just recloned the repository, and it's wiped all the changes and test files I made on my local folder. Ho hum, back to the drawing board.

Cheers

Chris

edit - I see that define_c_type returns an atom, which I imagine is a pointer to the block of memory allocated for the structure. The structure may need to be filled to be sent, or may be filled by the C function, but on the eu side the function still need to recieve pointers (atoms) to send to the C function of the block of memory allocated.

Cheers

Chris

19. Re: sdl2 and ffi

• Posted by Icy_Viking Nov 18, 2022
• 2115 views

I'll try and go through the code and update it, this weekend. I think my inital thought process must have been from looking at how Greg wrapped Raylib using FFI.

--Raylib Wrapper (FFI) 
public constant RL_VECTOR2 = define_c_type({ 
	C_FLOAT, -- x   // Vector x component 
	C_FLOAT  -- y   // Vector y component 
}) 
 
export constant raylib = open_dll( "raylib.dll" ), 
	xInitWindow         = define_c_proc( raylib, "+InitWindow", {C_INT,C_INT,C_STRING} ), 
	xWindowShouldClose  = define_c_func( raylib, "+WindowShouldClose", {}, C_BOOL ), 
	xCloseWindow        = define_c_proc( raylib, "+CloseWindow", {} ), 
	xGetWindowPosition  = define_c_func( raylib, "+GetWindowPosition", {}, RL_VECTOR2 ), 
	xGetScreenToWorld2D = define_c_func( raylib, "+GetScreenToWorld2D", {RL_VECTOR2,RL_CAMERA2D}, RL_VECTOR2 ) 
--Only copying what is relevant to my thought process 
 
public function GetScreenToWorld2D( sequence position, sequence camera ) 
	return c_func( xGetScreenToWorld2D, {position,camera} ) 
end function 

My thought process being that if a struct or so is defined as define_c_type() using FFI, then it must be called as a sequence in Euphoria. However that it is clear that is not always the case. SDL must not pass all structs by value as Raylib does.

public constant SDL_Rect = define_c_type({ 
--Part of My SDL Wrapper 
--From SDL_Rect.e 
	C_INT, --x 
	C_INT, --y 
	C_INT, --w 
	C_INT --h 
}) 
 
export constant xSDL_HasIntersection = define_c_func(sdl,"+SDL_HasIntersection",{SDL_Rect,SDL_Rect},C_BOOL) 
 
public function SDL_HasIntersection(sequence a,sequence b) 
	return c_func(xSDL_HasIntersection,{a,b}) 
end function 
 
--My thought being you could use it as such: 
sequence myRect = SDL_Rect() 
myRect[1] = 5 --x 
myRect[2] = 5 --y 
 
And so forth.  
}) 

My thought process being that sequence is the closest thing Euphoria has to struct in its current form.

EDIT: I have changed most of the sequences to atoms. Functions that returned a define_c_type() should now return a pointer as I changed it from I.E. SDL_Rect to C_POINTER.

21. Re: sdl2 and ffi

• Posted by ChrisB (moderator) Nov 19, 2022
• 2087 views
• Last edited Nov 22, 2022

Hi

There's a rule in there somewhere isn't there.

When the C library accepts pass by value you can pass the parameter as a sequence, eg

public constant RL_VECTOR2 = define_c_type({  
	C_FLOAT, -- x   // Vector x component  
	C_FLOAT  -- y   // Vector y component  
})  
 
constant xGetScreenToWorld2D = define_c_func( raylib, "+GetScreenToWorld2D", {RL_VECTOR2,RL_CAMERA2D}, RL_VECTOR2 )  
--Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position 
 
public function GetScreenToWorld2D( sequence position, sequence camera )  
	return c_func( xGetScreenToWorld2D, {position,camera} )  
end function  

However, when the C library accepts pass by reference, you must use the pointer to the structure as a parameter, eg

public constant SDL_Rect = define_c_type({  
	C_INT, --x  
	C_INT, --y  
	C_INT, --w  
	C_INT --h  
})  
 
--to illustrate the 2 ways of filling the structure 
a = allocate_struct(SDL_Rect) 
b = allocate_struct(SDL_Rect, {30,70,10,10}) 
 
poke4(a, {20,30,50,50} ) 
 
export constant xSDL_HasIntersection = define_c_func(sdl,"+SDL_HasIntersection",{SDL_Rect,SDL_Rect},C_BOOL)  
--SDL_bool SDL_HasIntersection(const SDL_Rect * A, const SDL_Rect * B);  
 
public function SDL_HasIntersection(atom a,atom b)  
        --a and b pointers to the SDL_RECT structures, already filled with values poked into the allocated memory blocks 
	return c_func(xSDL_HasIntersection,{a,b})  
end function  
 

Does that look ok to add to some documentation?

Chris

23. Re: sdl2 and ffi

• Posted by Icy_Viking Dec 04, 2022
• 1261 views

In the example program. I only have include sdl.e, I didn't include ffi.e in the example program.

So my example program as it is currently written

--Show CPU Info Demo 
 
include sdl.e 
 
puts(1,"1 Means True, 0 Means False\n") 
 
printf(1,"CPU Count: %d\n",{SDL_GetCPUCount() }) 
printf(1,"Cache Line Size: %d\n",{SDL_GetCPUCacheLineSize() }) 
printf(1,"Has RDTSC: %d\n",{SDL_HasRDTSC() }) 
printf(1,"Has AtltiVec: %d\n",{SDL_HasAltiVec() }) 
printf(1,"Has MMX:%d\n",{SDL_HasMMX() }) 
printf(1,"Has 3D Now:%d\n",{SDL_Has3DNow() }) 
printf(1,"Has SSE:%d\n",{SDL_HasSSE() }) 
printf(1,"Has SSE2:%d\n",{SDL_HasSSE2() }) 
printf(1,"Has SSE3:%d\n",{SDL_HasSSE3() }) 
printf(1,"Has SSE41:%d\n",{SDL_HasSSE41() }) 
printf(1,"Has SSE42:%d\n",{SDL_HasSSE42() }) 
printf(1,"Has AVX:%d\n",{SDL_HasAVX() }) 
printf(1,"Has AVX2:%d\n",{SDL_HasAVX2() }) 
printf(1,"Has AVX512F:%d\n",{SDL_HasAVX512F() }) 
printf(1,"Has ARMSIMD:%d\n",{SDL_HasARMSIMD() }) 
printf(1,"Has NEON:%d\n",{SDL_HasNEON() }) 
printf(1,"Has LSX:%d\n",{SDL_HasLSX() }) 
printf(1,"Has LASX:%d\n",{SDL_HasLASX() }) 
printf(1,"RAM: %d\n",{SDL_GetSystemRAM() }) 
printf(1,"OS: %s\n",{SDL_GetPlatform() }) 
 

Its a very simple program. It just uses the SDL functions to show what your OS is, how much RAM you have and what features your CPU has.

25. Re: sdl2 and ffi

• Posted by ghaberek (admin) Dec 05, 2022
• 1147 views

C:\EuProgramming\Euphoria4_1\libffi-euphoria\include\std\ffi.e:910 in function c_func()  
attempt to subscript an atom 
(reading from it) - in assignment to 'fn'  
    rid = 1 
 

The problem is that define_c_func() returned -1 for something and c_func() doesn't have good error handling. The first value of m_funcs is an atom because nothing is supposed to exist there. You can add a quick check in c_func() to help find the problem:

override function c_func( integer rid, sequence args ) 
 
    if rid > 0 then 
        return eu:c_func( rid, args ) 
    end if 
 
    -- add this: 
    if rid = -1 then 
        machine_proc( M_CRASH, "Invalid C function id: %d", {rid} ) 
    end if 
 
    rid = rid * -1 
 
    atom fn       = m_funcs[rid][1] 
    atom cif      = m_funcs[rid][2] 
    sequence name = m_funcs[rid][3] 
 

-Greg

27. Re: sdl2 and ffi

• Posted by ghaberek (admin) Dec 05, 2022
• 1114 views

I not sure I understand the problem. What do you mean by "you can't send the ffi types yet?" Maybe you're misunderstanding my intentions for using structures with FFI? If a function expects a pointer to a structure, then it expects a pointer to a structure, period. There's no changing that and I've no intention to change that.

What we need to keep in mind is that, while I'm trying to make wrapping C libraries easier, that doesn't mean it'll ever be easy. Such is the nature of interfacing from another language. When wrapping any C library, it's important to reflect on what parts should work "as is" and what parts should be made more "Euphorian."

Let's take a look at SDL_GetVersion() to start with. For reference, here's how you'd call the function in C. The first is more "traditional" but the second is more "Euphorian."

#include "SDL.h" 
 
// 
// Method 1 - Using the stack 
// This is typically what you'll see when calling a function directly from C code. 
// 
int main( int argc, char *argv[] ) 
{ 
    // Declaring a structure this way creates it on "the stack" not in memory ("the heap") 
    SDL_Version ver; 
 
    // Using "&" gives us the pointer to the structure, which the function will fill for us 
    SDL_GetVersion( &ver ); 
 
    // Since this is structure is "local" (on the stack) we use dots to access the members 
    printf( "major: %d\n", ver.major ); 
    printf( "minor: %d\n", ver.minor ); 
    printf( "patch: %d\n", ver.patch ); 
 
    // No free() here, the structure is cleared from the stack when it goes out of scope 
 
    return 0; 
} 
 
// 
// Method 2 - Using the heap 
// Manually allocate the memory. This is typically avoided and is technically slower. 
// 
int main( int argc, char *argv[] ) 
{ 
    // Allocate a pointer to some memory (on "the heap") the size of our structure 
    SDL_Version *ver = malloc( sizeof(SDL_Version) ); 
 
    // Here we pass "ver" directly since it is already a pointer to some memory 
    SDL_GetVersion( ver ); 
 
    // Since this is a pointer to a structure, we use "->" to access the members 
    printf( "major: %d\n", ver->major ); 
    printf( "minor: %d\n", ver->minor ); 
    printf( "patch: %d\n", ver->patch ); 
 
    // Free the memory from the heap otherwise we could cause a memory leak 
    free( ver ); 
 
    return 0; 
} 

And the naive approach would be to wrap it like this:

-- SDL_version.e 
include std/ffi.e 
 
constant xSDL_GetVersion = define_c_proc( libsdl, "+SDL_GetVersion", {C_POINTER} ) 
 
public constant SDL_Version = define_c_struct({ 
    C_UINT8, -- major 
    C_UINT8, -- minor 
    C_UINT8  -- patch 
}) 
 
public procedure SDL_GetVersion( atom ver ) 
    c_proc( xSDL_GetVersion, {ver} ) 
end procedure 

Which would require the user to allocate the structure, call the function, peek the result, and then free the memory, like this:

include std/ffi.e 
include SDL.e 
 
atom ver = allocate_struct( SDL_Version ) 
 
SDL_GetVersion( ver ) 
 
printf( 1, "major: %d\n", ver[1] ) 
printf( 1, "minor: %d\n", ver[2] ) 
printf( 1, "patch: %d\n", ver[3] ) 
 
free( ver ) 

Sure, that code works but it's messy and error-prone and I doubt anyone wants to spend much time writing such tedious boilerplate code.

Instead, we wrap these functions in such a way that we're doing all the boilerplate and heavy lifting behind the scenes. This is where FFI works best.

-- SDL_version.e 
include std/ffi.e 
 
constant xSDL_GetVersion = define_c_proc( libsdl, "+SDL_GetVersion", {C_POINTER} ) 
 
-- notice I made this this all-caps and removed the scope, since only 
-- the wrapper is concerned with dealing with the structure internally. 
constant SDL_VERSION = define_c_struct({ 
    C_UINT8, -- major 
    C_UINT8, -- minor 
    C_UINT8  -- patch 
}) 
 
public function SDL_GetVersion() 
 
    atom ver = allocate_struct( SDL_VERSION ) 
 
    c_proc( xSDL_GetVersion, {ver} ) 
 
    sequence result = peek_struct( ver, SDL_VERSION ) 
 
    free( ver ) 
 
    return result 
end function 

And now the end-user code is much cleaner and "feels" more like Euphoria code.

include SDL.e 
 
sequence ver = SDL_GetVersion() 
 
printf( 1, "major: %d\n", ver[1] ) 
printf( 1, "minor: %d\n", ver[2] ) 
printf( 1, "patch: %d\n", ver[3] ) 

This is the Way.

-Greg

P.S. Here's a good quick write-up on "stack" vs "heap" in C: https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap#80113

29. Re: sdl2 and ffi

• Posted by Icy_Viking Dec 05, 2022
• 1099 views

OK, I've changed the code in SDL_Version.e following Greg's advice. It works for me. I've changed from C_UINT to C_UINT8, and rewrote the SDL_GetVersion() function as Greg has shown. I tested it and it works for me. I've also pushed these changes on github. I had forgotten to update the values for the current SDL version in the SDL_Version.e code, but that has been fixed too.

include std/ffi.e 
include std/machine.e --I got "free" not found if I don't include machine.e 
 
include sdl.e 
 
public constant SDL_VERSION = define_c_type({ 
	C_UINT8, --major 
	C_UINT8, --minor 
	C_UINT8 --patch 
}) 
 
public constant SDL_MAJOR_VERSION = 2, 
				SDL_MINOR_VERSION = 26, 
				SDL_PATCHLEVEL = 1 
				 
export constant xSDL_GetVersion = define_c_proc(sdl,"+SDL_GetVersion",{C_POINTER}) 
 
public function SDL_GetVersion() 
 
	atom ver = allocate_struct(SDL_VERSION) 
	 
	c_proc(xSDL_GetVersion,{ver}) 
	 
	sequence res = peek_struct(ver,SDL_VERSION) 
	 
	free(ver) 
	 
	return res 
	 
end function 
 
export constant xSDL_GetRevision = define_c_func(sdl,"+SDL_GetRevision",{},C_STRING) 
 
public function SDL_GetRevision() 
	return c_func(xSDL_GetRevision,{}) 
end function 
 
export constant xSDL_GetRevisionNumber = define_c_func(sdl,"+SDL_GetRevisionNumber",{},C_INT) 
 
public function SDL_GetRevisionNumber() 
	return c_func(xSDL_GetRevisionNumber,{}) 
end function 
 

--Show CPU Info Demo 
 
include sdl.e 
 
puts(1,"1 Means True, 0 Means False\n") 
 
printf(1,"CPU Count: %d\n",{SDL_GetCPUCount() }) 
printf(1,"Cache Line Size: %d\n",{SDL_GetCPUCacheLineSize() }) 
printf(1,"Has RDTSC: %d\n",{SDL_HasRDTSC() }) 
printf(1,"Has AtltiVec: %d\n",{SDL_HasAltiVec() }) 
printf(1,"Has MMX:%d\n",{SDL_HasMMX() }) 
printf(1,"Has 3D Now:%d\n",{SDL_Has3DNow() }) 
printf(1,"Has SSE:%d\n",{SDL_HasSSE() }) 
printf(1,"Has SSE2:%d\n",{SDL_HasSSE2() }) 
printf(1,"Has SSE3:%d\n",{SDL_HasSSE3() }) 
printf(1,"Has SSE41:%d\n",{SDL_HasSSE41() }) 
printf(1,"Has SSE42:%d\n",{SDL_HasSSE42() }) 
printf(1,"Has AVX:%d\n",{SDL_HasAVX() }) 
printf(1,"Has AVX2:%d\n",{SDL_HasAVX2() }) 
printf(1,"Has AVX512F:%d\n",{SDL_HasAVX512F() }) 
printf(1,"Has ARMSIMD:%d\n",{SDL_HasARMSIMD() }) 
printf(1,"Has NEON:%d\n",{SDL_HasNEON() }) 
printf(1,"Has LSX:%d\n",{SDL_HasLSX() }) 
printf(1,"Has LASX:%d\n",{SDL_HasLASX() }) 
printf(1,"RAM: %d\n",{SDL_GetSystemRAM() }) 
printf(1,"OS: %s\n",{SDL_GetPlatform() }) 
 
sequence ver = SDL_GetVersion() 
 
printf(1,"SDL Version:\n") 
 
printf(1,"Major: %d\n",ver[1]) 
printf(1,"Minor: %d\n",ver[2]) 
printf(1,"Patch: %d\n",ver[3]) 

31. Re: sdl2 and ffi

• Posted by Icy_Viking Dec 05, 2022
• 1062 views

I've fixed the SDL_events.e file. I've changed the SDL_Event to a C_POINTER.