Changes in / [e8b1f23c:34b6a7b6]

Location:

doc/theses/colby_parsons_MMAth

Files:

• Makefile (modified) (1 diff)
• style/style.tex (modified) (1 diff)
• text/CFA_intro.tex (modified) (13 diffs)
• thesis.tex (modified) (1 diff)

doc/theses/colby_parsons_MMAth/Makefile

@@ -96 +96 @@
 
 ${BASE}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${DATA} \
-                style/style.tex ${Macros}/common.tex ${Macros}/indexstyle local.bib ../../bibliography/pl.bib | ${Build}
+                ${Macros}/common.tex ${Macros}/indexstyle local.bib ../../bibliography/pl.bib | ${Build}
         # Must have *.aux file containing citations for bibtex
         if [ ! -r ${basename $@}.aux ] ; then ${LaTeX} ${basename $@}.tex ; fi

doc/theses/colby_parsons_MMAth/style/style.tex

@@ -1 +1 @@
 \input{common}
-\CFAStyle                                               % CFA code-style
-\lstset{language=CFA}                                   % default language
 
 \lstdefinestyle{defaultStyle}{

doc/theses/colby_parsons_MMAth/text/CFA_intro.tex

@@ -9 +9 @@
 \CFA is a layer over C, is transpiled to C and is largely considered to be an extension of C. 
 Beyond C, it adds productivity features, libraries, a type system, and many other language constructions. 
-However, \CFA stays true to C as a language, with most code revolving around @struct@'s and routines, and respects the same rules as C. 
-\CFA is not object oriented as it has no notion of @this@ and no classes or methods, but supports some object oriented adjacent ideas including costructors, destructors, and limited inheritance. 
+However, \CFA stays true to C as a language, with most code revolving around \code{struct}'s and routines, and respects the same rules as C. 
+\CFA is not object oriented as it has no notion of \code{this} and no classes or methods, but supports some object oriented adjacent ideas including costructors, destructors, and limited inheritance. 
 \CFA is rich with interesting features, but a subset that is pertinent to this work will be discussed.
 
@@ -17 +17 @@
 References in \CFA are a layer of syntactic sugar over pointers to reduce the number of ref/deref operations needed with pointer usage. 
 Some examples of references in \CFA are shown in Listing~\ref{l:cfa_ref}. 
-Another related item to note is that the \CFA equivalent of \CC's @nullptr@ is @0p@.
-
-\begin{cfa}[caption={Example of \CFA references},label={l:cfa_ref}]
+Another related item to note is that the \CFA equivalent of \CC's \code{nullptr} is \code{0p}.
+
+\begin{cfacode}[caption={Example of \CFA references},label={l:cfa_ref}]
 int i = 2;
-int & ref_i = i;        $\C[1.5in]{// declare ref to i}$
-int * ptr_i = &i;       $\C{// ptr to i}$
+int & ref_i = i;            // declare ref to i
+int * ptr_i = &i;           // ptr to i
 
 // address of ref_i is the same as address of i
 assert( &ref_i == ptr_i );
 
-int && ref_ref_i = ref_i;   $\C{// can have a ref to a ref}$
-ref_i = 3;                  $\C{// set i to 3}$
+int && ref_ref_i = ref_i;   // can have a ref to a ref
+ref_i = 3;                  // set i to 3
 int new_i = 4;
 
 // syntax to rebind ref_i (must cancel implicit deref)
-&ref_i = &new_i;        $\C{// (\&*)ref\_i = \&new\_i; (sets underlying ptr)}\CRT$
-\end{cfa}
+&ref_i = &new_i; // (&*)ref_i = &new_i; (sets underlying ptr)
+\end{cfacode}
 
 
@@ -43 +43 @@
 
 
-\begin{cfa}[caption={Example of \CFA function overloading},label={l:cfa_overload}]
+\begin{cfacode}[caption={Example of \CFA function overloading},label={l:cfa_overload}]
 int foo() { printf("A\n");  return 0;}
 int foo( int bar ) { printf("B\n"); return 1; }
@@ -57 +57 @@
     foo( a );               // prints 3
 }
-\end{cfa}
+\end{cfacode}
 
 
@@ -68 +68 @@
 
 
-\begin{cfa}[tabsize=3,caption={Usage of \CFA with statement},label={l:cfa_with}]
+\begin{cfacode}[tabsize=3,caption={Usage of \CFA with statement},label={l:cfa_with}]
 struct obj {
     int a, b, c;
@@ -100 +100 @@
     p.y = 2.71;
 }
-\end{cfa}
+\end{cfacode}
 
 
@@ -109 +109 @@
 
 
-\begin{cfa}[tabsize=3,caption={Example of \CFA operators},label={l:cfa_operate}]
+\begin{cfacode}[tabsize=3,caption={Example of \CFA operators},label={l:cfa_operate}]
 struct coord {
     double x;
@@ -125 +125 @@
         (op2.x*op2.x + op2.y*op2.y + op2.z*op2.z);
 }
-\end{cfa}
+\end{cfacode}
 
 
@@ -134 +134 @@
 
 
-\begin{cfa}[tabsize=3,caption={Example of \CFA constructors and destructors},label={l:cfa_ctor}]
+\begin{cfacode}[tabsize=3,caption={Example of \CFA constructors and destructors},label={l:cfa_ctor}]
 struct discrete_point {
     int x;
@@ -157 +157 @@
     discrete_point dp{ 2, -4 }; // specialized ctor
 } // ^d{}, ^p{}, ^dp{} all called as they go out of scope
-\end{cfa}
+\end{cfacode}
 
 
@@ -165 +165 @@
 
 \subsection{Parametric Polymorphism}
-\CFA provides parametric polymorphism in the form of @forall@, and @trait@s. 
-A @forall@ takes in a set of types and a list of constraints. 
-The declarations that follow the @forall@ are parameterized over the types listed that satisfy the constraints. 
-Sometimes the list of constraints can be long, which is where a @trait@ can be used. 
-A @trait@ is a collection of constraints that is given a name and can be reused in foralls. 
+\CFA provides parametric polymorphism in the form of \code{forall}, and \code{trait}s. 
+A \code{forall} takes in a set of types and a list of constraints. 
+The declarations that follow the \code{forall} are parameterized over the types listed that satisfy the constraints. 
+Sometimes the list of constraints can be long, which is where a \code{trait} can be used. 
+A \code{trait} is a collection of constraints that is given a name and can be reused in foralls. 
 An example of the usage of parametric polymorphism in \CFA is shown in Listing~\ref{l:cfa_poly}.
 
-\begin{cfa}[tabsize=3,caption={Example of \CFA polymorphism},label={l:cfa_poly}]
+\begin{cfacode}[tabsize=3,caption={Example of \CFA polymorphism},label={l:cfa_poly}]
 // sized() is a trait that means the type has a size
 forall( V & | sized(V) )        // type params for trait
@@ -215 +215 @@
 }
 
-\end{cfa}
+\end{cfacode}
 
 \subsection{Inheritance}
 Inheritance in \CFA copies its style from Plan-9 C nominal inheritance. 
-In \CFA structs can @inline@ another struct type to gain its fields and to be able to be passed to routines that require a parameter of the inlined type. 
+In \CFA structs can \code{inline} another struct type to gain its fields and to be able to be passed to routines that require a parameter of the inlined type. 
 An example of \CFA inheritance is shown in Listing~\ref{l:cfa_inherit}.
 
-\begin{cfa}[tabsize=3,caption={Example of \CFA inheritance},label={l:cfa_inherit}]
+\begin{cfacode}[tabsize=3,caption={Example of \CFA inheritance},label={l:cfa_inherit}]
 struct one_d { double x; };
 struct two_d { 
@@ -260 +260 @@
     print_food( p ); // prints 5
 }
-\end{cfa}
-
-
+\end{cfacode}
+
+

doc/theses/colby_parsons_MMAth/thesis.tex

@@ -98 +98 @@
 \hypersetup{
     plainpages=false,       % needed if Roman numbers in frontpages
-    unicode=false,          % non-Latin characters in Acrobat's bookmarks
-    pdftoolbar=true,        % show Acrobat's toolbar?
-    pdfmenubar=true,        % show Acrobat's menu?
+    unicode=false,          % non-Latin characters in Acrobat’s bookmarks
+    pdftoolbar=true,        % show Acrobat’s toolbar?
+    pdfmenubar=true,        % show Acrobat’s menu?
     pdffitwindow=false,     % window fit to page when opened
     pdfstartview={FitH},    % fits the width of the page to the window