Changeset ec7f50a

Timestamp:

Jan 17, 2019, 3:39:33 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

bead1cf

Parents:

bd78797 (diff), 273ff10 (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

Files:

• doc/theses/aaron_moss_PhD/phd/background.tex (modified) (1 diff)
• doc/theses/aaron_moss_PhD/phd/resolution-heuristics.tex (modified) (1 diff)
• driver/cfa.cc (modified) (4 diffs)
• libcfa/src/concurrency/coroutine.cfa (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (2 diffs)
• src/Concurrency/Waitfor.cc (modified) (4 diffs)
• src/main.cc (modified) (2 diffs)

doc/theses/aaron_moss_PhD/phd/background.tex

@@ -213 +213 @@
 The ability of types to begin or cease to satisfy traits when declarations go into or out of scope makes caching of trait satisfaction judgements difficult, and the ability of traits to take multiple type parameters can lead to a combinatorial explosion of work in any attempt to pre-compute trait satisfaction relationships. 
 
-\subsection{Implicit Conversions}
+\subsection{Implicit Conversions} \label{implicit-conv-sec}
 
 In addition to the multiple interpretations of an expression produced by name overloading and polymorphic functions, for backward compatibility \CFA{} must support all of the implicit conversions present in C, producing further candidate interpretations for expressions. 

doc/theses/aaron_moss_PhD/phd/resolution-heuristics.tex

@@ -2 +2 @@
 \label{resolution-chap}
 
-Talk about the resolution heuristics. This is the bulk of the thesis.
+The main task of the \CFACC{} type-checker is \emph{expression resolution}, determining which declarations the identifiers in each expression correspond to. 
+Resolution is a straightforward task in C, as each declaration has a unique identifier, but in \CFA{} the name overloading features discussed in Section~\ref{overloading-sec} generate multiple candidate declarations for each identifier.
+I refer to a given matching between identifiers and declarations in an expression as an \emph{interpretation}; an interpretation also includes information about polymorphic type bindings and implicit casts to support the \CFA{} features discussed in Sections~\ref{poly-func-sec} and~\ref{implicit-conv-sec}, each of which increase the proportion of feasible candidate interpretations. 
+To choose between feasible interpretations, \CFA{} defines a \emph{conversion cost} to rank interpretations; the expression resolution problem is thus to find the unique minimal-cost interpretation for an expression, reporting an error if no such interpretation exists.
+
+\section{Conversion Cost}
+
+
 
 % Discuss changes to cost model, as promised in Ch. 2
+
+% Mention relevance of work to C++20 concepts

driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 14 23:02:59 2018
-// Update Count     : 277
+// Last Modified On : Tue Jan 15 20:56:03 2019
+// Update Count     : 280
 //
 
@@ -384 +384 @@
         nargs += 1;
 
+        for ( int i = 0; i < nlibs; i += 1 ) {                          // copy non-user libraries after all user libraries
+                args[nargs] = libs[i];
+                nargs += 1;
+        } // for
+
         if ( link ) {
                 args[nargs] = "-Xlinker";
@@ -414 +419 @@
                 nargs += 1;
                 args[nargs] = "-lrt";
+                nargs += 1;
+                args[nargs] = "-lm";
                 nargs += 1;
         } // if
@@ -498 +505 @@
                 args[nargs] = ( *new string( string("-B") + Bprefix ) ).c_str();
                 nargs += 1;
-                args[nargs] = "-lm";
-                nargs += 1;
         } else {
                 cerr << argv[0] << " error, compiler \"" << compiler_name << "\" unsupported." << endl;
                 exit( EXIT_FAILURE );
         } // if
-
-        for ( int i = 0; i < nlibs; i += 1 ) {                          // copy non-user libraries after all user libraries
-                args[nargs] = libs[i];
-                nargs += 1;
-        } // for
 
         args[nargs] = NULL;                                                                     // terminate with NULL

libcfa/src/concurrency/coroutine.cfa

@@ -83 +83 @@
 
 void ^?{}(coroutine_desc& this) {
-      if(this.state != Halted) {
+      if(this.state != Halted && this.state != Start) {
             coroutine_desc * src = TL_GET( this_coroutine );
             coroutine_desc * dst = &this;

src/Concurrency/Keywords.cc

@@ -575 +575 @@
 
                 //in reverse order :
-                // monitor_guard_t __guard = { __monitors, #, func };
+                // monitor_dtor_guard_t __guard = { __monitors, func };
                 body->push_front(
                         new DeclStmt( new ObjectDecl(
@@ -634 +634 @@
                 assert(generic_func);
 
-                //in reverse order :
+                // in reverse order :
                 // monitor_guard_t __guard = { __monitors, #, func };
                 body->push_front(

src/Concurrency/Waitfor.cc

@@ -66 +66 @@
 void foo() {
         while( true ) {
-
-                acceptable_t acceptables[3];
-                if( a < 1 ) {
-                        acceptables[0].func = f;
-                        acceptables[0].mon = a;
-                }
-                acceptables[1].func = g;
-                acceptables[1].mon = a;
-
-                acceptables[2].func = f;
-                acceptables[2].mon = a;
-                acceptables[2].is_dtor = true;
-
-                int ret = waitfor_internal( acceptables, swagl() );
-
-                switch( ret ) {
-                        case 0:
-                        {
-                                bar();
+                {
+                        acceptable_t acceptables[3];
+                        if( a < 1 ) {
+                                acceptables[0].func = f;
+                                acceptables[0].mon = a;
                         }
-                        case 1:
-                        {
-                                baz();
+                        acceptables[1].func = g;
+                        acceptables[1].mon = a;
+
+                        acceptables[2].func = f;
+                        acceptables[2].mon = a;
+                        acceptables[2].is_dtor = true;
+
+                        int ret = waitfor_internal( acceptables, swagl() );
+
+                        switch( ret ) {
+                                case 0:
+                                {
+                                        bar();
+                                }
+                                case 1:
+                                {
+                                        baz();
+                                }
+                                case 2:
+                                        signal(a);
+                                        {
+                                                break;
+                                        }
                         }
-                        case 2:
-                                signal(a);
-                                {
-                                        break;
-                                }
                 }
         }
@@ -555 +556 @@
                                         new ConstantExpr( Constant::from_ulong( i++ ) ),
                                         {
-                                                clause.statement,
-                                                new BranchStmt(
-                                                        "",
-                                                        BranchStmt::Break
-                                                )
+                                                new CompoundStmt({
+                                                        clause.statement,
+                                                        new BranchStmt(
+                                                                "",
+                                                                BranchStmt::Break
+                                                        )
+                                                })
                                         }
                                 )
@@ -570 +573 @@
                                         new ConstantExpr( Constant::from_int( -2 ) ),
                                         {
-                                                waitfor->timeout.statement,
-                                                new BranchStmt(
-                                                        "",
-                                                        BranchStmt::Break
-                                                )
+                                                new CompoundStmt({
+                                                        waitfor->timeout.statement,
+                                                        new BranchStmt(
+                                                                "",
+                                                                BranchStmt::Break
+                                                        )
+                                                })
                                         }
                                 )
@@ -585 +590 @@
                                         new ConstantExpr( Constant::from_int( -1 ) ),
                                         {
-                                                waitfor->orelse.statement,
-                                                new BranchStmt(
-                                                        "",
-                                                        BranchStmt::Break
-                                                )
+                                                new CompoundStmt({
+                                                        waitfor->orelse.statement,
+                                                        new BranchStmt(
+                                                                "",
+                                                                BranchStmt::Break
+                                                        )
+                                                })
                                         }
                                 )

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  6 15:51:47 2018
-// Update Count     : 498
+// Last Modified On : Wed Dec 26 08:11:19 2018
+// Update Count     : 499
 //
 
@@ -371 +371 @@
                         }
                 } catch(const std::exception& e) {
-                        std::cerr << "Unaught Exception \"" << e.what() << "\"\n";
+                        std::cerr << "Uncaught Exception \"" << e.what() << "\"\n";
                 }
                 return 1;