Changeset 1894e03

Timestamp:

Dec 2, 2021, 4:38:22 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

58b2638

Parents:

8157bde (diff), 56f519b (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:

• src/AST/Expr.cpp (modified) (2 diffs)
• src/Concurrency/Keywords.h (modified) (3 diffs)
• src/Concurrency/KeywordsNew.cpp (added)
• src/Concurrency/module.mk (modified) (1 diff)
• src/Validate/CompoundLiteral.cpp (added)
• src/Validate/CompoundLiteral.hpp (added)
• src/Validate/module.mk (modified) (1 diff)
• src/main.cc (modified) (6 diffs)
• tests/concurrent/.expect/ctor-check.txt (added)
• tests/concurrent/ctor-check.cfa (added)

src/AST/Expr.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May 15 17:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Created On       : Thr Jun 13 13:38:00 2019
-// Update Count     : 6
+// Last Modified By : Andrew Beach
+// Created On       : Tue Nov 30 14:23:00 2021
+// Update Count     : 7
 //
 
@@ -141 +141 @@
         /// The type of the address of a type.
         /// Caller is responsible for managing returned memory
-        Type * addrType( const Type * type ) {
-                if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * >( type ) ) {
-                        return new ReferenceType{ addrType( refType->base ), refType->qualifiers };
+        Type * addrType( const ptr<Type> & type ) {
+                if ( auto refType = type.as< ReferenceType >() ) {
+                        return new ReferenceType( addrType( refType->base ), refType->qualifiers );
                 } else {
-                        return new PointerType{ type };
+                        return new PointerType( type );
                 }
         }
-}
-
-AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) {
-        if ( arg->result ) {
-                if ( arg->get_lvalue() ) {
-                        // lvalue, retains all levels of reference, and gains a pointer inside the references
-                        Type * res = addrType( arg->result );
-                        result = res;
+
+        /// The type of the address of an expression.
+        /// Caller is responsible for managing returned memory
+        Type * addrExprType( const CodeLocation & loc, const Expr * arg ) {
+                assert( arg );
+                // If the expression's type is unknown, the address type is unknown.
+                if ( nullptr == arg->result ) {
+                        return nullptr;
+                // An lvalue is transformed directly.
+                } else if ( arg->get_lvalue() ) {
+                        return addrType( arg->result );
+                // Strip a layer of reference to "create" an lvalue expression.
+                } else if ( auto refType = arg->result.as< ReferenceType >() ) {
+                        return addrType( refType->base );
                 } else {
-                        // taking address of non-lvalue, must be a reference, loses one layer of reference
-                        if ( const ReferenceType * refType =
-                                        dynamic_cast< const ReferenceType * >( arg->result.get() ) ) {
-                                Type * res = addrType( refType->base );
-                                result = res;
-                        } else {
-                                SemanticError( loc, arg->result.get(),
-                                        "Attempt to take address of non-lvalue expression: " );
-                        }
+                        SemanticError( loc, arg->result.get(),
+                                "Attempt to take address of non-lvalue expression: " );
                 }
         }
 }
+
+AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) :
+        Expr( loc, addrExprType( loc, a ) ), arg( a )
+{}
 
 // --- LabelAddressExpr

src/Concurrency/Keywords.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Keywords.h --
+// Keywords.h -- Implement concurrency constructs from their keywords.
 //
 // Author           : Thierry Delisle
@@ -19 +19 @@
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace Concurrency {
@@ -24 +27 @@
         void implementMutexFuncs( std::list< Declaration * > & translationUnit );
         void implementThreadStarter( std::list< Declaration * > & translationUnit );
+
+/// Implement the sue-like keywords and the suspend keyword.
+void implementKeywords( ast::TranslationUnit & translationUnit );
+/// Implement the mutex parameters and mutex statement.
+void implementMutex( ast::TranslationUnit & translationUnit );
+/// Add the thread starter code to constructors.
+void implementThreadStarter( ast::TranslationUnit & translationUnit );
 };
 

src/Concurrency/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += Concurrency/Keywords.cc Concurrency/Keywords.h Concurrency/Waitfor.cc Concurrency/Waitfor.h
-SRCDEMANGLE += Concurrency/Keywords.cc
+SRC_CONCURRENCY = \
+        Concurrency/KeywordsNew.cpp \
+        Concurrency/Keywords.cc
 
+SRC += $(SRC_CONCURRENCY) \
+        Concurrency/Keywords.h \
+        Concurrency/Waitfor.cc \
+        Concurrency/Waitfor.h
+
+SRCDEMANGLE += $(SRC_CONCURRENCY)
+

src/Validate/module.mk

@@ -16 +16 @@
 
 SRC_VALIDATE = \
+        Validate/CompoundLiteral.cpp \
+        Validate/CompoundLiteral.hpp \
         Validate/HandleAttributes.cc \
         Validate/HandleAttributes.h \

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Nov 12 11:06:00 2021
-// Update Count     : 658
+// Last Modified On : Tue Nov 30 10:25:00 2021
+// Update Count     : 659
 //
 
@@ -50 +50 @@
 #include "Common/UnimplementedError.h"      // for UnimplementedError
 #include "Common/utility.h"                 // for deleteAll, filter, printAll
+#include "Concurrency/Keywords.h"           // for implementMutex, implement...
 #include "Concurrency/Waitfor.h"            // for generateWaitfor
 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
@@ -73 +74 @@
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
 #include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
+#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
 #include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
 #include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
@@ -325 +327 @@
                 PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
                 PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
-                PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
 
                 CodeTools::fillLocations( translationUnit );
@@ -338 +339 @@
                         forceFillCodeLocations( transUnit );
 
+                        PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
+                        PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );
+                        PASS( "Compound Literal", Validate::handleCompoundLiterals( transUnit ) );
                         PASS( "Set Length From Initializer", Validate::setLengthFromInitializer( transUnit ) );
                         PASS( "Find Global Decls", Validate::findGlobalDecls( transUnit ) );
@@ -402 +406 @@
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
                         PASS( "Validate-F", SymTab::validate_F( translationUnit ) );