Skip to content

Fortran binding reference

Generated from the native header and the C++ bridge header. Both modules use iso_c_binding. All pointer arguments are type(c_ptr), value: pass c_loc(target) or c_null_ptr only where the API allows it. All 64-bit integer arguments require _c_int64_t constants.

C unsigned integers preserve their bits in signed Fortran integers. A native result below zero is a raw kernel error. Bridge Boolean results are 0/1; bridge validation failures are negative, allocation failure is -12. Pointer constructors return c_null_ptr on failure.

Français: guide · English: guide

gaspardos_native

GO64_ticks

function GO64_ticks( &
  ) bind(C, name="GO64_ticks") result(r)
  import
  integer(c_int64_t) :: r
end function GO64_ticks

C ABI:

int64_t GO64_ticks(void);

GO64_console_write

function GO64_console_write( &
  buffer, &
  size) bind(C, name="GO64_console_write") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
end function GO64_console_write

C ABI:

int64_t GO64_console_write(const void* buffer, uint64_t size);

GO64_yield

function GO64_yield( &
  ) bind(C, name="GO64_yield") result(r)
  import
  integer(c_int64_t) :: r
end function GO64_yield

C ABI:

int64_t GO64_yield(void);

GO64_exit

subroutine GO64_exit( &
  ) bind(C, name="GO64_exit")
  import
end subroutine GO64_exit

C ABI:

void GO64_exit(void);

GO64_alloc

function GO64_alloc( &
  size) bind(C, name="GO64_alloc") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: size
end function GO64_alloc

C ABI:

int64_t GO64_alloc(uint64_t size);

GO64_free

function GO64_free( &
  pointer) bind(C, name="GO64_free") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: pointer
end function GO64_free

C ABI:

int64_t GO64_free(void* pointer);

GO64_fs_open

function GO64_fs_open( &
  path, &
  flags) bind(C, name="GO64_fs_open") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
  integer(c_int64_t), value :: flags
end function GO64_fs_open

C ABI:

int64_t GO64_fs_open(const wchar_t* path, uint64_t flags);

GO64_fs_close

function GO64_fs_close( &
  fd) bind(C, name="GO64_fs_close") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
end function GO64_fs_close

C ABI:

int64_t GO64_fs_close(int64_t fd);

GO64_fs_read

function GO64_fs_read( &
  fd, &
  buffer, &
  size) bind(C, name="GO64_fs_read") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
end function GO64_fs_read

C ABI:

int64_t GO64_fs_read(int64_t fd, void* buffer, uint64_t size);

GO64_fs_write

function GO64_fs_write( &
  fd, &
  buffer, &
  size) bind(C, name="GO64_fs_write") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
end function GO64_fs_write

C ABI:

int64_t GO64_fs_write(int64_t fd, const void* buffer, uint64_t size);

GO64_fs_seek

function GO64_fs_seek( &
  fd, &
  offset, &
  origin) bind(C, name="GO64_fs_seek") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  integer(c_int64_t), value :: offset
  integer(c_int64_t), value :: origin
end function GO64_fs_seek

C ABI:

int64_t GO64_fs_seek(int64_t fd, int64_t offset, uint64_t origin);

GO64_fs_stat

function GO64_fs_stat( &
  path, &
  info) bind(C, name="GO64_fs_stat") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
  type(c_ptr), value :: info
end function GO64_fs_stat

C ABI:

int64_t GO64_fs_stat(const wchar_t* path, GO64_FSInfo* info);

GO64_fs_fstat

function GO64_fs_fstat( &
  fd, &
  info) bind(C, name="GO64_fs_fstat") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: info
end function GO64_fs_fstat

C ABI:

int64_t GO64_fs_fstat(int64_t fd, GO64_FSInfo* info);

GO64_fs_mkdir

function GO64_fs_mkdir( &
  path) bind(C, name="GO64_fs_mkdir") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
end function GO64_fs_mkdir

C ABI:

int64_t GO64_fs_mkdir(const wchar_t* path);
function GO64_fs_unlink( &
  path) bind(C, name="GO64_fs_unlink") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
end function GO64_fs_unlink

C ABI:

int64_t GO64_fs_unlink(const wchar_t* path);

GO64_fs_rmdir

function GO64_fs_rmdir( &
  path) bind(C, name="GO64_fs_rmdir") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
end function GO64_fs_rmdir

C ABI:

int64_t GO64_fs_rmdir(const wchar_t* path);

GO64_fs_truncate

function GO64_fs_truncate( &
  fd, &
  size) bind(C, name="GO64_fs_truncate") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  integer(c_int64_t), value :: size
end function GO64_fs_truncate

C ABI:

int64_t GO64_fs_truncate(int64_t fd, uint64_t size);

GO64_fs_readdir

function GO64_fs_readdir( &
  fd, &
  info) bind(C, name="GO64_fs_readdir") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: info
end function GO64_fs_readdir

C ABI:

int64_t GO64_fs_readdir(int64_t fd, GO64_FSInfo* info);

GO64_fs_rename

function GO64_fs_rename( &
  oldpath, &
  newpath) bind(C, name="GO64_fs_rename") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: oldpath
  type(c_ptr), value :: newpath
end function GO64_fs_rename

C ABI:

int64_t GO64_fs_rename(const wchar_t* oldpath, const wchar_t* newpath);

GO64_fs_fcntl

function GO64_fs_fcntl( &
  fd, &
  command, &
  flags) bind(C, name="GO64_fs_fcntl") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  integer(c_int64_t), value :: command
  integer(c_int64_t), value :: flags
end function GO64_fs_fcntl

C ABI:

int64_t GO64_fs_fcntl(int64_t fd, uint64_t command, uint64_t flags);

GO64_socket

function GO64_socket( &
  family, &
  type, &
  protocol) bind(C, name="GO64_socket") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: family
  integer(c_int64_t), value :: type
  integer(c_int64_t), value :: protocol
end function GO64_socket

C ABI:

int64_t GO64_socket(uint64_t family, uint64_t type, uint64_t protocol);

GO64_bind

function GO64_bind( &
  fd, &
  address, &
  address_size) bind(C, name="GO64_bind") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: address
  integer(c_int64_t), value :: address_size
end function GO64_bind

C ABI:

int64_t GO64_bind(int64_t fd, const GO64_SocketAddress* address, uint64_t address_size);

GO64_listen

function GO64_listen( &
  fd, &
  backlog) bind(C, name="GO64_listen") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  integer(c_int64_t), value :: backlog
end function GO64_listen

C ABI:

int64_t GO64_listen(int64_t fd, int64_t backlog);

GO64_accept

function GO64_accept( &
  fd, &
  address, &
  address_size) bind(C, name="GO64_accept") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: address
  type(c_ptr), value :: address_size
end function GO64_accept

C ABI:

int64_t GO64_accept(int64_t fd, GO64_SocketAddress* address, uint32_t* address_size);

GO64_connect

function GO64_connect( &
  fd, &
  address, &
  address_size) bind(C, name="GO64_connect") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: address
  integer(c_int64_t), value :: address_size
end function GO64_connect

C ABI:

int64_t GO64_connect(int64_t fd, const GO64_SocketAddress* address, uint64_t address_size);

GO64_send

function GO64_send( &
  fd, &
  buffer, &
  size, &
  flags) bind(C, name="GO64_send") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
  integer(c_int64_t), value :: flags
end function GO64_send

C ABI:

int64_t GO64_send(int64_t fd, const void* buffer, uint64_t size, uint64_t flags);

GO64_recv

function GO64_recv( &
  fd, &
  buffer, &
  size, &
  flags) bind(C, name="GO64_recv") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
  integer(c_int64_t), value :: flags
end function GO64_recv

C ABI:

int64_t GO64_recv(int64_t fd, void* buffer, uint64_t size, uint64_t flags);

GO64_sendto

function GO64_sendto( &
  fd, &
  buffer, &
  size, &
  flags, &
  address, &
  address_size) bind(C, name="GO64_sendto") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
  integer(c_int64_t), value :: flags
  type(c_ptr), value :: address
  integer(c_int64_t), value :: address_size
end function GO64_sendto

C ABI:

int64_t GO64_sendto(int64_t fd, const void* buffer, uint64_t size, uint64_t flags, const GO64_SocketAddress* address, uint64_t address_size);

GO64_recvfrom

function GO64_recvfrom( &
  fd, &
  buffer, &
  size, &
  flags, &
  address, &
  address_size) bind(C, name="GO64_recvfrom") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
  integer(c_int64_t), value :: flags
  type(c_ptr), value :: address
  type(c_ptr), value :: address_size
end function GO64_recvfrom

C ABI:

int64_t GO64_recvfrom(int64_t fd, void* buffer, uint64_t size, uint64_t flags, GO64_SocketAddress* address, uint32_t* address_size);

GO64_getsockname

function GO64_getsockname( &
  fd, &
  address, &
  address_size) bind(C, name="GO64_getsockname") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: address
  type(c_ptr), value :: address_size
end function GO64_getsockname

C ABI:

int64_t GO64_getsockname(int64_t fd, GO64_SocketAddress* address, uint32_t* address_size);

GO64_getpeername

function GO64_getpeername( &
  fd, &
  address, &
  address_size) bind(C, name="GO64_getpeername") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
  type(c_ptr), value :: address
  type(c_ptr), value :: address_size
end function GO64_getpeername

C ABI:

int64_t GO64_getpeername(int64_t fd, GO64_SocketAddress* address, uint32_t* address_size);

GO64_socket_close

function GO64_socket_close( &
  fd) bind(C, name="GO64_socket_close") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: fd
end function GO64_socket_close

C ABI:

int64_t GO64_socket_close(int64_t fd);

GO64_log

function GO64_log( &
  text) bind(C, name="GO64_log") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: text
end function GO64_log

C ABI:

int64_t GO64_log(const char* text);

GO64_window_create

function GO64_window_create( &
  options) bind(C, name="GO64_window_create") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: options
end function GO64_window_create

C ABI:

int64_t GO64_window_create(const GO64_WindowOptions* options);

GO64_window_destroy

function GO64_window_destroy( &
  window) bind(C, name="GO64_window_destroy") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: window
end function GO64_window_destroy

C ABI:

int64_t GO64_window_destroy(uint64_t window);

GO64_window_fill

function GO64_window_fill( &
  window, &
  drawing) bind(C, name="GO64_window_fill") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: window
  type(c_ptr), value :: drawing
end function GO64_window_fill

C ABI:

int64_t GO64_window_fill(uint64_t window, const GO64_Drawing* drawing);

GO64_window_text

function GO64_window_text( &
  window, &
  drawing) bind(C, name="GO64_window_text") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: window
  type(c_ptr), value :: drawing
end function GO64_window_text

C ABI:

int64_t GO64_window_text(uint64_t window, const GO64_Drawing* drawing);

GO64_window_event

function GO64_window_event( &
  window, &
  event, &
  mode) bind(C, name="GO64_window_event") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: window
  type(c_ptr), value :: event
  integer(c_int64_t), value :: mode
end function GO64_window_event

C ABI:

int64_t GO64_window_event(uint64_t window, GO64_Event* event, uint64_t mode);

GO64_window_focus

function GO64_window_focus( &
  window) bind(C, name="GO64_window_focus") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: window
end function GO64_window_focus

C ABI:

int64_t GO64_window_focus(uint64_t window);

GO64_window_blit

function GO64_window_blit( &
  window, &
  tile) bind(C, name="GO64_window_blit") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int64_t), value :: window
  type(c_ptr), value :: tile
end function GO64_window_blit

C ABI:

int64_t GO64_window_blit(uint64_t window, const GO64_Blit* tile);

GO64_process_spawn

function GO64_process_spawn( &
  image, &
  size, &
  argc, &
  argv) bind(C, name="GO64_process_spawn") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: image
  integer(c_int64_t), value :: size
  integer(c_int64_t), value :: argc
  type(c_ptr), value :: argv
end function GO64_process_spawn

C ABI:

int64_t GO64_process_spawn(const void* image, uint64_t size, uint64_t argc, const char* const* argv);

GO64_process_read

function GO64_process_read( &
  buffer, &
  size) bind(C, name="GO64_process_read") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: buffer
  integer(c_int64_t), value :: size
end function GO64_process_read

C ABI:

int64_t GO64_process_read(void* buffer, uint64_t size);

GO64_process_status

function GO64_process_status( &
  ) bind(C, name="GO64_process_status") result(r)
  import
  integer(c_int64_t) :: r
end function GO64_process_status

C ABI:

int64_t GO64_process_status(void);

gaspardos_gui

gof_widgets_new

function gof_widgets_new( &
  width, &
  height) bind(C, name="gof_widgets_new") result(r)
  import
  type(c_ptr) :: r
  integer(c_int32_t), value :: width
  integer(c_int32_t), value :: height
end function gof_widgets_new

C ABI:

void* gof_widgets_new(int32_t width, int32_t height);

gof_widgets_delete

function gof_widgets_delete( &
  ui) bind(C, name="gof_widgets_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: ui
end function gof_widgets_delete

C ABI:

int64_t gof_widgets_delete(void* ui);

gof_widgets_add

function gof_widgets_add( &
  ui, &
  kind, &
  id, &
  x, &
  y, &
  width, &
  height, &
  text, &
  parent) bind(C, name="gof_widgets_add") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: ui
  integer(c_int32_t), value :: kind
  integer(c_int32_t), value :: id
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
  integer(c_int32_t), value :: width
  integer(c_int32_t), value :: height
  type(c_ptr), value :: text
  integer(c_int32_t), value :: parent
end function gof_widgets_add

C ABI:

int64_t gof_widgets_add(void* ui, int32_t kind, int32_t id, int32_t x, int32_t y, int32_t width, int32_t height, const char* text, int32_t parent);

gof_widgets_text

function gof_widgets_text( &
  ui, &
  id, &
  text) bind(C, name="gof_widgets_text") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: ui
  integer(c_int32_t), value :: id
  type(c_ptr), value :: text
end function gof_widgets_text

C ABI:

int64_t gof_widgets_text(void* ui, int32_t id, const char* text);

gof_widgets_value

function gof_widgets_value( &
  ui, &
  id, &
  output, &
  capacity) bind(C, name="gof_widgets_value") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: ui
  integer(c_int32_t), value :: id
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_widgets_value

C ABI:

int64_t gof_widgets_value(void* ui, int32_t id, char* output, int64_t capacity);

gof_widgets_event

function gof_widgets_event( &
  ui, &
  event) bind(C, name="gof_widgets_event") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: ui
  type(c_ptr), value :: event
end function gof_widgets_event

C ABI:

int64_t gof_widgets_event(void* ui, const void* event);

gof_widgets_dirty

function gof_widgets_dirty( &
  ui) bind(C, name="gof_widgets_dirty") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: ui
end function gof_widgets_dirty

C ABI:

int64_t gof_widgets_dirty(void* ui);

gof_widgets_paint

function gof_widgets_paint( &
  ui, &
  window) bind(C, name="gof_widgets_paint") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: ui
  integer(c_int64_t), value :: window
end function gof_widgets_paint

C ABI:

int64_t gof_widgets_paint(void* ui, int64_t window);

gof_dialog_new

function gof_dialog_new( &
  ) bind(C, name="gof_dialog_new") result(r)
  import
  type(c_ptr) :: r
end function gof_dialog_new

C ABI:

void* gof_dialog_new(void);

gof_dialog_delete

function gof_dialog_delete( &
  dialog) bind(C, name="gof_dialog_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
end function gof_dialog_delete

C ABI:

int64_t gof_dialog_delete(void* dialog);

gof_dialog_begin

function gof_dialog_begin( &
  dialog, &
  mode, &
  initial, &
  suggested, &
  overwrite) bind(C, name="gof_dialog_begin") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
  integer(c_int32_t), value :: mode
  type(c_ptr), value :: initial
  type(c_ptr), value :: suggested
  integer(c_int32_t), value :: overwrite
end function gof_dialog_begin

C ABI:

int64_t gof_dialog_begin(void* dialog, int32_t mode, const char* initial, const char* suggested, int32_t overwrite);

gof_dialog_event

function gof_dialog_event( &
  dialog, &
  event, &
  ticks) bind(C, name="gof_dialog_event") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
  type(c_ptr), value :: event
  integer(c_int64_t), value :: ticks
end function gof_dialog_event

C ABI:

int64_t gof_dialog_event(void* dialog, const void* event, int64_t ticks);

gof_dialog_tick

function gof_dialog_tick( &
  dialog) bind(C, name="gof_dialog_tick") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
end function gof_dialog_tick

C ABI:

int64_t gof_dialog_tick(void* dialog);

gof_dialog_paint

function gof_dialog_paint( &
  dialog, &
  window) bind(C, name="gof_dialog_paint") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
  integer(c_int64_t), value :: window
end function gof_dialog_paint

C ABI:

int64_t gof_dialog_paint(void* dialog, int64_t window);

gof_dialog_active

function gof_dialog_active( &
  dialog) bind(C, name="gof_dialog_active") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
end function gof_dialog_active

C ABI:

int64_t gof_dialog_active(void* dialog);

gof_dialog_accepted

function gof_dialog_accepted( &
  dialog) bind(C, name="gof_dialog_accepted") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
end function gof_dialog_accepted

C ABI:

int64_t gof_dialog_accepted(void* dialog);

gof_dialog_result

function gof_dialog_result( &
  dialog, &
  output, &
  capacity) bind(C, name="gof_dialog_result") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: dialog
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_dialog_result

C ABI:

int64_t gof_dialog_result(void* dialog, char* output, int64_t capacity);

gof_input_new

function gof_input_new( &
  text) bind(C, name="gof_input_new") result(r)
  import
  type(c_ptr) :: r
  type(c_ptr), value :: text
end function gof_input_new

C ABI:

void* gof_input_new(const char* text);

gof_input_delete

function gof_input_delete( &
  input) bind(C, name="gof_input_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: input
end function gof_input_delete

C ABI:

int64_t gof_input_delete(void* input);

gof_input_set

function gof_input_set( &
  input, &
  text) bind(C, name="gof_input_set") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: input
  type(c_ptr), value :: text
end function gof_input_set

C ABI:

int64_t gof_input_set(void* input, const char* text);

gof_input_key

function gof_input_key( &
  input, &
  key) bind(C, name="gof_input_key") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: input
  integer(c_int32_t), value :: key
end function gof_input_key

C ABI:

int64_t gof_input_key(void* input, int32_t key);

gof_input_value

function gof_input_value( &
  input, &
  output, &
  capacity) bind(C, name="gof_input_value") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: input
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_input_value

C ABI:

int64_t gof_input_value(void* input, char* output, int64_t capacity);

gof_input_visible

function gof_input_visible( &
  input, &
  columns, &
  focused, &
  output, &
  capacity) bind(C, name="gof_input_visible") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: input
  integer(c_int32_t), value :: columns
  integer(c_int32_t), value :: focused
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_input_visible

C ABI:

int64_t gof_input_visible(void* input, int32_t columns, int32_t focused, char* output, int64_t capacity);

gof_queue_new

function gof_queue_new( &
  ) bind(C, name="gof_queue_new") result(r)
  import
  type(c_ptr) :: r
end function gof_queue_new

C ABI:

void* gof_queue_new(void);

gof_queue_delete

function gof_queue_delete( &
  queue) bind(C, name="gof_queue_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
end function gof_queue_delete

C ABI:

int64_t gof_queue_delete(void* queue);

gof_queue_clear

function gof_queue_clear( &
  queue) bind(C, name="gof_queue_clear") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
end function gof_queue_clear

C ABI:

int64_t gof_queue_clear(void* queue);

gof_queue_fill

function gof_queue_fill( &
  queue, &
  x, &
  y, &
  width, &
  height, &
  color) bind(C, name="gof_queue_fill") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
  integer(c_int32_t), value :: width
  integer(c_int32_t), value :: height
  integer(c_int32_t), value :: color
end function gof_queue_fill

C ABI:

int64_t gof_queue_fill(void* queue, int32_t x, int32_t y, int32_t width, int32_t height, int32_t color);

gof_queue_text

function gof_queue_text( &
  queue, &
  x, &
  y, &
  text, &
  color, &
  columns) bind(C, name="gof_queue_text") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
  type(c_ptr), value :: text
  integer(c_int32_t), value :: color
  integer(c_int32_t), value :: columns
end function gof_queue_text

C ABI:

int64_t gof_queue_text(void* queue, int32_t x, int32_t y, const char* text, int32_t color, int32_t columns);

gof_queue_button

function gof_queue_button( &
  queue, &
  x, &
  y, &
  width, &
  text, &
  selected) bind(C, name="gof_queue_button") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
  integer(c_int32_t), value :: width
  type(c_ptr), value :: text
  integer(c_int32_t), value :: selected
end function gof_queue_button

C ABI:

int64_t gof_queue_button(void* queue, int32_t x, int32_t y, int32_t width, const char* text, int32_t selected);

gof_queue_input

function gof_queue_input( &
  queue, &
  x, &
  y, &
  width, &
  input, &
  focused) bind(C, name="gof_queue_input") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
  integer(c_int32_t), value :: width
  type(c_ptr), value :: input
  integer(c_int32_t), value :: focused
end function gof_queue_input

C ABI:

int64_t gof_queue_input(void* queue, int32_t x, int32_t y, int32_t width, void* input, int32_t focused);

gof_queue_finished

function gof_queue_finished( &
  queue) bind(C, name="gof_queue_finished") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
end function gof_queue_finished

C ABI:

int64_t gof_queue_finished(void* queue);

gof_queue_paint

function gof_queue_paint( &
  queue, &
  window) bind(C, name="gof_queue_paint") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: queue
  integer(c_int64_t), value :: window
end function gof_queue_paint

C ABI:

int64_t gof_queue_paint(void* queue, int64_t window);

gof_explorer_new

function gof_explorer_new( &
  ) bind(C, name="gof_explorer_new") result(r)
  import
  type(c_ptr) :: r
end function gof_explorer_new

C ABI:

void* gof_explorer_new(void);

gof_explorer_delete

function gof_explorer_delete( &
  explorer) bind(C, name="gof_explorer_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
end function gof_explorer_delete

C ABI:

int64_t gof_explorer_delete(void* explorer);

gof_explorer_begin

function gof_explorer_begin( &
  explorer, &
  mode, &
  initial, &
  overwrite) bind(C, name="gof_explorer_begin") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  integer(c_int32_t), value :: mode
  type(c_ptr), value :: initial
  integer(c_int32_t), value :: overwrite
end function gof_explorer_begin

C ABI:

int64_t gof_explorer_begin(void* explorer, int32_t mode, const char* initial, int32_t overwrite);

gof_explorer_navigate

function gof_explorer_navigate( &
  explorer, &
  path) bind(C, name="gof_explorer_navigate") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  type(c_ptr), value :: path
end function gof_explorer_navigate

C ABI:

int64_t gof_explorer_navigate(void* explorer, const char* path);

gof_explorer_tick

function gof_explorer_tick( &
  explorer) bind(C, name="gof_explorer_tick") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
end function gof_explorer_tick

C ABI:

int64_t gof_explorer_tick(void* explorer);

gof_explorer_select

function gof_explorer_select( &
  explorer, &
  index) bind(C, name="gof_explorer_select") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  integer(c_int32_t), value :: index
end function gof_explorer_select

C ABI:

int64_t gof_explorer_select(void* explorer, int32_t index);

gof_explorer_activate

function gof_explorer_activate( &
  explorer, &
  index) bind(C, name="gof_explorer_activate") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  integer(c_int32_t), value :: index
end function gof_explorer_activate

C ABI:

int64_t gof_explorer_activate(void* explorer, int32_t index);

gof_explorer_accept

function gof_explorer_accept( &
  explorer, &
  name) bind(C, name="gof_explorer_accept") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  type(c_ptr), value :: name
end function gof_explorer_accept

C ABI:

int64_t gof_explorer_accept(void* explorer, const char* name);

gof_explorer_mkdir

function gof_explorer_mkdir( &
  explorer, &
  name) bind(C, name="gof_explorer_mkdir") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  type(c_ptr), value :: name
end function gof_explorer_mkdir

C ABI:

int64_t gof_explorer_mkdir(void* explorer, const char* name);

gof_explorer_cancel

function gof_explorer_cancel( &
  explorer) bind(C, name="gof_explorer_cancel") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
end function gof_explorer_cancel

C ABI:

int64_t gof_explorer_cancel(void* explorer);

gof_explorer_state

function gof_explorer_state( &
  explorer, &
  field) bind(C, name="gof_explorer_state") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  integer(c_int32_t), value :: field
end function gof_explorer_state

C ABI:

int64_t gof_explorer_state(void* explorer, int32_t field);

gof_explorer_text

function gof_explorer_text( &
  explorer, &
  field, &
  output, &
  capacity) bind(C, name="gof_explorer_text") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  integer(c_int32_t), value :: field
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_explorer_text

C ABI:

int64_t gof_explorer_text(void* explorer, int32_t field, char* output, int64_t capacity);

gof_explorer_entry

function gof_explorer_entry( &
  explorer, &
  volume, &
  index, &
  field, &
  output, &
  capacity) bind(C, name="gof_explorer_entry") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  integer(c_int32_t), value :: volume
  integer(c_int32_t), value :: index
  integer(c_int32_t), value :: field
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_explorer_entry

C ABI:

int64_t gof_explorer_entry(void* explorer, int32_t volume, int32_t index, int32_t field, char* output, int64_t capacity);

gof_explorer_info

function gof_explorer_info( &
  explorer, &
  volume, &
  index, &
  field) bind(C, name="gof_explorer_info") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: explorer
  integer(c_int32_t), value :: volume
  integer(c_int32_t), value :: index
  integer(c_int32_t), value :: field
end function gof_explorer_info

C ABI:

int64_t gof_explorer_info(void* explorer, int32_t volume, int32_t index, int32_t field);

gof_tree_new

function gof_tree_new( &
  ) bind(C, name="gof_tree_new") result(r)
  import
  type(c_ptr) :: r
end function gof_tree_new

C ABI:

void* gof_tree_new(void);

gof_tree_delete

function gof_tree_delete( &
  tree) bind(C, name="gof_tree_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
end function gof_tree_delete

C ABI:

int64_t gof_tree_delete(void* tree);

gof_tree_open

function gof_tree_open( &
  tree, &
  root) bind(C, name="gof_tree_open") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
  type(c_ptr), value :: root
end function gof_tree_open

C ABI:

int64_t gof_tree_open(void* tree, const char* root);

gof_tree_toggle

function gof_tree_toggle( &
  tree, &
  index) bind(C, name="gof_tree_toggle") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
  integer(c_int32_t), value :: index
end function gof_tree_toggle

C ABI:

int64_t gof_tree_toggle(void* tree, int32_t index);

gof_tree_tick

function gof_tree_tick( &
  tree) bind(C, name="gof_tree_tick") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
end function gof_tree_tick

C ABI:

int64_t gof_tree_tick(void* tree);

gof_tree_state

function gof_tree_state( &
  tree, &
  field) bind(C, name="gof_tree_state") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
  integer(c_int32_t), value :: field
end function gof_tree_state

C ABI:

int64_t gof_tree_state(void* tree, int32_t field);

gof_tree_text

function gof_tree_text( &
  tree, &
  field, &
  output, &
  capacity) bind(C, name="gof_tree_text") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
  integer(c_int32_t), value :: field
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_tree_text

C ABI:

int64_t gof_tree_text(void* tree, int32_t field, char* output, int64_t capacity);

gof_tree_entry

function gof_tree_entry( &
  tree, &
  index, &
  field, &
  output, &
  capacity) bind(C, name="gof_tree_entry") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
  integer(c_int32_t), value :: index
  integer(c_int32_t), value :: field
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_tree_entry

C ABI:

int64_t gof_tree_entry(void* tree, int32_t index, int32_t field, char* output, int64_t capacity);

gof_tree_info

function gof_tree_info( &
  tree, &
  index, &
  field) bind(C, name="gof_tree_info") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: tree
  integer(c_int32_t), value :: index
  integer(c_int32_t), value :: field
end function gof_tree_info

C ABI:

int64_t gof_tree_info(void* tree, int32_t index, int32_t field);

gof_fs_open

function gof_fs_open( &
  path, &
  flags) bind(C, name="gof_fs_open") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
  integer(c_int64_t), value :: flags
end function gof_fs_open

C ABI:

int64_t gof_fs_open(const char* path, int64_t flags);

gof_fs_stat

function gof_fs_stat( &
  path, &
  info) bind(C, name="gof_fs_stat") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
  type(c_ptr), value :: info
end function gof_fs_stat

C ABI:

int64_t gof_fs_stat(const char* path, void* info);

gof_fs_mkdir

function gof_fs_mkdir( &
  path) bind(C, name="gof_fs_mkdir") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
end function gof_fs_mkdir

C ABI:

int64_t gof_fs_mkdir(const char* path);

gof_fs_remove

function gof_fs_remove( &
  path) bind(C, name="gof_fs_remove") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
end function gof_fs_remove

C ABI:

int64_t gof_fs_remove(const char* path);

gof_fs_rename

function gof_fs_rename( &
  from, &
  to) bind(C, name="gof_fs_rename") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: from
  type(c_ptr), value :: to
end function gof_fs_rename

C ABI:

int64_t gof_fs_rename(const char* from, const char* to);

gof_fs_read

function gof_fs_read( &
  path, &
  output, &
  capacity) bind(C, name="gof_fs_read") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_fs_read

C ABI:

int64_t gof_fs_read(const char* path, void* output, int64_t capacity);

gof_fs_create

function gof_fs_create( &
  path, &
  data, &
  size) bind(C, name="gof_fs_create") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
  type(c_ptr), value :: data
  integer(c_int64_t), value :: size
end function gof_fs_create

C ABI:

int64_t gof_fs_create(const char* path, const void* data, int64_t size);

gof_fs_save

function gof_fs_save( &
  path, &
  data, &
  size, &
  overwrite, &
  message, &
  capacity) bind(C, name="gof_fs_save") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: path
  type(c_ptr), value :: data
  integer(c_int64_t), value :: size
  integer(c_int32_t), value :: overwrite
  type(c_ptr), value :: message
  integer(c_int64_t), value :: capacity
end function gof_fs_save

C ABI:

int64_t gof_fs_save(const char* path, const void* data, int64_t size, int32_t overwrite, char* message, int64_t capacity);

gof_ipv4

function gof_ipv4( &
  a, &
  b, &
  c, &
  d, &
  port, &
  address) bind(C, name="gof_ipv4") result(r)
  import
  integer(c_int64_t) :: r
  integer(c_int32_t), value :: a
  integer(c_int32_t), value :: b
  integer(c_int32_t), value :: c
  integer(c_int32_t), value :: d
  integer(c_int32_t), value :: port
  type(c_ptr), value :: address
end function gof_ipv4

C ABI:

int64_t gof_ipv4(int32_t a, int32_t b, int32_t c, int32_t d, int32_t port, void* address);

gof_code_new

function gof_code_new( &
  ) bind(C, name="gof_code_new") result(r)
  import
  type(c_ptr) :: r
end function gof_code_new

C ABI:

void* gof_code_new(void);

gof_code_delete

function gof_code_delete( &
  code) bind(C, name="gof_code_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
end function gof_code_delete

C ABI:

int64_t gof_code_delete(void* code);

gof_code_load

function gof_code_load( &
  code, &
  data, &
  size, &
  error, &
  capacity) bind(C, name="gof_code_load") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
  type(c_ptr), value :: data
  integer(c_int64_t), value :: size
  type(c_ptr), value :: error
  integer(c_int64_t), value :: capacity
end function gof_code_load

C ABI:

int64_t gof_code_load(void* code, const void* data, int64_t size, char* error, int64_t capacity);

gof_code_clear

function gof_code_clear( &
  code) bind(C, name="gof_code_clear") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
end function gof_code_clear

C ABI:

int64_t gof_code_clear(void* code);

gof_code_saved

function gof_code_saved( &
  code) bind(C, name="gof_code_saved") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
end function gof_code_saved

C ABI:

int64_t gof_code_saved(void* code);

gof_code_key

function gof_code_key( &
  code, &
  key) bind(C, name="gof_code_key") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
  integer(c_int32_t), value :: key
end function gof_code_key

C ABI:

int64_t gof_code_key(void* code, int32_t key);

gof_code_undo

function gof_code_undo( &
  code) bind(C, name="gof_code_undo") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
end function gof_code_undo

C ABI:

int64_t gof_code_undo(void* code);

gof_code_place

function gof_code_place( &
  code, &
  row, &
  column) bind(C, name="gof_code_place") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
  integer(c_int32_t), value :: row
  integer(c_int32_t), value :: column
end function gof_code_place

C ABI:

int64_t gof_code_place(void* code, int32_t row, int32_t column);

gof_code_state

function gof_code_state( &
  code, &
  field) bind(C, name="gof_code_state") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
  integer(c_int32_t), value :: field
end function gof_code_state

C ABI:

int64_t gof_code_state(void* code, int32_t field);

gof_code_text

function gof_code_text( &
  code, &
  field, &
  index, &
  output, &
  capacity) bind(C, name="gof_code_text") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: code
  integer(c_int32_t), value :: field
  integer(c_int32_t), value :: index
  type(c_ptr), value :: output
  integer(c_int64_t), value :: capacity
end function gof_code_text

C ABI:

int64_t gof_code_text(void* code, int32_t field, int32_t index, char* output, int64_t capacity);

gof_framebuffer_new

function gof_framebuffer_new( &
  width, &
  height) bind(C, name="gof_framebuffer_new") result(r)
  import
  type(c_ptr) :: r
  integer(c_int32_t), value :: width
  integer(c_int32_t), value :: height
end function gof_framebuffer_new

C ABI:

void* gof_framebuffer_new(int32_t width, int32_t height);

gof_framebuffer_delete

function gof_framebuffer_delete( &
  framebuffer) bind(C, name="gof_framebuffer_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
end function gof_framebuffer_delete

C ABI:

int64_t gof_framebuffer_delete(void* framebuffer);

gof_framebuffer_resize

function gof_framebuffer_resize( &
  framebuffer, &
  width, &
  height) bind(C, name="gof_framebuffer_resize") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
  integer(c_int32_t), value :: width
  integer(c_int32_t), value :: height
end function gof_framebuffer_resize

C ABI:

int64_t gof_framebuffer_resize(void* framebuffer, int32_t width, int32_t height);

gof_framebuffer_width

function gof_framebuffer_width( &
  framebuffer) bind(C, name="gof_framebuffer_width") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
end function gof_framebuffer_width

C ABI:

int64_t gof_framebuffer_width(void* framebuffer);

gof_framebuffer_height

function gof_framebuffer_height( &
  framebuffer) bind(C, name="gof_framebuffer_height") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
end function gof_framebuffer_height

C ABI:

int64_t gof_framebuffer_height(void* framebuffer);

gof_framebuffer_pixels

function gof_framebuffer_pixels( &
  framebuffer) bind(C, name="gof_framebuffer_pixels") result(r)
  import
  type(c_ptr) :: r
  type(c_ptr), value :: framebuffer
end function gof_framebuffer_pixels

C ABI:

void* gof_framebuffer_pixels(void* framebuffer);

gof_framebuffer_clear

function gof_framebuffer_clear( &
  framebuffer, &
  color) bind(C, name="gof_framebuffer_clear") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
  integer(c_int32_t), value :: color
end function gof_framebuffer_clear

C ABI:

int64_t gof_framebuffer_clear(void* framebuffer, int32_t color);

gof_framebuffer_pixel

function gof_framebuffer_pixel( &
  framebuffer, &
  x, &
  y, &
  color) bind(C, name="gof_framebuffer_pixel") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
  integer(c_int32_t), value :: color
end function gof_framebuffer_pixel

C ABI:

int64_t gof_framebuffer_pixel(void* framebuffer, int32_t x, int32_t y, int32_t color);

gof_framebuffer_get

function gof_framebuffer_get( &
  framebuffer, &
  x, &
  y) bind(C, name="gof_framebuffer_get") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
end function gof_framebuffer_get

C ABI:

int64_t gof_framebuffer_get(void* framebuffer, int32_t x, int32_t y);

gof_framebuffer_circle

function gof_framebuffer_circle( &
  framebuffer, &
  x, &
  y, &
  radius, &
  color) bind(C, name="gof_framebuffer_circle") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: framebuffer
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
  integer(c_int32_t), value :: radius
  integer(c_int32_t), value :: color
end function gof_framebuffer_circle

C ABI:

int64_t gof_framebuffer_circle(void* framebuffer, int32_t x, int32_t y, int32_t radius, int32_t color);

gof_presenter_new

function gof_presenter_new( &
  window) bind(C, name="gof_presenter_new") result(r)
  import
  type(c_ptr) :: r
  integer(c_int64_t), value :: window
end function gof_presenter_new

C ABI:

void* gof_presenter_new(int64_t window);

gof_presenter_delete

function gof_presenter_delete( &
  presenter) bind(C, name="gof_presenter_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: presenter
end function gof_presenter_delete

C ABI:

int64_t gof_presenter_delete(void* presenter);

gof_presenter_present

function gof_presenter_present( &
  presenter, &
  framebuffer, &
  x, &
  y) bind(C, name="gof_presenter_present") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: presenter
  type(c_ptr), value :: framebuffer
  integer(c_int32_t), value :: x
  integer(c_int32_t), value :: y
end function gof_presenter_present

C ABI:

int64_t gof_presenter_present(void* presenter, void* framebuffer, int32_t x, int32_t y);

gof_presenter_pending

function gof_presenter_pending( &
  presenter) bind(C, name="gof_presenter_pending") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: presenter
end function gof_presenter_pending

C ABI:

int64_t gof_presenter_pending(void* presenter);

gof_presenter_cancel

function gof_presenter_cancel( &
  presenter) bind(C, name="gof_presenter_cancel") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: presenter
end function gof_presenter_cancel

C ABI:

int64_t gof_presenter_cancel(void* presenter);

gof_mesh_new

function gof_mesh_new( &
  ) bind(C, name="gof_mesh_new") result(r)
  import
  type(c_ptr) :: r
end function gof_mesh_new

C ABI:

void* gof_mesh_new(void);

gof_mesh_delete

function gof_mesh_delete( &
  mesh) bind(C, name="gof_mesh_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: mesh
end function gof_mesh_delete

C ABI:

int64_t gof_mesh_delete(void* mesh);

gof_mesh_vertex

function gof_mesh_vertex( &
  mesh, &
  x, &
  y, &
  z) bind(C, name="gof_mesh_vertex") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: mesh
  real(c_float), value :: x
  real(c_float), value :: y
  real(c_float), value :: z
end function gof_mesh_vertex

C ABI:

int64_t gof_mesh_vertex(void* mesh, float x, float y, float z);

gof_mesh_triangle

function gof_mesh_triangle( &
  mesh, &
  a, &
  b, &
  c, &
  color) bind(C, name="gof_mesh_triangle") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: mesh
  integer(c_int32_t), value :: a
  integer(c_int32_t), value :: b
  integer(c_int32_t), value :: c
  integer(c_int32_t), value :: color
end function gof_mesh_triangle

C ABI:

int64_t gof_mesh_triangle(void* mesh, int32_t a, int32_t b, int32_t c, int32_t color);

gof_shape

function gof_shape( &
  kind, &
  a, &
  b, &
  c, &
  slices, &
  stacks) bind(C, name="gof_shape") result(r)
  import
  type(c_ptr) :: r
  integer(c_int32_t), value :: kind
  real(c_float), value :: a
  real(c_float), value :: b
  real(c_float), value :: c
  integer(c_int32_t), value :: slices
  integer(c_int32_t), value :: stacks
end function gof_shape

C ABI:

void* gof_shape(int32_t kind, float a, float b, float c, int32_t slices, int32_t stacks);

gof_raster_new

function gof_raster_new( &
  framebuffer) bind(C, name="gof_raster_new") result(r)
  import
  type(c_ptr) :: r
  type(c_ptr), value :: framebuffer
end function gof_raster_new

C ABI:

void* gof_raster_new(void* framebuffer);

gof_raster_delete

function gof_raster_delete( &
  raster) bind(C, name="gof_raster_delete") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: raster
end function gof_raster_delete

C ABI:

int64_t gof_raster_delete(void* raster);

gof_raster_clear

function gof_raster_clear( &
  raster, &
  color) bind(C, name="gof_raster_clear") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: raster
  integer(c_int32_t), value :: color
end function gof_raster_clear

C ABI:

int64_t gof_raster_clear(void* raster, int32_t color);

gof_raster_draw

function gof_raster_draw( &
  raster, &
  mesh, &
  rx, &
  ry, &
  rz, &
  x, &
  y, &
  z, &
  wireframe, &
  hollow) bind(C, name="gof_raster_draw") result(r)
  import
  integer(c_int64_t) :: r
  type(c_ptr), value :: raster
  type(c_ptr), value :: mesh
  real(c_float), value :: rx
  real(c_float), value :: ry
  real(c_float), value :: rz
  real(c_float), value :: x
  real(c_float), value :: y
  real(c_float), value :: z
  integer(c_int32_t), value :: wireframe
  integer(c_int32_t), value :: hollow
end function gof_raster_draw

C ABI:

int64_t gof_raster_draw(void* raster, void* mesh, float rx, float ry, float rz, float x, float y, float z, int32_t wireframe, int32_t hollow);