source: src/AST/Stmt.cpp@ 19a2890

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Stmt.cpp --
//
// Author           : Aaron B. Moss
// Created On       : Wed May  8 13:00:00 2019
// Last Modified By : Andrew Beach
// Last Modified On : Tue May  3 15:18:20 2022
// Update Count     : 4
//

#include "Stmt.hpp"

#include "Copy.hpp"
#include "DeclReplacer.hpp"
#include "Type.hpp"

namespace ast {

// --- CompoundStmt
CompoundStmt::CompoundStmt( const CompoundStmt& other ) : Stmt(other), kids() {
        // Statements can have weak references to them, if that happens inserting
        // the original node into the new list will put the original node in a
        // bad state, where it cannot be mutated. To avoid this, just perform an
        // additional shallow copy on the statement.
        for ( const Stmt * kid : other.kids ) {
                if ( kid->isReferenced() ) {
                        kids.emplace_back( ast::shallowCopy( kid ) );
                } else {
                        kids.emplace_back( kid );
                }
        }

        // when cloning a compound statement, we may end up cloning declarations which
        // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
        // does a shallow copy, so the VariableExpr will end up pointing to the original
        // declaration. If the original declaration is deleted, e.g. because the original
        // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
        // find all DeclarationWithType nodes (since a VariableExpr must point to a
        // DeclarationWithType) in the original CompoundStmt and map them to the cloned
        // node in the new CompoundStmt ('this'), then replace the Declarations referred to
        // by each VariableExpr according to the constructed map. Note that only the declarations
        // in the current level are collected into the map, because child CompoundStmts will
        // recursively execute this routine. There may be more efficient ways of doing
        // this.
        DeclReplacer::DeclMap declMap;
        auto origit = other.kids.begin();
        for ( const Stmt * s : kids ) {
                assert( origit != other.kids.end() );
                const Stmt * origStmt = *origit++;
                if ( const DeclStmt * declStmt = dynamic_cast< const DeclStmt * >( s ) ) {
                        const DeclStmt * origDeclStmt = strict_dynamic_cast< const DeclStmt * >( origStmt );
                        if ( const DeclWithType * dwt = dynamic_cast< const DeclWithType * > ( declStmt->decl.get() ) ) {
                                const DeclWithType * origdwt = strict_dynamic_cast< const DeclWithType * > ( origDeclStmt->decl.get() );
                                assert( dwt->name == origdwt->name );
                                declMap[ origdwt ] = dwt;
                        } else assert( ! dynamic_cast< const DeclWithType * > ( origDeclStmt->decl.get() ) );
                } else assert( ! dynamic_cast< const DeclStmt * > ( s ) );
        }
        if ( ! declMap.empty() ) {
                DeclReplacer::replace( this, declMap );
        }
}

// --- BranchStmt
BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, const std::vector<Label>&& labels )
                : Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
        // Make sure a syntax error hasn't slipped through.
        assert( Goto != kind || !target.empty() );
}

const char * BranchStmt::kindNames[] = {
    "Goto", "Break", "Continue", "FallThrough", "FallThroughDefault"
};

}

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //