/usr/src/gnu/usr.bin/cvs/src/history.c

Bug Summary

File:	src/gnu/usr.bin/cvs/src/history.c
Warning:	line 1538, column 31 Null pointer passed as 1st argument to string length function
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name history.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/cvs/obj/src -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/cvs/src -I .. -I . -I /usr/src/gnu/usr.bin/cvs/lib -I /usr/src/gnu/usr.bin/cvs/diff -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/cvs/obj/src -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/cvs/src/history.c
1/*
*
*    You may distribute under the terms of the GNU General Public License
*    as specified in the README file that comes with the CVS 1.0 kit.
*
* **************** History of Users and Module ****************
*
* LOGGING:  Append record to "${CVSROOT}/CVSROOTADM/CVSROOTADM_HISTORY".
*
* On For each Tag, Add, Checkout, Commit, Update or Release command,
* one line of text is written to a History log.
*
*	X date | user | CurDir | special | rev(s) | argument '\n'
*
* where: [The spaces in the example line above are not in the history file.]
*
*  X		is a single character showing the type of event:
*		T	"Tag" cmd.
*		O	"Checkout" cmd.
*              E       "Export" cmd.
*		F	"Release" cmd.
*		W	"Update" cmd - No User file, Remove from Entries file.
*		U	"Update" cmd - File was checked out over User file.
*		G	"Update" cmd - File was merged successfully.
*		C	"Update" cmd - File was merged and shows overlaps.
*		M	"Commit" cmd - "Modified" file.
*		A	"Commit" cmd - "Added" file.
*		R	"Commit" cmd - "Removed" file.
*
*  date	is a fixed length 8-char hex representation of a Unix time_t.
*		[Starting here, variable fields are delimited by '|' chars.]
*
*  user	is the username of the person who typed the command.
*
*  CurDir	The directory where the action occurred.  This should be the
*		absolute path of the directory which is at the same level as
*		the "Repository" field (for W,U,G,C & M,A,R).
*
*  Repository	For record types [W,U,G,C,M,A,R] this field holds the
*		repository read from the administrative data where the
*		command was typed.
*		T	"A" --> New Tag, "D" --> Delete Tag
*			Otherwise it is the Tag or Date to modify.
*		O,F,E	A "" (null field)
*
*  rev(s)	Revision number or tag.
*		T	The Tag to apply.
*		O,E	The Tag or Date, if specified, else "" (null field).
*		F	"" (null field)
*		W	The Tag or Date, if specified, else "" (null field).
*		U	The Revision checked out over the User file.
*		G,C	The Revision(s) involved in merge.
*		M,A,R	RCS Revision affected.
*
*  argument	The module (for [TOEUF]) or file (for [WUGCMAR]) affected.
*
*
*** Report categories: "User" and "Since" modifiers apply to all reports.
*			[For "sort" ordering see the "sort_order" routine.]
*
*   Extract list of record types
*
*	-e, -x [TOEFWUGCMAR]
*
*		Extracted records are simply printed, No analysis is performed.
*		All "field" modifiers apply.  -e chooses all types.
*
*   Checked 'O'ut modules
*
*	-o, -w
*		Checked out modules.  'F' and 'O' records are examined and if
*		the last record for a repository/file is an 'O', a line is
*		printed.  "-w" forces the "working dir" to be used in the
*		comparison instead of the repository.
*
*   Committed (Modified) files
*
*	-c, -l, -w
*		All 'M'odified, 'A'dded and 'R'emoved records are examined.
*		"Field" modifiers apply.  -l forces a sort by file within user
*		and shows only the last modifier.  -w works as in Checkout.
*
*		Warning: Be careful with what you infer from the output of
*			 "cvs hi -c -l".  It means the last time *you*
*			 changed the file, not the list of files for which
*			 you were the last changer!!!
*
*   Module history for named modules.
*	-m module, -l
*
*		This is special.  If one or more modules are specified, the
*		module names are remembered and the files making up the
*		modules are remembered.  Only records matching exactly those
*		files and repositories are shown.  Sorting by "module", then
*		filename, is implied.  If -l ("last modified") is specified,
*		then "update" records (types WUCG), tag and release records
*		are ignored and the last (by date) "modified" record.
*
*   TAG history
*
*	-T	All Tag records are displayed.
*
*** Modifiers.
*
*   Since ...		[All records contain a timestamp, so any report
*			 category can be limited by date.]
*
*	-D date		- The "date" is parsed into a Unix "time_t" and
*			  records with an earlier time stamp are ignored.
*	-r rev/tag	- A "rev" begins with a digit.  A "tag" does not.  If
*			  you use this option, every file is searched for the
*			  indicated rev/tag.
*	-t tag		- The "tag" is searched for in the history file and no
*			  record is displayed before the tag is found.  An
*			  error is printed if the tag is never found.
*	-b string	- Records are printed only back to the last reference
*			  to the string in the "module", "file" or
*			  "repository" fields.
*
*   Field Selections	[Simple comparisons on existing fields.  All field
*			 selections are repeatable.]
*
*	-a		- All users.
*	-u user		- If no user is given and '-a' is not given, only
*			  records for the user typing the command are shown.
*			  ==> If -a or -u is not specified, just use "self".
*
*	-f filematch	- Only records in which the "file" field contains the
*			  string "filematch" are considered.
*
*	-p repository	- Only records in which the "repository" string is a
*			  prefix of the "repos" field are considered.
*
*	-n modulename	- Only records which contain "modulename" in the
*			  "module" field are considered.
*
*
* EXAMPLES: ("cvs history", "cvs his" or "cvs hi")
*
*** Checked out files for username.  (default self, e.g. "dgg")
*	cvs hi			[equivalent to: "cvs hi -o -u dgg"]
*	cvs hi -u user		[equivalent to: "cvs hi -o -u user"]
*	cvs hi -o		[equivalent to: "cvs hi -o -u dgg"]
*
*** Committed (modified) files from the beginning of the file.
*	cvs hi -c [-u user]
*
*** Committed (modified) files since Midnight, January 1, 1990:
*	cvs hi -c -D 'Jan 1 1990' [-u user]
*
*** Committed (modified) files since tag "TAG" was stored in the history file:
*	cvs hi -c -t TAG [-u user]
*
*** Committed (modified) files since tag "TAG" was placed on the files:
*	cvs hi -c -r TAG [-u user]
*
*** Who last committed file/repository X?
*	cvs hi -c -l -[fp] X
*
*** Modified files since tag/date/file/repos?
*	cvs hi -c {-r TAG | -D Date | -b string}
*
*** Tag history
*	cvs hi -T
*
*** History of file/repository/module X.
*	cvs hi -[fpn] X
*
*** History of user "user".
*	cvs hi -e -u user
*
*** Dump (eXtract) specified record types
*	cvs hi -x [TOFWUGCMAR]
*
*
* FUTURE:		J[Join], I[Import]  (Not currently implemented.)
*
*/

180#include "cvs.h"
181#include "savecwd.h"

183static struct hrec
184{
  char *type;		/* Type of record (In history record) */
  char *user;		/* Username (In history record) */
  char *dir;		/* "Compressed" Working dir (In history record) */
  char *repos;	/* (Tag is special.) Repository (In history record) */
  char *rev;		/* Revision affected (In history record) */
  char *file;		/* Filename (In history record) */
  char *end;		/* Ptr into repository to copy at end of workdir */
  char *mod;		/* The module within which the file is contained */
  time_t date;	/* Calculated from date stored in record */
  long idx;		/* Index of record, for "stable" sort. */
195} *hrec_head;
196static long hrec_idx;


199static void fill_hrec PROTO((char *line, struct hrec * hr))(char *line, struct hrec * hr);
200static int accept_hrec PROTO((struct hrec * hr, struct hrec * lr))(struct hrec * hr, struct hrec * lr);
201static int select_hrec PROTO((struct hrec * hr))(struct hrec * hr);
202static int sort_order PROTO((const PTR l, const PTR r))(const void * l, const void * r);
203static int within PROTO((char *find, char *string))(char *find, char *string);
204static void expand_modules PROTO((void))(void);
205static void read_hrecs PROTO((char *fname))(char *fname);
206static void report_hrecs PROTO((void))(void);
207static void save_file PROTO((char *dir, char *name, char *module))(char *dir, char *name, char *module);
208static void save_module PROTO((char *module))(char *module);
209static void save_user PROTO((char *name))(char *name);

211#define ALL_REC_TYPES"TOEFWUCGMAR" "TOEFWUCGMAR"
212#define USER_INCREMENT2	2
213#define FILE_INCREMENT128	128
214#define MODULE_INCREMENT5 5
215#define HREC_INCREMENT128	128

217static short report_count;

219static short extract;
220static short v_checkout;
221static short modified;
222static short tag_report;
223static short module_report;
224static short working;
225static short last_entry;
226static short all_users;

228static short user_sort;
229static short repos_sort;
230static short file_sort;
231static short module_sort;

233static short tz_local;
234static time_t tz_seconds_east_of_GMT;
235static char *tz_name = "+0000";

237char *logHistory = ALL_REC_TYPES"TOEFWUCGMAR";

239/* -r, -t, or -b options, malloc'd.  These are "" if the option in
 question is not specified or is overridden by another option.  The
 main reason for using "" rather than NULL is historical.  Together
 with since_date, these are a mutually exclusive set; one overrides the
 others.  */
244static char *since_rev;
245static char *since_tag;
246static char *backto;
247/* -D option, or 0 if not specified.  RCS format.  */
248static char * since_date;

250static struct hrec *last_since_tag;
251static struct hrec *last_backto;

253/* Record types to look for, malloc'd.  Probably could be statically
 allocated, but only if we wanted to check for duplicates more than
 we do.  */
256static char *rec_types;

258static int hrec_count;
259static int hrec_max;

261static char **user_list;	/* Ptr to array of ptrs to user names */
262static int user_max;		/* Number of elements allocated */
263static int user_count;		/* Number of elements used */

265static struct file_list_str
266{
  char *l_file;
  char *l_module;
269} *file_list;			/* Ptr to array file name structs */
270static int file_max;		/* Number of elements allocated */
271static int file_count;		/* Number of elements used */

273static char **mod_list;		/* Ptr to array of ptrs to module names */
274static int mod_max;		/* Number of elements allocated */
275static int mod_count;		/* Number of elements used */

277static char *histfile;		/* Ptr to the history file name */

279/* This is pretty unclear.  First of all, separating "flags" vs.
 "options" (I think the distinction is that "options" take arguments)
 is nonstandard, and not something we do elsewhere in CVS.  Second of
 all, what does "reports" mean?  I think it means that you can only
 supply one of those options, but "reports" hardly has that meaning in
 a self-explanatory way.  */
285static const char *const history_usg[] =
286{
  "Usage: %s %s [-report] [-flags] [-options args] [files...]\n\n",
  "   Reports:\n",
  "        -T              Produce report on all TAGs\n",
  "        -c              Committed (Modified) files\n",
  "        -o              Checked out modules\n",
  "        -m <module>     Look for specified module (repeatable)\n",
  "        -x [TOEFWUCGMAR] Extract by record type\n",
  "        -e              Everything (same as -x, but all record types)\n",
  "   Flags:\n",
  "        -a              All users (Default is self)\n",
  "        -l              Last modified (committed or modified report)\n",
  "        -w              Working directory must match\n",
  "   Options:\n",
  "        -D <date>       Since date (Many formats)\n",
  "        -b <str>        Back to record with str in module/file/repos field\n",
  "        -f <file>       Specified file (same as command line) (repeatable)\n",
  "        -n <modulename> In module (repeatable)\n",
  "        -p <repos>      In repository (repeatable)\n",
  "        -r <rev/tag>    Since rev or tag (looks inside RCS files!)\n",
  "        -t <tag>        Since tag record placed in history file (by anyone).\n",
  "        -u <user>       For user name (repeatable)\n",
  "        -z <tz>         Output for time zone <tz> (e.g. -z -0700)\n",
  NULL((void*)0)};

311/* Sort routine for qsort:
 - If a user is selected at all, sort it first. User-within-file is useless.
 - If a module was selected explicitly, sort next on module.
 - Then sort by file.  "File" is "repository/file" unless "working" is set,
   then it is "workdir/file".  (Revision order should always track date.)
 - Always sort timestamp last.
317*/
318static int
319sort_order (l, r)
  const PTRvoid * l;
  const PTRvoid * r;
322{
  int i;
  const struct hrec *left = (const struct hrec *) l;
  const struct hrec *right = (const struct hrec *) r;

  if (user_sort)	/* If Sort by username, compare users */
  {
if ((i = strcmp (left->user, right->user)) != 0)
   return (i);
  }
  if (module_sort)	/* If sort by modules, compare module names */
  {
if (left->mod && right->mod)
   if ((i = strcmp (left->mod, right->mod)) != 0)
return (i);
  }
  if (repos_sort)	/* If sort by repository, compare them. */
  {
if ((i = strcmp (left->repos, right->repos)) != 0)
   return (i);
  }
  if (file_sort)	/* If sort by filename, compare files, NOT dirs. */
  {
if ((i = strcmp (left->file, right->file)) != 0)
   return (i);

if (working)
{
   if ((i = strcmp (left->dir, right->dir)) != 0)
return (i);

   if ((i = strcmp (left->end, right->end)) != 0)
return (i);
}
  }

  /*
   * By default, sort by date, time
   * XXX: This fails after 2030 when date slides into sign bit
   */
  if ((i = ((long) (left->date) - (long) (right->date))) != 0)
return (i);

  /* For matching dates, keep the sort stable by using record index */
  return (left->idx - right->idx);
367}

369int
370history (argc, argv)
  int argc;
  char **argv;
373{
  int i, c;
  char *fname;

  if (argc == -1)
1
Assuming the condition is false→
2
←
Taking false branch→
usage (history_usg);

  since_rev = xstrdup ("");
  since_tag = xstrdup ("");
  backto = xstrdup ("");
  rec_types = xstrdup ("");
  optind = 0;
  while ((c = getopt (argc, argv, "+Tacelow?D:b:f:m:n:p:r:t:u:x:X:z:")) != -1)
3
←
Assuming the condition is false→
4
←
Loop condition is false. Execution continues on line 532→
  {
switch (c)
{
   case 'T':			/* Tag list */
report_count++;
tag_report++;
break;
   case 'a':			/* For all usernames */
all_users++;
break;
   case 'c':
report_count++;
modified = 1;
break;
   case 'e':
report_count++;
extract++;
free (rec_types);
rec_types = xstrdup (ALL_REC_TYPES"TOEFWUCGMAR");
break;
   case 'l':			/* Find Last file record */
last_entry = 1;
break;
   case 'o':
report_count++;
v_checkout = 1;
break;
   case 'w':			/* Match Working Dir (CurDir) fields */
working = 1;
break;
   case 'X':			/* Undocumented debugging flag */
417#ifdef DEBUG
histfile = optarg;
419#endif
break;

   case 'D':			/* Since specified date */
if (*since_rev || *since_tag || *backto)
{
    error (0, 0, "date overriding rev/tag/backto");
    *since_rev = *since_tag = *backto = '\0';
}
since_date = Make_Date (optarg);
break;
   case 'b':			/* Since specified file/Repos */
if (since_date || *since_rev || *since_tag)
{
    error (0, 0, "backto overriding date/rev/tag");
    *since_rev = *since_tag = '\0';
    if (since_date != NULL((void*)0))
	free (since_date);
    since_date = NULL((void*)0);
}
free (backto);
backto = xstrdup (optarg);
break;
   case 'f':			/* For specified file */
save_file ("", optarg, (char *) NULL((void*)0));
break;
   case 'm':			/* Full module report */
if (!module_report++) report_count++;
/* fall through */
   case 'n':			/* Look for specified module */
save_module (optarg);
break;
   case 'p':			/* For specified directory */
save_file (optarg, "", (char *) NULL((void*)0));
break;
   case 'r':			/* Since specified Tag/Rev */
if (since_date || *since_tag || *backto)
{
    error (0, 0, "rev overriding date/tag/backto");
    *since_tag = *backto = '\0';
    if (since_date != NULL((void*)0))
	free (since_date);
    since_date = NULL((void*)0);
}
free (since_rev);
since_rev = xstrdup (optarg);
break;
   case 't':			/* Since specified Tag/Rev */
if (since_date || *since_rev || *backto)
{
    error (0, 0, "tag overriding date/marker/file/repos");
    *since_rev = *backto = '\0';
    if (since_date != NULL((void*)0))
	free (since_date);
    since_date = NULL((void*)0);
}
free (since_tag);
since_tag = xstrdup (optarg);
break;
   case 'u':			/* For specified username */
save_user (optarg);
break;
   case 'x':
report_count++;
extract++;
{
    char *cp;

    for (cp = optarg; *cp; cp++)
	if (!strchr (ALL_REC_TYPES"TOEFWUCGMAR", *cp))
	    error (1, 0, "%c is not a valid report type", *cp);
}
free (rec_types);
rec_types = xstrdup (optarg);
break;
   case 'z':
tz_local = 
    (optarg[0] == 'l' || optarg[0] == 'L')
    && (optarg[1] == 't' || optarg[1] == 'T')
    && !optarg[2];
if (tz_local)
    tz_name = optarg;
else
{
    /*
     * Convert a known time with the given timezone to time_t.
     * Use the epoch + 23 hours, so timezones east of GMT work.
     */
    static char f[] = "1/1/1970 23:00 %s";
    char *buf = xmalloc (sizeof (f) - 2 + strlen (optarg));
    time_t t;
    sprintf (buf, f, optarg);
    t = get_date (buf);
    free (buf);
    if (t == (time_t) -1)
	error (0, 0, "%s is not a known time zone", optarg);
    else
    {
	/*
	 * Convert to seconds east of GMT, removing the
	 * 23-hour offset mentioned above.
	 */
	tz_seconds_east_of_GMT = (time_t)23 * 60 * 60  -  t;
	tz_name = optarg;
    }
}
break;
   case '?':
   default:
usage (history_usg);
break;
}
  }
  argc -= optind;
  argv += optind;
  for (i = 0; i < argc; i++)
5
←
Assuming 'i' is >= 'argc'→
6
←
Loop condition is false. Execution continues on line 539→
save_file ("", argv[i], (char *) NULL((void*)0));


  /* ================ Now analyze the arguments a bit */
  if (!report_count)
7
←
Assuming 'report_count' is not equal to 0→
8
←
Taking false branch→
v_checkout++;
  else if (report_count > 1)
9
←
Assuming 'report_count' is <= 1→
10
←
Taking false branch→
error (1, 0, "Only one report type allowed from: \"-Tcomxe\".");

544#ifdef CLIENT_SUPPORT1
  if (current_parsed_root->isremote)
11
←
Assuming field 'isremote' is 0→
12
←
Taking false branch→
  {
struct file_list_str *f1;
char **mod;

/* We're the client side.  Fire up the remote server.  */
start_server ();

ign_setup ();

if (tag_report)
   send_arg("-T");
if (all_users)
   send_arg("-a");
if (modified)
   send_arg("-c");
if (last_entry)
   send_arg("-l");
if (v_checkout)
   send_arg("-o");
if (working)
   send_arg("-w");
if (histfile)
   send_arg("-X");
if (since_date)
   client_senddate (since_date);
if (backto[0] != '\0')
   option_with_arg ("-b", backto);
for (f1 = file_list; f1 < &file_list[file_count]; ++f1)
{
   if (f1->l_file[0] == '*')
option_with_arg ("-p", f1->l_file + 1);
   else
option_with_arg ("-f", f1->l_file);
}
if (module_report)
   send_arg("-m");
for (mod = mod_list; mod < &mod_list[mod_count]; ++mod)
   option_with_arg ("-n", *mod);
if (*since_rev)
   option_with_arg ("-r", since_rev);
if (*since_tag)
   option_with_arg ("-t", since_tag);
for (mod = user_list; mod < &user_list[user_count]; ++mod)
   option_with_arg ("-u", *mod);
if (extract)
   option_with_arg ("-x", rec_types);
option_with_arg ("-z", tz_name);

send_to_server ("history\012", 0);
      return get_responses_and_close ();
  }
597#endif

  if (all_users)
13
←
Assuming 'all_users' is 0→
14
←
Taking false branch→
save_user ("");

  if (mod_list)
15
←
Assuming 'mod_list' is null→
16
←
Taking false branch→
expand_modules ();

  if (tag_report)
17
←
Assuming 'tag_report' is 0→
18
←
Taking false branch→
  {
if (!strchr (rec_types, 'T'))
{
   rec_types = xrealloc (rec_types, strlen (rec_types) + 5);
   (void) strcat (rec_types, "T");
}
  }
  else if (extract)
19
←
Assuming 'extract' is 0→
20
←
Taking false branch→
  {
if (user_list)
   user_sort++;
  }
  else if (modified)
21
←
Assuming 'modified' is not equal to 0→
22
←
Taking true branch→
  {
free (rec_types);
rec_types = xstrdup ("MAR");
/*
* If the user has not specified a date oriented flag ("Since"), sort
* by Repository/file before date.  Default is "just" date.
*/
if (last_entry
23
←
Assuming 'last_entry' is 0→
   || (!since_date && !*since_rev && !*since_tag && !*backto))
24
←
Assuming 'since_date' is non-null→
{
   repos_sort++;
   file_sort++;
   /*
    * If we are not looking for last_modified and the user specified
    * one or more users to look at, sort by user before filename.
    */
   if (!last_entry && user_list)
user_sort++;
}
  }
  else if (module_report)
  {
free (rec_types);
rec_types = xstrdup (last_entry ? "OMAR" : ALL_REC_TYPES"TOEFWUCGMAR");
module_sort++;
repos_sort++;
file_sort++;
working = 0;			/* User's workdir doesn't count here */
  }
  else
/* Must be "checkout" or default */
  {
free (rec_types);
rec_types = xstrdup ("OF");
/* See comments in "modified" above */
if (!last_entry && user_list)
   user_sort++;
if (last_entry
   || (!since_date && !*since_rev && !*since_tag && !*backto))
   file_sort++;
  }

  /* If no users were specified, use self (-a saves a universal ("") user) */
  if (!user_list)
25
←
Assuming 'user_list' is non-null→
26
←
Taking false branch→
save_user (getcaller ());

  /* If we're looking back to a Tag value, must consider "Tag" records */
  if (*since_tag && !strchr (rec_types, 'T'))
27
←
Assuming the condition is false→
  {
rec_types = xrealloc (rec_types, strlen (rec_types) + 5);
(void) strcat (rec_types, "T");
  }

  if (histfile)
28
←
Assuming 'histfile' is null→
29
←
Taking false branch→
fname = xstrdup (histfile);
  else
  {
fname = xmalloc (strlen (current_parsed_root->directory) + sizeof (CVSROOTADM"CVSROOT")
	 + sizeof (CVSROOTADM_HISTORY"history") + 10);
(void) sprintf (fname, "%s/%s/%s", current_parsed_root->directory,
	CVSROOTADM"CVSROOT", CVSROOTADM_HISTORY"history");
  }

  read_hrecs (fname);
  if(hrec_count>0)
30
←
Assuming 'hrec_count' is > 0→
31
←
Taking true branch→
  {
qsort ((PTRvoid *) hrec_head, hrec_count, 
sizeof (struct hrec), sort_order);
  }
  report_hrecs ();
32
←
Calling 'report_hrecs'→
  free (fname);
  if (since_date != NULL((void*)0))
free (since_date);
  free (since_rev);
  free (since_tag);
  free (backto);
  free (rec_types);

  return (0);
698}

700void
701history_write (type, update_dir, revs, name, repository)
  int type;
  char *update_dir;
  char *revs;
  char *name;
  char *repository;
707{
  char *fname;
  char *workdir;
  char *username = getcaller ();
  int fd;
  char *line;
  char *slash = "", *cp, *cp2, *repos;
  int i;
  static char *tilde = "";
  static char *PrCurDir = NULL((void*)0);

  if (logoff)			/* History is turned off by cmd line switch */
return;
  if ( strchr(logHistory, type) == NULL((void*)0) )	
return;
  fname = xmalloc (strlen (current_parsed_root->directory) + sizeof (CVSROOTADM"CVSROOT")
     + sizeof (CVSROOTADM_HISTORY"history") + 3);
  (void) sprintf (fname, "%s/%s/%s", current_parsed_root->directory,
    CVSROOTADM"CVSROOT", CVSROOTADM_HISTORY"history");

  /* turn off history logging if the history file does not exist */
  if (!isfile (fname))
  {
logoff = 1;
goto out;
  }

  if (trace)
fprintf (stderr(&__sF[2]), "%s-> fopen(%s,a)\n",
 CLIENT_SERVER_STR((server_active) ? "S" : " "), fname);
  if (noexec)
goto out;
  fd = CVS_OPENopen (fname, O_WRONLY0x0001 | O_APPEND0x0008 | O_CREAT0x0200 | OPEN_BINARY(0), 0666);
  if (fd < 0)
  {
if (! really_quiet)
      {
          error (0, errno(*__errno()), "warning: cannot write to history file %s",
                 fname);
      }
      goto out;
  }

  repos = Short_Repository (repository);

  if (!PrCurDir)
  {
char *pwdir;

pwdir = get_homedir ();
PrCurDir = CurDir;
if (pwdir != NULL((void*)0))
{
   /* Assumes neither CurDir nor pwdir ends in '/' */
   i = strlen (pwdir);
   if (!strncmp (CurDir, pwdir, i))
   {
PrCurDir += i;		/* Point to '/' separator */
tilde = "~";
   }
   else
   {
/* Try harder to find a "homedir" */
struct saved_cwd cwd;
char *homedir;

if (save_cwd (&cwd))
    error_exit ();

if ( CVS_CHDIRchdir (pwdir) < 0)
    error (1, errno(*__errno()), "can't chdir(%s)", pwdir);
homedir = xgetwd ();
if (homedir == NULL((void*)0))
    error (1, errno(*__errno()), "can't getwd in %s", pwdir);

if (restore_cwd (&cwd, NULL((void*)0)))
    error_exit ();
free_cwd (&cwd);

i = strlen (homedir);
if (!strncmp (CurDir, homedir, i))
{
    PrCurDir += i;	/* Point to '/' separator */
    tilde = "~";
}
free (homedir);
   }
}
  }

  if (type == 'T')
  {
repos = update_dir;
update_dir = "";
  }
  else if (update_dir && *update_dir)
slash = "/";
  else
update_dir = "";

  workdir = xmalloc (strlen (tilde) + strlen (PrCurDir) + strlen (slash)
       + strlen (update_dir) + 10);
  (void) sprintf (workdir, "%s%s%s%s", tilde, PrCurDir, slash, update_dir);

  /*
   * "workdir" is the directory where the file "name" is. ("^~" == $HOME)
   * "repos"	is the Repository, relative to $CVSROOT where the RCS file is.
   *
   * "$workdir/$name" is the working file name.
   * "$CVSROOT/$repos/$name,v" is the RCS file in the Repository.
   *
   * First, note that the history format was intended to save space, not
   * to be human readable.
   *
   * The working file directory ("workdir") and the Repository ("repos")
   * usually end with the same one or more directory elements.  To avoid
   * duplication (and save space), the "workdir" field ends with
   * an integer offset into the "repos" field.  This offset indicates the
   * beginning of the "tail" of "repos", after which all characters are
   * duplicates.
   *
   * In other words, if the "workdir" field has a '*' (a very stupid thing
   * to put in a filename) in it, then every thing following the last '*'
   * is a hex offset into "repos" of the first character from "repos" to
   * append to "workdir" to finish the pathname.
   *
   * It might be easier to look at an example:
   *
   *  M273b3463|dgg|~/work*9|usr/local/cvs/examples|1.2|loginfo
   *
   * Indicates that the workdir is really "~/work/cvs/examples", saving
   * 10 characters, where "~/work*d" would save 6 characters and mean that
   * the workdir is really "~/work/examples".  It will mean more on
   * directories like: usr/local/gnu/emacs/dist-19.17/lisp/term
   *
   * "workdir" is always an absolute pathname (~/xxx is an absolute path)
   * "repos" is always a relative pathname.  So we can assume that we will
   * never run into the top of "workdir" -- there will always be a '/' or
   * a '~' at the head of "workdir" that is not matched by anything in
   * "repos".  On the other hand, we *can* run off the top of "repos".
   *
   * Only "compress" if we save characters.
   */

  if (!repos)
repos = "";

  cp = workdir + strlen (workdir) - 1;
  cp2 = repos + strlen (repos) - 1;
  for (i = 0; cp2 >= repos && cp > workdir && *cp == *cp2--; cp--)
i++;

  if (i > 2)
  {
i = strlen (repos) - i;
(void) sprintf ((cp + 1), "*%x", i);
  }

  if (!revs)
revs = "";
  line = xmalloc (strlen (username) + strlen (workdir) + strlen (repos)
    + strlen (revs) + strlen (name) + 100);
  sprintf (line, "%c%08llx|%s|%s|%s|%s|%s\n",
    type, (long long) time ((time_t *) NULL((void*)0)),
    username, workdir, repos, revs, name);

  /* Lessen some race conditions on non-Posix-compliant hosts.  */
  if (lseek (fd, (off_t) 0, SEEK_END2) == -1)
error (1, errno(*__errno()), "cannot seek to end of history file: %s", fname);

  if (write (fd, line, strlen (line)) < 0)
error (1, errno(*__errno()), "cannot write to history file: %s", fname);
  free (line);
  if (close (fd) != 0)
error (1, errno(*__errno()), "cannot close history file: %s", fname);
  free (workdir);
out:
  free (fname);
885}

887/*
* save_user() adds a user name to the user list to select.  Zero-length
*		username ("") matches any user.
*/
891static void
892save_user (name)
  char *name;
894{
  if (user_count == user_max)
  {
user_max = xsum (user_max, USER_INCREMENT2);
if (size_overflow_p (xtimes (user_max, sizeof (char *)))((((user_max) <= 0xffffffffffffffffUL / (sizeof (char *)) ?
 (size_t) (user_max) * (sizeof (char *)) : 0xffffffffffffffffUL
)) == 0xffffffffffffffffUL))
{
   error (0, 0, "save_user: too many users");
   return;
}
user_list = xrealloc (user_list, xtimes (user_max, sizeof (char *))((user_max) <= 0xffffffffffffffffUL / (sizeof (char *)) ? (
size_t) (user_max) * (sizeof (char *)) : 0xffffffffffffffffUL
));
  }
  user_list[user_count++] = xstrdup (name);
906}

908/*
* save_file() adds file name and associated module to the file list to select.
*
* If "dir" is null, store a file name as is.
* If "name" is null, store a directory name with a '*' on the front.
* Else, store concatenated "dir/name".
*
* Later, in the "select" stage:
*	- if it starts with '*', it is prefix-matched against the repository.
*	- if it has a '/' in it, it is matched against the repository/file.
*	- else it is matched against the file name.
*/
920static void
921save_file (dir, name, module)
  char *dir;
  char *name;
  char *module;
925{
  char *cp;
  struct file_list_str *fl;

  if (file_count == file_max)
  {
file_max = xsum (file_max, FILE_INCREMENT128);
if (size_overflow_p (xtimes (file_max, sizeof (*fl)))((((file_max) <= 0xffffffffffffffffUL / (sizeof (*fl)) ? (
size_t) (file_max) * (sizeof (*fl)) : 0xffffffffffffffffUL)) ==
 0xffffffffffffffffUL))
{
   error (0, 0, "save_file: too many files");
   return;
}
file_list = xrealloc (file_list, xtimes (file_max, sizeof (*fl))((file_max) <= 0xffffffffffffffffUL / (sizeof (*fl)) ? (size_t
) (file_max) * (sizeof (*fl)) : 0xffffffffffffffffUL));
  }
  fl = &file_list[file_count++];
  fl->l_file = cp = xmalloc (strlen (dir) + strlen (name) + 2);
  fl->l_module = module;

  if (dir && *dir)
  {
if (name && *name)
{
   (void) strcpy (cp, dir);
   (void) strcat (cp, "/");
   (void) strcat (cp, name);
}
else
{
   *cp++ = '*';
   (void) strcpy (cp, dir);
}
  }
  else
  {
if (name && *name)
{
   (void) strcpy (cp, name);
}
else
{
   error (0, 0, "save_file: null dir and file name");
}
  }
968}

970static void
971save_module (module)
  char *module;
973{
  if (mod_count == mod_max)
  {
mod_max = xsum (mod_max, MODULE_INCREMENT5);
if (size_overflow_p (xtimes (mod_max, sizeof (char *)))((((mod_max) <= 0xffffffffffffffffUL / (sizeof (char *)) ?
 (size_t) (mod_max) * (sizeof (char *)) : 0xffffffffffffffffUL
)) == 0xffffffffffffffffUL))
{
   error (0, 0, "save_module: too many modules");
   return;
}
mod_list = xrealloc (mod_list, xtimes (mod_max, sizeof (char *))((mod_max) <= 0xffffffffffffffffUL / (sizeof (char *)) ? (
size_t) (mod_max) * (sizeof (char *)) : 0xffffffffffffffffUL));
  }
  mod_list[mod_count++] = xstrdup (module);
985}

987static void
988expand_modules ()
989{
990}

992/* fill_hrec
*
* Take a ptr to 7-part history line, ending with a newline, for example:
*
*	M273b3463|dgg|~/work*9|usr/local/cvs/examples|1.2|loginfo
*
* Split it into 7 parts and drop the parts into a "struct hrec".
* Return a pointer to the character following the newline.
* 
*/

1003#define NEXT_BAR(here)do { while (isspace(*line)) line++; hr->here = line; while
 ((c = *line++) && c != '|') ; if (!c) return; line[-
1] = '\0'; } while (0) do { \
while (isspace(*line)) line++; \
hr->here = line; \
while ((c = *line++) && c != '|') ; \
if (!c) return; line[-1] = '\0'; \
} while (0)

1010static void
1011fill_hrec (line, hr)
  char *line;
  struct hrec *hr;
1014{
  char *cp;
  int c;

  hr->type = hr->user = hr->dir = hr->repos = hr->rev = hr->file =
hr->end = hr->mod = NULL((void*)0);
  hr->date = -1;
  hr->idx = ++hrec_idx;

  while (isspace ((unsigned char) *line))
line++;

  hr->type = line++;
  hr->date = strtoul (line, &cp, 16);
  if (cp == line || *cp != '|')
return;
  line = cp + 1;
  NEXT_BAR (user)do { while (isspace(*line)) line++; hr->user = line; while
 ((c = *line++) && c != '|') ; if (!c) return; line[-
1] = '\0'; } while (0);
  NEXT_BAR (dir)do { while (isspace(*line)) line++; hr->dir = line; while (
(c = *line++) && c != '|') ; if (!c) return; line[-1]
 = '\0'; } while (0);
  if ((cp = strrchr (hr->dir, '*')) != NULL((void*)0))
  {
*cp++ = '\0';
hr->end = line + strtoul (cp, NULL((void*)0), 16);
  }
  else
hr->end = line - 1;		/* A handy pointer to '\0' */
  NEXT_BAR (repos)do { while (isspace(*line)) line++; hr->repos = line; while
 ((c = *line++) && c != '|') ; if (!c) return; line[-
1] = '\0'; } while (0);
  NEXT_BAR (rev)do { while (isspace(*line)) line++; hr->rev = line; while (
(c = *line++) && c != '|') ; if (!c) return; line[-1]
 = '\0'; } while (0);
  if (strchr ("FOET", *(hr->type)))
hr->mod = line;

  NEXT_BAR (file)do { while (isspace(*line)) line++; hr->file = line; while
 ((c = *line++) && c != '|') ; if (!c) return; line[-
1] = '\0'; } while (0);
1046}


1049#ifndef STAT_BLOCKSIZE
1050#if HAVE_ST_BLKSIZE1
1051#define STAT_BLOCKSIZE(s)(s).st_blksize (s).st_blksize
1052#else
1053#define STAT_BLOCKSIZE(s)(s).st_blksize (4 * 1024)
1054#endif
1055#endif


1058/* read_hrecs's job is to read the history file and fill in all the "hrec"
* (history record) array elements with the ones we need to print.
*
* Logic:
* - Read a block from the file. 
* - Walk through the block parsing line into hr records. 
* - if the hr isn't used, free its strings, if it is, bump the hrec counter
* - at the end of a block, copy the end of the current block to the start 
* of space for the next block, then read in the next block.  If we get less
* than the whole block, we're done. 
*/
1069static void
1070read_hrecs (fname)
  char *fname;
1072{
  unsigned char *cpstart, *cpend, *cp, *nl;
  char *hrline;
  int i;
  int fd;
  struct stat st_buf;

  if ((fd = CVS_OPENopen (fname, O_RDONLY0x0000 | OPEN_BINARY(0))) < 0)
error (1, errno(*__errno()), "cannot open history file: %s", fname);

  if (fstat (fd, &st_buf) < 0)
error (1, errno(*__errno()), "can't stat history file");

  if (!(st_buf.st_size))
error (1, 0, "history file is empty");

  cpstart = xmalloc (2 * STAT_BLOCKSIZE(st_buf)(st_buf).st_blksize);
  cpstart[0] = '\0';
  cp = cpend = cpstart;

  hrec_max = HREC_INCREMENT128;
  hrec_head = xmalloc (hrec_max * sizeof (struct hrec));
  hrec_idx = 0;

  for (;;)
  {
for (nl = cp; nl < cpend && *nl != '\n'; nl++)
   if (!isprint(*nl)) *nl = ' ';

if (nl >= cpend)
{
   if (nl - cp >= STAT_BLOCKSIZE(st_buf)(st_buf).st_blksize)
   {
error(1, 0, "history line %ld too long (> %lu)", hrec_idx + 1,
      (unsigned long) STAT_BLOCKSIZE(st_buf)(st_buf).st_blksize);
   }
   if (nl > cp)
memmove (cpstart, cp, nl - cp);
   nl = cpstart + (nl - cp);
   cp = cpstart;
   i = read (fd, nl, STAT_BLOCKSIZE(st_buf)(st_buf).st_blksize);
   if (i > 0)
   {
cpend = nl + i;
*cpend = '\0';
continue;
   }
   if (i < 0)
error (1, errno(*__errno()), "error reading history file");
   if (nl == cp) break;
   error (0, 0, "warning: no newline at end of history file");
}
*nl = '\0';

if (hrec_count == hrec_max)
{
   struct hrec *old_head = hrec_head;

   hrec_max += HREC_INCREMENT128;
   hrec_head = xrealloc ((char *) hrec_head,
		  hrec_max * sizeof (struct hrec));
   if (last_since_tag)
last_since_tag = hrec_head + (last_since_tag - old_head);
   if (last_backto)
last_backto = hrec_head + (last_backto - old_head);
}

/* fill_hrec dates from when history read the entire 
  history file in one chunk, and then records were pulled out
  by pointing to the various parts of this big chunk.  This is
  why there are ugly hacks here:  I don't want to completely
  re-write the whole history stuff right now.  */

hrline = xstrdup ((char *)cp);
fill_hrec (hrline, &hrec_head[hrec_count]);
if (select_hrec (&hrec_head[hrec_count]))
   hrec_count++;
else 
   free(hrline);

cp = nl + 1;
  }
  free (cpstart);
  close (fd);

  /* Special selection problem: If "since_tag" is set, we have saved every
   * record from the 1st occurrence of "since_tag", when we want to save
   * records since the *last* occurrence of "since_tag".  So what we have
   * to do is bump hrec_head forward and reduce hrec_count accordingly.
   */
  if (last_since_tag)
  {
hrec_count -= (last_since_tag - hrec_head);
hrec_head = last_since_tag;
  }

  /* Much the same thing is necessary for the "backto" option. */
  if (last_backto)
  {
hrec_count -= (last_backto - hrec_head);
hrec_head = last_backto;
  }
1174}

1176/* Utility program for determining whether "find" is inside "string" */
1177static int
1178within (find, string)
  char *find, *string;
1180{
  int c, len;

  if (!find || !string)
return (0);

  c = *find++;
  len = strlen (find);

  while (*string)
  {
if (!(string = strchr (string, c)))
   return (0);
string++;
if (!strncmp (find, string, len))
   return (1);
  }
  return (0);
1198}

1200/* The purpose of "select_hrec" is to apply the selection criteria based on
* the command arguments and defaults and return a flag indicating whether
* this record should be remembered for printing.
*/
1204static int
1205select_hrec (hr)
  struct hrec *hr;
1207{
  char **cpp, *cp, *cp2;
  struct file_list_str *fl;
  int count;

  /* basic validity checking */
  if (!hr->type || !hr->user || !hr->dir || !hr->repos || !hr->rev ||
!hr->file || !hr->end)
  {
error (0, 0, "warning: history line %ld invalid", hr->idx);
return (0);
  }

  /* "Since" checking:  The argument parser guarantees that only one of the
   *			  following four choices is set:
   *
   * 1. If "since_date" is set, it contains the date specified on the
   *    command line. hr->date fields earlier than "since_date" are ignored.
   * 2. If "since_rev" is set, it contains either an RCS "dotted" revision
   *    number (which is of limited use) or a symbolic TAG.  Each RCS file
   *    is examined and the date on the specified revision (or the revision
   *    corresponding to the TAG) in the RCS file (CVSROOT/repos/file) is
   *    compared against hr->date as in 1. above.
   * 3. If "since_tag" is set, matching tag records are saved.  The field
   *    "last_since_tag" is set to the last one of these.  Since we don't
   *    know where the last one will be, all records are saved from the
   *    first occurrence of the TAG.  Later, at the end of "select_hrec"
   *    records before the last occurrence of "since_tag" are skipped.
   * 4. If "backto" is set, all records with a module name or file name
   *    matching "backto" are saved.  In addition, all records with a
   *    repository field with a *prefix* matching "backto" are saved.
   *    The field "last_backto" is set to the last one of these.  As in
   *    3. above, "select_hrec" adjusts to include the last one later on.
   */
  if (since_date)
  {
char *ourdate = date_from_time_t (hr->date);
count = RCS_datecmp (ourdate, since_date);
free (ourdate);
if (count < 0)
   return (0);
  }
  else if (*since_rev)
  {
Vers_TS *vers;
time_t t;
struct file_info finfo;

memset (&finfo, 0, sizeof finfo);
finfo.file = hr->file;
/* Not used, so don't worry about it.  */
finfo.update_dir = NULL((void*)0);
finfo.fullname = finfo.file;
finfo.repository = hr->repos;
finfo.entries = NULL((void*)0);
finfo.rcs = NULL((void*)0);

vers = Version_TS (&finfo, (char *) NULL((void*)0), since_rev, (char *) NULL((void*)0),
	   1, 0);
if (vers->vn_rcs)
{
   if ((t = RCS_getrevtime (vers->srcfile, vers->vn_rcs, (char *) 0, 0))
!= (time_t) 0)
   {
if (hr->date < t)
{
    freevers_ts (&vers);
    return (0);
}
   }
}
freevers_ts (&vers);
  }
  else if (*since_tag)
  {
if (*(hr->type) == 'T')
{
   /*
    * A 'T'ag record, the "rev" field holds the tag to be set,
    * while the "repos" field holds "D"elete, "A"dd or a rev.
    */
   if (within (since_tag, hr->rev))
   {
last_since_tag = hr;
return (1);
   }
   else
return (0);
}
if (!last_since_tag)
   return (0);
  }
  else if (*backto)
  {
if (within (backto, hr->file) || within (backto, hr->mod) ||
   within (backto, hr->repos))
   last_backto = hr;
else
   return (0);
  }

  /* User checking:
   *
   * Run down "user_list", match username ("" matches anything)
   * If "" is not there and actual username is not there, return failure.
   */
  if (user_list && hr->user)
  {
for (cpp = user_list, count = user_count; count; cpp++, count--)
{
   if (!**cpp)
break;			/* null user == accept */
   if (!strcmp (hr->user, *cpp))	/* found listed user */
break;
}
if (!count)
   return (0);			/* Not this user */
  }

  /* Record type checking:
   *
   * 1. If Record type is not in rec_types field, skip it.
   * 2. If mod_list is null, keep everything.  Otherwise keep only modules
   *    on mod_list.
   * 3. If neither a 'T', 'F' nor 'O' record, run through "file_list".  If
   *    file_list is null, keep everything.  Otherwise, keep only files on
   *    file_list, matched appropriately.
   */
  if (!strchr (rec_types, *(hr->type)))
return (0);
  if (!strchr ("TFOE", *(hr->type)))	/* Don't bother with "file" if "TFOE" */
  {
if (file_list)			/* If file_list is null, accept all */
{
   for (fl = file_list, count = file_count; count; fl++, count--)
   {
/* 1. If file_list entry starts with '*', skip the '*' and
 *    compare it against the repository in the hrec.
 * 2. If file_list entry has a '/' in it, compare it against
 *    the concatenation of the repository and file from hrec.
 * 3. Else compare the file_list entry against the hrec file.
 */
char *cmpfile = NULL((void*)0);

if (*(cp = fl->l_file) == '*')
{
    cp++;
    /* if argument to -p is a prefix of repository */
    if (!strncmp (cp, hr->repos, strlen (cp)))
    {
	hr->mod = fl->l_module;
	break;
    }
}
else
{
    if (strchr (cp, '/'))
    {
	cmpfile = xmalloc (strlen (hr->repos)
			   + strlen (hr->file)
			   + 10);
	(void) sprintf (cmpfile, "%s/%s",
			hr->repos, hr->file);
	cp2 = cmpfile;
    }
    else
    {
	cp2 = hr->file;
    }

    /* if requested file is found within {repos}/file fields */
    if (within (cp, cp2))
    {
	hr->mod = fl->l_module;
	break;
    }
    if (cmpfile != NULL((void*)0))
	free (cmpfile);
}
   }
   if (!count)
return (0);		/* String specified and no match */
}
  }
  if (mod_list)
  {
for (cpp = mod_list, count = mod_count; count; cpp++, count--)
{
   if (hr->mod && !strcmp (hr->mod, *cpp))	/* found module */
break;
}
if (!count)
   return (0);	/* Module specified & this record is not one of them. */
  }

  return (1);		/* Select this record unless rejected above. */
1403}

1405/* The "sort_order" routine (when handed to qsort) has arranged for the
* hrecs files to be in the right order for the report.
*
* Most of the "selections" are done in the select_hrec routine, but some
* selections are more easily done after the qsort by "accept_hrec".
*/
1411static void
1412report_hrecs ()
1413{
  struct hrec *hr, *lr;
  struct tm *tm;
  int i, count, ty;
  char *cp;
  int user_len, file_len, rev_len, mod_len, repos_len;

  if (*since_tag && !last_since_tag)
33
←
Assuming the condition is false→
  {
(void) printf ("No tag found: %s\n", since_tag);
return;
  }
  else if (*backto && !last_backto)
34
←
Assuming the condition is false→
  {
(void) printf ("No module, file or repository with: %s\n", backto);
return;
  }
  else if (hrec_count34.1
'hrec_count' is >= 1
 < 1)
35
←
Taking false branch→
  {
(void) printf ("No records selected.\n");
return;
  }

  user_len = file_len = rev_len = mod_len = repos_len = 0;

  /* Run through lists and find maximum field widths */
  hr = lr = hrec_head;
  hr++;
  for (count = hrec_count; count--; lr = hr, hr++)
36
←
Loop condition is true.  Entering loop body→
48
←
Loop condition is false. Execution continues on line 1481→
  {
char *repos;

if (!count)
37
←
Assuming 'count' is not equal to 0→
38
←
Taking false branch→
   hr = NULL((void*)0);
if (!accept_hrec (lr, hr))
39
←
Taking false branch→
   continue;

ty = *(lr->type);
repos = xstrdup (lr->repos);
if ((cp = strrchr (repos, '/')) != NULL((void*)0))
40
←
Assuming the condition is false→
41
←
Taking false branch→
{
   if (lr->mod && !strcmp (++cp, lr->mod))
   {
(void) strcpy (cp, "*");
   }
}
if ((i = strlen (lr->user)) > user_len)
42
←
Assuming the condition is false→
43
←
Taking false branch→
   user_len = i;
if ((i = strlen (lr->file)) > file_len)
44
←
Assuming the condition is false→
45
←
Taking false branch→
   file_len = i;
if (ty != 'T' && (i = strlen (repos)) > repos_len)
46
←
Assuming the condition is false→
   repos_len = i;
if (ty != 'T' && (i = strlen (lr->rev)) > rev_len)
   rev_len = i;
if (lr->mod && (i = strlen (lr->mod)) > mod_len)
47
←
Assuming field 'mod' is null→
   mod_len = i;
free (repos);
  }

  /* Walk through hrec array setting "lr" (Last Record) to each element.
   * "hr" points to the record following "lr" -- It is NULL in the last
   * pass.
   *
   * There are two sections in the loop below:
   * 1. Based on the report type (e.g. extract, checkout, tag, etc.),
   *    decide whether the record should be printed.
   * 2. Based on the record type, format and print the data.
   */
  for (lr = hrec_head, hr = (lr + 1); hrec_count--; lr = hr, hr++)
49
←
Loop condition is true.  Entering loop body→
  {
char *workdir;
char *repos;

if (!hrec_count)
50
←
Assuming 'hrec_count' is not equal to 0→
51
←
Taking false branch→
   hr = NULL((void*)0);
if (!accept_hrec (lr, hr))
52
←
Calling 'accept_hrec'→
58
←
Returning from 'accept_hrec'→
59
←
Taking false branch→
   continue;

ty = *(lr->type);
if (!tz_local)
60
←
Assuming 'tz_local' is not equal to 0→
61
←
Taking false branch→
{
   time_t t = lr->date + tz_seconds_east_of_GMT;
   tm = gmtime (&t);
}
else
   tm = localtime (&(lr->date));

(void) printf ("%c %04d-%02d-%02d %02d:%02d %s %-*s", ty,
  tm->tm_year+1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,
  tm->tm_min, tz_name, user_len, lr->user);

workdir = xmalloc (strlen (lr->dir) + strlen (lr->end) + 10);
(void) sprintf (workdir, "%s%s", lr->dir, lr->end);
if ((cp = strrchr (workdir, '/')) != NULL((void*)0))
62
←
Assuming the condition is false→
63
←
Taking false branch→
{
   if (lr->mod && !strcmp (++cp, lr->mod))
   {
(void) strcpy (cp, "*");
   }
}
repos = xmalloc (strlen (lr->repos) + 10);
(void) strcpy (repos, lr->repos);
if ((cp = strrchr (repos, '/')) != NULL((void*)0))
64
←
Assuming the condition is true→
65
←
Taking true branch→
{
   if (lr->mod && !strcmp (++cp, lr->mod))
66
←
Assuming field 'mod' is null→
   {
(void) strcpy (cp, "*");
   }
}

switch (ty)
67
←
Control jumps to 'case 79:'  at line 1534→
{
   case 'T':
/* 'T'ag records: repository is a "tag type", rev is the tag */
(void) printf (" %-*s [%s:%s]", mod_len, lr->mod, lr->rev,
	       repos);
if (working)
    (void) printf (" {%s}", workdir);
break;
   case 'F':
   case 'E':
   case 'O':
if (lr->rev && *(lr->rev))
68
←
Assuming field 'rev' is null→
    (void) printf (" [%s]", lr->rev);
(void) printf (" %-*s =%s%-*s %s", repos_len, repos, lr->mod,
	       mod_len + 1 - (int) strlen (lr->mod),
69
←
Null pointer passed as 1st argument to string length function
	       "=", workdir);
break;
   case 'W':
   case 'U':
   case 'C':
   case 'G':
   case 'M':
   case 'A':
   case 'R':
(void) printf (" %-*s %-*s %-*s =%s= %s", rev_len, lr->rev,
	       file_len, lr->file, repos_len, repos,
	       lr->mod ? lr->mod : "", workdir);
break;
   default:
(void) printf ("Hey! What is this junk? RecType[0x%2.2x]", ty);
break;
}
(void) putchar ('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
free (workdir);
free (repos);
  }
1560}

1562static int
1563accept_hrec (lr, hr)
  struct hrec *hr, *lr;
1565{
  int ty;

  ty = *(lr->type);

  if (last_since_tag && ty == 'T')
53
←
Assuming 'last_since_tag' is non-null→
54
←
Assuming the condition is true→
55
←
Taking true branch→
return (1);
56
←
Returning without writing to 'lr->mod'→
57
←
Returning the value 1, which participates in a condition later→

  if (v_checkout)
  {
if (ty != 'O')
   return (0);			/* Only interested in 'O' records */

/* We want to identify all the states that cause the next record
* ("hr") to be different from the current one ("lr") and only
* print a line at the allowed boundaries.
*/

if (!hr ||			/* The last record */
   strcmp (hr->user, lr->user) ||	/* User has changed */
   strcmp (hr->mod, lr->mod) ||/* Module has changed */
   (working &&			/* If must match "workdir" */
    (strcmp (hr->dir, lr->dir) ||	/*    and the 1st parts or */
     strcmp (hr->end, lr->end))))	/*    the 2nd parts differ */

   return (1);
  }
  else if (modified)
  {
if (!last_entry ||		/* Don't want only last rec */
   !hr ||			/* Last entry is a "last entry" */
   strcmp (hr->repos, lr->repos) ||	/* Repository has changed */
   strcmp (hr->file, lr->file))/* File has changed */
   return (1);

if (working)
{				/* If must match "workdir" */
   if (strcmp (hr->dir, lr->dir) ||	/*    and the 1st parts or */
strcmp (hr->end, lr->end))	/*    the 2nd parts differ */
return (1);
}
  }
  else if (module_report)
  {
if (!last_entry ||		/* Don't want only last rec */
   !hr ||			/* Last entry is a "last entry" */
   strcmp (hr->mod, lr->mod) ||/* Module has changed */
   strcmp (hr->repos, lr->repos) ||	/* Repository has changed */
   strcmp (hr->file, lr->file))/* File has changed */
   return (1);
  }
  else
  {
/* "extract" and "tag_report" always print selected records. */
return (1);
  }

  return (0);
1623}