Changeset 81e8ab0 for doc/papers/general/Paper.tex

Timestamp:

Mar 9, 2018, 9:30:47 AM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, 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:

8b001bd

Parents:

29db723

Message:

more updates

File:

• doc/papers/general/Paper.tex (modified) (14 diffs)

doc/papers/general/Paper.tex

@@ -836 +836 @@
 % \end{cfa}
 % so the thunk provides flattening and structuring conversions to inferred functions, improving the compatibility of tuples and polymorphism.
-% These thunks are generated locally using gcc nested-functions, rather hositing them to the external scope, so they can easily access local state.
+% These thunks are generated locally using gcc nested-functions, rather hoisting them to the external scope, so they can easily access local state.
 
 
@@ -1167 +1167 @@
 \lstMakeShortInline@%
 \end{cquote}
-The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structor, \ie it must be at the same level as the @case@ clauses;
+The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structure, \ie it must be at the same level as the @case@ clauses;
 the target label may be case @default@.
 
@@ -2719 +2719 @@
 
 \CC is the best known C-based language, and is similar to \CFA in that both are extensions to C with source and runtime backwards compatibility.
-Specific difference between \CFA and \CC have been identified in prior sections, with a final observation that \CFA has equal or few tokens to express the same notion in several cases.
-The key difference between design philosophies is that \CFA is easier for C programmers to understand, by maintaining a procedural paradigm and avoiding complex interactions among extensions.
+Specific difference between \CFA and \CC have been identified in prior sections, with a final observation that \CFA has equal or fewer tokens to express the same notion in many cases.
+The key difference in design philosophies is that \CFA is easier for C programmers to understand by maintaining a procedural paradigm and avoiding complex interactions among extensions.
 \CC, on the other hand, has multiple overlapping features (such as the three forms of polymorphism), many of which have complex interactions with its object-oriented design. 
-As a result, \CC has a steep learning curve for even experienced C programmers, especially when attempting to maintain performance equivalent to C legacy code.
+As a result, \CC has a steep learning curve for even experienced C programmers, especially when attempting to maintain performance equivalent to C legacy-code.
 
 There are several other C extension-languages with less usage and even more dramatic changes than \CC. 
@@ -2728 +2728 @@
 Other languages extend C with more focused features. 
 CUDA~\cite{Nickolls08}, ispc~\cite{Pharr12}, and Sierra~\cite{Leissa14} add data-parallel primitives to C or \CC;
-such features have not yet been added to \CFA, but are not precluded by the design.
-Finaly, some C extensions (or suggested extensions) attempt to provide a more memory-safe C~\cite{Boehm88};
-type-checked polymorphism in \CFA covers several of C's memory-safety holes, but more aggressive approaches such as annotating all pointer types with their nullability are contradictory to \CFA's backwards compatibility goals.
+such features have not yet been added to \CFA, but are easily incorporated within its design.
+Finally, some C extensions (or suggested extensions) attempt to provide a more memory-safe C~\cite{Boehm88,Rafkind09};
+type-checked polymorphism in \CFA covers several of C's memory-safety issues, but more aggressive approaches such as annotating all pointer types with their nullability are contradictory to \CFA's backwards compatibility goals.
 
 
@@ -2807 +2807 @@
 struct stack { struct stack_node* head; };
 struct stack new_stack() { return (struct stack){ NULL }; /***/ }
+void clear_stack( struct stack * s, void (*free_el)( void * ) ) {
+        for ( struct stack_node * next = s->head; next; ) {
+                struct stack_node * crnt = next;
+                next = crnt->next;
+                free_el( crnt->value );
+                free( crnt );
+        }
+        s->head = NULL;
+}
 void copy_stack( struct stack * s, const struct stack * t, void * (*copy)( const void * ) ) {
         struct stack_node ** crnt = &s->head;
@@ -2825 +2834 @@
         struct stack_node * n = s->head;
         s->head = n->next;
-        void * x = n->value;
+        void * v = n->value;
         free( n );
-        return x;
-}
-void clear_stack( struct stack * s, void (*free_el)( void * ) ) {
-        for ( struct stack_node * next = s->head; next; ) {
-                struct stack_node * crnt = next;
-                next = crnt->next;
-                free_el( crnt->value );
-                free( crnt );
-        }
-        s->head = NULL;
+        return v;
 }
 \end{cfa}
@@ -2858 +2858 @@
         *crnt = 0;
 }
-forall( otype T ) stack(T) ?=?( stack(T) & s, stack(T) t ) {
-        if ( s.head == t.head ) return s;
-        clear( s );
-        s{ t };
-        return s;
-}
-forall( otype T ) void ^?{}( stack(T) & s) { clear( s ); }
-forall( otype T ) _Bool empty( const stack(T) & s ) { return s.head == 0; }
-forall( otype T ) void push( stack(T) & s, T value ) with( s ) {
-        stack_node(T) * n = alloc();
-        (*n){ value, head };
-        head = n;
-}
-forall( otype T ) T pop( stack(T) & s ) with( s ) {
-        stack_node(T) * n = head;
-        head = n->next;
-        T v = n->value;
-        ^(*n){};
-        free( n );
-        return v;
-}
 forall( otype T ) void clear( stack(T) & s ) with( s ) {
         for ( stack_node(T) * next = head; next; ) {
@@ -2888 +2867 @@
         head = 0;
 }
+forall( otype T ) stack(T) ?=?( stack(T) & s, stack(T) t ) {
+        if ( s.head == t.head ) return s;
+        clear( s );
+        s{ t };
+        return s;
+}
+forall( otype T ) void ^?{}( stack(T) & s) { clear( s ); }
+forall( otype T ) _Bool empty( const stack(T) & s ) { return s.head == 0; }
+forall( otype T ) void push( stack(T) & s, T value ) with( s ) {
+        stack_node(T) * n = alloc();
+        (*n){ value, head };
+        head = n;
+}
+forall( otype T ) T pop( stack(T) & s ) with( s ) {
+        stack_node(T) * n = head;
+        head = n->next;
+        T v = n->value;
+        ^(*n){};
+        free( n );
+        return v;
+}
 \end{cfa}
 
@@ -2897 +2897 @@
                 T value;
                 node * next;
-                node( const T & v, node * n = nullptr ) : value( v), next( n) {}
+                node( const T & v, node * n = nullptr ) : value( v ), next( n ) {}
         };
         node * head;
-        void copy( const stack<T> & o) {
+        stack() : head( nullptr ) {}
+        stack( const stack<T> & o) { copy( o ); }
+        stack( stack<T> && o ) : head( o.head ) { o.head = nullptr; }
+        void copy( const stack<T> & o ) {
                 node ** crnt = &head;
-                for ( node * next = o.head;; next; next = next->next ) {
+                for ( node * next = o.head; next; next = next->next ) {
                         *crnt = new node{ next->value }; /***/
                         crnt = &(*crnt)->next;
                 }
                 *crnt = nullptr;
-        }
-        stack() : head( nullptr) {}
-        stack( const stack<T> & o) { copy( o); }
-        stack( stack<T> && o) : head( o.head) { o.head = nullptr; }
-        ~stack() { clear(); }
-        stack & operator= ( const stack<T> & o) {
-                if ( this == &o ) return *this;
-                clear();
-                copy( o);
-                return *this;
-        }
-        stack & operator= ( stack<T> && o) {
-                if ( this == &o ) return *this;
-                head = o.head;
-                o.head = nullptr;
-                return *this;
-        }
-        bool empty() const { return head == nullptr; }
-        void push( const T & value) { head = new node{ value, head };  /***/ }
-        T pop() {
-                node * n = head;
-                head = n->next;
-                T x = std::move( n->value);
-                delete n;
-                return x;
         }
         void clear() {
@@ -2941 +2919 @@
                 head = nullptr;
         }
+        ~stack() { clear(); }
+        stack & operator= ( const stack<T> & o ) {
+                if ( this == &o ) return *this;
+                clear();
+                copy( o );
+                return *this;
+        }
+        stack & operator= ( stack<T> && o ) {
+                if ( this == &o ) return *this;
+                head = o.head;
+                o.head = nullptr;
+                return *this;
+        }
+        bool empty() const { return head == nullptr; }
+        void push( const T & value ) { head = new node{ value, head };  /***/ }
+        T pop() {
+                node * n = head;
+                head = n->next;
+                T v = std::move( n->value );
+                delete n;
+                return v;
+        }
 };
 \end{cfa}
@@ -2950 +2950 @@
         struct node {
                 ptr<object> value;
-                node* next;
-                node( const object & v, node * n ) : value( v.new_copy() ), next( n ) {}
+                node * next;
+                node( const object & v, node * n = nullptr ) : value( v.new_copy() ), next( n ) {}
         };
-        node* head;
+        node * head;
         void copy( const stack & o ) {
                 node ** crnt = &head;
@@ -2962 +2962 @@
                 *crnt = nullptr;
         }
+        void clear() {
+                for ( node * next = head; next; ) {
+                        node * crnt = next;
+                        next = crnt->next;
+                        delete crnt;
+                }
+                head = nullptr;
+        }
         stack() : head( nullptr ) {}
         stack( const stack & o ) { copy( o ); }
         stack( stack && o ) : head( o.head ) { o.head = nullptr; }
         ~stack() { clear(); }
-        stack & operator= ( const stack & o ) {
+        stack & operator=( const stack & o ) {
                 if ( this == &o ) return *this;
                 clear();
@@ -2972 +2980 @@
                 return *this;
         }
-        stack & operator= ( stack && o ) {
+        stack & operator=( stack && o ) {
                 if ( this == &o ) return *this;
                 head = o.head;
@@ -2983 +2991 @@
                 node * n = head;
                 head = n->next;
-                ptr<object> x = std::move( n->value );
+                ptr<object> v = std::move( n->value );
                 delete n;
-                return x;
-        }
-        void clear() {
-                for ( node * next = head; next; ) {
-                        node * crnt = next;
-                        next = crnt->next;
-                        delete crnt;
-                }
-                head = nullptr;
+                return v;
         }
 };