Changeset 0cf5b79 for src/libcfa/bits/containers.h

Timestamp:

Nov 20, 2017, 12:12:34 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

fdd3786

Parents:

b7f8cb4

Message:

Added generic containers for runtime.
Moved some internal code to bits folder.
consistently used cforall instead of CFORALL define.

File:

• src/libcfa/bits/containers.h (modified) (10 diffs)

src/libcfa/bits/containers.h

@@ -15 +15 @@
 #pragma once
 
-#include <stddef.h>
+#include "bits/defs.h"
+#include "libhdr.h"
 
-#include "libhdr.h"
+//-----------------------------------------------------------------------------
+// Array
+//-----------------------------------------------------------------------------
+
+#ifdef __cforall
+        forall(dtype T)
+#else
+        #define T void
+#endif
+struct __small_array {
+        T *           data;
+        __lock_size_t size;
+};
+#undef T
+
+#ifdef __cforall
+        #define __small_array_t(T) __small_array(T)
+#else
+        #define __small_array_t(T) struct __small_array
+#endif
+
+#ifdef __cforall
+        // forall(otype T | sized(T))
+        // static inline void ?{}(__small_array(T) & this) {}
+
+        forall(dtype T | sized(T))
+        static inline T& ?[?]( __small_array(T) & this, __lock_size_t idx) {
+                return ((typeof(this.data))this.data)[idx];
+        }
+
+        forall(dtype T | sized(T))
+        static inline T& ?[?]( const __small_array(T) & this, __lock_size_t idx) {
+                return ((typeof(this.data))this.data)[idx];
+        }
+
+        forall(dtype T | sized(T))
+        static inline T* begin( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data);
+        }
+
+        forall(dtype T | sized(T))
+        static inline T* end( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data) + this.size;
+        }
+#endif
 
 //-----------------------------------------------------------------------------
@@ -23 +68 @@
 //-----------------------------------------------------------------------------
 
-#ifdef __CFORALL__
+#ifdef __cforall
         trait is_node(dtype T) {
                 T*& get_next( T& );
@@ -32 +77 @@
 // Stack
 //-----------------------------------------------------------------------------
-#ifdef __CFORALL__
+#ifdef __cforall
         forall(dtype TYPE | is_node(TYPE))
         #define T TYPE
@@ -41 +86 @@
         T * top;
 };
+#undef T
 
-#ifdef __CFORALL__
+#ifdef __cforall
 #define __stack_t(T) __stack(T)
 #else
@@ -48 +94 @@
 #endif
 
-#ifdef __CFORALL__
+#ifdef __cforall
         forall(dtype T | is_node(T))
-        void ?{}( __stack(T) & this ) {
-                this.top = NULL;
+        static inline void ?{}( __stack(T) & this ) {
+                (this.top){ NULL };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        void push( __stack(T) & this, T * val ) {
+        static inline void push( __stack(T) & this, T * val ) {
                 verify( !get_next( *val ) );
                 get_next( *val ) = this.top;
@@ -62 +108 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * pop( __stack(T) & this ) {
+        static inline T * pop( __stack(T) & this ) {
                 T * top = this.top;
                 if( top ) {
@@ -75 +121 @@
 // Queue
 //-----------------------------------------------------------------------------
-#ifdef __CFORALL__
-        forall(dtype T | is_node(T))
+#ifdef __cforall
+        forall(dtype TYPE | is_node(TYPE))
         #define T TYPE
 #else
@@ -85 +131 @@
         T ** tail;
 };
+#undef T
 
-#ifdef __CFORALL__
+#ifdef __cforall
+#define __queue_t(T) __queue(T)
+#else
+#define __queue_t(T) struct __queue
+#endif
+
+#ifdef __cforall
         forall(dtype T | is_node(T))
-        void ?{}( __queue(T) & this ) {
-                this.head = NULL;
-                this.tail = &this.head;
+        static inline void ?{}( __queue(T) & this ) {
+                (this.head){ NULL };
+                (this.tail){ &this.head };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        void append( __queue(T) & this, T * val ) {
+        static inline void append( __queue(T) & this, T * val ) {
                 verify(this.tail != NULL);
                 *this.tail = val;
@@ -101 +154 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * pop_head( __queue(T) & this ) {
+        static inline T * pop_head( __queue(T) & this ) {
                 T * head = this.head;
                 if( head ) {
@@ -114 +167 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * remove( __queue(T) & this, T ** it ) {
+        static inline T * remove( __queue(T) & this, T ** it ) {
                 T * val = *it;
                 verify( val );