Changeset 8bf784a for src/SynTree

Timestamp:

Dec 21, 2016, 2:54:31 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

e33f321

Parents:

6d4d1a6

Message:

name mangling for ttype, fix SynTree? operator<< to work with nullptr, add isTtype check, ttype variables are automatically "sized"

Location:

src/SynTree

Files:

• Declaration.cc (modified) (1 diff)
• Expression.cc (modified) (1 diff)
• FunctionType.cc (modified) (3 diffs)
• Statement.cc (modified) (1 diff)
• Type.cc (modified) (1 diff)
• Type.h (modified) (1 diff)
• TypeDecl.cc (modified) (2 diffs)

src/SynTree/Declaration.cc ¶

@@ -57 +57 @@
 
 std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
-        decl->print( out );
+        if ( decl ){
+                decl->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/Expression.cc ¶

@@ -672 +672 @@
 
 std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
-        expr->print( out );
+        if ( expr ) {
+                expr->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/FunctionType.cc ¶

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FunctionType.cc -- 
+// FunctionType.cc --
 //
 // Author           : Richard C. Bilson
@@ -19 +19 @@
 #include "Declaration.h"
 #include "Common/utility.h"
+#include "Tuples/Tuples.h"
 
 FunctionType::FunctionType( const Type::Qualifiers &tq, bool isVarArgs ) : Type( tq ), isVarArgs( isVarArgs ) {
@@ -31 +32 @@
         deleteAll( returnVals );
         deleteAll( parameters );
+}
+
+namespace {
+        bool containsTtype( const std::list<DeclarationWithType * > & l ) {
+                if ( ! l.empty() ) {
+                        return Tuples::isTtype( l.back()->get_type() );
+                }
+                return false;
+        }
+}
+
+bool FunctionType::isTtype() const {
+        return containsTtype( returnVals ) || containsTtype( parameters );
 }
 

src/SynTree/Statement.cc ¶

@@ -388 +388 @@
 
 std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
-        statement->print( out );
+        if ( statement ) {
+                statement->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/Type.cc ¶

@@ -85 +85 @@
 
 std::ostream & operator<<( std::ostream & out, const Type * type ) {
-        type->print( out );
+        if ( type ) {
+                type->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/Type.h ¶

@@ -204 +204 @@
         std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
         std::list<DeclarationWithType*> & get_parameters() { return parameters; }
-        bool get_isVarArgs() { return isVarArgs; }
+        bool get_isVarArgs() const { return isVarArgs; }
         void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
+
+        bool isTtype() const;
 
         virtual FunctionType *clone() const { return new FunctionType( *this ); }

src/SynTree/TypeDecl.cc ¶

@@ -18 +18 @@
 #include "Common/utility.h"
 
-TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ), sized( kind == Any ) {
+TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
 }
 
@@ -25 +25 @@
 
 std::string TypeDecl::typeString() const {
-        static const char *kindNames[] = { "type", "incomplete type", "function type" };
+        static const char *kindNames[] = { "type", "incomplete type", "function type", "tuple type" };
         return kindNames[ kind ];
 }