rem: return copy (source, new_dest, new_dst, x, &unused, NULL);
add: ok = copy (source, new_dest, 0, x, &unused, NULL);
context: do_copy (int n_files, char **file, const char *target_directory,	 struct cp_options *x){  const char *dest;  struct stat sb;  int new_dst = 0;  int ret = 0;  int dest_is_dir = 0;  if (n_files <= 0)    {      error (0, 0, _("missing file argument"));      usage (EXIT_FAILURE);    }  if (n_files == 1 && !target_directory)    {      error (0, 0, _("missing destination file"));      usage (EXIT_FAILURE);    }  if (target_directory)    dest = target_directory;  else    {      dest = file[n_files - 1];      --n_files;    }  /* Initialize these hash tables only if we'll need them.     The problems they're used to detect can arise only if     there are two or more files to copy.  */  if (n_files >= 2)    {      dest_info_init (x);      src_info_init (x);    }  if (lstat (dest, &sb))    {      if (errno != ENOENT)	{	  error (0, errno, _("accessing %s"), quote (dest));	  return 1;	}      new_dst = 1;    }  else    {      struct stat sbx;      /* If `dest' is not a symlink to a nonexistent file, use	 the results of stat instead of lstat, so we can copy files	 into symlinks to directories. */      if (stat (dest, &sbx) == 0)	sb = sbx;      dest_is_dir = S_ISDIR (sb.st_mode);    }  if (!dest_is_dir)    {      if (target_directory)	{	  error (0, 0, _("%s: specified target is not a directory"),		 quote (dest));	  usage (EXIT_FAILURE);	}      if (n_files > 1)	{	  error (0, 0,	 _("copying multiple files, but last argument %s is not a directory"),	     quote (dest));	  usage (EXIT_FAILURE);	}    }  if (dest_is_dir)    {      /* cp file1...filen edir	 Copy the files `file1' through `filen'	 to the existing directory `edir'. */      int i;      for (i = 0; i < n_files; i++)	{	  char *dst_path;	  int parent_exists = 1; /* True if dir_name (dst_path) exists. */	  struct dir_attr *attr_list;	  char *arg_in_concat = NULL;	  char *arg = file[i];	  /* Trailing slashes are meaningful (i.e., maybe worth preserving)	     only in the source file names.  */	  if (remove_trailing_slashes)	    strip_trailing_slashes (arg);	  if (flag_path)	    {	      char *arg_no_trailing_slash;	      /* Use `arg' without trailing slashes in constructing destination		 file names.  Otherwise, we can end up trying to create a		 directory via `mkdir ("dst/foo/"...', which is not portable.		 It fails, due to the trailing slash, on at least		 NetBSD 1.[34] systems.  */	      ASSIGN_STRDUPA (arg_no_trailing_slash, arg);	      strip_trailing_slashes (arg_no_trailing_slash);	      /* Append all of `arg' (minus any trailing slash) to `dest'.  */	      dst_path = path_concat (dest, arg_no_trailing_slash,				      &arg_in_concat);	      if (dst_path == NULL)		xalloc_die ();	      /* For --parents, we have to make sure that the directory	         dir_name (dst_path) exists.  We may have to create a few	         leading directories. */	      parent_exists = !make_path_private (dst_path,						  arg_in_concat - dst_path,						  S_IRWXU,						  (x->verbose						   ? "%s -> %s\n" : NULL),						  &attr_list, &new_dst,						  x->xstat);	    }  	  else  	    {	      char *arg_base;	      /* Append the last component of `arg' to `dest'.  */	      ASSIGN_BASENAME_STRDUPA (arg_base, arg);	      /* For `cp -R source/.. dest', don't copy into `dest/..'. */	      dst_path = (STREQ (arg_base, "..")			  ? xstrdup (dest)			  : path_concat (dest, arg_base, NULL));	    }	  if (!parent_exists)	    {	      /* make_path_private failed, so don't even attempt the copy. */	      ret = 1;  	    }	  else	    {	      int copy_into_self;	      ret |= copy (arg, dst_path, new_dst, x, &copy_into_self, NULL);	      if (flag_path)		{		  ret |= re_protect (dst_path, arg_in_concat - dst_path,				     attr_list, x);		}	    }	  free (dst_path);	}      return ret;    }  else /* if (n_files == 1) */    {      char *new_dest;      char *source;      int unused;      struct stat source_stats;      if (flag_path)	{	  error (0, 0,	       _("when preserving paths, the destination must be a directory"));	  usage (EXIT_FAILURE);	}      source = file[0];      /* When the force and backup options have been specified and	 the source and destination are the same name for an existing	 regular file, convert the user's command, e.g.,	 `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'	 where SUFFIX is determined by any version control options used.  */      if (x->unlink_dest_after_failed_open	  && x->backup_type != none	  && STREQ (source, dest)	  && !new_dst && S_ISREG (sb.st_mode))	{	  static struct cp_options x_tmp;	  new_dest = find_backup_file_name (dest, x->backup_type);	  /* Set x->backup_type to `none' so that the normal backup	     mechanism is not used when performing the actual copy.	     backup_type must be set to `none' only *after* the above	     call to find_backup_file_name -- that function uses	     backup_type to determine the suffix it applies.  */	  x_tmp = *x;	  x_tmp.backup_type = none;	  x = &x_tmp;	  if (new_dest == NULL)	    xalloc_die ();	}      /* When the destination is specified with a trailing slash and the	 source exists but is not a directory, convert the user's command	 `cp source dest/' to `cp source dest/basename(source)'.  Doing	 this ensures that the command `cp non-directory file/' will now	 fail rather than performing the copy.  COPY diagnoses the case of	 `cp directory non-directory'.  */      else if (dest[strlen (dest) - 1] == '/'	  && lstat (source, &source_stats) == 0	  && !S_ISDIR (source_stats.st_mode))	{	  char *source_base;	  ASSIGN_BASENAME_STRDUPA (source_base, source);	  new_dest = (char *) alloca (strlen (dest)				      + strlen (source_base) + 1);	  stpcpy (stpcpy (new_dest, dest), source_base);	}      else	{	  new_dest = (char *) dest;	}      return copy (source, new_dest, new_dst, x, &unused, NULL);    }  /* unreachable */}