rem: sprintf (p, "%s %3lu ", modebuf, (unsigned long) f->stat.st_nlink); p += strlen (p);  if (print_owner) p += format_user (p, f->stat.st_uid);  if (print_group) { char const *group_name = (numeric_ids ? NULL : getgroup (f->stat.st_gid)); if (group_name) sprintf (p, "%-8s ", group_name); else sprintf (p, "%-8lu ", (unsigned long) f->stat.st_gid); p += strlen (p); }  if (print_author) p += format_user (p, f->stat.st_author);
add: { char hbuf[INT_BUFSIZE_BOUND (uintmax_t)]; sprintf (p, "%s %*s ", modebuf, nlink_width, umaxtostr (f->stat.st_nlink, hbuf)); } p += sizeof modebuf + nlink_width + 1;  DIRED_INDENT ();  if (print_owner | print_group | print_author) { DIRED_FPUTS (buf, stdout, p - buf);  if (print_owner) format_user (f->stat.st_uid, owner_width);  if (print_group) format_group (f->stat.st_gid, group_width);  if (print_author) format_user (f->stat.st_author, author_width);  p = buf; }
context: print_long_format (const struct fileinfo *f){  char modebuf[12];  char init_bigbuf    [LONGEST_HUMAN_READABLE + 1		/* inode */     + LONGEST_HUMAN_READABLE + 1	/* size in blocks */     + sizeof (modebuf) - 1 + 1		/* mode string */     + LONGEST_HUMAN_READABLE + 1	/* st_nlink */     + ID_LENGTH_MAX + 1		/* owner name */     + ID_LENGTH_MAX + 1		/* group name */     + ID_LENGTH_MAX + 1		/* author name */     + LONGEST_HUMAN_READABLE + 1	/* major device number */     + LONGEST_HUMAN_READABLE + 1	/* minor device number */     + 35 + 1	/* usual length of time/date -- may be longer; see below */     ];  char *buf = init_bigbuf;  size_t bufsize = sizeof (init_bigbuf);  size_t s;  char *p;  time_t when;  int when_ns IF_LINT (= 0);  struct tm *when_local;  /* Compute mode string.  On most systems, it's based on st_mode.     On systems with migration (via the stat.st_dm_mode field), use     the file's migrated status.  */  mode_string (ST_DM_MODE (f->stat), modebuf);  modebuf[10] = (FILE_HAS_ACL (f) ? '+' : ' ');  modebuf[11] = '\0';  switch (time_type)    {    case time_ctime:      when = f->stat.st_ctime;      when_ns = TIMESPEC_NS (f->stat.st_ctim);      break;    case time_mtime:      when = f->stat.st_mtime;      when_ns = TIMESPEC_NS (f->stat.st_mtim);      break;    case time_atime:      when = f->stat.st_atime;      when_ns = TIMESPEC_NS (f->stat.st_atim);      break;    }  p = buf;  if (print_inode)    {      char hbuf[LONGEST_HUMAN_READABLE + 1];      sprintf (p, "%*s ", INODE_DIGITS, umaxtostr (f->stat.st_ino, hbuf));      p += strlen (p);    }  if (print_block_size)    {      char hbuf[LONGEST_HUMAN_READABLE + 1];      sprintf (p, "%*s ", block_size_size,	       human_readable (ST_NBLOCKS (f->stat), hbuf, human_output_opts,			       ST_NBLOCKSIZE, output_block_size));      p += strlen (p);    }  /* The last byte of the mode string is the POSIX     "optional alternate access method flag".  */  sprintf (p, "%s %3lu ", modebuf, (unsigned long) f->stat.st_nlink);  p += strlen (p);  if (print_owner)    p += format_user (p, f->stat.st_uid);  if (print_group)    {      char const *group_name = (numeric_ids ? NULL : getgroup (f->stat.st_gid));      if (group_name)	sprintf (p, "%-8s ", group_name);      else	sprintf (p, "%-8lu ", (unsigned long) f->stat.st_gid);      p += strlen (p);    }  if (print_author)    p += format_user (p, f->stat.st_author);#ifndef __BEOS__  if (S_ISCHR (f->stat.st_mode) || S_ISBLK (f->stat.st_mode))    sprintf (p, "%3lu, %3lu ",	     (unsigned long) major (f->stat.st_rdev),	     (unsigned long) minor (f->stat.st_rdev));  else#endif    {      char hbuf[LONGEST_HUMAN_READABLE + 1];      uintmax_t size = f->stat.st_size;      /* POSIX requires that the size be printed without a sign, even	 when negative.  Assume the typical case where negative sizes	 are actually positive values that have wrapped around.  */      size += (f->stat.st_size < 0) * ((uintmax_t) OFF_T_MAX - OFF_T_MIN + 1);      sprintf (p, "%8s ",	       human_readable (size, hbuf, human_output_opts,			       1, file_output_block_size));    }  p += strlen (p);  if ((when_local = localtime (&when)))    {      time_t six_months_ago;      int recent;      char const *fmt;      /* If the file appears to be in the future, update the current	 time, in case the file happens to have been modified since	 the last time we checked the clock.  */      if (current_time < when	  || (current_time == when && current_time_ns < when_ns))	{	  /* Note that get_current_time calls gettimeofday which, on some non-	     compliant systems, clobbers the buffer used for localtime's result.	     But it's ok here, because we use a gettimeofday wrapper that	     saves and restores the buffer around the gettimeofday call.  */	  get_current_time ();	}      /* Consider a time to be recent if it is within the past six	 months.  A Gregorian year has 365.2425 * 24 * 60 * 60 ==	 31556952 seconds on the average.  Write this value as an	 integer constant to avoid floating point hassles.  */      six_months_ago = current_time - 31556952 / 2;      recent = (six_months_ago <= when		&& (when < current_time		    || (when == current_time && when_ns <= current_time_ns)));      fmt = long_time_format[recent];      for (;;)	{	  char *newbuf;	  *p = '\1';	  s = nstrftime (p, buf + bufsize - p - 1, fmt,			 when_local, 0, when_ns);	  if (s || ! *p)	    break;	  newbuf = alloca (bufsize *= 2);	  memcpy (newbuf, buf, p - buf);	  p = newbuf + (p - buf);	  buf = newbuf;	}      p += s;      *p++ = ' ';      /* NUL-terminate the string -- fputs (via DIRED_FPUTS) requires it.  */      *p = '\0';    }  else    {      /* The time cannot be represented as a local time;	 print it as a huge integer number of seconds.  */      char hbuf[INT_BUFSIZE_BOUND (intmax_t)];      sprintf (p, "%*s ", long_time_expected_width (),	       (TYPE_SIGNED (time_t)		? imaxtostr (when, hbuf)		: umaxtostr (when, hbuf)));      p += strlen (p);    }  DIRED_INDENT ();  DIRED_FPUTS (buf, stdout, p - buf);  print_name_with_quoting (f->name, FILE_OR_LINK_MODE (f), f->linkok,			   &dired_obstack);  if (f->filetype == symbolic_link)    {      if (f->linkname)	{	  DIRED_FPUTS_LITERAL (" -> ", stdout);	  print_name_with_quoting (f->linkname, f->linkmode, f->linkok - 1,				   NULL);	  if (indicator_style != none)	    print_type_indicator (f->linkmode);	}    }  else if (indicator_style != none)    print_type_indicator (f->stat.st_mode);}