rem: return 1;
add: return false;
context: do_link (const char *source, const char *dest){  struct stat source_stats;  struct stat dest_stats;  char *dest_backup = NULL;  int lstat_status;  int backup_succeeded = 0;  /* Use stat here instead of lstat.     On SVR4, link does not follow symlinks, so this check disallows     making hard links to symlinks that point to directories.  Big deal.     On other systems, link follows symlinks, so this check is right.  */  if (!symbolic_link)    {      if (STAT_LIKE_LINK (source, &source_stats) != 0)	{	  error (0, errno, _("accessing %s"), quote (source));	  return 1;	}      if (S_ISLNK (source_stats.st_mode))	{	  error (0, 0, _("%s: warning: making a hard link to a symbolic link\ is not portable"),		 quote (source));	}      if (!hard_dir_link && S_ISDIR (source_stats.st_mode))	{	  error (0, 0, _("%s: hard link not allowed for directory"),		 quote (source));	  return 1;	}    }  lstat_status = lstat (dest, &dest_stats);  if (lstat_status != 0 && errno != ENOENT)    {      error (0, errno, _("accessing %s"), quote (dest));      return 1;    }  /* If the destination is a directory or (it is a symlink to a directory     and the user has not specified --no-dereference), then form the     actual destination name by appending base_name (source) to the     specified destination directory.  */  if ((lstat_status == 0       && S_ISDIR (dest_stats.st_mode))#ifdef S_ISLNK      || (dereference_dest_dir_symlinks	  && (lstat_status == 0	      && S_ISLNK (dest_stats.st_mode)	      && isdir (dest)))#endif     )    {      /* Target is a directory; build the full filename. */      char *new_dest;      PATH_BASENAME_CONCAT (new_dest, dest, source);      dest = new_dest;      /* Get stats for new DEST.  */      lstat_status = lstat (dest, &dest_stats);      if (lstat_status != 0 && errno != ENOENT)	{	  error (0, errno, _("accessing %s"), quote (dest));	  return 1;	}    }  /* If --force (-f) has been specified without --backup, then before     making a link ln must remove the destination file if it exists.     (with --backup, it just renames any existing destination file)     But if the source and destination are the same, don't remove     anything and fail right here.  */  if (remove_existing_files      && lstat_status == 0      /* Allow `ln -sf --backup k k' to succeed in creating the	 self-referential symlink, but don't allow the hard-linking	 equivalent: `ln -f k k' (with or without --backup) to get	 beyond this point, because the error message you'd get is	 misleading.  */      && (backup_type == none || !symbolic_link)      && (!symbolic_link || stat (source, &source_stats) == 0)      && source_stats.st_dev == dest_stats.st_dev      && source_stats.st_ino == dest_stats.st_ino      /* The following detects whether removing DEST will also remove 	 SOURCE.  If the file has only one link then both are surely 	 the same link.  Otherwise check whether they point to the same	 name in the same directory.  */      && (source_stats.st_nlink == 1 || same_name (source, dest)))    {      error (0, 0, _("%s and %s are the same file"),	     quote_n (0, source), quote_n (1, dest));      return 1;    }  if (lstat_status == 0 || lstat (dest, &dest_stats) == 0)    {      if (S_ISDIR (dest_stats.st_mode))	{	  error (0, 0, _("%s: cannot overwrite directory"), quote (dest));	  return 1;	}      if (interactive)	{	  fprintf (stderr, _("%s: replace %s? "), program_name, quote (dest));	  if (!yesno ())	    return 0;	}      else if (!remove_existing_files && backup_type == none)	{	  error (0, 0, _("%s: File exists"), quote (dest));	  return 1;	}      if (backup_type != none)	{	  char *tmp_backup = find_backup_file_name (dest, backup_type);	  if (tmp_backup == NULL)	    xalloc_die ();	  dest_backup = (char *) alloca (strlen (tmp_backup) + 1);	  strcpy (dest_backup, tmp_backup);	  free (tmp_backup);	  if (rename (dest, dest_backup))	    {	      if (errno != ENOENT)		{		  error (0, errno, _("cannot backup %s"), quote (dest));		  return 1;		}	      else		dest_backup = NULL;	    }	  else	    {	      backup_succeeded = 1;	    }	}      /* Try to unlink DEST even if we may have renamed it.  In some unusual	 cases (when DEST and DEST_BACKUP are hard-links that refer to the	 same file), rename succeeds and DEST remains.  If we didn't remove	 DEST in that case, the subsequent LINKFUNC call would fail.  */      if (unlink (dest) && errno != ENOENT)	{	  error (0, errno, _("cannot remove %s"), quote (dest));	  return 1;	}    }  else if (errno != ENOENT)    {      error (0, errno, _("accessing %s"), quote (dest));      return 1;    }  if (verbose)    {      printf ((symbolic_link	       ? _("create symbolic link %s to %s")	       : _("create hard link %s to %s")),	      quote_n (0, dest), quote_n (1, source));      if (backup_succeeded)	printf (_(" (backup: %s)"), quote (dest_backup));      putchar ('\n');    }  if ((*linkfunc) (source, dest) == 0)    {      return 0;    }  error (0, errno,	 (symbolic_link	  ? _("creating symbolic link %s to %s")	  : _("creating hard link %s to %s")),	 quote_n (0, dest), quote_n (1, source));  if (dest_backup)    {      if (rename (dest_backup, dest))	error (0, errno, _("cannot un-backup %s"), quote (dest));    }  return 1;}