386BSD 0.1 development

[unix-history] / usr / othersrc / public / cvs-1.3 / src / recurse.c

/*
* Copyright (c) 1992, Brian Berliner and Jeff Polk
* 
* You may distribute under the terms of the GNU General Public License as
* specified in the README file that comes with the CVS 1.3 kit.
* 
* General recursion handler
* 
*/

#include "cvs.h"

#ifndef lint
static char rcsid[] = "@(#)recurse.c 1.22 92/04/10";
#endif

#if __STDC__
static int do_dir_proc (Node * p);
static int do_file_proc (Node * p);
static void addlist (List ** listp, char *key);
#else
static int do_file_proc ();
static int do_dir_proc ();
static void addlist ();
#endif                          /* __STDC__ */


/*
* Local static versions eliminates the need for globals
*/
static int (*fileproc) ();
static int (*filesdoneproc) ();
static Dtype (*direntproc) ();
static int (*dirleaveproc) ();
static int which;
static Dtype flags;
static int aflag;
static int readlock;
static int dosrcs;
static char update_dir[PATH_MAX];
static char *repository = NULL;
static List *entries = NULL;
static List *srcfiles = NULL;
static List *filelist = NULL;
static List *dirlist = NULL;

/*
* Called to start a recursive command Command line arguments are processed
* if present, otherwise the local directory is processed.
*/
int
start_recursion (fileproc, filesdoneproc, direntproc, dirleaveproc,
                argc, argv, local, which, aflag, readlock,
                update_preload, dosrcs)
   int (*fileproc) ();
   int (*filesdoneproc) ();
   Dtype (*direntproc) ();
   int (*dirleaveproc) ();
   int argc;
   char *argv[];
   int local;
   int which;
   int aflag;
   int readlock;
   char *update_preload;
   int dosrcs;
{
   int i, err = 0;
   Dtype flags;

   if (update_preload == NULL)
       update_dir[0] = '\0';
   else
       (void) strcpy (update_dir, update_preload);

   if (local)
       flags = R_SKIP_DIRS;
   else
       flags = R_PROCESS;

   /* clean up from any previous calls to start_recursion */
   if (repository)
   {
       free (repository);
       repository = (char *) NULL;
   }
   if (entries)
       dellist (&entries);
   if (srcfiles)
       dellist (&srcfiles);
   if (filelist)
       dellist (&filelist);
   if (dirlist)
       dellist (&dirlist);

   if (argc == 0)
   {

       /*
        * There were no arguments, so we'll probably just recurse. The
        * exception to the rule is when we are called from a directory
        * without any CVS administration files.  That has always meant to
        * process each of the sub-directories, so we pretend like we were
        * called with the list of sub-dirs of the current dir as args
        */
       if ((which & W_LOCAL) && !isdir (CVSADM) && !isdir (OCVSADM))
           dirlist = Find_Dirs ((char *) NULL, W_LOCAL);
       else
           addlist (&dirlist, ".");

       err += do_recursion (fileproc, filesdoneproc, direntproc,
                           dirleaveproc, flags, which, aflag,
                           readlock, dosrcs);
   }
   else
   {

       /*
        * There were arguments, so we have to handle them by hand. To do
        * that, we set up the filelist and dirlist with the arguments and
        * call do_recursion.  do_recursion recognizes the fact that the
        * lists are non-null when it starts and doesn't update them
        */

       /* look for args with /-s in them */
       for (i = 0; i < argc; i++)
           if (index (argv[i], '/') != NULL)
               break;

       /* if we didn't find any hard one's, do it the easy way */
       if (i == argc)
       {
           /* set up the lists */
           for (i = 0; i < argc; i++)
           {
               if (isdir (argv[i]))
                   addlist (&dirlist, argv[i]);
               else
               {
                   if (isdir (CVSADM) || isdir (OCVSADM))
                   {
                       char *repos;
                       char tmp[PATH_MAX];

                       repos = Name_Repository ((char *) NULL, update_dir);
                       (void) sprintf (tmp, "%s/%s", repos, argv[i]);
                       if (isdir (tmp))
                           addlist (&dirlist, argv[i]);
                       else
                           addlist (&filelist, argv[i]);
                       free (repos);
                   }
                   else
                       addlist (&filelist, argv[i]);
               }
           }

           /* we aren't recursive if no directories were specified */
           if (dirlist == NULL)
               local = 1;

           /* process the lists */
           err += do_recursion (fileproc, filesdoneproc, direntproc,
                               dirleaveproc, flags, which, aflag,
                               readlock, dosrcs);
       }
       /* otherwise - do it the hard way */
       else
       {
           char *cp;
           char *dir = (char *) NULL;
           char *comp = (char *) NULL;
           char *oldupdate = (char *) NULL;
           char savewd[PATH_MAX];

           if (getwd (savewd) == NULL)
               error (1, 0, "could not get working directory: %s", savewd);

           for (i = 0; i < argc; i++)
           {
               /* split the arg into the dir and component parts */
               dir = xstrdup (argv[i]);
               if ((cp = rindex (dir, '/')) != NULL)
               {
                   *cp = '\0';
                   comp = xstrdup (cp + 1);
                   oldupdate = xstrdup (update_dir);
                   if (update_dir[0] != '\0')
                       (void) strcat (update_dir, "/");
                   (void) strcat (update_dir, dir);
               }
               else
               {
                   comp = xstrdup (dir);
                   if (dir)
                       free (dir);
                   dir = (char *) NULL;
               }

               /* chdir to the appropriate place if necessary */
               if (dir && chdir (dir) < 0)
                   error (1, errno, "could not chdir to %s", dir);

               /* set up the list */
               if (isdir (comp))
                   addlist (&dirlist, comp);
               else
               {
                   if (isdir (CVSADM) || isdir (OCVSADM))
                   {
                       char *repos;
                       char tmp[PATH_MAX];

                       repos = Name_Repository ((char *) NULL, update_dir);
                       (void) sprintf (tmp, "%s/%s", repos, comp);
                       if (isdir (tmp))
                           addlist (&dirlist, comp);
                       else
                           addlist (&filelist, comp);
                       free (repos);
                   }
                   else
                       addlist (&filelist, comp);
               }

               /* do the recursion */
               err += do_recursion (fileproc, filesdoneproc, direntproc,
                                   dirleaveproc, flags, which,
                                   aflag, readlock, dosrcs);

               /* chdir back and fix update_dir if necessary */
               if (dir && chdir (savewd) < 0)
                   error (1, errno, "could not chdir to %s", dir);
               if (oldupdate)
               {
                   (void) strcpy (update_dir, oldupdate);
                   free (oldupdate);
               }

           }
           if (dir)
               free (dir);
           if (comp)
               free (comp);
       }
   }
   return (err);
}

/*
* Implement the recursive policies on the local directory.  This may be
* called directly, or may be called by start_recursion
*/
int
do_recursion (xfileproc, xfilesdoneproc, xdirentproc, xdirleaveproc,
             xflags, xwhich, xaflag, xreadlock, xdosrcs)
   int (*xfileproc) ();
   int (*xfilesdoneproc) ();
   Dtype (*xdirentproc) ();
   int (*xdirleaveproc) ();
   Dtype xflags;
   int xwhich;
   int xaflag;
   int xreadlock;
   int xdosrcs;
{
   int err = 0;
   int dodoneproc = 1;
   char *srepository;

   /* do nothing if told */
   if (xflags == R_SKIP_ALL)
       return (0);

   /* set up the static vars */
   fileproc = xfileproc;
   filesdoneproc = xfilesdoneproc;
   direntproc = xdirentproc;
   dirleaveproc = xdirleaveproc;
   flags = xflags;
   which = xwhich;
   aflag = xaflag;
   readlock = noexec ? 0 : xreadlock;
   dosrcs = xdosrcs;

   /*
    * Fill in repository with the current repository
    */
   if (which & W_LOCAL)
   {
       if (isdir (CVSADM) || isdir (OCVSADM))
           repository = Name_Repository ((char *) NULL, update_dir);
       else
           repository = NULL;
   }
   else
   {
       repository = xmalloc (PATH_MAX);
       (void) getwd (repository);
   }
   srepository = repository;           /* remember what to free */

   /*
    * The filesdoneproc needs to be called for each directory where files
    * processed, or each directory that is processed by a call where no
    * directories were passed in.  In fact, the only time we don't want to
    * call back the filesdoneproc is when we are processing directories that
    * were passed in on the command line (or in the special case of `.' when
    * we were called with no args
    */
   if (dirlist != NULL && filelist == NULL)
       dodoneproc = 0;

   /*
    * If filelist or dirlist is already set, we don't look again. Otherwise,
    * find the files and directories
    */
   if (filelist == NULL && dirlist == NULL)
   {
       /* both lists were NULL, so start from scratch */
       if (fileproc != NULL && flags != R_SKIP_FILES)
       {
           int lwhich = which;

           /* be sure to look in the attic if we have sticky tags/date */
           if ((lwhich & W_ATTIC) == 0)
               if (isreadable (CVSADM_TAG))
                   lwhich |= W_ATTIC;

           /* find the files and fill in entries if appropriate */
           filelist = Find_Names (repository, lwhich, aflag, &entries);
       }

       /* find sub-directories if we will recurse */
       if (flags != R_SKIP_DIRS)
           dirlist = Find_Dirs (repository, which);
   }
   else
   {
       /* something was passed on the command line */
       if (filelist != NULL && fileproc != NULL)
       {
           /* we will process files, so pre-parse entries */
           if (which & W_LOCAL)
               entries = ParseEntries (aflag);
       }
   }

   /* process the files (if any) */
   if (filelist != NULL)
   {
       /* read lock it if necessary */
       if (readlock && repository && Reader_Lock (repository) != 0)
           error (1, 0, "read lock failed - giving up");

       /* pre-parse the source files */
       if (dosrcs && repository)
           srcfiles = RCS_parsefiles (filelist, repository);
       else
           srcfiles = (List *) NULL;

       /* process the files */
       err += walklist (filelist, do_file_proc);

       /* unlock it */
       if (readlock)
           Lock_Cleanup ();

       /* clean up */
       dellist (&filelist);
       dellist (&srcfiles);
       dellist (&entries);
   }

   /* call-back files done proc (if any) */
   if (dodoneproc && filesdoneproc != NULL)
       err = filesdoneproc (err, repository, update_dir[0] ? update_dir : ".");

   /* process the directories (if necessary) */
   if (dirlist != NULL)
       err += walklist (dirlist, do_dir_proc);
#ifdef notdef
   else if (dirleaveproc != NULL)
       err += dirleaveproc(".", err, ".");
#endif
   dellist (&dirlist);

   /* free the saved copy of the pointer if necessary */
   if (srepository)
   {
       (void) free (srepository);
       repository = (char *) NULL;
   }

   return (err);
}

/*
* Process each of the files in the list with the callback proc
*/
static int
do_file_proc (p)
   Node *p;
{
   if (fileproc != NULL)
       return (fileproc (p->key, update_dir, repository, entries, srcfiles));
   else
       return (0);
}

/*
* Process each of the directories in the list (recursing as we go)
*/
static int
do_dir_proc (p)
   Node *p;
{
   char *dir = p->key;
   char savewd[PATH_MAX];
   char newrepos[PATH_MAX];
   List *sdirlist;
   char *srepository;
   char *cp;
   Dtype dir_return = R_PROCESS;
   int stripped_dot = 0;
   int err = 0;

   /* set up update_dir - skip dots if not at start */
   if (strcmp (dir, ".") != 0)
   {
       if (update_dir[0] != '\0')
       {
           (void) strcat (update_dir, "/");
           (void) strcat (update_dir, dir);
       }
       else
           (void) strcpy (update_dir, dir);

       /*
        * Here we need a plausible repository name for the sub-directory. We
        * create one by concatenating the new directory name onto the
        * previous repository name.  The only case where the name should be
        * used is in the case where we are creating a new sub-directory for
        * update -d and in that case the generated name will be correct.
        */
       if (repository == NULL)
           newrepos[0] = '\0';
       else
           (void) sprintf (newrepos, "%s/%s", repository, dir);
   }
   else
   {
       if (update_dir[0] == '\0')
           (void) strcpy (update_dir, dir);

       if (repository == NULL)
           newrepos[0] = '\0';
       else
           (void) strcpy (newrepos, repository);
   }

   /* call-back dir entry proc (if any) */
   if (direntproc != NULL)
       dir_return = direntproc (dir, newrepos, update_dir);

   /* only process the dir if the return code was 0 */
   if (dir_return != R_SKIP_ALL)
   {
       /* save our current directory and static vars */
       if (getwd (savewd) == NULL)
           error (1, 0, "could not get working directory: %s", savewd);
       sdirlist = dirlist;
       srepository = repository;
       dirlist = NULL;

       /* cd to the sub-directory */
       if (chdir (dir) < 0)
           error (1, errno, "could not chdir to %s", dir);

       /* honor the global SKIP_DIRS (a.k.a. local) */
       if (flags == R_SKIP_DIRS)
           dir_return = R_SKIP_DIRS;

       /* remember if the `.' will be stripped for subsequent dirs */
       if (strcmp (update_dir, ".") == 0)
       {
           update_dir[0] = '\0';
           stripped_dot = 1;
       }

       /* make the recursive call */
       err += do_recursion (fileproc, filesdoneproc, direntproc, dirleaveproc,
                           dir_return, which, aflag, readlock, dosrcs);

       /* put the `.' back if necessary */
       if (stripped_dot)
           (void) strcpy (update_dir, ".");

       /* call-back dir leave proc (if any) */
       if (dirleaveproc != NULL)
           err = dirleaveproc (dir, err, update_dir);

       /* get back to where we started and restore state vars */
       if (chdir (savewd) < 0)
           error (1, errno, "could not chdir to %s", savewd);
       dirlist = sdirlist;
       repository = srepository;
   }

   /* put back update_dir */
   if ((cp = rindex (update_dir, '/')) != NULL)
       *cp = '\0';
   else
       update_dir[0] = '\0';

   return (err);
}

/*
* Add a node to a list allocating the list if necessary
*/
static void
addlist (listp, key)
   List **listp;
   char *key;
{
   Node *p;

   if (*listp == NULL)
       *listp = getlist ();
   p = getnode ();
   p->type = FILES;
   p->key = xstrdup (key);
   (void) addnode (*listp, p);
}