erts: Rename ErlNifResource as ErtsResource

as it's not part of the API

3 files changed, 30 insertions, 30 deletions

diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index fbe94708a5..b7425b9e45 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -1913,7 +1913,7 @@ int enif_snprintf(char *buffer, size_t size, const char* format, ...)
 /* dummy node in circular list */
 struct enif_resource_type_t resource_type_list; 
 
-#define SIZEOF_ErlNifResource(SIZE) (offsetof(ErlNifResource,data) + (SIZE))
+#define SIZEOF_ErlNifResource(SIZE) (offsetof(ErtsResource,data) + (SIZE))
 
 static ErlNifResourceType* find_resource_type(Eterm module, Eterm name)
 {
@@ -2111,7 +2111,7 @@ static void rollback_opened_resource_types(void)
 
 static int nif_resource_dtor(Binary* bin)
 {
-    ErlNifResource* resource = (ErlNifResource*) ERTS_MAGIC_BIN_UNALIGNED_DATA(bin);
+    ErtsResource* resource = (ErtsResource*) ERTS_MAGIC_BIN_UNALIGNED_DATA(bin);
     ErlNifResourceType* type = resource->type;
     ASSERT(ERTS_MAGIC_BIN_DESTRUCTOR(bin) == &nif_resource_dtor);
 
@@ -2131,7 +2131,7 @@ static int nif_resource_dtor(Binary* bin)
     return 1;
 }
 
-void erts_resource_stop(ErlNifResource* resource, ErlNifEvent e,
+void erts_resource_stop(ErtsResource* resource, ErlNifEvent e,
                         int is_direct_call)
 {
     struct enif_msg_environment_t msg_env;
@@ -2146,7 +2146,7 @@ void* enif_alloc_resource(ErlNifResourceType* type, size_t size)
     Binary* bin = erts_create_magic_binary_x(SIZEOF_ErlNifResource(size),
                                              &nif_resource_dtor,
                                              1); /* unaligned */
-    ErlNifResource* resource = ERTS_MAGIC_BIN_UNALIGNED_DATA(bin);
+    ErtsResource* resource = ERTS_MAGIC_BIN_UNALIGNED_DATA(bin);
 
     ASSERT(type->owner && type->next && type->prev); /* not allowed in load/upgrade */
     resource->type = type;
@@ -2160,7 +2160,7 @@ void* enif_alloc_resource(ErlNifResourceType* type, size_t size)
 
 void enif_release_resource(void* obj)
 {
-    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsResource* resource = DATA_TO_RESOURCE(obj);
     ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource);
 
     ASSERT(ERTS_MAGIC_BIN_DESTRUCTOR(bin) == &nif_resource_dtor);
@@ -2174,7 +2174,7 @@ void enif_release_resource(void* obj)
 
 void enif_keep_resource(void* obj)
 {
-    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsResource* resource = DATA_TO_RESOURCE(obj);
     ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource);
 
     ASSERT(ERTS_MAGIC_BIN_DESTRUCTOR(bin) == &nif_resource_dtor);
@@ -2186,7 +2186,7 @@ void enif_keep_resource(void* obj)
 
 ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj)
 {
-    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsResource* resource = DATA_TO_RESOURCE(obj);
     ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource);
     Eterm* hp = alloc_heap(env,PROC_BIN_SIZE);
     return erts_mk_magic_binary_term(&hp, &MSO(env->proc), &bin->binary);
@@ -2207,7 +2207,7 @@ int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* typ
 {
     ProcBin* pb;
     Binary* mbin;
-    ErlNifResource* resource;
+    ErtsResource* resource;
     if (!ERTS_TERM_IS_MAGIC_BINARY(term)) {
 	return 0;
     }
@@ -2216,7 +2216,7 @@ int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* typ
 	return 0; / * Or should we allow "resource binaries" as handles? * /
     }*/
     mbin = pb->val;
-    resource = (ErlNifResource*) ERTS_MAGIC_BIN_UNALIGNED_DATA(mbin);
+    resource = (ErtsResource*) ERTS_MAGIC_BIN_UNALIGNED_DATA(mbin);
     if (ERTS_MAGIC_BIN_DESTRUCTOR(mbin) != &nif_resource_dtor
 	|| resource->type != type) {	
 	return 0;
@@ -2227,9 +2227,9 @@ int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* typ
 
 size_t enif_sizeof_resource(void* obj)
 {
-    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsResource* resource = DATA_TO_RESOURCE(obj);
     Binary* bin = &ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource)->binary;
-    return ERTS_MAGIC_BIN_UNALIGNED_DATA_SIZE(bin) - offsetof(ErlNifResource,data);
+    return ERTS_MAGIC_BIN_UNALIGNED_DATA_SIZE(bin) - offsetof(ErtsResource,data);
 }
 
 
@@ -3303,7 +3303,7 @@ erts_unload_nif(struct erl_module_nif* lib)
 
 void erl_nif_init()
 {
-    ERTS_CT_ASSERT((offsetof(ErlNifResource,data) % 8) == ERTS_MAGIC_BIN_BYTES_TO_ALIGN);
+    ERTS_CT_ASSERT((offsetof(ErtsResource,data) % 8) == ERTS_MAGIC_BIN_BYTES_TO_ALIGN);
 
     resource_type_list.next = &resource_type_list;
     resource_type_list.prev = &resource_type_list;
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 91e5bbbd98..86c38f8e8c 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -71,7 +71,7 @@ struct enif_resource_type_t
     Eterm module;
     Eterm name;
 };
-typedef struct enif_resource_t
+typedef struct
 {
     struct enif_resource_type_t* type;
 #ifdef DEBUG
@@ -82,14 +82,14 @@ typedef struct enif_resource_t
 #endif
 
     char data[1];
-}ErlNifResource;
+}ErtsResource;
 
-#define DATA_TO_RESOURCE(PTR) ((ErlNifResource*)((char*)(PTR) - offsetof(ErlNifResource,data)))
+#define DATA_TO_RESOURCE(PTR) ((ErtsResource*)((char*)(PTR) - offsetof(ErtsResource,data)))
 
 extern void erts_pre_nif(struct enif_environment_t*, Process*,
 			 struct erl_module_nif*, Process* tracee);
 extern void erts_post_nif(struct enif_environment_t* env);
-extern void erts_resource_stop(ErlNifResource*, ErlNifEvent, int is_direct_call);
+extern void erts_resource_stop(ErtsResource*, ErlNifEvent, int is_direct_call);
 extern Eterm erts_nif_taints(Process* p);
 extern void erts_print_nif_taints(fmtfn_t to, void* to_arg);
 void erts_unload_nif(struct erl_module_nif* nif);
diff --git a/erts/emulator/sys/common/erl_check_io.c b/erts/emulator/sys/common/erl_check_io.c
index 4fc95624c7..79f567d16c 100644
--- a/erts/emulator/sys/common/erl_check_io.c
+++ b/erts/emulator/sys/common/erl_check_io.c
@@ -127,7 +127,7 @@ typedef struct {
         ErtsNifSelectDataState *nif;      /* ERTS_EV_TYPE_NIF */
         union {
             erts_driver_t*  drv_ptr;    /* ERTS_EV_TYPE_STOP_USE */
-            ErlNifResource* resource;   /* ERTS_EV_TYPE_STOP_NIF */
+            ErtsResource* resource;   /* ERTS_EV_TYPE_STOP_NIF */
         }stop;
     } driver;
     ErtsPollEvents events;
@@ -220,16 +220,16 @@ static void stale_drv_select(Eterm id, ErtsDrvEventState *state, int mode);
 static void drv_select_steal(ErlDrvPort ix, ErtsDrvEventState *state,
                              int mode, int on);
 static void nif_select_steal(ErtsDrvEventState *state, int mode,
-                             ErlNifResource* resource, Eterm ref);
+                             ErtsResource* resource, Eterm ref);
 
 static void print_drv_select_op(erts_dsprintf_buf_t *dsbufp,
                                 ErlDrvPort ix, ErtsSysFdType fd, int mode, int on);
 static void print_nif_select_op(erts_dsprintf_buf_t*, ErtsSysFdType,
-                                int mode, ErlNifResource*, Eterm ref);
+                                int mode, ErtsResource*, Eterm ref);
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
 static void drv_select_large_fd_error(ErlDrvPort, ErtsSysFdType, int, int);
-static void nif_select_large_fd_error(ErtsSysFdType, int, ErlNifResource*,Eterm ref);
+static void nif_select_large_fd_error(ErtsSysFdType, int, ErtsResource*,Eterm ref);
 #endif
 #if ERTS_CIO_HAVE_DRV_EVENT
 static void drv_event_steal(ErlDrvPort ix, ErtsDrvEventState *state,
@@ -244,7 +244,7 @@ static void
 steal_pending_stop_use(erts_dsprintf_buf_t*, ErlDrvPort, ErtsDrvEventState*,
                        int mode, int on);
 static void
-steal_pending_stop_nif(erts_dsprintf_buf_t *dsbufp, ErlNifResource*,
+steal_pending_stop_nif(erts_dsprintf_buf_t *dsbufp, ErtsResource*,
                        ErtsDrvEventState *state, int mode, int on);
 
 #ifdef ERTS_SMP
@@ -387,7 +387,7 @@ forget_removed(struct pollset_info* psi)
     erts_smp_spin_unlock(&psi->removed_list_lock);
 
     while (fdlp) {
-        ErlNifResource* resource = NULL;
+        ErtsResource* resource = NULL;
 	erts_driver_t* drv_ptr = NULL;
 	erts_smp_mtx_t* mtx;
 	ErtsSysFdType fd;
@@ -1207,7 +1207,7 @@ ERTS_CIO_EXPORT(enif_select)(ErlNifEnv* env,
 {
     int on;
     const Eterm id = env->proc->common.id;
-    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsResource* resource = DATA_TO_RESOURCE(obj);
     ErtsSysFdType fd = (ErtsSysFdType) e;
     ErtsPollEvents ctl_events = (ErtsPollEvents) 0;
     ErtsPollEvents new_events, old_events;
@@ -1769,7 +1769,7 @@ print_drv_select_op(erts_dsprintf_buf_t *dsbufp,
 static void
 print_nif_select_op(erts_dsprintf_buf_t *dsbufp,
                     ErtsSysFdType fd, int mode,
-                    ErlNifResource* resource, Eterm ref)
+                    ErtsResource* resource, Eterm ref)
 {
     erts_dsprintf(dsbufp,
 		  "enif_select(_, %d,%s%s%s, %T:%T, %T) ",
@@ -1796,7 +1796,7 @@ drv_select_steal(ErlDrvPort ix, ErtsDrvEventState *state, int mode, int on)
 
 static void
 nif_select_steal(ErtsDrvEventState *state, int mode,
-                 ErlNifResource* resource, Eterm ref)
+                 ErtsResource* resource, Eterm ref)
 {
     if (need2steal(state, mode)) {
 	erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
@@ -1826,7 +1826,7 @@ drv_select_large_fd_error(ErlDrvPort ix, ErtsSysFdType fd, int mode, int on)
 }
 static void
 nif_select_large_fd_error(ErtsSysFdType fd, int mode,
-                          ErlNifResource* resource, Eterm ref)
+                          ErtsResource* resource, Eterm ref)
 {
     erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
     print_nif_select_op(dsbufp, fd, mode, resource, ref);
@@ -1878,7 +1878,7 @@ steal_pending_stop_use(erts_dsprintf_buf_t *dsbufp, ErlDrvPort ix,
 }
 
 static void
-steal_pending_stop_nif(erts_dsprintf_buf_t *dsbufp, ErlNifResource* resource,
+steal_pending_stop_nif(erts_dsprintf_buf_t *dsbufp, ErtsResource* resource,
                        ErtsDrvEventState *state, int mode, int on)
 {
     int cancel = 0;
@@ -2046,7 +2046,7 @@ oready(Eterm id, ErtsDrvEventState *state, erts_aint_t current_cio_time)
 }
 
 static ERTS_INLINE void
-send_event_tuple(struct erts_nif_select_event* e, ErlNifResource* resource,
+send_event_tuple(struct erts_nif_select_event* e, ErtsResource* resource,
                  Eterm event_atom)
 {
     Process* rp = erts_proc_lookup(e->pid);
@@ -2289,7 +2289,7 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
         case ERTS_EV_TYPE_NIF: { /* Requested via enif_select()... */
             struct erts_nif_select_event in = {NIL};
             struct erts_nif_select_event out = {NIL};
-            ErlNifResource* resource;
+            ErtsResource* resource;
             ErtsPollEvents revents = pollres[i].events;
 
             if (revents & ERTS_POLL_EV_ERR) {
@@ -2916,7 +2916,7 @@ static void doit_erts_check_io_debug(void *vstate, void *vcounters)
 	    }
 	}
         else if (state->type == ERTS_EV_TYPE_NIF) {
-            ErlNifResource* r;
+            ErtsResource* r;
             erts_printf("enif_select ");
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS