Ignore:
Timestamp:
May 23, 2019, 4:22:58 PM (3 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
a16e246, f1ec88a
Parents:
20a5977 (diff), effe5b0 (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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/InitTweak.cc

    r20a5977 raf1e8f56  
    346346        namespace {
    347347                DeclarationWithType * getCalledFunction( Expression * expr );
     348                const ast::DeclWithType * getCalledFunction( const ast::Expr * expr );
    348349
    349350                template<typename CallExpr>
     
    355356                        return getCalledFunction( expr->get_args().front() );
    356357                }
     358
     359                template<typename CallExpr>
     360                const ast::DeclWithType * handleDerefCalledFunction( const CallExpr * expr ) {
     361                        // (*f)(x) => should get "f"
     362                        std::string name = getFunctionName( expr );
     363                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
     364                        assertf( ! expr->args.empty(), "Cannot get called function from dereference with no arguments" );
     365                        return getCalledFunction( expr->args.front() );
     366                }
     367
    357368
    358369                DeclarationWithType * getCalledFunction( Expression * expr ) {
     
    375386                        return nullptr;
    376387                }
     388
     389                const ast::DeclWithType * getCalledFunction( const ast::Expr * expr ) {
     390                        assert( expr );
     391                        if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( expr ) ) {
     392                                return varExpr->var;
     393                        } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( expr ) ) {
     394                                return memberExpr->member;
     395                        } else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( expr ) ) {
     396                                return getCalledFunction( castExpr->arg );
     397                        } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * >( expr ) ) {
     398                                return handleDerefCalledFunction( untypedExpr );
     399                        } else if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * > ( expr ) ) {
     400                                return handleDerefCalledFunction( appExpr );
     401                        } else if ( const ast::AddressExpr * addrExpr = dynamic_cast< const ast::AddressExpr * >( expr ) ) {
     402                                return getCalledFunction( addrExpr->arg );
     403                        } else if ( const ast::CommaExpr * commaExpr = dynamic_cast< const ast::CommaExpr * >( expr ) ) {
     404                                return getCalledFunction( commaExpr->arg2 );
     405                        }
     406                        return nullptr;
     407                }
    377408        }
    378409
     
    382413                } else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * > ( expr ) ) {
    383414                        return getCalledFunction( untyped->get_function() );
     415                }
     416                assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
     417        }
     418
     419        const ast::DeclWithType * getFunction( const ast::Expr * expr ) {
     420                if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( expr ) ) {
     421                        return getCalledFunction( appExpr->func );
     422                } else if ( const ast::UntypedExpr * untyped = dynamic_cast< const ast::UntypedExpr * > ( expr ) ) {
     423                        return getCalledFunction( untyped->func );
    384424                }
    385425                assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
     
    434474                }
    435475
    436                 // template<typename CallExpr>
    437                 // const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
    438                 //      if( pos >= call->args.size() ) {
    439                 //              assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.",
    440                 //                      pos, toString( call ).c_str() );
    441                 //      }
    442                 //      for ( const ast::Expr * arg : call->args ) {
    443                 //              if ( pos == 0 ) return arg;
    444                 //              --pos;
    445                 //      }
    446                 //      assert( false );
    447                 // }
     476                template<typename CallExpr>
     477                const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
     478                        if( pos >= call->args.size() ) {
     479                                assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.",
     480                                        pos, toString( call ).c_str() );
     481                        }
     482                        for ( const ast::Expr * arg : call->args ) {
     483                                if ( pos == 0 ) return arg;
     484                                --pos;
     485                        }
     486                        assert( false );
     487                }
    448488        }
    449489
     
    466506                }
    467507        }
     508
    468509        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos ) {
    469                 (void)call;
    470                 (void)pos;
    471                 #warning unimplemented; needs to build AST/Expr.cpp
    472                 assertf(false, "unimplemented; needs to build AST/Expr.cpp");
    473                 // if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
    474                 //      return callArg( app, pos );
    475                 // } else if ( auto untyped = dynamic_cast< const ast::UntypedExpr * >( call ) ) {
    476                 //      return callArg( untyped, pos );
    477                 // } else if ( auto tupleAssn = dynamic_cast< const ast::TupleAssignExpr * >( call ) ) {
    478                 //      const std::list<ast::ptr<ast::Stmt>>& stmts = tupleAssn->stmtExpr->stmts->kids;
    479                 //      assertf( ! stmts.empty(), "TupleAssignExpr missing statements." );
    480                 //      const ExprStmt * stmt = strict_dynamic_cast< const ast::ExprStmt * >( stmts.back() );
    481                 //      const TupleExpr * tuple = strict_dynamic_cast< const ast::TupleExpr * >( stmt->expr );
    482                 //      assertf( ! tuple->exprs.empty(), "TupleAssignExpr has empty tuple expr.");
    483                 //      return getCallArg( tuple->exprs.front(), pos );
    484                 // } else if ( auto ctor = dynamic_cast< const ast::ImplicitCopyCtorExpr * >( call ) ) {
    485                 //      return getCallArg( ctor->callExpr, pos );
    486                 // } else {
    487                 //      assertf( false, "Unexpected expression type passed to getCallArg: %s",
    488                 //              toString( call ).c_str() );
    489                 // }
     510                if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
     511                        return callArg( app, pos );
     512                } else if ( auto untyped = dynamic_cast< const ast::UntypedExpr * >( call ) ) {
     513                        return callArg( untyped, pos );
     514                } else if ( auto tupleAssn = dynamic_cast< const ast::TupleAssignExpr * >( call ) ) {
     515                        const std::list<ast::ptr<ast::Stmt>>& stmts = tupleAssn->stmtExpr->stmts->kids;
     516                        assertf( ! stmts.empty(), "TupleAssignExpr missing statements." );
     517                        auto stmt  = strict_dynamic_cast< const ast::ExprStmt * >( stmts.back().get() );
     518                        auto tuple = strict_dynamic_cast< const ast::TupleExpr * >( stmt->expr.get() );
     519                        assertf( ! tuple->exprs.empty(), "TupleAssignExpr has empty tuple expr.");
     520                        return getCallArg( tuple->exprs.front(), pos );
     521                } else if ( auto ctor = dynamic_cast< const ast::ImplicitCopyCtorExpr * >( call ) ) {
     522                        return getCallArg( ctor->callExpr, pos );
     523                } else {
     524                        assertf( false, "Unexpected expression type passed to getCallArg: %s",
     525                                toString( call ).c_str() );
     526                }
    490527        }
    491528
    492529        namespace {
    493530                std::string funcName( Expression * func );
     531                std::string funcName( const ast::Expr * func );
    494532
    495533                template<typename CallExpr>
     
    500538                        assertf( ! expr->get_args().empty(), "Cannot get function name from dereference with no arguments" );
    501539                        return funcName( expr->get_args().front() );
     540                }
     541
     542                template<typename CallExpr>
     543                std::string handleDerefName( const CallExpr * expr ) {
     544                        // (*f)(x) => should get name "f"
     545                        std::string name = getFunctionName( expr );
     546                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
     547                        assertf( ! expr->args.empty(), "Cannot get function name from dereference with no arguments" );
     548                        return funcName( expr->args.front() );
    502549                }
    503550
     
    523570                        }
    524571                }
     572
     573                std::string funcName( const ast::Expr * func ) {
     574                        if ( const ast::NameExpr * nameExpr = dynamic_cast< const ast::NameExpr * >( func ) ) {
     575                                return nameExpr->name;
     576                        } else if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( func ) ) {
     577                                return varExpr->var->name;
     578                        }       else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
     579                                return funcName( castExpr->arg );
     580                        } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( func ) ) {
     581                                return memberExpr->member->name;
     582                        } else if ( const ast::UntypedMemberExpr * memberExpr = dynamic_cast< const ast::UntypedMemberExpr * > ( func ) ) {
     583                                return funcName( memberExpr->member );
     584                        } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * >( func ) ) {
     585                                return handleDerefName( untypedExpr );
     586                        } else if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( func ) ) {
     587                                return handleDerefName( appExpr );
     588                        } else if ( const ast::ConstructorExpr * ctorExpr = dynamic_cast< const ast::ConstructorExpr * >( func ) ) {
     589                                return funcName( getCallArg( ctorExpr->callExpr, 0 ) );
     590                        } else {
     591                                assertf( false, "Unexpected expression type being called as a function in call expression: %s", toString( func ).c_str() );
     592                        }
     593                }
    525594        }
    526595
     
    539608        }
    540609
     610        std::string getFunctionName( const ast::Expr * expr ) {
     611                // there's some unforunate overlap here with getCalledFunction. Ideally this would be able to use getCalledFunction and
     612                // return the name of the DeclarationWithType, but this needs to work for NameExpr and UntypedMemberExpr, where getCalledFunction
     613                // can't possibly do anything reasonable.
     614                if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( expr ) ) {
     615                        return funcName( appExpr->func );
     616                } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * > ( expr ) ) {
     617                        return funcName( untypedExpr->func );
     618                } else {
     619                        std::cerr << expr << std::endl;
     620                        assertf( false, "Unexpected expression type passed to getFunctionName" );
     621                }
     622        }
     623
    541624        Type * getPointerBase( Type * type ) {
    542625                if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
     
    551634        }
    552635        const ast::Type* getPointerBase( const ast::Type* t ) {
    553                 (void)t;
    554                 #warning needs to build Type.cpp before inclusion
    555                 assertf(false, "needs to build Type.cpp before inclusion");
    556                 // if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
    557                 //      return p->base;
    558                 // } else if ( const auto * a = dynamic_cast< const ast::ArrayType * >( t ) ) {
    559                 //      return a->base;
    560                 // } else if ( const auto * r = dynamic_cast< const ast::ReferenceType * >( t ) ) {
    561                 //      return r->base;
    562                 // } else return nullptr;
     636                if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
     637                        return p->base;
     638                } else if ( const auto * a = dynamic_cast< const ast::ArrayType * >( t ) ) {
     639                        return a->base;
     640                } else if ( const auto * r = dynamic_cast< const ast::ReferenceType * >( t ) ) {
     641                        return r->base;
     642                } else return nullptr;
    563643        }
    564644
Note: See TracChangeset for help on using the changeset viewer.