CloneSet11


Previous CloneSetNext CloneSetBack to Main Report
Clone
Mass
Clones in
CloneSet
Parameter
Count
Clone
Similarity
Syntax Category
[Sequence Length]
28210.993compound_statement
Clone AbstractionParameter Bindings
Clone Instance
(Click to see clone)
Line CountSource Line
Source File
1291550
InclusionConstraintGraph/Graph.h
2281585
InclusionConstraintGraph/Graph.h
Clone Instance
1
Line Count
29
Source Line
1550
Source File
InclusionConstraintGraph/Graph.h

                                                                                                                             {
                                                                                                                                // bind indirect call node to function result node
                                                                                                                                Node *included_node = function->GetFunctionResult()->TransitivelyCollapse();
                                                                                                                                if (indirect_call != included_node) {
                                                                                                                                        #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
                                                                                                                                                if (!indirect_call->GetInclusionConstraints().IsIn(included_node)) {
                                                                                                                                                        bool already_included=false;
                                                                                                                                                        const SetOfNodes &inclusion_constraints = indirect_call->GetInclusionConstraints();
                                                                                                                                                        for (std::size_t ic=0; ic <inclusion_constraints.Size();ic++) {
                                                                                                                                                                if (inclusion_constraints[ic] != included_node) {
                                                                                                                                                                        if (inclusion_constraints[ic]->TransitivelyCollapse() == included_node) {
                                                                                                                                                                                already_included = true;
                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                }
                                                                                                                                                                else   {
                                                                                                                                                                        already_included = true;
                                                                                                                                                                       }
                                                                                                                                                                                                                      }
                                                                                                                                                        if (!already_included) {
                                                                                                                                                                indirect_call->EstablishIncludes(included_node);
                                                                                                                                                                changed_on_current_iteration = true;
                                                                                                                                                                number_of_changes++;
                                                                                                                                                                               }
                                                                                                                                                                                                                   }
                                                                                                                                        #else
                                                                                                                                                if (indirect_call->EstablishIncludes(included_node)) {
                                                                                                                                                        changed_on_current_iteration = true;
                                                                                                                                                        number_of_changes++;
                                                                                                                                                                                                     }
                                                                                                                                        #endif
                                                                                                                                                                    }
                                                                                                                             }


Clone Instance
2
Line Count
28
Source Line
1585
Source File
InclusionConstraintGraph/Graph.h

                                                                                                                                                {
                                                                                                                        Node *included_node = m_generic_function->GetFunctionResult()->TransitivelyCollapse();
                                                                                                                        if (indirect_call != included_node) {
                                                                                                                                #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
                                                                                                                                        if (!indirect_call->GetInclusionConstraints().IsIn(included_node)) {
                                                                                                                                                bool already_included=false;
                                                                                                                                                const SetOfNodes &inclusion_constraints = indirect_call->GetInclusionConstraints();
                                                                                                                                                for (std::size_t ic=0; ic <inclusion_constraints.Size();ic++) {
                                                                                                                                                        if (inclusion_constraints[ic] != included_node) {
                                                                                                                                                                if (inclusion_constraints[ic]->TransitivelyCollapse() == included_node) {
                                                                                                                                                                        already_included = true;
                                                                                                                                                                                                                                        }
                                                                                                                                                                                                        }
                                                                                                                                                        else   {
                                                                                                                                                                already_included = true;
                                                                                                                                                               }
                                                                                                                                                                                                              }
                                                                                                                                                if (!already_included) {
                                                                                                                                                        indirect_call->EstablishIncludes(included_node);
                                                                                                                                                        changed_on_current_iteration = true;
                                                                                                                                                        number_of_changes++;
                                                                                                                                                                       }
                                                                                                                                                                                                           }
                                                                                                                                #else
                                                                                                                                        if (indirect_call->EstablishIncludes(included_node)) {
                                                                                                                                                changed_on_current_iteration = true;
                                                                                                                                                number_of_changes++;
                                                                                                                                                                                             }
                                                                                                                                #endif
                                                                                                                                                            }
                                                                                                                                                }


Clone AbstractionParameter Count: 1Parameter Bindings

{
  // bind indirect call node to function result node
  Node * included_node = [[#variablea8970c0]]->GetFunctionResult()->TransitivelyCollapse();
  if (indirect_call != included_node)
    {
      #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
        if (!indirect_call->GetInclusionConstraints().IsIn(included_node))
          {
            bool already_included = false;
            const SetOfNodes &inclusion_constraints = indirect_call->GetInclusionConstraints();
            for (std::size_t ic = 0; ic < inclusion_constraints.Size(); ic++)
              {
                if (inclusion_constraints[ic] != included_node)
                  {
                    if (inclusion_constraints[ic]->TransitivelyCollapse() == included_node)
                      {
                        already_included = true;
                      }
                  }
                else
                  {
                    already_included = true;
                  }
              }
            if (!already_included)
              {
                indirect_call->EstablishIncludes(included_node);
                changed_on_current_iteration = true;
                number_of_changes++;
              }
          }
      #else
        if (indirect_call->EstablishIncludes(included_node))
          {
            changed_on_current_iteration = true;
            number_of_changes++;
          }
      #endif
    }
}
 

CloneAbstraction
Parameter Bindings
Parameter
Index
Clone
Instance
Parameter
Name
Value
11[[#a8970c0]]
m_generic_function 
12[[#a8970c0]]
function