Some days ago I've created a topic about using libffi for an enhanced native
call interface.
I've changed my mind all the way about how to build a native call interface for
VIM, right
now I'm changing VIM sources to implement it as I'm thinking, some comments at
this stage
would be good.
Goals:
Make VIM able to call and be called, efficiently, from native libraries
built as VIM plugins.
Non Goals:
Make VIM able to call any native function.
Make VIM automatically marshal VIM types to C types.
I started thinking of using libffi to do something as python ctypes for VIM but
I thought it was not
a good idea because:
Too much complexity for marshaling VIM types to C equivalents.
Marshaling is not efficient.
If there going be limitations at which functions are able to be called from
VIM, why expend time on this.
What I, myself, really want is build efficient plugins for VIM in C, not
being able to call any function.
So this is about a interface to call VIM crafted plugins, exporting specific
prototypes to be called from VIM
with not overhead.
How I'm building this:
libload
function to load a library from path/name and return a Libhandle.
libfunc
function to get a Libfunc from a Libhandle and function name.
libcall / libcallex / call (not decided yet which one to use)
function to call a Libfunc passing a raw VIM List of raw VIM types as
arguments and returning a raw
VIM type.
libinit
function initialize a VIM library from a Libhandle. This function will
try to call an exported initialization
function from the library:
void vim( void *(*vim_get)(char *name) )
If the function exist, the library should use the given vim_get
function to ask for VIM functions and settings
by name.
The functions exposed by this function should be an API to allow the
library to deal with raw VIM types
without overhead and without internal implementation knowledge. Beyond
dealing with VIM types
it should export functions for VIM evaluation from strings and maybe
other stuff.
This API should be documented and may be extended over time.
To have libload and libfunc, I needed a way to represent library handles and
function pointers. No VIM type
can represent that well, so I started by extending VIM variables to become yet
more two types, Libhandle and
Libfunc. These types only show up in the context of these functions. Variables
of these types can only be assigned,
compared (==, !=) and used in the empty function to check for nullity.
Right now I've extend VIM variables, I'm implementing the functions, the hard
part will be to define and implement
what the vim_get callback will return.
Any comments please?
Regards
---
Francisco Lopes
--
You received this message from the "vim_dev" maillist.
Do not top-post! Type your reply below the text you are replying to.
For more information, visit http://www.vim.org/maillist.php
