Changeset 4c80a75 for doc/papers/general/evaluation

Timestamp:

May 1, 2018, 9:17:06 AM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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, with_gc

Children:

1518b39, 7f0001c, 94dea96

Parents:

8a5bdf0

Message:

update evaluation programs

Location:

doc/papers/general/evaluation

Files:

• c-stack.c (modified) (2 diffs)
• c-stack.h (modified) (1 diff)
• cfa-stack.c (modified) (3 diffs)
• cfa-stack.h (modified) (1 diff)
• cpp-stack.hpp (modified) (3 diffs)
• cpp-vstack.cpp (modified) (3 diffs)
• cpp-vstack.hpp (modified) (1 diff)

doc/papers/general/evaluation/c-stack.c

@@ -27 +27 @@
 }
 
-stack new_stack() { return (stack){ NULL }; /***/ }
+stack new_stack() {
+        return (stack){ NULL }; /***/
+}
 
 stack * assign_stack( stack * s, const stack * t, 
@@ -37 +39 @@
 }
 
-_Bool stack_empty( const stack * s ) { return s->head == NULL; }
+_Bool stack_empty( const stack * s ) {
+        return s->head == NULL;
+}
 
 void push_stack( stack * s, void * v ) {

doc/papers/general/evaluation/c-stack.h

@@ -6 +6 @@
 } stack;
 
+void copy_stack(stack * dst, const stack * src, void * (* copy)(const void *));
+void clear_stack(stack * s, void (*free_el)(void *));
 stack new_stack();
-void copy_stack(stack * dst, const stack * src, void * (* copy)(const void *));
 stack * assign_stack( stack * dst, const stack * src, 
         void * (* copy_el)(const void *), void (* free_el)(void *));
-void clear_stack(stack * s, void (*free_el)(void *));
 
 _Bool stack_empty( const stack * s );

doc/papers/general/evaluation/cfa-stack.c

@@ -8 +8 @@
         };
 
-        void ?{}( stack(T) & s ) { (s.head){ 0 }; }
-
-        void ?{}( stack(T) & s, stack(T) t ) {
+        void ?{}( stack(T) & s, stack(T) t ) {          // copy
                 node(T) ** cr = &s.head;
                 for ( node(T) * nx = t.head; nx; nx = nx->next ) {
@@ -20 +18 @@
         }
 
-        void ^?{}( stack(T) & s) { clear( s ); }
-
-    void clear( stack(T) & s ) with( s ) {
+        void clear( stack(T) & s ) with( s ) {
                 for ( node(T) * nx = head; nx; ) {
                         node(T) * cr = nx;
                         nx = cr->next;
                         ^(*cr){};
-                        free(cr);
+                        free( cr );
                 }
                 head = 0;
         }
+
+        void ?{}( stack(T) & s ) { (s.head){ 0 }; }
+        void ^?{}( stack(T) & s) { clear( s ); }
 
         stack(T) ?=?( stack(T) & s, stack(T) t ) {
@@ -39 +38 @@
         }
 
-        _Bool empty( const stack(T) & s ) { return s.head == 0; }
+        _Bool empty( const stack(T) & s ) {
+                return s.head == 0;
+        }
 
         void push( stack(T) & s, T value ) with( s ) {

doc/papers/general/evaluation/cfa-stack.h

@@ -7 +7 @@
         };
 
+        void ?{}( stack(T) & s, stack(T) t );
+        void clear( stack(T) & s );
         void ?{}( stack(T) & s );
-        void ?{}( stack(T) & s, stack(T) t );
         void ^?{}( stack(T) & s);
-        void clear( stack(T) & s );
 
         stack(T) ?=?( stack(T) & s, stack(T) t );

doc/papers/general/evaluation/cpp-stack.hpp

@@ -10 +10 @@
         node * head;
 
-        stack() : head( nullptr ) {}
-        stack( const stack<T> & o ) { copy( o ); }
+        void copy( const stack<T> & o ) {
+                node ** cr = &head;
+                for ( node * nx = o.head; nx; nx = nx->next ) {
+                        *cr = new node{ nx->value }; /***/
+                        cr = &(*cr)->next;
+                }
+                *cr = nullptr;
+        }
 
         void clear() {
@@ -22 +28 @@
         }
 
-        void copy( const stack<T> & o ) {
-                node ** cr = &head;
-                for ( node * nx = o.head; nx; nx = nx->next ) {
-                        *cr = new node{ nx->value }; /***/
-                        cr = &(*cr)->next;
-                }
-                *cr = nullptr;
-        }
-
+        stack() : head( nullptr ) {}
+        stack( const stack<T> & o ) { copy( o ); }
         ~stack() { clear(); }
 
-        stack & operator= ( const stack<T> & o ) {
+        stack & operator=( const stack<T> & o ) {
                 if ( this == &o ) return *this;
                 clear();
@@ -40 +39 @@
         }
 
-        bool empty() const { return head == nullptr; }
+        bool empty() const {
+                return head == nullptr;
+        }
 
-        void push( const T & value ) { head = new node{ value, head };  /***/ }
+        void push( const T & value ) {
+                head = new node{ value, head };  /***/
+        }
 
         T pop() {

doc/papers/general/evaluation/cpp-vstack.cpp

@@ -3 +3 @@
 
 stack::node::node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {}
+
+void stack::copy( const stack & o ) {
+        node ** cr = &head;
+        for ( node * nx = o.head; nx; nx = nx->next ) {
+                *cr = new node{ *nx->value }; /***/
+                cr = &(*cr)->next;
+        }
+        *cr = nullptr;
+}
 
 void stack::clear() {
@@ -11 +20 @@
         }
         head = nullptr;
-}
-
-void stack::copy( const stack & o ) {
-        node ** cr = &head;
-        for ( node * nx = o.head; nx; nx = nx->next ) {
-                *cr = new node{ *nx->value }; /***/
-                cr = &(*cr)->next;
-        }
-        *cr = nullptr;
 }
 
@@ -33 +33 @@
 }
 
-bool stack::empty() const { return head == nullptr; }
+bool stack::empty() const {
+        return head == nullptr;
+}
 
-void stack::push( const object & value ) { head = new node{ value, head }; /***/ }
+void stack::push( const object & value ) {
+        head = new node{ value, head }; /***/
+}
 
 ptr<object> stack::pop() {

doc/papers/general/evaluation/cpp-vstack.hpp

@@ -10 +10 @@
         node * head;
 
+        void copy( const stack & o );
         void clear();
-        void copy( const stack & o );
 
         stack();