source: src/SynTree/Mutator.cc @ 6a8df56

//
// 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.
//
// Mutator.cc --
//
// Author           : Richard C. Bilson
// Created On       : Mon May 18 07:44:20 2015
// Last Modified By : Peter A. Buhr
// Last Modified On : Thu Aug 17 15:39:37 2017
// Update Count     : 27
//

#include <cassert>             // for assert
#include <list>                // for list

#include "Attribute.h"         // for Attribute
#include "Declaration.h"       // for ObjectDecl, Declaration, DeclarationWi...
#include "Expression.h"        // for Expression, ConstantExpr, ConditionalExpr
#include "Initializer.h"       // for ConstructorInit, Initializer, Designation
#include "Mutator.h"
#include "Statement.h"         // for Statement, CatchStmt, AsmStmt, ForStmt
#include "Type.h"              // for Type, Type::ForallList, AttrType, Arra...
#include "TypeSubstitution.h"  // for TypeSubstitution

class Constant;
class Subrange;

Mutator::Mutator() {}

Mutator::~Mutator() {}

Type * Mutator::mutate( TupleType *tupleType ) {
        mutateAll( tupleType->get_forall(), *this );
        mutateAll( tupleType->get_types(), *this );
        mutateAll( tupleType->get_members(), *this );
        return tupleType;
}

Type * Mutator::mutate( TypeofType *typeofType ) {
        assert( typeofType->get_expr() );
        typeofType->set_expr( typeofType->get_expr()->acceptMutator( *this ) );
        return typeofType;
}

Type * Mutator::mutate( AttrType *attrType ) {
        if ( attrType->get_isType() ) {
                assert( attrType->get_type() );
                attrType->set_type( attrType->get_type()->acceptMutator( *this ) );
        } else {
                assert( attrType->get_expr() );
                attrType->set_expr( attrType->get_expr()->acceptMutator( *this ) );
        }
        return attrType;
}

Type * Mutator::mutate( VarArgsType *varArgsType ) {
        mutateAll( varArgsType->get_forall(), *this );
        return varArgsType;
}

Type * Mutator::mutate( ZeroType *zeroType ) {
        mutateAll( zeroType->get_forall(), *this );
        return zeroType;
}

Type * Mutator::mutate( OneType *oneType ) {
        mutateAll( oneType->get_forall(), *this );
        return oneType;
}


Designation * Mutator::mutate( Designation * designation ) {
        mutateAll( designation->get_designators(), *this );
        return designation;
}

Initializer * Mutator::mutate( SingleInit *singleInit ) {
        singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
        return singleInit;
}

Initializer * Mutator::mutate( ListInit *listInit ) {
        mutateAll( listInit->get_designations(), *this );
        mutateAll( listInit->get_initializers(), *this );
        return listInit;
}

Initializer * Mutator::mutate( ConstructorInit *ctorInit ) {
        ctorInit->set_ctor( maybeMutate( ctorInit->get_ctor(), *this ) );
        ctorInit->set_dtor( maybeMutate( ctorInit->get_dtor(), *this ) );
        ctorInit->set_init( maybeMutate( ctorInit->get_init(), *this ) );
        return ctorInit;
}


Subrange * Mutator::mutate( Subrange *subrange ) {
        return subrange;
}


Constant * Mutator::mutate( Constant *constant ) {
        return constant;
}

Attribute * Mutator::mutate( Attribute * attribute ) {
        mutateAll( attribute->parameters, *this );
        return attribute;
}

TypeSubstitution * Mutator::mutate( TypeSubstitution * sub ) {
        for ( auto & p : sub->typeEnv ) {
                p.second = maybeMutate( p.second, *this );
        }
        for ( auto & p : sub->varEnv ) {
                p.second = maybeMutate( p.second, *this );
        }
        return sub;
}

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