Changeset 55da258 for libcfa/src/bits/containers.hfa

Timestamp:

Dec 3, 2020, 7:46:34 PM (4 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:

6855d14

Parents:

4011b98 (diff), 0797198 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

libcfa/src/bits/containers.hfa

@@ -17 +17 @@
 #include "bits/align.hfa"
 #include "bits/defs.hfa"
-
+#include <stdio.h>
 //-----------------------------------------------------------------------------
 // Array
@@ -146 +146 @@
         static inline forall( dtype T | is_node(T) ) {
                 void ?{}( __queue(T) & this ) with( this ) {
-                        head{ 1p };
-                        tail{ &head };
-                        verify(*tail == 1p);
+                        (this.head){ 1p };
+                        (this.tail){ &this.head };
+                        verify(*this.tail == 1p);
                 }
 
                 void append( __queue(T) & this, T * val ) with( this ) {
-                        verify(tail != 0p);
-                        verify(*tail == 1p);
-                        *tail = val;
-                        tail = &get_next( *val );
-                        *tail = 1p;
+                        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 * head = this.head;
-                        if( head != 1p ) {
+                        T * front = this.head;
+                        if( front != 1p ) {
                                 verify(*this.tail == 1p);
-                                return head;
+                                return front;
                         }
                         verify(*this.tail == 1p);
@@ -172 +172 @@
                 T * pop_head( __queue(T) & this ) {
                         verify(*this.tail == 1p);
-                        T * head = this.head;
-                        if( head != 1p ) {
-                                this.head = get_next( *head );
-                                if( get_next( *head ) == 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;
+                                get_next( *_head ) = 0p;
                                 verify(*this.tail == 1p);
-                                verify( get_next(*head) == 0p );
-                                return head;
+                                verify( get_next(*_head) == 0p );
+                                return _head;
                         }
                         verify(*this.tail == 1p);
@@ -193 +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 == 1p) == (&head == tail) );
-                        verify( *tail == 1p );
+                        verify( (this.head == 1p) == (&this.head == this.tail) );
+                        verify( *this.tail == 1p );
                         return val;
                 }
@@ -239 +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;
         }
@@ -248 +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;
@@ -264 +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;
                                 }
                         }