Context Navigation

-                      r553f8abe
+                      r4ed7946e
 \label{c:existing}
 \CFA (C-for-all)~\cite{Cforall} is an open-source project extending ISO C with
+\CFA is an open-source project extending ISO C with
 modern safety and productivity features, while still ensuring backwards
 compatibility with C and its programmers.  \CFA is designed to have an
 …
 existing C code-base allowing programmers to learn \CFA on an as-needed basis.
 Only those \CFA features pertinent to this thesis are discussed.  Many of the
+Only those \CFA features pertaining to this thesis are discussed.  Many of the
 \CFA syntactic and semantic features used in the thesis should be fairly
 obvious to the reader.
 …
 // name mangling on by default
 int i; // _X1ii_1
 extern "C" {  // disables name mangling
+@extern "C"@ {  // disables name mangling
         int j; // j
         extern "Cforall" {  // enables name mangling
+        @extern "Cforall"@ {  // enables name mangling
                 int k; // _X1ki_1
+        }
 …
 \CFA adds a reference type to C as an auto-dereferencing pointer.
 They work very similarly to pointers.
 Reference-types are written the same way as a pointer-type is but each
+Reference-types are written the same way as a pointer-type but each
 asterisk (@*@) is replaced with a ampersand (@&@);
+this includes cv-qualifiers and multiple levels of reference.
+They are intended for cases where you would want to use pointers but would
+be dereferencing them (almost) every usage.
+In most cases a reference can just be thought of as a pointer that
+automatically puts a dereference infront of each of its uses (per-level of
+reference).
+The address-of operator (@&@) acts as an escape and removes one of the
+automatic dereference operations.
+Mutable references may be assigned to by converting them to a pointer
+with a @&@ and then assigning a pointer too them.
+\begin{minipage}{0,45\textwidth}
+this includes cv-qualifiers and multiple levels of reference, \eg:
+\begin{minipage}{0,5\textwidth}
 With references:
 \begin{cfa}
 …
 int && rri = ri;
 rri = 3;
 &ri = &j;
+&ri = &j; // reference assignment
 ri = 5;
 \end{cfa}
 \end{minipage}
 \begin{minipage}{0,45\textwidth}
+\begin{minipage}{0,5\textwidth}
 With pointers:
 \begin{cfa}
 …
 int ** ppi = &pi;
 **ppi = 3;
 pi = &j;
+pi = &j; // pointer assignment
 *pi = 5;
 \end{cfa}
 \end{minipage}
+\section{Constructors and Destructors}
+Both constructors and destructors are operators, which means they are
+functions with special operator names rather than type names in \Cpp. The
+special operator names may be used to call the functions explicitly (not
+allowed in \Cpp for constructors).
+References are intended for cases where you would want to use pointers but would
+be dereferencing them (almost) every usage.
+In most cases a reference can just be thought of as a pointer that
+automatically puts a dereference in front of each of its uses (per-level of
+reference).
+The address-of operator (@&@) acts as an escape and removes one of the
+automatic dereference operations.
+Mutable references may be assigned by converting them to a pointer
+with a @&@ and then assigning a pointer to them, as in @&ri = &j;@ above.
+\section{Operators}
 In general, operator names in \CFA are constructed by bracketing an operator
 …
 (such as @++?@) and post-fix operations (@?++@).
+The special name for a constructor is @?{}@, which comes from the
+initialization syntax in C. That initialation syntax is also the operator
+form. \CFA will generate a constructor call each time a variable is declared,
+passing the initialization arguments to the constructort.
+\begin{cfa}
+struct Example { ... };
+void ?{}(Example & this) { ... }
+{
+        Example a;
+        Example b = {};
+}
+void ?{}(Example & this, char first, int num) { ... }
+{
+        Example c = {'a', 2};
+}
+\end{cfa}
+Both @a@ and @b@ will be initalized with the first constructor (there is no
+general way to skip initialation) while @c@ will be initalized with the
+second.
+An operator name may describe any function signature (it is just a name) but
+only certain signatures may be called in operator form.
+\begin{cfa}
+int ?+?( int i, int j, int k ) { return i + j + k; }
+{
+        sout | ?+?( 3, 4, 5 ); // no infix form
+}
+\end{cfa}
+Some ``near-misses" for unary/binary operator prototypes generate warnings.
+Both constructors and destructors are operators, which means they are
+functions with special operator names rather than type names in \Cpp. The
+special operator names may be used to call the functions explicitly (not
+allowed in \Cpp for constructors).
+The special name for a constructor is @?{}@, where the name @{}@ comes from the
+initialization syntax in C, \eg @Structure s = {...}@.
+% That initialization syntax is also the operator form.
+\CFA generates a constructor call each time a variable is declared,
+passing the initialization arguments to the constructor.
+\begin{cfa}
+struct Structure { ... };
+void ?{}(Structure & this) { ... }
+{
+        Structure a;
+        Structure b = {};
+}
+void ?{}(Structure & this, char first, int num) { ... }
+{
+        Structure c = {'a', 2};
+}
+\end{cfa}
+Both @a@ and @b@ are initialized with the first constructor,
+while @c@ is initialized with the second.
+Currently, there is no general way to skip initialization.
 % I don't like the \^{} symbol but $^\wedge$ isn't better.
 Similarly destructors use the special name @^?{}@ (the @^@ has no special
 meaning). They can be called explicatly as well but normally they are
 implicitly called on a variable when it goes out of scope.
 \begin{cfa}
 void ^?{}(Example & this) { ... }
+{
     Example d;
+Similarly, destructors use the special name @^?{}@ (the @^@ has no special
+meaning).  Normally, they are implicitly called on a variable when it goes out
+of scope but they can be called explicitly as well.
+\begin{cfa}
+void ^?{}(Structure & this) { ... }
+{
+        Structure d;
 } // <- implicit destructor call
 \end{cfa}
+No operator name is restricted in what function signatures they may be bound
+to although most of the forms cannot be called in operator form. Some
+``near-misses" will generate warnings.
+Whenever a type is defined, \CFA will create a default zero-argument
+Whenever a type is defined, \CFA creates a default zero-argument
 constructor, a copy constructor, a series of argument-per-field constructors
 and a destructor. All user constructors are defined after this.
 …
 char capital_a = identity( 'A' );
 \end{cfa}
 Each use of a polymorphic declaration will resolve its polymorphic parameters
+Each use of a polymorphic declaration resolves its polymorphic parameters
 (in this case, just @T@) to concrete types (@int@ in the first use and @char@
 in the second).
 …
 To allow a polymorphic function to be separately compiled, the type @T@ must be
 constrained by the operations used on @T@ in the function body. The @forall@
 clauses is augmented with a list of polymorphic variables (local type names)
+clause is augmented with a list of polymorphic variables (local type names)
 and assertions (constraints), which represent the required operations on those
 types used in a function, \eg:
 \begin{cfa}
 forall( T | { void do_once(T); })
+forall( T | { void do_once(T); } )
 void do_twice(T value) {
         do_once(value);
 …
 void do_once(double y) { ... }
 int quadruple(int x) {
+        void do_once(int y) { y = y * 2; }
+        do_twice(x);
+        void do_once(int y) { y = y * 2; } // replace global do_once
+        do_twice(x); // use local do_once
+        do_twice(x + 1.5); // use global do_once
         return x;
+}
 \end{cfa}
 Specifically, the complier deduces that @do_twice@'s T is an integer from the
 argument @x@. It then looks for the most specific definition matching the
+argument @x@. It then looks for the most \emph{specific} definition matching the
 assertion, which is the nested integral @do_once@ defined within the
 function. The matched assertion function is then passed as a function pointer
 to @do_twice@ and called within it.
 The global definition of @do_once@ is ignored.
+to @do_twice@ and called within it.  The global definition of @do_once@ is used
+for the second call because the float-point argument is a better match.
 To avoid typing long lists of assertions, constraints can be collect into
 …
 Each coroutine has a @main@ function, which takes a reference to a coroutine
 object and returns @void@.
 \begin{cfa}
+\begin{cfa}[numbers=left]
 void main(CountUp & this) {
     for (unsigned int next = 0 ; true ; ++next) {
+        for (unsigned int next = 0 ; true ; ++next) {
                 next = up;
                 suspend;$\label{suspend}$

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 4ed7946e for doc/theses/andrew_beach_MMath/existing.tex

Legend:

doc/theses/andrew_beach_MMath/existing.tex

Download in other formats: