rename render_tree to rendertree in C API

crates/gosub-bindings/Makefile

@@ -47,8 +47,8 @@ endif
 
 TEST_SRC_DIR := tests
 test: # build and run tests for bindings
-	$(CC) $(TEST_SRC_DIR)/render_tree_test.c -L./ -lgosub $(LDFLAGS) -lgosub_bindings -lsqlite3 -lm -o $(TEST_SRC_DIR)/render_tree_test $(CPPFLAGS) $(CFLAGS)
-	./$(TEST_SRC_DIR)/render_tree_test
+	$(CC) $(TEST_SRC_DIR)/rendertree_test.c -L./ -lgosub $(LDFLAGS) -lgosub_bindings -lsqlite3 -lm -o $(TEST_SRC_DIR)/rendertree_test $(CPPFLAGS) $(CFLAGS)
+	./$(TEST_SRC_DIR)/rendertree_test
 
 format:
 	cargo clippy --fix --allow-dirty --allow-staged

crates/gosub-bindings/include/gosub_api.h

@@ -3,15 +3,15 @@
 
 #include "nodes.h"
 
-extern void *gosub_render_tree_init(const char *html);
-extern void *gosub_render_tree_iterator_init(void *render_tree);
-extern const void *gosub_render_tree_next_node(void *tree_iterator);
-extern void gosub_render_tree_get_node_data(const void *current_node,
+extern void *gosub_rendertree_init(const char *html);
+extern void *gosub_rendertree_iterator_init(void *rendertree);
+extern const void *gosub_rendertree_next_node(void *tree_iterator);
+extern void gosub_rendertree_get_node_data(const void *current_node,
                                             struct node_t *node);
-extern void gosub_render_tree_iterator_free(void *tree_iterator);
-extern void gosub_render_tree_free(void *render_free);
+extern void gosub_rendertree_iterator_free(void *tree_iterator);
+extern void gosub_rendertree_free(void *render_free);
 
-struct render_tree_t {
+struct rendertree_t {
   void *tree;
   void *iterator;
   const void *current_node;
@@ -21,17 +21,17 @@ struct render_tree_t {
 /// Initialize a render tree by passing a stack-allocated
 /// struct by address.
 /// Returns 0 on success or -1 if a failure occurred.
-int8_t render_tree_init(struct render_tree_t *render_tree, const char *html);
+int8_t rendertree_init(struct rendertree_t *rendertree, const char *html);
 
 /// Get the next node in the render tree as a read-only pointer.
 /// Returns NULL when reaching end of tree.
-const struct node_t *render_tree_next(struct render_tree_t *render_tree);
+const struct node_t *rendertree_next(struct rendertree_t *rendertree);
 
 /// Get the type of the current node the render tree is pointing to.
 enum node_type_e
-render_tree_get_current_node_type(const struct render_tree_t *render_tree);
+rendertree_get_current_node_type(const struct rendertree_t *rendertree);
 
 /// Free all memory tied to the render tree
-void render_tree_free(struct render_tree_t *render_tree);
+void rendertree_free(struct rendertree_t *rendertree);
 
 #endif

crates/gosub-bindings/include/nodes.h

@@ -9,8 +9,8 @@
 #include "nodes/text.h"
 #include "properties.h"
 
-struct node_t *render_tree_node_init();
-void render_tree_node_free(struct node_t **node);
+struct node_t *rendertree_node_init();
+void rendertree_node_free(struct node_t **node);
 
 enum node_type_e { NODE_TYPE_ROOT = 0u, NODE_TYPE_TEXT };
 
@@ -25,18 +25,18 @@ struct node_t {
   } data;
 };
 
-struct node_t *render_tree_node_init();
-double render_tree_node_get_x(const struct node_t *node);
-double render_tree_node_get_y(const struct node_t *node);
-double render_tree_node_get_margin_top(const struct node_t *node);
-double render_tree_node_get_margin_left(const struct node_t *node);
-double render_tree_node_get_margin_right(const struct node_t *node);
-double render_tree_node_get_margin_bottom(const struct node_t *node);
-double render_tree_node_get_padding_top(const struct node_t *node);
-double render_tree_node_get_padding_left(const struct node_t *node);
-double render_tree_node_get_padding_right(const struct node_t *node);
-double render_tree_node_get_padding_bottom(const struct node_t *node);
-void render_tree_node_free_data(struct node_t *node);
-void render_tree_node_free(struct node_t **node);
+struct node_t *rendertree_node_init();
+double rendertree_node_get_x(const struct node_t *node);
+double rendertree_node_get_y(const struct node_t *node);
+double rendertree_node_get_margin_top(const struct node_t *node);
+double rendertree_node_get_margin_left(const struct node_t *node);
+double rendertree_node_get_margin_right(const struct node_t *node);
+double rendertree_node_get_margin_bottom(const struct node_t *node);
+double rendertree_node_get_padding_top(const struct node_t *node);
+double rendertree_node_get_padding_left(const struct node_t *node);
+double rendertree_node_get_padding_right(const struct node_t *node);
+double rendertree_node_get_padding_bottom(const struct node_t *node);
+void rendertree_node_free_data(struct node_t *node);
+void rendertree_node_free(struct node_t **node);
 
 #endif

crates/gosub-bindings/include/nodes/text.h

@@ -15,11 +15,11 @@ struct node_text_t {
   bool is_bold;
 };
 
-void render_tree_node_text_free_data(struct node_text_t *text);
+void rendertree_node_text_free_data(struct node_text_t *text);
 
-const char *render_tree_node_text_get_value(const struct node_t *node);
-const char *render_tree_node_text_get_font(const struct node_t *node);
-double render_tree_node_text_get_font_size(const struct node_t *node);
-bool render_tree_node_text_get_bold(const struct node_t *node);
+const char *rendertree_node_text_get_value(const struct node_t *node);
+const char *rendertree_node_text_get_font(const struct node_t *node);
+double rendertree_node_text_get_font_size(const struct node_t *node);
+bool rendertree_node_text_get_bold(const struct node_t *node);
 
 #endif

crates/gosub-bindings/src/gosub_api.c

@@ -1,50 +1,50 @@
 #include "gosub_api.h"
 
-int8_t render_tree_init(struct render_tree_t *render_tree, const char *html) {
+int8_t rendertree_init(struct rendertree_t *rendertree, const char *html) {
 
-  render_tree->tree = gosub_render_tree_init(html);
-  if (!render_tree->tree) {
+  rendertree->tree = gosub_rendertree_init(html);
+  if (!rendertree->tree) {
     return -1;
   }
 
-  render_tree->iterator = gosub_render_tree_iterator_init(render_tree->tree);
-  if (!render_tree->iterator) {
-    gosub_render_tree_free(render_tree->tree);
+  rendertree->iterator = gosub_rendertree_iterator_init(rendertree->tree);
+  if (!rendertree->iterator) {
+    gosub_rendertree_free(rendertree->tree);
     return -1;
   }
 
-  render_tree->current_node = NULL;
+  rendertree->current_node = NULL;
 
-  render_tree->data = render_tree_node_init();
-  if (!render_tree->data) {
-    gosub_render_tree_iterator_free(render_tree->iterator);
-    gosub_render_tree_free(render_tree->tree);
+  rendertree->data = rendertree_node_init();
+  if (!rendertree->data) {
+    gosub_rendertree_iterator_free(rendertree->iterator);
+    gosub_rendertree_free(rendertree->tree);
     return -1;
   }
 
   return 0;
 }
 
-const struct node_t *render_tree_next(struct render_tree_t *render_tree) {
-  render_tree_node_free_data(render_tree->data);
-  render_tree->current_node =
-      gosub_render_tree_next_node(render_tree->iterator);
-  if (!render_tree->current_node)
+const struct node_t *rendertree_next(struct rendertree_t *rendertree) {
+  rendertree_node_free_data(rendertree->data);
+  rendertree->current_node =
+      gosub_rendertree_next_node(rendertree->iterator);
+  if (!rendertree->current_node)
     return NULL;
-  gosub_render_tree_get_node_data(render_tree->current_node, render_tree->data);
-  return (const struct node_t *)render_tree->data;
+  gosub_rendertree_get_node_data(rendertree->current_node, rendertree->data);
+  return (const struct node_t *)rendertree->data;
 }
 
 enum node_type_e
-render_tree_get_current_node_type(const struct render_tree_t *render_tree) {
-  return render_tree->data->type;
+rendertree_get_current_node_type(const struct rendertree_t *rendertree) {
+  return rendertree->data->type;
 }
 
-void render_tree_free(struct render_tree_t *render_tree) {
-  gosub_render_tree_iterator_free(render_tree->iterator);
-  render_tree->iterator = NULL;
-  gosub_render_tree_free(render_tree->tree);
-  render_tree->tree = NULL;
-  render_tree_node_free(&render_tree->data);
-  render_tree->data = NULL;
+void rendertree_free(struct rendertree_t *rendertree) {
+  gosub_rendertree_iterator_free(rendertree->iterator);
+  rendertree->iterator = NULL;
+  gosub_rendertree_free(rendertree->tree);
+  rendertree->tree = NULL;
+  rendertree_node_free(&rendertree->data);
+  rendertree->data = NULL;
 }

crates/gosub-bindings/src/lib.rs

@@ -23,10 +23,10 @@ use wrapper::node::CNode;
 /// to build a render tree. DO NOT take ownership of this pointer in Rust or the
 /// universe might collapse.
 ///
-/// Moves an owning pointer to the render_tree using Box::into_raw() to the C API.
-/// This pointer MUST be passed to gosub_render_tree_free() after usage for proper cleanup.
+/// Moves an owning pointer to the rendertree using Box::into_raw() to the C API.
+/// This pointer MUST be passed to gosub_rendertree_free() after usage for proper cleanup.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_init(html: *const c_char) -> *mut RenderTree {
+pub unsafe extern "C" fn gosub_rendertree_init(html: *const c_char) -> *mut RenderTree {
     let html_str = unsafe {
         if let Ok(html_str) = CStr::from_ptr(html).to_str() {
             html_str
@@ -42,10 +42,10 @@ pub unsafe extern "C" fn gosub_render_tree_init(html: *const c_char) -> *mut Ren
     let parse_result = Html5Parser::parse_document(&mut chars, Document::clone(&doc), None);
 
     if parse_result.is_ok() {
-        let mut render_tree = Box::new(RenderTree::new(&doc));
-        render_tree.build();
+        let mut rendertree = Box::new(RenderTree::new(&doc));
+        rendertree.build();
 
-        Box::into_raw(render_tree)
+        Box::into_raw(rendertree)
     } else {
         ptr::null_mut()
     }
@@ -55,24 +55,24 @@ pub unsafe extern "C" fn gosub_render_tree_init(html: *const c_char) -> *mut Ren
 ///
 /// # Safety
 /// Moves an owning pointer to the tree iterator using Box::into_raw() to the C API.
-/// This pointer MUST be passed to gosub_render_tree_iterator_free() after usage for proper cleanup.
+/// This pointer MUST be passed to gosub_rendertree_iterator_free() after usage for proper cleanup.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_iterator_init(
-    render_tree: *const RenderTree,
+pub unsafe extern "C" fn gosub_rendertree_iterator_init(
+    rendertree: *const RenderTree,
 ) -> *mut TreeIterator {
-    let tree_iterator = Box::new(TreeIterator::new(&(*render_tree)));
+    let tree_iterator = Box::new(TreeIterator::new(&(*rendertree)));
     Box::into_raw(tree_iterator)
 }
 
 /// Takes a tree_iterator and returns a non-owning pointer to the next node
 ///
 /// # Safety
-/// Takes a tree_iterator pointer (owned by the C API generated by gosub_render_tree_iterator_init())
+/// Takes a tree_iterator pointer (owned by the C API generated by gosub_rendertree_iterator_init())
 /// and modifies it to point to the next tree-order node in the tree. Any heap-allocated data
 /// on the current node is free'd before pointing to the next node. Returns a ready-only pointer
 /// to the next node.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_next_node(
+pub unsafe extern "C" fn gosub_rendertree_next_node(
     tree_iterator: *mut TreeIterator,
 ) -> *const Node {
     let next = (*tree_iterator).next();
@@ -86,28 +86,28 @@ pub unsafe extern "C" fn gosub_render_tree_next_node(
 /// Fetch the node data according to the NodeType of the current node.
 ///
 /// # Safety
-/// Uses a read-only pointer obtained from gosub_render_tree_next_node()
+/// Uses a read-only pointer obtained from gosub_rendertree_next_node()
 /// and a mutable pointer owned by the C API to write (copy) the contents
 /// of the read-only pointer into the mutable pointer.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_get_node_data(node: *const Node, c_node: *mut CNode) {
+pub unsafe extern "C" fn gosub_rendertree_get_node_data(node: *const Node, c_node: *mut CNode) {
     // Change this to a match when we have more types
     if let NodeType::Text(text_node) = &(*node).node_type {
         *c_node = CNode::new_text(&*node, text_node);
     }
 }
 
-/// Free the iterator pointer obtained from gosub_render_tree_iterator_init()
+/// Free the iterator pointer obtained from gosub_rendertree_iterator_init()
 ///
 /// # Safety
 /// This takes ownership of the pointer from the C API and transfers it to Rust so it can
 /// be deallocated.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_iterator_free(tree_iterator: *mut TreeIterator) {
+pub unsafe extern "C" fn gosub_rendertree_iterator_free(tree_iterator: *mut TreeIterator) {
     let _ = Box::from_raw(tree_iterator);
 }
 
-/// Free the render_tree pointer obtained from gosub_render_tree_init()
+/// Free the rendertree pointer obtained from gosub_rendertree_init()
 ///
 /// # Safety
 /// This takes ownership of the pointer from the C API and transfers it to Rust so it can
@@ -117,6 +117,6 @@ pub unsafe extern "C" fn gosub_render_tree_iterator_free(tree_iterator: *mut Tre
 // check with valgrind) although I cannot figure out how to resolve this memory leak...
 // needs more investigation; I've tried various methods.
 #[no_mangle]
-pub unsafe extern "C" fn gosub_render_tree_free(render_tree: *mut RenderTree) {
-    let _ = Box::from_raw(render_tree);
+pub unsafe extern "C" fn gosub_rendertree_free(rendertree: *mut RenderTree) {
+    let _ = Box::from_raw(rendertree);
 }

crates/gosub-bindings/src/nodes.c

@@ -1,6 +1,6 @@
 #include "nodes.h"
 
-struct node_t *render_tree_node_init() {
+struct node_t *rendertree_node_init() {
   struct node_t *node = malloc(sizeof(*node));
   if (!node)
     return NULL;
@@ -11,57 +11,57 @@ struct node_t *render_tree_node_init() {
   return node;
 }
 
-void render_tree_node_free_data(struct node_t *node) {
+void rendertree_node_free_data(struct node_t *node) {
   switch (node->type) {
   case NODE_TYPE_ROOT:
     break;
   case NODE_TYPE_TEXT:
-    render_tree_node_text_free_data(&node->data.text);
+    rendertree_node_text_free_data(&node->data.text);
     break;
   }
 }
 
-double render_tree_node_get_x(const struct node_t *node) {
+double rendertree_node_get_x(const struct node_t *node) {
   return node->position.x;
 }
 
-double render_tree_node_get_y(const struct node_t *node) {
+double rendertree_node_get_y(const struct node_t *node) {
   return node->position.y;
 }
 
-double render_tree_node_get_margin_top(const struct node_t *node) {
+double rendertree_node_get_margin_top(const struct node_t *node) {
   return node->margin.top;
 }
 
-double render_tree_node_get_margin_left(const struct node_t *node) {
+double rendertree_node_get_margin_left(const struct node_t *node) {
   return node->margin.left;
 }
 
-double render_tree_node_get_margin_right(const struct node_t *node) {
+double rendertree_node_get_margin_right(const struct node_t *node) {
   return node->margin.right;
 }
 
-double render_tree_node_get_margin_bottom(const struct node_t *node) {
+double rendertree_node_get_margin_bottom(const struct node_t *node) {
   return node->margin.bottom;
 }
 
-double render_tree_node_get_padding_top(const struct node_t *node) {
+double rendertree_node_get_padding_top(const struct node_t *node) {
   return node->padding.top;
 }
 
-double render_tree_node_get_padding_left(const struct node_t *node) {
+double rendertree_node_get_padding_left(const struct node_t *node) {
   return node->padding.left;
 }
 
-double render_tree_node_get_padding_right(const struct node_t *node) {
+double rendertree_node_get_padding_right(const struct node_t *node) {
   return node->padding.right;
 }
 
-double render_tree_node_get_padding_bottom(const struct node_t *node) {
+double rendertree_node_get_padding_bottom(const struct node_t *node) {
   return node->padding.bottom;
 }
 
-void render_tree_node_free(struct node_t **node) {
+void rendertree_node_free(struct node_t **node) {
   free(*node);
   *node = NULL;
 }