Changeset 97fed44 for src

Timestamp:

Jan 25, 2022, 4:54:35 PM (4 years ago)

Author:

caparsons <caparson@…>

Branches:

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

Children:

6b2d444, a488783, f681823

Parents:

f57f6ea0 (diff), 4fcbf26 (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

Location:

src

Files:

• AST/Decl.cpp (modified) (2 diffs)
• AST/Decl.hpp (modified) (2 diffs)
• AST/Eval.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• Validate/InitializerLength.cpp (modified) (1 diff)
• Validate/InitializerLength.hpp (modified) (1 diff)

src/AST/Decl.cpp

@@ -26 +26 @@
 #include "Node.hpp"            // for readonly
 #include "Type.hpp"            // for readonly
+#include "Expr.hpp"
 
 namespace ast {
@@ -65 +66 @@
         for (auto & tp : this->type_params) {
                 ftype->forall.emplace_back(new TypeInstType(tp->name, tp));
+                for (auto & ap: tp->assertions) {
+                        ftype->assertions.emplace_back(new VariableExpr(loc, ap));
+                }
         }
         this->type = ftype;

src/AST/Decl.hpp

@@ -34 +34 @@
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
 #define MUTATE_FRIEND \
-    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * mutate(const node_t * node); \
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
@@ -135 +135 @@
         std::vector< ptr<Expr> > withExprs;
 
-
         FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,

src/AST/Eval.hpp

@@ -24 +24 @@
 template< typename... Args >
 UntypedExpr * call( const CodeLocation & loc, const std::string & name, Args &&... args ) {
-        return new UntypedExpr { 
-                loc, new NameExpr { loc, name }, 
+        return new UntypedExpr {
+                loc, new NameExpr { loc, name },
                 std::vector< ptr< Expr > > { std::forward< Args >( args )... } };
 }

src/AST/Print.cpp

@@ -333 +333 @@
                 print( node->funcSpec );
 
-                if ( node->type ) {
+
+
+                if ( node->type && node->isTypeFixed ) {
                         node->type->accept( *this );
                 } else {
-                        os << "untyped entity";
+                        if (!node->type_params.empty()) {
+                                os << "forall" << endl;
+                                ++indent;
+                                printAll(node->type_params);
+                                os << indent;
+                                --indent;
+
+                                if (!node->assertions.empty()) {
+                                        os << "with assertions" << endl;
+                                        ++indent;
+                                        printAll(node->assertions);
+                                        os << indent;
+                                        --indent;
+                                }
+                        }
+
+                        os << "function" << endl;
+                        if ( ! node->params.empty() ) {
+                                os << indent << "... with parameters" << endl;
+                                ++indent;
+                                printAll( node->params );
+                                if ( node->type->isVarArgs ) {
+                                        os << indent << "and a variable number of other arguments" << endl;
+                                }
+                                --indent;
+                        } else if ( node->type->isVarArgs ) {
+                                os << indent+1 << "accepting unspecified arguments" << endl;
+                        }
+
+                        os << indent << "... returning";
+                        if ( node->returns.empty() ) {
+                                os << " nothing" << endl;
+                        } else {
+                                os << endl;
+                                ++indent;
+                                printAll( node->returns );
+                                --indent;
+                        }
                 }
 

src/Validate/InitializerLength.cpp

@@ -14 +14 @@
 //
 
-//#include "InitializerLength.hpp"
+#include "InitializerLength.hpp"
 
 #include "AST/Expr.hpp"

src/Validate/InitializerLength.hpp

@@ -14 +14 @@
 //
 
+#pragma once
+
+namespace ast {
+        class TranslationUnit;
+}
+
 namespace Validate {