1684 lines
34 KiB
Plaintext
1684 lines
34 KiB
Plaintext
import eina_types;
|
|
|
|
type Dummy.MyInt: int;
|
|
|
|
const Dummy.Constvar_Bool : bool = true;
|
|
const Dummy.Constvar_Int : int = -32766;
|
|
const Dummy.Constvar_UInt : uint = 65533U;
|
|
const Dummy.Constvar_Long : long = -2147483644L;
|
|
const Dummy.Constvar_ULong : ulong = 4294967288UL;
|
|
const Dummy.Constvar_LLong : llong = -9223372036854775800LL;
|
|
const Dummy.Constvar_ULLong : ullong = 18446744073709551615ULL;
|
|
const Dummy.Constvar_Float : float = 16777211.0f;
|
|
const Dummy.Constvar_Double : double = 9007199254740988.0;
|
|
const Dummy.Constvar_Char : char = '!';
|
|
const Dummy.Constvar_String : string = "test_str";
|
|
|
|
enum Dummy.SampleEnum {
|
|
v0,
|
|
v1,
|
|
v2,
|
|
v3,
|
|
v4,
|
|
}
|
|
|
|
struct @free(free) Dummy.StructSimple
|
|
{
|
|
fbyte: byte;
|
|
fubyte: ubyte;
|
|
fchar: char;
|
|
fshort: short;
|
|
fushort: ushort;
|
|
fint: int;
|
|
fuint: uint;
|
|
flong: long;
|
|
fulong: ulong;
|
|
fllong: llong;
|
|
fullong: ullong;
|
|
fint8: int8;
|
|
fuint8: uint8;
|
|
fint16: int16;
|
|
fuint16: uint16;
|
|
fint32: int32;
|
|
fuint32: uint32;
|
|
fint64: int64;
|
|
fuint64: uint64;
|
|
fssize: ssize;
|
|
fsize: size;
|
|
fintptr: intptr;
|
|
// fuintptr: uintptr; // TODO
|
|
fptrdiff: ptrdiff;
|
|
ffloat: float;
|
|
fdouble: double;
|
|
fbool: bool;
|
|
fvoid_ptr: void_ptr;
|
|
fenum: Dummy.SampleEnum;
|
|
// fboolptr: ptr(bool); // TODO
|
|
// fbyteptr: ptr(byte);
|
|
// fubyteptr: ptr(ubyte);
|
|
// fcharptr: ptr(char);
|
|
// fuint8ptr: ptr(uint8);
|
|
// fint16ptr: ptr(int16);
|
|
// fuint64ptr: ptr(uint64);
|
|
// fssizeptr: ptr(ssize);
|
|
// fsizeptr: ptr(size);
|
|
// fintptrptr: ptr(intptr);
|
|
// fptrdiffptr: ptr(ptrdiff);
|
|
// ffloatptr: ptr(float);
|
|
// fdoubleptr: ptr(double);
|
|
// fvoid_ptrptr: ptr(void_ptr);
|
|
// fenumptr: ptr(Dummy.SampleEnum);
|
|
fstring: string;
|
|
fmstring: mstring;
|
|
fstringshare: stringshare;
|
|
fmyint: Dummy.MyInt;
|
|
}
|
|
|
|
struct @beta @free(free) Dummy.StructComplex {
|
|
farray: array<string>;
|
|
flist: list<string>;
|
|
fhash: hash<string, string>;
|
|
fiterator: iterator<string>;
|
|
fany_value: any_value;
|
|
fany_value_ptr: any_value_ptr;
|
|
// fbinbuf: ptr(Eina.Binbuf);
|
|
fslice: slice<ubyte>;
|
|
// fslice: ptr(Eina.Slice); // TODO
|
|
fobj: Dummy.Numberwrapper;
|
|
}
|
|
|
|
function Dummy.SimpleCb {
|
|
params {
|
|
a: int;
|
|
}
|
|
return: int;
|
|
};
|
|
|
|
function Dummy.FormatCb {
|
|
params {
|
|
@in str: strbuf;
|
|
@in value: const(any_value);
|
|
}
|
|
};
|
|
|
|
class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
|
|
methods {
|
|
return_object {
|
|
return: Dummy.Test_Object;
|
|
}
|
|
|
|
return_null_object {
|
|
return: Dummy.Test_Object;
|
|
}
|
|
|
|
return_iface {
|
|
return: Dummy.Test_Iface;
|
|
}
|
|
|
|
int_out {
|
|
params {
|
|
@in x: int;
|
|
@out y: int;
|
|
}
|
|
}
|
|
|
|
/*
|
|
int_ptr_out {
|
|
params {
|
|
@in x: int;
|
|
@out y: ptr(int);
|
|
}
|
|
}
|
|
*/
|
|
|
|
in_stringshare {
|
|
params {
|
|
@in v: stringshare;
|
|
}
|
|
return: stringshare @owned;
|
|
}
|
|
in_own_stringshare {
|
|
params {
|
|
@in v: stringshare @owned;
|
|
}
|
|
return: stringshare @owned;
|
|
}
|
|
|
|
out_stringshare {
|
|
params {
|
|
@out v: stringshare;
|
|
}
|
|
}
|
|
out_own_stringshare {
|
|
params {
|
|
@out v: stringshare @owned;
|
|
}
|
|
}
|
|
|
|
return_stringshare {
|
|
return: stringshare;
|
|
}
|
|
return_own_stringshare {
|
|
return: stringshare @owned;
|
|
}
|
|
|
|
in_string {
|
|
params {
|
|
@in str: string;
|
|
}
|
|
return: mstring @owned;
|
|
}
|
|
|
|
in_own_string {
|
|
params {
|
|
@in str: mstring @owned;
|
|
}
|
|
return: mstring @owned;
|
|
}
|
|
|
|
return_string {
|
|
return: string;
|
|
}
|
|
|
|
return_own_string {
|
|
return: mstring @owned;
|
|
}
|
|
|
|
out_string {
|
|
params {
|
|
@out str: string;
|
|
}
|
|
}
|
|
|
|
out_own_string {
|
|
params {
|
|
@out str: mstring @owned;
|
|
}
|
|
}
|
|
|
|
call_in_string {
|
|
params {
|
|
@in str: string;
|
|
}
|
|
}
|
|
|
|
call_in_own_string {
|
|
params {
|
|
@in str: mstring @owned;
|
|
}
|
|
}
|
|
|
|
call_return_string {
|
|
return: string;
|
|
}
|
|
|
|
call_return_own_string {
|
|
return: mstring @owned;
|
|
}
|
|
|
|
call_out_string {
|
|
return: string;
|
|
}
|
|
|
|
call_out_own_string {
|
|
return: mstring @owned;
|
|
}
|
|
|
|
// Stringshare virtual helpers
|
|
call_in_stringshare {
|
|
params {
|
|
@in str: stringshare;
|
|
}
|
|
}
|
|
|
|
call_in_own_stringshare {
|
|
params {
|
|
@in str: stringshare @owned;
|
|
}
|
|
}
|
|
|
|
call_return_stringshare {
|
|
return: stringshare;
|
|
}
|
|
|
|
call_return_own_stringshare {
|
|
return: stringshare @owned;
|
|
}
|
|
|
|
call_out_stringshare {
|
|
return: stringshare;
|
|
}
|
|
|
|
call_out_own_stringshare {
|
|
return: stringshare @owned;
|
|
}
|
|
|
|
eina_slice_in {
|
|
params {
|
|
@in slice: slice<ubyte>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_rw_slice_in {
|
|
params {
|
|
@in slice: rw_slice<ubyte>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_slice_out {
|
|
params {
|
|
@out slice: slice<ubyte>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_rw_slice_out {
|
|
params {
|
|
@out slice: rw_slice<ubyte>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_rw_slice_inout {
|
|
params {
|
|
@inout slice: rw_slice<ubyte>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
/*
|
|
eina_slice_return {
|
|
return: slice<ubyte>;
|
|
}
|
|
|
|
eina_rw_slice_return {
|
|
return: rw_slice<ubyte>;
|
|
}
|
|
*/
|
|
|
|
/*
|
|
eina_binbuf_in @beta {
|
|
params {
|
|
@in binbuf: ptr(Eina.Binbuf);
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
call_eina_binbuf_in @beta {
|
|
params {
|
|
@in binbuf: ptr(Eina.Binbuf);
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_binbuf_in_own @beta {
|
|
params {
|
|
@in binbuf: ptr(Eina.Binbuf) @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
call_eina_binbuf_in_own @beta {
|
|
params {
|
|
@in str: ptr(Eina.Binbuf) @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
check_binbuf_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_binbuf_out @beta {
|
|
params {
|
|
@out binbuf: ptr(Eina.Binbuf);
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
call_eina_binbuf_out @beta {
|
|
return: ptr(Eina.Binbuf);
|
|
}
|
|
|
|
check_binbuf_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_binbuf_out_own @beta {
|
|
params {
|
|
@out binbuf: ptr(Eina.Binbuf) @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
call_eina_binbuf_out_own @beta {
|
|
return: ptr(Eina.Binbuf) @owned;
|
|
}
|
|
|
|
eina_binbuf_return @beta {
|
|
return: ptr(Eina.Binbuf);
|
|
}
|
|
|
|
call_eina_binbuf_return @beta {
|
|
return: ptr(Eina.Binbuf);
|
|
}
|
|
|
|
check_binbuf_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_binbuf_return_own @beta {
|
|
return: ptr(Eina.Binbuf) @owned;
|
|
}
|
|
|
|
call_eina_binbuf_return_own @beta {
|
|
return: ptr(Eina.Binbuf) @owned;
|
|
}
|
|
*/
|
|
|
|
/* Eina Array */
|
|
|
|
/* Integer */
|
|
/*
|
|
eina_array_int_in {
|
|
params {
|
|
@in arr: array<ptr(int)>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_int_in_own {
|
|
params {
|
|
@in arr: array<free(ptr(int),free) @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_int_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_int_out {
|
|
params {
|
|
@out arr: array<ptr(int)>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_int_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_int_out_own {
|
|
params {
|
|
@out arr: array<free(ptr(int),free) @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_int_return {
|
|
return: array<ptr(int)>;
|
|
}
|
|
check_eina_array_int_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_int_return_own {
|
|
return: array<free(ptr(int),free) @owned> @owned;
|
|
}
|
|
*/
|
|
|
|
/* String */
|
|
eina_array_str_in {
|
|
params {
|
|
@in arr: array<string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_str_in_own {
|
|
params {
|
|
@in arr: array<mstring @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_str_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_str_out {
|
|
params {
|
|
@out arr: array<string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_str_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_str_out_own {
|
|
params {
|
|
@out arr: array<mstring @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_str_return {
|
|
return: array<string>;
|
|
}
|
|
check_eina_array_str_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_str_return_own {
|
|
return: array<mstring @owned> @owned;
|
|
}
|
|
|
|
/* Eina_Stringshare */
|
|
eina_array_strshare_in {
|
|
params {
|
|
@in arr: array<stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_strshare_in_own {
|
|
params {
|
|
@in arr: array<stringshare @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_strshare_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_strshare_out {
|
|
params {
|
|
@out arr: array<stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_strshare_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_strshare_out_own {
|
|
params {
|
|
@out arr: array<stringshare @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_strshare_return {
|
|
return: array<stringshare>;
|
|
}
|
|
check_eina_array_strshare_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_strshare_return_own {
|
|
return: array<stringshare @owned> @owned;
|
|
}
|
|
|
|
/* Object */
|
|
eina_array_obj_in {
|
|
params {
|
|
@in arr: array<Dummy.Numberwrapper>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_obj_in_own {
|
|
params {
|
|
@in arr: array<Dummy.Numberwrapper @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_obj_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_obj_out {
|
|
params {
|
|
@out arr: array<Dummy.Numberwrapper>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_array_obj_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_obj_out_own {
|
|
params {
|
|
@out arr: array<Dummy.Numberwrapper @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_obj_return {
|
|
return: array<Dummy.Numberwrapper>;
|
|
}
|
|
check_eina_array_obj_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_array_obj_return_own {
|
|
return: array<Dummy.Numberwrapper @owned> @owned;
|
|
}
|
|
|
|
eina_array_obj_return_in {
|
|
params {
|
|
@in arr: array<Dummy.Numberwrapper>;
|
|
}
|
|
return: array<Dummy.Numberwrapper>;
|
|
}
|
|
|
|
/* Eina List */
|
|
|
|
/* Integer */
|
|
/*
|
|
eina_list_int_in {
|
|
params {
|
|
@in lst: list<ptr(int)>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_int_in_own {
|
|
params {
|
|
@in lst: list<free(ptr(int),free) @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_int_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_int_out {
|
|
params {
|
|
@out lst: list<ptr(int)>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_int_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_int_out_own {
|
|
params {
|
|
@out lst: list<free(ptr(int),free) @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_int_return {
|
|
return: list<ptr(int)>;
|
|
}
|
|
check_eina_list_int_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_int_return_own {
|
|
return: list<free(ptr(int),free) @owned> @owned;
|
|
}
|
|
*/
|
|
|
|
/* String */
|
|
eina_list_str_in {
|
|
params {
|
|
@in lst: list<string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_str_in_own {
|
|
params {
|
|
@in lst: list<mstring @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_str_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_str_out {
|
|
params {
|
|
@out lst: list<string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_str_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_str_out_own {
|
|
params {
|
|
@out lst: list<mstring @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_str_return {
|
|
return: list<string>;
|
|
}
|
|
check_eina_list_str_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_str_return_own {
|
|
return: list<mstring @owned> @owned;
|
|
}
|
|
|
|
/* Eina_Stringshare */
|
|
eina_list_strshare_in {
|
|
params {
|
|
@in lst: list<stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_strshare_in_own {
|
|
params {
|
|
@in lst: list<stringshare @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_strshare_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_strshare_out {
|
|
params {
|
|
@out lst: list<stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_strshare_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_strshare_out_own {
|
|
params {
|
|
@out lst: list<stringshare @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_strshare_return {
|
|
return: list<stringshare>;
|
|
}
|
|
check_eina_list_strshare_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_strshare_return_own {
|
|
return: list<stringshare @owned> @owned;
|
|
}
|
|
|
|
/* Object */
|
|
eina_list_obj_in {
|
|
params {
|
|
@in lst: list<Dummy.Numberwrapper>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_obj_in_own {
|
|
params {
|
|
@in lst: list<Dummy.Numberwrapper @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_obj_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_obj_out {
|
|
params {
|
|
@out lst: list<Dummy.Numberwrapper>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_list_obj_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_obj_out_own {
|
|
params {
|
|
@out lst: list<Dummy.Numberwrapper @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_obj_return {
|
|
return: list<Dummy.Numberwrapper>;
|
|
}
|
|
check_eina_list_obj_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_list_obj_return_own {
|
|
return: list<Dummy.Numberwrapper @owned> @owned;
|
|
}
|
|
|
|
eina_list_obj_return_in {
|
|
params {
|
|
@in lst: list<Dummy.Numberwrapper>;
|
|
}
|
|
return: list<Dummy.Numberwrapper>;
|
|
}
|
|
|
|
// Eina Hash //
|
|
|
|
// Integer //
|
|
/*
|
|
eina_hash_int_in {
|
|
params {
|
|
@in hsh: hash<ptr(int), ptr(int)>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_int_in_own {
|
|
params {
|
|
@in hsh: hash<ptr(int), free(ptr(int),free) @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_int_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_int_out {
|
|
params {
|
|
@out hsh: hash<ptr(int), ptr(int)>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_int_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_int_out_own {
|
|
params {
|
|
@out hsh: hash<ptr(int), free(ptr(int),free) @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_int_out_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_int_return {
|
|
return: hash<ptr(int), ptr(int)>;
|
|
}
|
|
check_eina_hash_int_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_int_return_own {
|
|
return: hash<ptr(int), free(ptr(int),free) @owned> @owned;
|
|
}
|
|
check_eina_hash_int_return_own {
|
|
return: bool;
|
|
}
|
|
*/
|
|
|
|
// String //
|
|
eina_hash_str_in {
|
|
params {
|
|
@in hsh: hash<string, string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_str_in_own {
|
|
params {
|
|
@in hsh: hash<string, mstring @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_str_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_str_out {
|
|
params {
|
|
@out hsh: hash<string, string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_str_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_str_out_own {
|
|
params {
|
|
@out hsh: hash<string, mstring @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_str_out_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_str_return {
|
|
return: hash<string, string>;
|
|
}
|
|
check_eina_hash_str_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_str_return_own {
|
|
return: hash<string, mstring @owned> @owned;
|
|
}
|
|
check_eina_hash_str_return_own {
|
|
return: bool;
|
|
}
|
|
|
|
// Eina_Stringshare //
|
|
eina_hash_strshare_in {
|
|
params {
|
|
@in hsh: hash<stringshare, stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_strshare_in_own {
|
|
params {
|
|
@in hsh: hash<stringshare, stringshare @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_strshare_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_strshare_out {
|
|
params {
|
|
@out hsh: hash<stringshare, stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_strshare_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_strshare_out_own {
|
|
params {
|
|
@out hsh: hash<stringshare, stringshare @owned> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_strshare_out_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_strshare_return {
|
|
return: hash<stringshare, stringshare>;
|
|
}
|
|
check_eina_hash_strshare_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_strshare_return_own {
|
|
return: hash<stringshare, stringshare @owned> @owned;
|
|
}
|
|
check_eina_hash_strshare_return_own {
|
|
return: bool;
|
|
}
|
|
|
|
// Object //
|
|
eina_hash_obj_in {
|
|
params {
|
|
@in hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper>;
|
|
@in nwk1: Dummy.Numberwrapper;
|
|
@in nwv1: Dummy.Numberwrapper;
|
|
@out nwk2: Dummy.Numberwrapper;
|
|
@out nwv2: Dummy.Numberwrapper;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_obj_in_own {
|
|
params {
|
|
@in hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper @owned> @owned;
|
|
@in nwk1: Dummy.Numberwrapper;
|
|
@in nwv1: Dummy.Numberwrapper;
|
|
@out nwk2: Dummy.Numberwrapper;
|
|
@out nwv2: Dummy.Numberwrapper;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_obj_in_own {
|
|
params {
|
|
@in nwk1: Dummy.Numberwrapper;
|
|
@in nwv1: Dummy.Numberwrapper;
|
|
@in nwk2: Dummy.Numberwrapper;
|
|
@in nwv2: Dummy.Numberwrapper;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_obj_out {
|
|
params {
|
|
@out hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper>;
|
|
@out nwk: Dummy.Numberwrapper;
|
|
@out nwv: Dummy.Numberwrapper;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_obj_out {
|
|
params {
|
|
@in nwk1: Dummy.Numberwrapper;
|
|
@in nwv1: Dummy.Numberwrapper;
|
|
@in nwk2: Dummy.Numberwrapper;
|
|
@in nwv2: Dummy.Numberwrapper;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_obj_out_own {
|
|
params {
|
|
@out hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper @owned> @owned;
|
|
@out nwk: Dummy.Numberwrapper;
|
|
@out nwv: Dummy.Numberwrapper;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_hash_obj_out_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_obj_return {
|
|
params {
|
|
@out nwk: Dummy.Numberwrapper;
|
|
@out nwv: Dummy.Numberwrapper;
|
|
}
|
|
return: hash<Dummy.Numberwrapper, Dummy.Numberwrapper>;
|
|
}
|
|
check_eina_hash_obj_return {
|
|
params {
|
|
@in nwk1: Dummy.Numberwrapper;
|
|
@in nwv1: Dummy.Numberwrapper;
|
|
@in nwk2: Dummy.Numberwrapper;
|
|
@in nwv2: Dummy.Numberwrapper;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_hash_obj_return_own {
|
|
params {
|
|
@out nwk: Dummy.Numberwrapper;
|
|
@out nwv: Dummy.Numberwrapper;
|
|
}
|
|
return: hash<Dummy.Numberwrapper, Dummy.Numberwrapper @owned> @owned;
|
|
}
|
|
check_eina_hash_obj_return_own {
|
|
return: bool;
|
|
}
|
|
|
|
/* Eina Iterator */
|
|
|
|
/* Integer */
|
|
eina_iterator_int_in {
|
|
params {
|
|
@in itr: iterator<int>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_int_in_own {
|
|
params {
|
|
@in itr: iterator<int> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_int_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_int_out {
|
|
params {
|
|
@out itr: iterator<int>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_int_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_int_out_own {
|
|
params {
|
|
@out itr: iterator<int> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_int_return {
|
|
return: iterator<int>;
|
|
}
|
|
check_eina_iterator_int_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_int_return_own {
|
|
return: iterator<int> @owned;
|
|
}
|
|
|
|
/* String */
|
|
eina_iterator_str_in {
|
|
params {
|
|
@in itr: iterator<string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_str_in_own {
|
|
params {
|
|
@in itr: iterator<mstring> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_str_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_str_out {
|
|
params {
|
|
@out itr: iterator<string>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_str_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_str_out_own {
|
|
params {
|
|
@out itr: iterator<mstring> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_str_return {
|
|
return: iterator<string>;
|
|
}
|
|
check_eina_iterator_str_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_str_return_own {
|
|
return: iterator<mstring> @owned;
|
|
}
|
|
|
|
/* Eina_Stringshare */
|
|
eina_iterator_strshare_in {
|
|
params {
|
|
@in itr: iterator<stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_strshare_in_own {
|
|
params {
|
|
@in itr: iterator<stringshare> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_strshare_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_strshare_out {
|
|
params {
|
|
@out itr: iterator<stringshare>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_strshare_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_strshare_out_own {
|
|
params {
|
|
@out itr: iterator<stringshare> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_strshare_return {
|
|
return: iterator<stringshare>;
|
|
}
|
|
check_eina_iterator_strshare_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_strshare_return_own {
|
|
return: iterator<stringshare> @owned;
|
|
}
|
|
|
|
/* Object */
|
|
eina_iterator_obj_in {
|
|
params {
|
|
@in itr: iterator<Dummy.Numberwrapper>;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_obj_in_own {
|
|
params {
|
|
@in itr: iterator<Dummy.Numberwrapper> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_obj_in_own {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_obj_out {
|
|
params {
|
|
@out itr: iterator<Dummy.Numberwrapper>;
|
|
}
|
|
return: bool;
|
|
}
|
|
check_eina_iterator_obj_out {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_obj_out_own {
|
|
params {
|
|
@out itr: iterator<Dummy.Numberwrapper> @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_obj_return {
|
|
return: iterator<Dummy.Numberwrapper>;
|
|
}
|
|
check_eina_iterator_obj_return {
|
|
return: bool;
|
|
}
|
|
|
|
eina_iterator_obj_return_own {
|
|
return: iterator<Dummy.Numberwrapper> @owned;
|
|
}
|
|
|
|
/* Function Pointer */
|
|
|
|
set_callback {
|
|
params {
|
|
cb: Dummy.SimpleCb;
|
|
}
|
|
}
|
|
|
|
call_callback {
|
|
params {
|
|
a: int;
|
|
}
|
|
return: int;
|
|
}
|
|
|
|
call_set_callback {
|
|
}
|
|
|
|
raises_eina_error {
|
|
|
|
}
|
|
|
|
children_raise_error {
|
|
|
|
}
|
|
call_children_raise_error {
|
|
|
|
}
|
|
|
|
error_ret_set {
|
|
params {
|
|
error: Eina.Error;
|
|
}
|
|
}
|
|
|
|
returns_error {
|
|
return: Eina.Error;
|
|
}
|
|
|
|
/* Eina Values */
|
|
set_value_ptr {
|
|
params {
|
|
value: any_value_ptr;
|
|
}
|
|
}
|
|
|
|
set_value_ptr_own {
|
|
params {
|
|
value: any_value_ptr @owned;
|
|
}
|
|
}
|
|
|
|
set_value {
|
|
params {
|
|
value: any_value;
|
|
}
|
|
}
|
|
|
|
call_set_value {
|
|
params {
|
|
value: const(any_value);
|
|
}
|
|
}
|
|
|
|
get_value_ptr_own {
|
|
return: any_value_ptr @owned;
|
|
}
|
|
|
|
get_value_ptr {
|
|
return: any_value_ptr;
|
|
}
|
|
|
|
/* Commented out due to issues regarding eolian treatment of any_value.
|
|
* Somehow eolian is giving 0 as the default value when declaring the function below,
|
|
* leading to compiler errors.
|
|
*/
|
|
/* get_value {
|
|
return: any_value;
|
|
}
|
|
*/
|
|
|
|
clear_value {
|
|
}
|
|
|
|
out_value_ptr {
|
|
params {
|
|
@out value: any_value_ptr;
|
|
}
|
|
}
|
|
|
|
out_value_ptr_own {
|
|
params {
|
|
@out value: any_value_ptr @owned;
|
|
}
|
|
}
|
|
|
|
out_value {
|
|
params {
|
|
@out value: any_value;
|
|
}
|
|
}
|
|
|
|
/* Structs */
|
|
|
|
struct_simple_in {
|
|
params {
|
|
@in simple: Dummy.StructSimple;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
/*
|
|
struct_simple_ptr_in {
|
|
params {
|
|
@in simple: ptr(Dummy.StructSimple);
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
struct_simple_ptr_in_own {
|
|
params {
|
|
@in simple: ptr(Dummy.StructSimple) @owned;
|
|
}
|
|
return: Dummy.StructSimple;
|
|
}
|
|
*/
|
|
|
|
struct_simple_out {
|
|
params {
|
|
@out simple: Dummy.StructSimple;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
/*
|
|
struct_simple_ptr_out {
|
|
params {
|
|
@out simple: ptr(Dummy.StructSimple);
|
|
}
|
|
return: Dummy.StructSimple;
|
|
}
|
|
|
|
struct_simple_ptr_out_own {
|
|
params {
|
|
@out simple: ptr(Dummy.StructSimple) @owned;
|
|
}
|
|
return: Dummy.StructSimple;
|
|
}
|
|
*/
|
|
|
|
struct_simple_return {
|
|
return: Dummy.StructSimple;
|
|
}
|
|
|
|
/*
|
|
struct_simple_ptr_return {
|
|
return: ptr(Dummy.StructSimple);
|
|
}
|
|
|
|
struct_simple_ptr_return_own {
|
|
return: ptr(Dummy.StructSimple) @owned;
|
|
}
|
|
*/
|
|
|
|
call_struct_simple_in {
|
|
params {
|
|
@in simple: Dummy.StructSimple;
|
|
}
|
|
}
|
|
|
|
/*
|
|
call_struct_simple_ptr_in {
|
|
params {
|
|
@in simple: ptr(Dummy.StructSimple);
|
|
}
|
|
}
|
|
|
|
call_struct_simple_ptr_in_own {
|
|
params {
|
|
@in simple: ptr(Dummy.StructSimple) @owned;
|
|
}
|
|
}
|
|
*/
|
|
|
|
call_struct_simple_out {
|
|
params {
|
|
@out simple: Dummy.StructSimple;
|
|
}
|
|
}
|
|
|
|
/*
|
|
call_struct_simple_ptr_out {
|
|
params {
|
|
@out simple: ptr(Dummy.StructSimple);
|
|
}
|
|
}
|
|
|
|
call_struct_simple_ptr_out_own {
|
|
params {
|
|
@out simple: ptr(Dummy.StructSimple) @owned;
|
|
}
|
|
}
|
|
*/
|
|
|
|
call_struct_simple_return {
|
|
return: Dummy.StructSimple;
|
|
}
|
|
|
|
/*
|
|
call_struct_simple_ptr_return {
|
|
return: ptr(Dummy.StructSimple);
|
|
}
|
|
|
|
call_struct_simple_ptr_return_own {
|
|
return: ptr(Dummy.StructSimple) @owned;
|
|
}
|
|
*/
|
|
|
|
struct_complex_in @beta {
|
|
params {
|
|
@in complex: Dummy.StructComplex;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
/*
|
|
struct_complex_ptr_in @beta {
|
|
params {
|
|
@in complex: ptr(Dummy.StructComplex);
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
struct_complex_ptr_in_own @beta {
|
|
params {
|
|
@in complex: ptr(Dummy.StructComplex) @owned;
|
|
}
|
|
return: bool;
|
|
}
|
|
*/
|
|
|
|
struct_complex_out @beta {
|
|
params {
|
|
@out complex: Dummy.StructComplex;
|
|
}
|
|
return: bool;
|
|
}
|
|
|
|
// struct_complex_ptr_out @beta {
|
|
// params {
|
|
// @out complex: ptr(Dummy.StructComplex);
|
|
// }
|
|
// return: bool;
|
|
// }
|
|
//
|
|
// struct_complex_ptr_out_own @beta {
|
|
// params {
|
|
// @out complex: ptr(Dummy.StructComplex) @owned;
|
|
// }
|
|
// return: bool;
|
|
// }
|
|
|
|
struct_complex_return @beta {
|
|
return: Dummy.StructComplex;
|
|
}
|
|
|
|
// struct_complex_ptr_return @beta {
|
|
// return: ptr(Dummy.StructComplex);
|
|
// }
|
|
//
|
|
// struct_complex_ptr_return_own @beta {
|
|
// return: ptr(Dummy.StructComplex) @owned;
|
|
// }
|
|
|
|
emit_event_with_string {
|
|
params {
|
|
@in data: string;
|
|
}
|
|
}
|
|
emit_event_with_bool {
|
|
params {
|
|
@in data: bool;
|
|
}
|
|
}
|
|
emit_event_with_int {
|
|
params {
|
|
@in data: int;
|
|
}
|
|
}
|
|
emit_event_with_uint {
|
|
params {
|
|
@in data: uint;
|
|
}
|
|
}
|
|
emit_event_with_float {
|
|
params {
|
|
@in data: float;
|
|
}
|
|
}
|
|
emit_event_with_double {
|
|
params {
|
|
@in data: double;
|
|
}
|
|
}
|
|
emit_event_with_obj {
|
|
params {
|
|
@in data: Dummy.Test_Object;
|
|
}
|
|
}
|
|
|
|
emit_event_with_error {
|
|
params {
|
|
@in data: Eina.Error;
|
|
}
|
|
}
|
|
|
|
emit_event_with_struct {
|
|
params {
|
|
@in data: Dummy.StructSimple;
|
|
}
|
|
}
|
|
|
|
emit_event_with_struct_complex @beta {
|
|
params {
|
|
@in data: Dummy.StructComplex;
|
|
}
|
|
}
|
|
|
|
emit_event_with_array {
|
|
params {
|
|
@in data: array<string>;
|
|
}
|
|
}
|
|
|
|
emit_event_with_under {
|
|
}
|
|
|
|
append_to_strbuf {
|
|
params {
|
|
@in buf: strbuf;
|
|
@in str: string;
|
|
}
|
|
}
|
|
|
|
call_append_to_strbuf {
|
|
params {
|
|
@in buf: strbuf;
|
|
@in str: string;
|
|
}
|
|
}
|
|
|
|
call_format_cb {
|
|
params {
|
|
@in str: strbuf;
|
|
@in value: const(any_value);
|
|
@in func: Dummy.FormatCb;
|
|
}
|
|
}
|
|
|
|
bypass_typedef {
|
|
params {
|
|
@in data: Dummy.MyInt;
|
|
@out receiver: Dummy.MyInt;
|
|
}
|
|
|
|
return: Dummy.MyInt;
|
|
}
|
|
|
|
@property klass_prop @class {
|
|
get {}
|
|
set {}
|
|
values {
|
|
prop: int;
|
|
}
|
|
}
|
|
|
|
create_cmp_array_objects @class {
|
|
}
|
|
|
|
destroy_cmp_array_objects @class {
|
|
}
|
|
|
|
/* Futures */
|
|
|
|
get_future {
|
|
return: future<any_value_ptr>;
|
|
}
|
|
|
|
fulfill_promise {
|
|
params {
|
|
@in data: int;
|
|
}
|
|
}
|
|
|
|
reject_promise {
|
|
params {
|
|
@in error: Eina.Error;
|
|
}
|
|
}
|
|
|
|
/* Accessors */
|
|
clone_accessor {
|
|
params {
|
|
@in acc: accessor<int>;
|
|
}
|
|
return: accessor<int> @owned;
|
|
}
|
|
|
|
@property setter_only {
|
|
set {}
|
|
values {
|
|
prop: int;
|
|
}
|
|
}
|
|
|
|
get_setter_only {
|
|
return: int;
|
|
}
|
|
|
|
call_find_provider {
|
|
params {
|
|
@in type: const(Efl.Class);
|
|
}
|
|
return: Efl.Object;
|
|
}
|
|
|
|
call_find_provider_for_iface {
|
|
return: Efl.Object;
|
|
}
|
|
}
|
|
implements {
|
|
Efl.Object.constructor;
|
|
Efl.Object.destructor;
|
|
Efl.Object.provider_find;
|
|
Dummy.Test_Iface.emit_nonconflicted;
|
|
Dummy.Test_Iface.iface_prop { get; set; }
|
|
}
|
|
events {
|
|
evt,with,string @hot: const(string);
|
|
evt,with,bool: bool;
|
|
evt,with,int @hot: int;
|
|
evt,with,uint @hot: uint;
|
|
evt,with,float @hot: float;
|
|
evt,with,double @hot: double;
|
|
evt,with,obj @hot: Dummy.Test_Object;
|
|
evt,with,error @hot: Eina.Error;
|
|
evt,with,struct @hot: Dummy.StructSimple;
|
|
evt,with,struct,complex @beta @hot: Dummy.StructComplex;
|
|
evt,with,array @hot: const(array<string>);
|
|
evt_with,under @hot: void;
|
|
|
|
// Extra events to test generation, but not invocation
|
|
evt,with,byte: byte;
|
|
evt,with,ubyte: ubyte;
|
|
|
|
evt,with,char: char;
|
|
|
|
evt,with,short: short;
|
|
evt,with,ushort: ushort;
|
|
|
|
evt,with,llong: llong;
|
|
evt,with,ullong: ullong;
|
|
|
|
evt,with,int8 @hot: int8;
|
|
evt,with,uint8 @hot: uint8;
|
|
|
|
evt,with,int16 @hot: int16;
|
|
evt,with,uint16 @hot: uint16;
|
|
|
|
evt,with,int32 @hot: int32;
|
|
evt,with,uint32 @hot: uint32;
|
|
|
|
evt,with,int64 @hot: int64;
|
|
evt,with,uint64 @hot: uint64;
|
|
|
|
}
|
|
}
|