Changeset 5170d95

Timestamp:

Feb 19, 2019, 11:24:40 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

2ede686

Parents:

45af7e1

Message:

fix implict void cast problem

Location:

src

Files:

• ResolvExpr/Resolver.cc (modified) (27 diffs)
• ResolvExpr/Resolver.h (modified) (2 diffs)
• SynTree/Expression.cc (modified) (48 diffs)
• SynTree/Expression.h (modified) (2 diffs)

src/ResolvExpr/Resolver.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 13 18:13:43 2019
-// Update Count     : 216
+// Last Modified On : Tue Feb 19 18:09:56 2019
+// Update Count     : 240
 //
 
@@ -53 +53 @@
                 }
 
-                void previsit( FunctionDecl *functionDecl );
-                void postvisit( FunctionDecl *functionDecl );
-                void previsit( ObjectDecl *objectDecll );
+                void previsit( FunctionDecl * functionDecl );
+                void postvisit( FunctionDecl * functionDecl );
+                void previsit( ObjectDecl * objectDecll );
                 void previsit( EnumDecl * enumDecl );
                 void previsit( StaticAssertDecl * assertDecl );
@@ -62 +62 @@
                 void previsit( PointerType * at );
 
-                void previsit( ExprStmt *exprStmt );
-                void previsit( AsmExpr *asmExpr );
-                void previsit( AsmStmt *asmStmt );
-                void previsit( IfStmt *ifStmt );
-                void previsit( WhileStmt *whileStmt );
-                void previsit( ForStmt *forStmt );
-                void previsit( SwitchStmt *switchStmt );
-                void previsit( CaseStmt *caseStmt );
-                void previsit( BranchStmt *branchStmt );
-                void previsit( ReturnStmt *returnStmt );
-                void previsit( ThrowStmt *throwStmt );
-                void previsit( CatchStmt *catchStmt );
+                void previsit( ExprStmt * exprStmt );
+                void previsit( AsmExpr * asmExpr );
+                void previsit( AsmStmt * asmStmt );
+                void previsit( IfStmt * ifStmt );
+                void previsit( WhileStmt * whileStmt );
+                void previsit( ForStmt * forStmt );
+                void previsit( SwitchStmt * switchStmt );
+                void previsit( CaseStmt * caseStmt );
+                void previsit( BranchStmt * branchStmt );
+                void previsit( ReturnStmt * returnStmt );
+                void previsit( ThrowStmt * throwStmt );
+                void previsit( CatchStmt * catchStmt );
                 void previsit( WaitForStmt * stmt );
 
-                void previsit( SingleInit *singleInit );
-                void previsit( ListInit *listInit );
-                void previsit( ConstructorInit *ctorInit );
+                void previsit( SingleInit * singleInit );
+                void previsit( ListInit * listInit );
+                void previsit( ConstructorInit * ctorInit );
           private:
                 typedef std::list< Initializer * >::iterator InitIterator;
@@ -104 +104 @@
         }
 
-        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
+        void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
                 PassVisitor<Resolver> resolver( indexer );
                 maybeAccept( decl, resolver );
@@ -148 +148 @@
                 };
 
-                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                void finishExpr( Expression *& expr, const TypeEnvironment & env, TypeSubstitution * oldenv = nullptr ) {
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->env );
@@ -279 +279 @@
 
         // used in resolveTypeof
-        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
+        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ) {
                 TypeEnvironment env;
                 return resolveInVoidContext( expr, indexer, env );
         }
 
-        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
+        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer, TypeEnvironment & env ) {
                 // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
                 // interpretations, an exception has already been thrown.
                 assertf( expr, "expected a non-null expression." );
 
-                static CastExpr untyped( nullptr ); // cast to void
-                untyped.location = expr->location;
+                CastExpr * untyped = new CastExpr( expr ); // cast to void
+                untyped->location = expr->location;
 
                 // set up and resolve expression cast to void
-                untyped.arg = expr;
                 Alternative choice;
-                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
+                findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
+                assert( castExpr );
                 env = std::move( choice.env );
 
@@ -304 +304 @@
 
                 // unlink the arg so that it isn't deleted twice at the end of the program
-                untyped.arg = nullptr;
+                untyped->arg = nullptr;
                 return ret;
         }
 
-        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
                 resetTyVarRenaming();
                 TypeEnvironment env;
@@ -317 +317 @@
         }
 
-        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
+        void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
                 findKindExpression( untyped, indexer, "", standardAlternativeFilter );
         }
@@ -336 +336 @@
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
                                 return true;
-                        } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
+                        } else if ( BasicType * bt = dynamic_cast< BasicType * >( type ) ) {
                                 return bt->isInteger();
                         } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
@@ -345 +345 @@
                 }
 
-                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
+                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
                         findKindExpression( untyped, indexer, "condition", isIntegralType );
                 }
@@ -401 +401 @@
         }
 
-        void Resolver::previsit( ObjectDecl *objectDecl ) {
+        void Resolver::previsit( ObjectDecl * objectDecl ) {
                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
                 // class-variable initContext is changed multiple time because the LHS is analysed twice. 
@@ -431 +431 @@
         }
 
-        void Resolver::previsit( FunctionDecl *functionDecl ) {
+        void Resolver::previsit( FunctionDecl * functionDecl ) {
 #if 0
                 std::cerr << "resolver visiting functiondecl ";
@@ -441 +441 @@
         }
 
-        void Resolver::postvisit( FunctionDecl *functionDecl ) {
+        void Resolver::postvisit( FunctionDecl * functionDecl ) {
                 // default value expressions have an environment which shouldn't be there and trips up 
                 // later passes.
@@ -466 +466 @@
         }
 
-        void Resolver::previsit( ExprStmt *exprStmt ) {
+        void Resolver::previsit( ExprStmt * exprStmt ) {
                 visit_children = false;
                 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
@@ -472 +472 @@
         }
 
-        void Resolver::previsit( AsmExpr *asmExpr ) {
+        void Resolver::previsit( AsmExpr * asmExpr ) {
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
@@ -480 +480 @@
         }
 
-        void Resolver::previsit( AsmStmt *asmStmt ) {
+        void Resolver::previsit( AsmStmt * asmStmt ) {
                 visit_children = false;
                 acceptAll( asmStmt->get_input(), *visitor );
@@ -486 +486 @@
         }
 
-        void Resolver::previsit( IfStmt *ifStmt ) {
+        void Resolver::previsit( IfStmt * ifStmt ) {
                 findIntegralExpression( ifStmt->condition, indexer );
         }
 
-        void Resolver::previsit( WhileStmt *whileStmt ) {
+        void Resolver::previsit( WhileStmt * whileStmt ) {
                 findIntegralExpression( whileStmt->condition, indexer );
         }
 
-        void Resolver::previsit( ForStmt *forStmt ) {
+        void Resolver::previsit( ForStmt * forStmt ) {
                 if ( forStmt->condition ) {
                         findIntegralExpression( forStmt->condition, indexer );
@@ -504 +504 @@
         }
 
-        void Resolver::previsit( SwitchStmt *switchStmt ) {
+        void Resolver::previsit( SwitchStmt * switchStmt ) {
                 GuardValue( currentObject );
                 findIntegralExpression( switchStmt->condition, indexer );
@@ -511 +511 @@
         }
 
-        void Resolver::previsit( CaseStmt *caseStmt ) {
+        void Resolver::previsit( CaseStmt * caseStmt ) {
                 if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
@@ -530 +530 @@
         }
 
-        void Resolver::previsit( BranchStmt *branchStmt ) {
+        void Resolver::previsit( BranchStmt * branchStmt ) {
                 visit_children = false;
                 // must resolve the argument for a computed goto
@@ -541 +541 @@
         }
 
-        void Resolver::previsit( ReturnStmt *returnStmt ) {
+        void Resolver::previsit( ReturnStmt * returnStmt ) {
                 visit_children = false;
                 if ( returnStmt->expr ) {
@@ -548 +548 @@
         }
 
-        void Resolver::previsit( ThrowStmt *throwStmt ) {
+        void Resolver::previsit( ThrowStmt * throwStmt ) {
                 visit_children = false;
                 // TODO: Replace *exception type with &exception type.
@@ -560 +560 @@
         }
 
-        void Resolver::previsit( CatchStmt *catchStmt ) {
+        void Resolver::previsit( CatchStmt * catchStmt ) {
                 if ( catchStmt->cond ) {
                         findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
@@ -724 +724 @@
 
                                                 }
-                                                catch( SemanticErrorException &e ) {
+                                                catch( SemanticErrorException & e ) {
                                                         errors.append( e );
                                                 }
                                         }
                                 }
-                                catch( SemanticErrorException &e ) {
+                                catch( SemanticErrorException & e ) {
                                         errors.append( e );
                                 }
@@ -781 +781 @@
         }
 
-        void Resolver::previsit( SingleInit *singleInit ) {
+        void Resolver::previsit( SingleInit * singleInit ) {
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
@@ -813 +813 @@
                                 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
                                         if ( isCharType( pt->get_base() ) ) {
-                                                if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                                if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
                                                         // strip cast if we're initializing a char[] with a char *, 
                                                         // e.g.  char x[] = "hello";
@@ -893 +893 @@
         }
 
-        void Resolver::previsit( ConstructorInit *ctorInit ) {
+        void Resolver::previsit( ConstructorInit * ctorInit ) {
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit

src/ResolvExpr/Resolver.h

@@ -10 +10 @@
 // Created On       : Sun May 17 12:18:34 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:36:57 2017
-// Update Count     : 3
+// Last Modified On : Mon Feb 18 20:40:38 2019
+// Update Count     : 4
 //
 
@@ -29 +29 @@
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
-        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
-        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer );
-        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
-        void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
-        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer &indexer );
+        void resolveDecl( Declaration *, const SymTab::Indexer & indexer );
+        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer );
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer );
+        void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer );
+        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/SynTree/Expression.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 25 14:15:47 2017
-// Update Count     : 54
+// Last Modified On : Tue Feb 19 18:10:55 2019
+// Update Count     : 60
 //
 
@@ -33 +33 @@
 #include "GenPoly/Lvalue.h"
 
-void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
+void printInferParams( const InferredParams & inferParams, std::ostream & os, Indenter indent, int level ) {
         if ( ! inferParams.empty() ) {
                 os << indent << "with inferred parameters " << level << ":" << std::endl;
@@ -47 +47 @@
 Expression::Expression() : result( 0 ), env( 0 ) {}
 
-Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
+Expression::Expression( const Expression & other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
 
 void Expression::spliceInferParams( Expression * other ) {
@@ -62 +62 @@
 }
 
-void Expression::print( std::ostream &os, Indenter indent ) const {
+void Expression::print( std::ostream & os, Indenter indent ) const {
         printInferParams( inferParams, os, indent+1, 0 );
 
@@ -79 +79 @@
 }
 
-ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
+ConstantExpr::ConstantExpr( const ConstantExpr & other) : Expression( other ), constant( other.constant ) {
 }
 
 ConstantExpr::~ConstantExpr() {}
 
-void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
+void ConstantExpr::print( std::ostream & os, Indenter indent ) const {
         os << "constant expression " ;
         constant.print( os );
@@ -124 +124 @@
 }
 
-VariableExpr::VariableExpr( const VariableExpr &other ) : Expression( other ), var( other.var ) {
+VariableExpr::VariableExpr( const VariableExpr & other ) : Expression( other ), var( other.var ) {
 }
 
@@ -137 +137 @@
 }
 
-void VariableExpr::print( std::ostream &os, Indenter indent ) const {
+void VariableExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Variable Expression: ";
         var->printShort(os, indent);
@@ -143 +143 @@
 }
 
-SizeofExpr::SizeofExpr( Expression *expr_ ) :
+SizeofExpr::SizeofExpr( Expression * expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( Type *type_ ) :
+SizeofExpr::SizeofExpr( Type * type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( const SizeofExpr &other ) :
+SizeofExpr::SizeofExpr( const SizeofExpr & other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -162 +162 @@
 }
 
-void SizeofExpr::print( std::ostream &os, Indenter indent) const {
+void SizeofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Sizeof Expression on: ";
         if (isType) type->print(os, indent+1);
@@ -169 +169 @@
 }
 
-AlignofExpr::AlignofExpr( Expression *expr_ ) :
+AlignofExpr::AlignofExpr( Expression * expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( Type *type_ ) :
+AlignofExpr::AlignofExpr( Type * type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
+AlignofExpr::AlignofExpr( const AlignofExpr & other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -188 +188 @@
 }
 
-void AlignofExpr::print( std::ostream &os, Indenter indent) const {
+void AlignofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Alignof Expression on: ";
         if (isType) type->print(os, indent+1);
@@ -195 +195 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type * type, const std::string & member ) :
                 Expression(), type(type), member(member) {
         assert( type );
@@ -201 +201 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr &other ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr & other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -208 +208 @@
 }
 
-void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void UntypedOffsetofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Untyped Offsetof Expression on member " << member << " of ";
         type->print(os, indent+1);
@@ -214 +214 @@
 }
 
-OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
+OffsetofExpr::OffsetofExpr( Type * type, DeclarationWithType * member ) :
                 Expression(), type(type), member(member) {
         assert( member );
@@ -221 +221 @@
 }
 
-OffsetofExpr::OffsetofExpr( const OffsetofExpr &other ) :
+OffsetofExpr::OffsetofExpr( const OffsetofExpr & other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -228 +228 @@
 }
 
-void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void OffsetofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Offsetof Expression on member " << member->name << " of ";
         type->print(os, indent+1);
@@ -234 +234 @@
 }
 
-OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
+OffsetPackExpr::OffsetPackExpr( StructInstType * type ) : Expression(), type( type ) {
         assert( type );
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
-OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr & other ) : Expression( other ), type( maybeClone( other.type ) ) {}
 
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
 
-void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
+void OffsetPackExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Offset pack expression on ";
         type->print(os, indent+1);
@@ -249 +249 @@
 }
 
-AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
+AttrExpr::AttrExpr( Expression * attr, Expression * expr_ ) :
                 Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
 }
 
-AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
+AttrExpr::AttrExpr( Expression * attr, Type * type_ ) :
                 Expression(), attr( attr ), expr(0), type(type_), isType(true) {
 }
 
-AttrExpr::AttrExpr( const AttrExpr &other ) :
+AttrExpr::AttrExpr( const AttrExpr & other ) :
                 Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -267 +267 @@
 }
 
-void AttrExpr::print( std::ostream &os, Indenter indent) const {
+void AttrExpr::print( std::ostream & os, Indenter indent) const {
         os << "Attr ";
         attr->print( os, indent+1);
@@ -278 +278 @@
 }
 
-CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -293 +293 @@
 }
 
-void CastExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Cast of:" << std::endl << indent+1;
+void CastExpr::print( std::ostream & os, Indenter indent ) const {
+        os << (isGenerated ? "Generated " : "Explicit ") << "Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
         os << std::endl << indent << "... to:";
@@ -306 +306 @@
 }
 
-KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
-}
-
-KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+KeywordCastExpr::KeywordCastExpr( Expression * arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
 }
 
@@ -327 +327 @@
 }
 
-void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+void KeywordCastExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Keyword Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
@@ -335 +335 @@
 }
 
-VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+VirtualCastExpr::VirtualCastExpr( Expression * arg_, Type * toType ) : Expression(), arg(arg_) {
         set_result(toType);
 }
 
-VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
 }
 
@@ -346 +346 @@
 }
 
-void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
+void VirtualCastExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Virtual Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
@@ -359 +359 @@
 }
 
-UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression * aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( aggregate );
 }
 
-UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
+UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr & other ) :
                 Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -373 +373 @@
 }
 
-void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
+void UntypedMemberExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
         member->print(os, indent+1 );
@@ -381 +381 @@
 }
 
-MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
+MemberExpr::MemberExpr( DeclarationWithType * member, Expression * aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( member );
@@ -395 +395 @@
 }
 
-MemberExpr::MemberExpr( const MemberExpr &other ) :
+MemberExpr::MemberExpr( const MemberExpr & other ) :
                 Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -404 +404 @@
 }
 
-void MemberExpr::print( std::ostream &os, Indenter indent ) const {
+void MemberExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Member Expression, with field:" << std::endl;
         os << indent+1;
@@ -413 +413 @@
 }
 
-UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
+UntypedExpr::UntypedExpr( Expression * function, const std::list<Expression *> & args ) :
                 Expression(), function(function), args(args) {}
 
-UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
+UntypedExpr::UntypedExpr( const UntypedExpr & other ) :
                 Expression( other ), function( maybeClone( other.function ) ) {
         cloneAll( other.args, args );
@@ -455 +455 @@
 
 
-void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
+void UntypedExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Applying untyped:" << std::endl;
         os << indent+1;
@@ -469 +469 @@
 }
 
-NameExpr::NameExpr( const NameExpr &other ) : Expression( other ), name( other.name ) {
+NameExpr::NameExpr( const NameExpr & other ) : Expression( other ), name( other.name ) {
 }
 
 NameExpr::~NameExpr() {}
 
-void NameExpr::print( std::ostream &os, Indenter indent ) const {
+void NameExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Name: " << get_name();
         Expression::print( os, indent );
 }
 
-LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
+LogicalExpr::LogicalExpr( Expression * arg1_, Expression * arg2_, bool andp ) :
                 Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
-LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
+LogicalExpr::LogicalExpr( const LogicalExpr & other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
 }
@@ -493 +493 @@
 }
 
-void LogicalExpr::print( std::ostream &os, Indenter indent )const {
+void LogicalExpr::print( std::ostream & os, Indenter indent )const {
         os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
         arg1->print(os);
@@ -504 +504 @@
                 Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 
-ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
+ConditionalExpr::ConditionalExpr( const ConditionalExpr & other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
 }
@@ -514 +514 @@
 }
 
-void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
+void ConditionalExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Conditional expression on: " << std::endl << indent+1;
         arg1->print( os, indent+1 );
@@ -527 +527 @@
 
 
-void AsmExpr::print( std::ostream &os, Indenter indent ) const {
+void AsmExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
         if ( inout ) inout->print( os, indent+1 );
@@ -555 +555 @@
 }
 
-void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
+void ImplicitCopyCtorExpr::print( std::ostream & os, Indenter indent ) const {
         os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent+1 );
@@ -581 +581 @@
 }
 
-void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
+void ConstructorExpr::print( std::ostream & os, Indenter indent ) const {
         os <<  "Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent + 2 );
@@ -594 +594 @@
 }
 
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr & other ) : Expression( other ), initializer( other.initializer->clone() ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -600 +600 @@
 }
 
-void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
+void CompoundLiteralExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Compound Literal Expression: " << std::endl << indent+1;
         result->print( os, indent+1 );
@@ -608 +608 @@
 }
 
-RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
-void RangeExpr::print( std::ostream &os, Indenter indent ) const {
+RangeExpr::RangeExpr( Expression * low, Expression * high ) : low( low ), high( high ) {}
+RangeExpr::RangeExpr( const RangeExpr & other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
+void RangeExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Range Expression: ";
         low->print( os, indent );
@@ -618 +618 @@
 }
 
-StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
+StmtExpr::StmtExpr( CompoundStmt * statements ) : statements( statements ) {
         computeResult();
 }
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
+StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ) {
         cloneAll( other.returnDecls, returnDecls );
         cloneAll( other.dtors, dtors );
@@ -650 +650 @@
         }
 }
-void StmtExpr::print( std::ostream &os, Indenter indent ) const {
+void StmtExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Statement Expression: " << std::endl << indent+1;
         statements->print( os, indent+1 );
@@ -666 +666 @@
 
 long long UniqueExpr::count = 0;
-UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
+UniqueExpr::UniqueExpr( Expression * expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
         assert( expr );
         assert( count != -1 );
@@ -674 +674 @@
         }
 }
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+UniqueExpr::UniqueExpr( const UniqueExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
 }
 UniqueExpr::~UniqueExpr() {
@@ -681 +681 @@
         delete var;
 }
-void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
+void UniqueExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Unique Expression with id:" << id << std::endl << indent+1;
         expr->print( os, indent+1 );

src/SynTree/Expression.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 19:23:46 2017
-// Update Count     : 48
+// Last Modified On : Mon Feb 18 18:29:51 2019
+// Update Count     : 49
 //
 
@@ -195 +195 @@
   public:
         Expression * arg;
-        bool isGenerated = true; // whether this cast appeared in the source program
+        bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
 
         CastExpr( Expression * arg, bool isGenerated = true );