Changeset 417117e


Ignore:
Timestamp:
Jun 28, 2019, 3:50:21 PM (2 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
03bf5c8
Parents:
55b6476
Message:

Assorted cleanup

Location:
src
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Expr.cpp

    r55b6476 r417117e  
    2020#include <vector>
    2121
     22#include "Eval.hpp"                // for call
    2223#include "GenericSubstitution.hpp"
    2324#include "Stmt.hpp"
     
    5152        assert( arg );
    5253
    53         UntypedExpr * ret = new UntypedExpr{
    54                 loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } }
    55         };
     54        UntypedExpr * ret = call( loc, "*?", arg );
    5655        if ( const Type * ty = arg->result ) {
    5756                const Type * base = InitTweak::getPointerBase( ty );
     
    7473        assert( lhs && rhs );
    7574
    76         UntypedExpr * ret = new UntypedExpr{
    77                 loc, new NameExpr{loc, "?=?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ lhs }, ptr<Expr>{ rhs } }
    78         };
     75        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
    7976        if ( lhs->result && rhs->result ) {
    8077                // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
  • src/AST/Pass.impl.hpp

    r55b6476 r417117e  
    19201920                                guard_symtab guard { *this };
    19211921                                auto new_node = p.second->accept( *this );
    1922                                 if (new_node != p.second) mutated = false;
     1922                                if (new_node != p.second) mutated = true;
    19231923                                new_map.insert({ p.first, new_node });
    19241924                        }
     
    19361936                                guard_symtab guard { *this };
    19371937                                auto new_node = p.second->accept( *this );
    1938                                 if (new_node != p.second) mutated = false;
     1938                                if (new_node != p.second) mutated = true;
    19391939                                new_map.insert({ p.first, new_node });
    19401940                        }
  • src/AST/TypeSubstitution.cpp

    r55b6476 r417117e  
    183183                // bind type variables from generic type instantiations
    184184                if ( auto decl = type->aggr() ) {
    185                         const std::vector<ptr<TypeDecl>> &baseParameters =  decl->params;
    186                         if (! type->params.empty()) {
    187                                 for ( const TypeDecl * tyvar : baseParameters ) {
     185                        if ( ! type->params.empty() ) {
     186                                for ( const TypeDecl * tyvar : decl->params ) {
    188187                                        boundVars.insert( tyvar->name );
    189188                                } // for
  • src/ResolvExpr/CandidateFinder.cpp

    r55b6476 r417117e  
    370370                                                        // push empty tuple expression
    371371                                                        newResult.parent = i;
    372                                                         std::vector< ast::ptr< ast::Expr > > emptyList;
    373                                                         newResult.expr =
    374                                                                 new ast::TupleExpr{ CodeLocation{}, move( emptyList ) };
     372                                                        newResult.expr = new ast::TupleExpr{ CodeLocation{}, {} };
    375373                                                        argType = newResult.expr->result;
    376374                                                } else {
  • src/ResolvExpr/ResolveTypeof.cc

    r55b6476 r417117e  
    153153                        }
    154154
    155                         return newType;
     155                        return newType.release();
    156156                }
    157157        };
  • src/ResolvExpr/Resolver.cc

    r55b6476 r417117e  
    11091109               
    11101110                // set up and resolve expression cast to void
    1111                 ast::CastExpr * untyped = new ast::CastExpr{ expr };
     1111                ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
    11121112                CandidateRef choice = findUnfinishedKindExpression(
    11131113                        untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
     
    12481248        };
    12491249
    1250         void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
     1250        void resolve( std::list< ast::ptr< ast::Decl > >& translationUnit ) {
    12511251                ast::Pass< Resolver_new > resolver;
    12521252                accept_all( translationUnit, resolver );
     
    12821282                ast::ptr< ast::FunctionDecl > ret = functionDecl;
    12831283                for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
    1284                         const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
     1284                        const ast::ptr< ast::DeclWithType > & d = functionDecl->type->params[i];
    12851285
    12861286                        if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
     
    12991299                        }
    13001300                }
    1301                 return ret.get();
     1301                return ret.release();
    13021302        }
    13031303
  • src/SymTab/Autogen.h

    r55b6476 r417117e  
    2121
    2222#include "AST/Decl.hpp"
     23#include "AST/Eval.hpp"
    2324#include "AST/Expr.hpp"
    2425#include "AST/Init.hpp"
     
    264265                }
    265266
    266                 ast::ptr< ast::Expr > begin, end, cmp, update;
     267                ast::ptr< ast::Expr > begin, end;
     268                std::string cmp, update;
    267269
    268270                if ( forward ) {
     
    270272                        begin = ast::ConstantExpr::from_int( loc, 0 );
    271273                        end = array->dimension;
    272                         cmp = new ast::NameExpr{ loc, "?<?" };
    273                         update = new ast::NameExpr{ loc, "++?" };
     274                        cmp = "?<?";
     275                        update = "++?";
    274276                } else {
    275277                        // generate: for ( int i = N-1; i >= 0; --i )
    276                         begin = new ast::UntypedExpr{
    277                                 loc, new ast::NameExpr{ loc, "?-?" },
    278                                 { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } };
     278                        begin = ast::call(
     279                                loc, "?-?", array->dimension, ast::ConstantExpr::from_int( loc, 1 ) );
    279280                        end = ast::ConstantExpr::from_int( loc, 0 );
    280                         cmp = new ast::NameExpr{ loc, "?>=?" };
    281                         update = new ast::NameExpr{ loc, "--?" };
     281                        cmp = "?>=?";
     282                        update = "--?";
    282283                }
    283284
     
    285286                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
    286287                        new ast::SingleInit{ loc, begin } };
    287                
    288                 ast::ptr< ast::Expr > cond = new ast::UntypedExpr{
    289                         loc, cmp, { new ast::VariableExpr{ loc, index }, end } };
    290                
    291                 ast::ptr< ast::Expr > inc = new ast::UntypedExpr{
    292                         loc, update, { new ast::VariableExpr{ loc, index } } };
    293                
    294                 ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{
    295                         loc, new ast::NameExpr{ loc, "?[?]" },
    296                         { dstParam, new ast::VariableExpr{ loc, index } } };
     288                ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
     289               
     290                ast::ptr< ast::Expr > cond = ast::call( loc, cmp, indexVar, end );
     291               
     292                ast::ptr< ast::Expr > inc = ast::call( loc, update, indexVar );
     293               
     294                ast::ptr< ast::Expr > dstIndex = ast::call( loc, "?[?]", dstParam, indexVar );
    297295               
    298296                // srcParam must keep track of the array indices to build the source parameter and/or
    299297                // array list initializer
    300                 srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension );
     298                srcParam.addArrayIndex( indexVar, array->dimension );
    301299
    302300                // for stmt's body, eventually containing call
     
    384382                if ( isUnnamedBitfield( obj ) ) return {};
    385383
    386                 ast::ptr< ast::Type > addCast = nullptr;
     384                ast::ptr< ast::Type > addCast;
    387385                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
    388386                        assert( dstParam->result );
  • src/Tuples/Explode.cc

    r55b6476 r417117e  
    129129                        for ( const ast::Expr * expr : tupleExpr->exprs ) {
    130130                                exprs.emplace_back( applyCast( expr, false ) );
    131                                 //exprs.emplace_back( ast::ptr< ast::Expr >( applyCast( expr, false ) ) );
    132131                        }
    133132                        if ( first ) {
  • src/Tuples/Explode.h

    r55b6476 r417117e  
    210210                        }
    211211                        // Cast a reference away to a value-type to allow further explosion.
    212                         if ( dynamic_cast< const ast::ReferenceType *>( local->result.get() ) ) {
     212                        if ( local->result.as< ast::ReferenceType >() ) {
    213213                                local = new ast::CastExpr{ local, tupleType };
    214214                        }
     
    220220                                // delete idx;
    221221                        }
    222                         // delete local;
    223222                }
    224223        } else {
Note: See TracChangeset for help on using the changeset viewer.