Git Product home page Git Product logo

rust-efl's Introduction

Rust EFL

Rust bindings for the Enlightenment Foundation Libraries (version 1.10.0-0.0.1.99).

These versions of the bindings currently correspond to the latest code base both for EFL (1.10.x) and the Rust language, so it is required to fetch and install the necessary libraries/implementation from the master git repository for both of these projects.

Requirements:

  • efl EFL core libraries
  • evas_generic_loaders Loaders for Evas using 'generic' module
  • emotion_generic_players Players for Emotion using 'generic' module
  • elementary EFL widget toolkit

Building library:

In the top level directory of this source code:

$ rustc src/efl.rs --crate-type=lib

Now you can build programs using the rust-efl library bindings:

$ rustc tests/test_simple.rs -L.

Run:

$ ./test_simple

Enjoy!

rust-efl's People

Contributors

araujol avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar

rust-efl's Issues

Unable to compile with Rust 1.0.0 alpha.

$ rustc src/efl.rs --crate-type=lib
src/eo.rs:33:26: 33:27 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:33     fn _eo_do_start(obj: *Eo, cur_klass: *EoClass, is_super: eina::EinaBool,
                                      ^
src/eo.rs:33:42: 33:43 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:33     fn _eo_do_start(obj: *Eo, cur_klass: *EoClass, is_super: eina::EinaBool,
                                                      ^
src/eo.rs:34:27: 34:28 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:34                     file: *c_char, func: *c_char, line: c_uint) -> eina::EinaBool;
                                       ^
src/eo.rs:34:42: 34:43 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:34                     file: *c_char, func: *c_char, line: c_uint) -> eina::EinaBool;
                                                      ^
src/eo.rs:35:24: 35:25 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:35     fn _eo_do_end(obj: **Eo);
                                    ^
src/eo.rs:35:25: 35:26 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:35     fn _eo_do_end(obj: **Eo);
                                     ^
src/eo.rs:49:23: 49:24 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:49 pub fn _do_start(obj: *Eo, cur_klass: *EoClass, is_super: bool,
                                   ^
src/eo.rs:49:39: 49:40 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:49 pub fn _do_start(obj: *Eo, cur_klass: *EoClass, is_super: bool,
                                                   ^
src/eo.rs:58:21: 58:22 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:58 pub fn _do_end(obj: **Eo) {
                                 ^
src/eo.rs:58:22: 58:23 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eo.rs:58 pub fn _do_end(obj: **Eo) {
                                  ^
src/ecore.rs:57:19: 57:20 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:57     pub ext_data: *c_void,
                                  ^
src/ecore.rs:68:25: 68:26 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:68 type CEcoreTaskCb = fn (*c_void) -> u8;
                                        ^
src/ecore.rs:73:33: 73:34 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:73 type CEcoreEventHandlerCb = fn (*c_void, c_int, *c_void) -> u8;
                                                ^
src/ecore.rs:73:49: 73:50 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:73 type CEcoreEventHandlerCb = fn (*c_void, c_int, *c_void) -> u8;
                                                                ^
src/ecore.rs:76:31: 76:32 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:76 type _CEcoreEvasEventCb = fn (*EcoreEvas);
                                              ^
src/ecore.rs:81:46: 81:47 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:81     fn ecore_app_args_set(argc: c_int, argv: **c_char);
                                                             ^
src/ecore.rs:81:47: 81:48 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:81     fn ecore_app_args_set(argc: c_int, argv: **c_char);
                                                              ^
src/ecore.rs:87:60: 87:61 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:87     fn ecore_timer_add(inv: f64, func: CEcoreTaskCb, data: *c_void);
                                                                           ^
src/ecore.rs:89:38: 89:39 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:89                                data: *c_void) -> *EcoreEventHandler;
                                                     ^
src/ecore.rs:89:50: 89:51 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:89                                data: *c_void) -> *EcoreEventHandler;
                                                                 ^
src/ecore.rs:96:36: 96:37 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:96     fn ecore_evas_new(engine_name: *c_char, 
                                                   ^
src/ecore.rs:99:38: 99:39 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:99                       extra_options: *c_char) -> *EcoreEvas;
                                                     ^
src/ecore.rs:99:50: 99:51 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:99                       extra_options: *c_char) -> *EcoreEvas;
                                                                 ^
src/ecore.rs:100:28: 100:29 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:100     fn ecore_evas_show(ee: *EcoreEvas);
                                            ^
src/ecore.rs:101:27: 101:28 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:101     fn ecore_evas_get(ee: *EcoreEvas) -> *evas::Evas;
                                           ^
src/ecore.rs:101:42: 101:43 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:101     fn ecore_evas_get(ee: *EcoreEvas) -> *evas::Evas;
                                                          ^
src/ecore.rs:102:32: 102:33 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:102     fn ecore_evas_data_set(ee: *EcoreEvas, key: *c_char, data: *c_void);
                                                ^
src/ecore.rs:102:49: 102:50 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:102     fn ecore_evas_data_set(ee: *EcoreEvas, key: *c_char, data: *c_void);
                                                                 ^
src/ecore.rs:102:64: 102:65 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:102     fn ecore_evas_data_set(ee: *EcoreEvas, key: *c_char, data: *c_void);
                                                                                ^
src/ecore.rs:103:32: 103:33 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:103     fn ecore_evas_data_get(ee: *EcoreEvas, key: *c_char) -> *c_void;
                                                ^
src/ecore.rs:103:49: 103:50 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:103     fn ecore_evas_data_get(ee: *EcoreEvas, key: *c_char) -> *c_void;
                                                                 ^
src/ecore.rs:103:61: 103:62 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:103     fn ecore_evas_data_get(ee: *EcoreEvas, key: *c_char) -> *c_void;
                                                                             ^
src/ecore.rs:104:28: 104:29 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:104     fn ecore_evas_free(ee: *EcoreEvas);
                                            ^
src/ecore.rs:105:43: 105:44 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:105     fn ecore_evas_callback_resize_set(ee: *EcoreEvas, func: _CEcoreEvasEventCb);
                                                           ^
src/ecore.rs:106:36: 106:37 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:106     fn ecore_evas_geometry_get(ee: *EcoreEvas,
                                                    ^
src/ecore.rs:107:35: 107:36 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:107                                x: *c_int, y: *c_int,
                                                   ^
src/ecore.rs:107:46: 107:47 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:107                                x: *c_int, y: *c_int,
                                                              ^
src/ecore.rs:108:35: 108:36 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:108                                w: *c_int, h: *c_int);
                                                   ^
src/ecore.rs:108:46: 108:47 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:108                                w: *c_int, h: *c_int);
                                                              ^
src/ecore.rs:124:21: 124:22 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:124     let vchars_ptr: **c_char = to_c_args(argv);
                                     ^
src/ecore.rs:124:22: 124:23 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:124     let vchars_ptr: **c_char = to_c_args(argv);
                                      ^
src/ecore.rs:149:17: 149:18 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/ecore.rs:149     let c_data: *c_void = unsafe { transmute(data) };
                                 ^
src/evas.rs:115:32: 115:33 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:115 type _CEvasObjectEventCb = fn (*c_void, *Evas, *EvasObject, *c_void);
                                               ^
src/evas.rs:115:41: 115:42 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:115 type _CEvasObjectEventCb = fn (*c_void, *Evas, *EvasObject, *c_void);
                                                        ^
src/evas.rs:115:48: 115:49 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:115 type _CEvasObjectEventCb = fn (*c_void, *Evas, *EvasObject, *c_void);
                                                               ^
src/evas.rs:115:61: 115:62 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:115 type _CEvasObjectEventCb = fn (*c_void, *Evas, *EvasObject, *c_void);
                                                                            ^
src/evas.rs:120:25: 120:26 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:120 type CEvasSmartCb = fn (*c_void, *EvasObject, *c_void) -> c_void;
                                        ^
src/evas.rs:120:34: 120:35 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:120 type CEvasSmartCb = fn (*c_void, *EvasObject, *c_void) -> c_void;
                                                 ^
src/evas.rs:120:47: 120:48 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:120 type CEvasSmartCb = fn (*c_void, *EvasObject, *c_void) -> c_void;
                                                              ^
src/evas.rs:127:22: 127:23 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:127     fn evas_new() -> *Evas;
                                     ^
src/evas.rs:128:21: 128:22 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:128     fn evas_free(e: *Evas);
                                    ^
src/evas.rs:129:25: 129:26 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:129     fn evas_focus_in(e: *Evas);
                                        ^
src/evas.rs:130:26: 130:27 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:130     fn evas_focus_out(e: *Evas);
                                         ^
src/evas.rs:131:37: 131:38 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:131     fn evas_object_rectangle_add(e: *Evas) -> *EvasObject;
                                                    ^
src/evas.rs:131:47: 131:48 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:131     fn evas_object_rectangle_add(e: *Evas) -> *EvasObject;
                                                              ^
src/evas.rs:132:28: 132:29 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:132     fn evas_object_show(e: *EvasObject);
                                           ^
src/evas.rs:133:30: 133:31 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:133     fn evas_object_resize(e: *EvasObject, w: c_int, h: c_int);
                                             ^
src/evas.rs:134:29: 134:30 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:134     fn evas_object_del(obj: *EvasObject);   
                                            ^
src/evas.rs:135:28: 135:29 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:135     fn evas_object_move(e: *EvasObject, x: c_int, y: c_int);
                                           ^
src/evas.rs:136:34: 136:35 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:136     fn evas_object_name_set(obj: *EvasObject, name: *c_char); 
                                                 ^
src/evas.rs:136:53: 136:54 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:136     fn evas_object_name_set(obj: *EvasObject, name: *c_char); 
                                                                    ^
src/evas.rs:137:35: 137:36 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:137     fn evas_object_color_set(obj: *EvasObject,
                                                  ^
src/evas.rs:140:41: 140:42 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:140     fn evas_object_size_hint_min_set(e: *EvasObject, x: c_int, y: c_int);
                                                        ^
src/evas.rs:141:44: 141:45 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:141     fn evas_object_size_hint_weight_set(e: *EvasObject, x: f64, y: f64);
                                                           ^
src/evas.rs:142:43: 142:44 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:142     fn evas_object_size_hint_align_set(e: *EvasObject, x: f64, y: f64);
                                                          ^
src/evas.rs:143:35: 143:36 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:143     fn evas_object_focus_set(obj: *EvasObject, focus: eina::EinaBool);
                                                  ^
src/evas.rs:144:33: 144:34 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:144     fn evas_object_image_add(e: *Evas) -> *EvasObject;
                                                ^
src/evas.rs:144:43: 144:44 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:144     fn evas_object_image_add(e: *Evas) -> *EvasObject;
                                                          ^
src/evas.rs:145:40: 145:41 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:145     fn evas_object_image_filled_add(e: *Evas) -> *EvasObject;
                                                       ^
src/evas.rs:145:50: 145:51 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:145     fn evas_object_image_filled_add(e: *Evas) -> *EvasObject;
                                                                 ^
src/evas.rs:146:40: 146:41 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:146     fn evas_object_image_fill_set(obj: *EvasObject,
                                                       ^
src/evas.rs:149:40: 149:41 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:149     fn evas_object_image_file_set(obj: *EvasObject, file: *c_char, key: *c_char);
                                                       ^
src/evas.rs:149:59: 149:60 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:149     fn evas_object_image_file_set(obj: *EvasObject, file: *c_char, key: *c_char);
                                                                          ^
src/evas.rs:149:73: 149:74 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:149     fn evas_object_image_file_set(obj: *EvasObject, file: *c_char, key: *c_char);
                                                                                        ^
src/evas.rs:150:40: 150:41 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:150     fn evas_object_image_size_set(obj: *EvasObject, w: c_int, h: c_int);
                                                       ^
src/evas.rs:151:42: 151:43 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:151     fn evas_object_image_filled_set(obj: *EvasObject, setting: eina::EinaBool);
                                                         ^
src/evas.rs:152:39: 152:40 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:152     fn evas_object_image_preload(obj: *EvasObject, cancel: eina::EinaBool);
                                                      ^
src/evas.rs:153:44: 153:45 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:153     fn evas_object_event_callback_add(obj: *EvasObject, cbtype: c_uint,
                                                           ^
src/evas.rs:154:72: 154:73 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:154                                       func: _CEvasObjectEventCb, data: *c_void);
                                                                                       ^
src/evas.rs:155:42: 155:43 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:155     fn evas_object_smart_callback_add(e: *EvasObject, event: *c_char,
                                                         ^
src/evas.rs:155:62: 155:63 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:155     fn evas_object_smart_callback_add(e: *EvasObject, event: *c_char,
                                                                             ^
src/evas.rs:156:63: 156:64 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:156                                       cb: CEvasSmartCb, data: *c_void);
                                                                              ^
src/evas.rs:247:35: 247:36 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:247 pub fn object_image_fill_set(obj: *EvasObject, xy: Coord, wh: Coord) {
                                                  ^
src/evas.rs:301:17: 301:18 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/evas.rs:301     let c_data: *c_void = unsafe { transmute(data) };
                                ^
src/eina.rs:49:17: 49:18 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:49     accounting: *_EinaListAccounting<'r, T>,
                               ^
src/eina.rs:63:11: 63:12 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:63     data: *c_void,
                         ^
src/eina.rs:64:11: 64:12 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:64     next: *_CEinaList,
                         ^
src/eina.rs:65:11: 65:12 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:65     prev: *_CEinaList,
                         ^
src/eina.rs:66:17: 66:18 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:66     accounting: *_CEinaListAccounting,
                               ^
src/eina.rs:72:11: 72:12 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:72     last: *_CEinaList,
                         ^
src/eina.rs:83:10: 83:11 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:83     _eo: *_EinaInlist
                        ^
src/eina.rs:88:11: 88:12 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:88     next: *_EinaInlist,
                         ^
src/eina.rs:90:11: 90:12 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:90     prev: *_EinaInlist,
                         ^
src/eina.rs:92:11: 92:12 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:92     last: *_EinaInlist
                         ^
src/eina.rs:105:14: 105:15 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:105     buckets: **EinaRbtree,
                             ^
src/eina.rs:105:15: 105:16 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:105     buckets: **EinaRbtree,
                              ^
src/eina.rs:122:14: 122:15 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:122     buckets: **EinaRbtree,
                             ^
src/eina.rs:122:15: 122:16 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:122     buckets: **EinaRbtree,
                              ^
src/eina.rs:135:28: 135:29 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:135 type _CEinaKeyLength = fn (*c_void) -> c_int;
                                           ^
src/eina.rs:139:25: 139:26 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:139 type _CEinaKeyCmp = fn (*c_void, c_int, *c_void, c_int) -> c_int;
                                        ^
src/eina.rs:139:41: 139:42 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:139 type _CEinaKeyCmp = fn (*c_void, c_int, *c_void, c_int) -> c_int;
                                                        ^
src/eina.rs:143:26: 143:27 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:143 type _CEinaKeyHash = fn (*c_void, c_int) -> c_int;
                                         ^
src/eina.rs:147:25: 147:26 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:147 type _CEinaFreeCb = fn (*c_void);
                                        ^
src/eina.rs:151:10: 151:11 error: bare raw pointers are no longer allowed, you should likely use `*mut T`, but otherwise `*T` is now known as `*const T`
src/eina.rs:151     son: *[EinaRbtree, ..2],
                         ^
src/eina.rs:151:22: 151:23 error: expected one of `(`, `+`, `::`, `;`, or `]`, found `,`
src/eina.rs:151     son: *[EinaRbtree, ..2],

Development

Hi,

I'm from efl upstream, and I just wanted to ping this project to let @araujol and @arlowhite know that we've been working hard to improve the situation with bindings development (eolian), and I think it's ready to be used more seriously at this point.

I'm not sure if anyone has any interest in further development of rust bindings for efl, but we'd love to have them, or at least to get some feedback about any changes which would need to be made to further enable bindings to be created for rust.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.