Changeset eef8dfb for libcfa/src/bits/containers.hfa

Timestamp:

Jan 7, 2021, 2:55:57 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

58fe85a

Parents:

bdfc032 (diff), 44e37ef (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into dkobets-vector

File:

• libcfa/src/bits/containers.hfa (modified) (8 diffs)

libcfa/src/bits/containers.hfa

@@ -17 +17 @@
 #include "bits/align.hfa"
 #include "bits/defs.hfa"
-
+#include <stdio.h>
 //-----------------------------------------------------------------------------
 // Array
@@ -36 +36 @@
         #define __small_array_t(T) __small_array(T)
 #else
-        #define __small_array_t(T) struct __small_array
+        #define __small_array_t(T) __small_array
 #endif
 
@@ -146 +146 @@
         static inline forall( dtype T | is_node(T) ) {
                 void ?{}( __queue(T) & this ) with( this ) {
-                        head{ 0p };
-                        tail{ &head };
+                        (this.head){ 1p };
+                        (this.tail){ &this.head };
+                        verify(*this.tail == 1p);
                 }
 
                 void append( __queue(T) & this, T * val ) with( this ) {
-                        verify(tail != 0p);
-                        *tail = val;
-                        tail = &get_next( *val );
+                        verify(this.tail != 0p);
+                        verify(*this.tail == 1p);
+                        *this.tail = val;
+                        this.tail = &get_next( *val );
+                        *this.tail = 1p;
+                }
+
+                T * peek( __queue(T) & this ) {
+                        verify(*this.tail == 1p);
+                        T * front = this.head;
+                        if( front != 1p ) {
+                                verify(*this.tail == 1p);
+                                return front;
+                        }
+                        verify(*this.tail == 1p);
+                        return 0p;
                 }
 
                 T * pop_head( __queue(T) & this ) {
-                        T * head = this.head;
-                        if( head ) {
-                                this.head = get_next( *head );
-                                if( !get_next( *head ) ) {
+                        verify(*this.tail == 1p);
+                        T * _head = this.head;
+                        if( _head != 1p ) {
+                                this.head = get_next( *_head );
+                                if( get_next( *_head ) == 1p ) {
                                         this.tail = &this.head;
                                 }
-                                get_next( *head ) = 0p;
-                        }
-                        return head;
+                                get_next( *_head ) = 0p;
+                                verify(*this.tail == 1p);
+                                verify( get_next(*_head) == 0p );
+                                return _head;
+                        }
+                        verify(*this.tail == 1p);
+                        return 0p;
                 }
 
@@ -174 +193 @@
                         (*it) = get_next( *val );
 
-                        if( tail == &get_next( *val ) ) {
-                                tail = it;
+                        if( this.tail == &get_next( *val ) ) {
+                                this.tail = it;
                         }
 
                         get_next( *val ) = 0p;
 
-                        verify( (head == 0p) == (&head == tail) );
-                        verify( *tail == 0p );
+                        verify( (this.head == 1p) == (&this.head == this.tail) );
+                        verify( *this.tail == 1p );
                         return val;
                 }
 
                 int ?!=?( const __queue(T) & this, __attribute__((unused)) zero_t zero ) {
-                        return this.head != 0;
+                        return this.head != 1p;
                 }
         }
@@ -220 +239 @@
         forall(dtype T )
         static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
-                this.head{ 0p };
+                (this.head){ 0p };
                 this.__get = __get;
         }
@@ -229 +248 @@
                 void push_front( __dllist(T) & this, T & node ) with( this ) {
                         verify(__get);
-                        if ( head ) {
-                                __get( node ).next = head;
-                                __get( node ).prev = __get( *head ).prev;
+                        if ( this.head ) {
+                                __get( node ).next = this.head;
+                                __get( node ).prev = __get( *this.head ).prev;
                                 // inserted node must be consistent before it is seen
                                 // prevent code movement across barrier
                                 asm( "" : : : "memory" );
-                                __get( *head ).prev = &node;
+                                __get( *this.head ).prev = &node;
                                 T & _prev = *__get( node ).prev;
                                 __get( _prev ).next = &node;
@@ -245 +264 @@
                         // prevent code movement across barrier
                         asm( "" : : : "memory" );
-                        head = &node;
+                        this.head = &node;
                 }
 
                 void remove( __dllist(T) & this, T & node ) with( this ) {
                         verify(__get);
-                        if ( &node == head ) {
-                                if ( __get( *head ).next == head ) {
-                                        head = 0p;
+                        if ( &node == this.head ) {
+                                if ( __get( *this.head ).next == this.head ) {
+                                        this.head = 0p;
                                 } else {
-                                        head = __get( *head ).next;
+                                        this.head = __get( *this.head ).next;
                                 }
                         }
@@ -266 +285 @@
                         return this.head != 0;
                 }
+
+                void move_to_front( __dllist(T) & src, __dllist(T) & dst, T & node ) {
+                        remove    (src, node);
+                        push_front(dst, node);
+                }
         }
         #undef next