code: def gen_for(self, node, target, local_iter, local_iter_decl, loop_body):
          
          # Choose target variable for iterator (which is iterator type)
          local_target = "__target{0}".format(id(node))
          local_target_decl = self.types.builder.IteratorOfType(local_iter_decl)
  
          # If variable is local to the for body it's a ref to the iterator value
          # type
          if node.target.id in self.scope[node] and not hasattr(self, 'yields'):
              local_type = "auto&&"
          else:
              local_type = ""
  
          # Assign iterable value
          loop_body_prelude = Statement("{} {}= *{}".format(local_type,
                                                            target,
                                                            local_target))
  
          # Create the loop
          assign = self.make_assign(local_target_decl, local_target, local_iter)
          loop = For("{}.begin()".format(assign),
                     "{0} < {1}.end()".format(local_target, local_iter),
                     "++{0}".format(local_target),
                     Block([loop_body_prelude, loop_body]))
          return [self.process_omp_attachements(node, loop)]
docs: Create For representation on iterator for Cxx generation.
  
          Examples
          --------
          >> "omp parallel for"
          >> for i in xrange(10):
          >>     ... do things ...
  
          Becomes
  
          >> "omp parallel for shared(__iterX)"
          >> for(decltype(__iterX)::iterator __targetX = __iterX.begin();
                 __targetX < __iterX.end(); ++__targetX)
          >>         auto&& i = *__targetX;
          >>     ... do things ...
  
          It the case of not local variable, typing for `i` disappear and typing
          is removed for iterator in case of yields statement in function.