More compliance with C11.

author: 3gg <3gg@shellblade.net> 2023-02-04 18:15:15 -0800
committer: 3gg <3gg@shellblade.net> 2023-02-04 18:15:15 -0800
commit: c5aecf2d5a8b29c8b960380255d3a74982ad1f67 (patch)
tree: 2e01ad0b466207b0fc453846aa88855abf87c224
parent: ca9cfa9be4c70be879d5a2fb0cfef8a70ddda00d (diff)
1 files changed, 39 insertions, 39 deletions
diff --git a/gfx/src/scene/scene_graph.h b/gfx/src/scene/scene_graph.h
index 93d2e38..a26f828 100644
--- a/gfx/src/scene/scene_graph.h
+++ b/gfx/src/scene/scene_graph.h
@@ -44,50 +44,50 @@
 /// - The node's parent cannot be the node's child or sibling, unless it's 0.
 /// - If the node has a parent and the node is the leftmost sibling, then the
 ///   parent's child is the node.
-#define ASSERT_TREE_NODE_INVARIANT(ITEM)                        \
+#define ASSERT_TREE_NODE_INVARIANT(ITEM)                            \
-  {                                                             \
+  {                                                                 \
-    const gfx_idx item_idx = MEM_GET_INDEX(ITEM).val;           \
+    const gfx_idx item_idx = MEM_GET_INDEX(ITEM).val;               \
-    assert((ITEM)->prev.val != item_idx);                       \
+    assert((ITEM)->prev.val != item_idx);                           \
-    assert((ITEM)->next.val != item_idx);                       \
+    assert((ITEM)->next.val != item_idx);                           \
-    if ((ITEM)->prev.val) {                                     \
+    if ((ITEM)->prev.val) {                                         \
-      assert((ITEM)->prev.val != (ITEM)->next.val);             \
+      assert((ITEM)->prev.val != (ITEM)->next.val);                 \
-    }                                                           \
+    }                                                               \
-    if ((ITEM)->child.val) {                                    \
+    if ((ITEM)->child.val) {                                        \
-      assert((ITEM)->child.val != (ITEM)->prev.val);            \
+      assert((ITEM)->child.val != (ITEM)->prev.val);                \
-      assert((ITEM)->child.val != (ITEM)->next.val);            \
+      assert((ITEM)->child.val != (ITEM)->next.val);                \
-    }                                                           \
+    }                                                               \
-    assert((ITEM)->parent.val != item_idx);                     \
+    assert((ITEM)->parent.val != item_idx);                         \
-    if ((ITEM)->parent.val && !(ITEM)->prev.val) {              \
+    if ((ITEM)->parent.val && !(ITEM)->prev.val) {                  \
-      assert((ITEM)->parent.val != (ITEM)->prev.val);           \
+      assert((ITEM)->parent.val != (ITEM)->prev.val);               \
-      assert((ITEM)->parent.val != (ITEM)->next.val);           \
+      assert((ITEM)->parent.val != (ITEM)->next.val);               \
-      const typeof(ITEM) item_parent = MEM_GET((ITEM)->parent); \
+      const __typeof__(ITEM) item_parent = MEM_GET((ITEM)->parent); \
-      assert(item_parent->child.val == item_idx);               \
+      assert(item_parent->child.val == item_idx);                   \
-    }                                                           \
+    }                                                               \
  }
 /// Prepend an item to a list.
 /// Modify HEAD_INDEX to equal the index of the new head.
-#define LIST_PREPEND(HEAD_INDEX, ITEM)           \
+#define LIST_PREPEND(HEAD_INDEX, ITEM)               \
-  (ITEM)->next = HEAD_INDEX;                     \
+  (ITEM)->next = HEAD_INDEX;                         \
-  if (HEAD_INDEX.val) {                          \
+  if (HEAD_INDEX.val) {                              \
-    typeof(ITEM) old_head = MEM_GET(HEAD_INDEX); \
+    __typeof__(ITEM) old_head = MEM_GET(HEAD_INDEX); \
-    old_head->prev        = MEM_GET_INDEX(ITEM); \
+    old_head->prev            = MEM_GET_INDEX(ITEM); \
-  }                                              \
+  }                                                  \
-  HEAD_INDEX = MEM_GET_INDEX(ITEM);              \
+  HEAD_INDEX = MEM_GET_INDEX(ITEM);                  \
  ASSERT_LIST_NODE_INVARIANT(ITEM);
 /// Disconnect an item from its siblings.
-#define LIST_REMOVE(ITEM)                              \
+#define LIST_REMOVE(ITEM)                                  \
-  if ((ITEM)->prev.val) {                              \
+  if ((ITEM)->prev.val) {                                  \
-    typeof(ITEM) prev_sibling = MEM_GET((ITEM)->prev); \
+    __typeof__(ITEM) prev_sibling = MEM_GET((ITEM)->prev); \
-    prev_sibling->next        = (ITEM)->next;          \
+    prev_sibling->next            = (ITEM)->next;          \
-  }                                                    \
+  }                                                        \
-  if ((ITEM)->next.val) {                              \
+  if ((ITEM)->next.val) {                                  \
-    typeof(ITEM) next_sibling = MEM_GET((ITEM)->next); \
+    __typeof__(ITEM) next_sibling = MEM_GET((ITEM)->next); \
-    next_sibling->prev        = (ITEM)->prev;          \
+    next_sibling->prev            = (ITEM)->prev;          \
-  }                                                    \
+  }                                                        \
-  (ITEM)->prev.val = 0;                                \
+  (ITEM)->prev.val = 0;                                    \
-  (ITEM)->next.val = 0;                                \
+  (ITEM)->next.val = 0;                                    \
  ASSERT_LIST_NODE_INVARIANT(ITEM);
 /// Set the child's parent.
@@ -126,8 +126,8 @@
    /* The parent points only to its first/leftmost child. If this item is */ \
    /* the leftmost sibling, then we need to rewire the parent to point to */ \
    /* the next sibling to keep the parent connected to its children. */      \
-    typeof(ITEM)       parent       = MEM_GET((ITEM)->parent);                \
+    __typeof__(ITEM)       parent       = MEM_GET((ITEM)->parent);            \
-    const typeof(ITEM) parent_child = MEM_GET(parent->child);                 \
+    const __typeof__(ITEM) parent_child = MEM_GET(parent->child);             \
    if (parent_child == ITEM) {                                               \
      assert((ITEM)->prev.val == 0);                                          \
      parent->child = (ITEM)->next;                                           \
author	3gg <3gg@shellblade.net>	2023-02-04 18:15:15 -0800
committer	3gg <3gg@shellblade.net>	2023-02-04 18:15:15 -0800
commit	c5aecf2d5a8b29c8b960380255d3a74982ad1f67 (patch)
tree	2e01ad0b466207b0fc453846aa88855abf87c224
parent	ca9cfa9be4c70be879d5a2fb0cfef8a70ddda00d (diff)

diff --git a/gfx/src/scene/scene_graph.h b/gfx/src/scene/scene_graph.h index 93d2e38..a26f828 100644 --- a/gfx/src/scene/scene_graph.h +++ b/gfx/src/scene/scene_graph.h
@@ -44,50 +44,50 @@
44	/// - The node's parent cannot be the node's child or sibling, unless it's 0.	44	/// - The node's parent cannot be the node's child or sibling, unless it's 0.
45	/// - If the node has a parent and the node is the leftmost sibling, then the	45	/// - If the node has a parent and the node is the leftmost sibling, then the
46	/// parent's child is the node.	46	/// parent's child is the node.
47	#define ASSERT_TREE_NODE_INVARIANT(ITEM) \	47	#define ASSERT_TREE_NODE_INVARIANT(ITEM) \
48	{ \	48	{ \
49	const gfx_idx item_idx = MEM_GET_INDEX(ITEM).val; \	49	const gfx_idx item_idx = MEM_GET_INDEX(ITEM).val; \
50	assert((ITEM)->prev.val != item_idx); \	50	assert((ITEM)->prev.val != item_idx); \
51	assert((ITEM)->next.val != item_idx); \	51	assert((ITEM)->next.val != item_idx); \
52	if ((ITEM)->prev.val) { \	52	if ((ITEM)->prev.val) { \
53	assert((ITEM)->prev.val != (ITEM)->next.val); \	53	assert((ITEM)->prev.val != (ITEM)->next.val); \
54	} \	54	} \
55	if ((ITEM)->child.val) { \	55	if ((ITEM)->child.val) { \
56	assert((ITEM)->child.val != (ITEM)->prev.val); \	56	assert((ITEM)->child.val != (ITEM)->prev.val); \
57	assert((ITEM)->child.val != (ITEM)->next.val); \	57	assert((ITEM)->child.val != (ITEM)->next.val); \
58	} \	58	} \
59	assert((ITEM)->parent.val != item_idx); \	59	assert((ITEM)->parent.val != item_idx); \
60	if ((ITEM)->parent.val && !(ITEM)->prev.val) { \	60	if ((ITEM)->parent.val && !(ITEM)->prev.val) { \
61	assert((ITEM)->parent.val != (ITEM)->prev.val); \	61	assert((ITEM)->parent.val != (ITEM)->prev.val); \
62	assert((ITEM)->parent.val != (ITEM)->next.val); \	62	assert((ITEM)->parent.val != (ITEM)->next.val); \
63	const typeof(ITEM) item_parent = MEM_GET((ITEM)->parent); \	63	const __typeof__(ITEM) item_parent = MEM_GET((ITEM)->parent); \
64	assert(item_parent->child.val == item_idx); \	64	assert(item_parent->child.val == item_idx); \
65	} \	65	} \
66	}	66	}
67		67
68	/// Prepend an item to a list.	68	/// Prepend an item to a list.
69	/// Modify HEAD_INDEX to equal the index of the new head.	69	/// Modify HEAD_INDEX to equal the index of the new head.
70	#define LIST_PREPEND(HEAD_INDEX, ITEM) \	70	#define LIST_PREPEND(HEAD_INDEX, ITEM) \
71	(ITEM)->next = HEAD_INDEX; \	71	(ITEM)->next = HEAD_INDEX; \
72	if (HEAD_INDEX.val) { \	72	if (HEAD_INDEX.val) { \
73	typeof(ITEM) old_head = MEM_GET(HEAD_INDEX); \	73	__typeof__(ITEM) old_head = MEM_GET(HEAD_INDEX); \
74	old_head->prev = MEM_GET_INDEX(ITEM); \	74	old_head->prev = MEM_GET_INDEX(ITEM); \
75	} \	75	} \
76	HEAD_INDEX = MEM_GET_INDEX(ITEM); \	76	HEAD_INDEX = MEM_GET_INDEX(ITEM); \
77	ASSERT_LIST_NODE_INVARIANT(ITEM);	77	ASSERT_LIST_NODE_INVARIANT(ITEM);
78		78
79	/// Disconnect an item from its siblings.	79	/// Disconnect an item from its siblings.
80	#define LIST_REMOVE(ITEM) \	80	#define LIST_REMOVE(ITEM) \
81	if ((ITEM)->prev.val) { \	81	if ((ITEM)->prev.val) { \
82	typeof(ITEM) prev_sibling = MEM_GET((ITEM)->prev); \	82	__typeof__(ITEM) prev_sibling = MEM_GET((ITEM)->prev); \
83	prev_sibling->next = (ITEM)->next; \	83	prev_sibling->next = (ITEM)->next; \
84	} \	84	} \
85	if ((ITEM)->next.val) { \	85	if ((ITEM)->next.val) { \
86	typeof(ITEM) next_sibling = MEM_GET((ITEM)->next); \	86	__typeof__(ITEM) next_sibling = MEM_GET((ITEM)->next); \
87	next_sibling->prev = (ITEM)->prev; \	87	next_sibling->prev = (ITEM)->prev; \
88	} \	88	} \
89	(ITEM)->prev.val = 0; \	89	(ITEM)->prev.val = 0; \
90	(ITEM)->next.val = 0; \	90	(ITEM)->next.val = 0; \
91	ASSERT_LIST_NODE_INVARIANT(ITEM);	91	ASSERT_LIST_NODE_INVARIANT(ITEM);
92		92
93	/// Set the child's parent.	93	/// Set the child's parent.
@@ -126,8 +126,8 @@
126	/* The parent points only to its first/leftmost child. If this item is */ \	126	/* The parent points only to its first/leftmost child. If this item is */ \
127	/* the leftmost sibling, then we need to rewire the parent to point to */ \	127	/* the leftmost sibling, then we need to rewire the parent to point to */ \
128	/* the next sibling to keep the parent connected to its children. */ \	128	/* the next sibling to keep the parent connected to its children. */ \
129	typeof(ITEM) parent = MEM_GET((ITEM)->parent); \	129	__typeof__(ITEM) parent = MEM_GET((ITEM)->parent); \
130	const typeof(ITEM) parent_child = MEM_GET(parent->child); \	130	const __typeof__(ITEM) parent_child = MEM_GET(parent->child); \
131	if (parent_child == ITEM) { \	131	if (parent_child == ITEM) { \
132	assert((ITEM)->prev.val == 0); \	132	assert((ITEM)->prev.val == 0); \
133	parent->child = (ITEM)->next; \	133	parent->child = (ITEM)->next; \