[BACK]Return to getlog.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / cvs

Diff for /src/usr.bin/cvs/getlog.c between version 1.56 and 1.57

version 1.56, 2006/04/14 22:33:15 version 1.57, 2006/05/28 21:11:12
Line 1 
Line 1 
 /*      $OpenBSD$       */  /*      $OpenBSD$       */
 /*  /*
  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>   * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
  * Copyright (c) 2005, 2006 Xavier Santolaria <xsa@openbsd.org>  
  * All rights reserved.  
  *   *
  * Redistribution and use in source and binary forms, with or without   * Permission to use, copy, modify, and distribute this software for any
  * modification, are permitted provided that the following conditions   * purpose with or without fee is hereby granted, provided that the above
  * are met:   * copyright notice and this permission notice appear in all copies.
  *   *
  * 1. Redistributions of source code must retain the above copyright   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  *    notice, this list of conditions and the following disclaimer.   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * 2. The name of the author may not be used to endorse or promote products   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  *    derived from this software without specific prior written permission.   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  *   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL  
  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  
  * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,  
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;  
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,  
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR  
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF  
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
  */   */
   
 #include "includes.h"  #include "includes.h"
   
 #include "cvs.h"  #include "cvs.h"
   #include "diff.h"
 #include "log.h"  #include "log.h"
 #include "proto.h"  #include "proto.h"
   
   #define LOG_REVSEP \
   "----------------------------"
   
 #define CVS_GETLOG_REVSEP       "----------------------------"  #define LOG_REVEND \
 #define CVS_GETLOG_REVEND \  
  "============================================================================="   "============================================================================="
   
 #define GLOG_BRANCH             (1<<0)  int     cvs_getlog(int, char **);
 #define GLOG_HEADER             (1<<1)  void    cvs_log_local(struct cvs_file *);
 #define GLOG_HEADER_DESCR       (1<<2)  
 #define GLOG_NAME               (1<<3)  
 #define GLOG_NOTAGS             (1<<4)  
   
 static int      cvs_getlog_init(struct cvs_cmd *, int, char **, int *);  char    *logrev = NULL;
 static int      cvs_getlog_remote(CVSFILE *, void *);  
 static int      cvs_getlog_local(CVSFILE *, void *);  
 static int      cvs_getlog_pre_exec(struct cvsroot *);  
   
 struct cvs_cmd cvs_cmd_log = {  struct cvs_cmd cvs_cmd_log = {
         CVS_OP_LOG, CVS_REQ_LOG, "log",          CVS_OP_LOG, CVS_REQ_LOG, "log",
Line 54 
Line 40 
         "[-bhlNRt] [-d dates] [-r revisions] [-s states] [-w logins]",          "[-bhlNRt] [-d dates] [-r revisions] [-s states] [-w logins]",
         "bd:hlNRr:s:tw:",          "bd:hlNRr:s:tw:",
         NULL,          NULL,
         CF_NOSYMS | CF_IGNORE | CF_SORT | CF_RECURSE,          cvs_getlog
         cvs_getlog_init,  
         cvs_getlog_pre_exec,  
         cvs_getlog_remote,  
         cvs_getlog_local,  
         NULL,  
         NULL,  
         CVS_CMD_SENDDIR | CVS_CMD_ALLOWSPEC | CVS_CMD_SENDARGS2  
 };  };
   
   int
 struct cvs_cmd cvs_cmd_rlog = {  cvs_getlog(int argc, char **argv)
         CVS_OP_LOG, CVS_REQ_LOG, "log",  
         { "lo" },  
         "Print out history information for files",  
         "[-bhlNRt] [-d dates] [-r revisions] [-s states] [-w logins]",  
         "d:hlRr:",  
         NULL,  
         CF_NOSYMS | CF_IGNORE | CF_SORT | CF_RECURSE,  
         cvs_getlog_init,  
         cvs_getlog_pre_exec,  
         cvs_getlog_remote,  
         cvs_getlog_local,  
         NULL,  
         NULL,  
         CVS_CMD_SENDDIR | CVS_CMD_ALLOWSPEC | CVS_CMD_SENDARGS2  
 };  
   
 static int runflags = 0;  
   
 static int  
 cvs_getlog_init(struct cvs_cmd *cmd, int argc, char **argv, int *arg)  
 {  {
         int ch;          int ch;
           int flags;
           char *arg = ".";
           struct cvs_recursion cr;
   
         while ((ch = getopt(argc, argv, cmd->cmd_opts)) != -1) {          rcsnum_flags |= RCSNUM_NO_MAGIC;
           flags = CR_RECURSE_DIRS;
   
           while ((ch = getopt(argc, argv, cvs_cmd_log.cmd_opts)) != -1) {
                 switch (ch) {                  switch (ch) {
                 case 'b':  
                         runflags |= GLOG_BRANCH;  
                         break;  
                 case 'd':  
                         break;  
                 case 'h':  
                         runflags |= GLOG_HEADER;  
                         break;  
                 case 'l':                  case 'l':
                         cmd->file_flags &= ~CF_RECURSE;                          flags &= ~CR_RECURSE_DIRS;
                         break;                          break;
                 case 'N':  
                         runflags |= GLOG_NOTAGS;  
                         break;  
                 case 'R':  
                         runflags |= GLOG_NAME;  
                         break;  
                 case 'r':                  case 'r':
                           logrev = optarg;
                         break;                          break;
                 case 's':  
                         break;  
                 case 't':  
                         runflags |= GLOG_HEADER_DESCR;  
                         break;  
                 case 'w':  
                         break;  
                 default:                  default:
                         return (CVS_EX_USAGE);                          fatal("%s", cvs_cmd_log.cmd_synopsis);
                 }                  }
         }          }
   
         *arg = optind;          argc -= optind;
         rcsnum_flags |= RCSNUM_NO_MAGIC;          argv += optind;
         return (0);  
 }  
   
 static int          cr.enterdir = NULL;
 cvs_getlog_pre_exec(struct cvsroot *root)          cr.leavedir = NULL;
 {          cr.remote = NULL;
         if (root->cr_method != CVS_METHOD_LOCAL) {          cr.local = cvs_log_local;
                 if (runflags & GLOG_BRANCH)          cr.flags = flags;
                         cvs_sendarg(root, "-b", 0);  
   
                 if (runflags & GLOG_HEADER)          if (argc > 0)
                         cvs_sendarg(root, "-h", 0);                  cvs_file_run(argc, argv, &cr);
           else
                   cvs_file_run(1, &arg, &cr);
   
                 if (runflags & GLOG_NOTAGS)  
                         cvs_sendarg(root, "-N", 0);  
   
                 if (runflags & GLOG_NAME)  
                         cvs_sendarg(root, "-R", 0);  
   
                 if (runflags & GLOG_HEADER_DESCR)  
                         cvs_sendarg(root, "-t", 0);  
         }  
         return (0);          return (0);
 }  }
   
 /*  void
  * cvs_getlog_remote()  cvs_log_local(struct cvs_file *cf)
  *  
  */  
 static int  
 cvs_getlog_remote(CVSFILE *cf, void *arg)  
 {  {
         char fpath[MAXPATHLEN];          u_int nrev;
         struct cvsroot *root;  
   
         root = CVS_DIR_ROOT(cf);  
   
         if (cf->cf_type == DT_DIR) {  
                 if (cf->cf_cvstat == CVS_FST_UNKNOWN)  
                         cvs_sendreq(root, CVS_REQ_QUESTIONABLE, cf->cf_name);  
                 else  
                         cvs_senddir(root, cf);  
                 return (0);  
         }  
   
         cvs_file_getpath(cf, fpath, sizeof(fpath));  
   
         cvs_sendentry(root, cf);  
   
         switch (cf->cf_cvstat) {  
         case CVS_FST_UNKNOWN:  
                 cvs_sendreq(root, CVS_REQ_QUESTIONABLE, cf->cf_name);  
                 break;  
         case CVS_FST_UPTODATE:  
                 cvs_sendreq(root, CVS_REQ_UNCHANGED, cf->cf_name);  
                 break;  
         case CVS_FST_ADDED:  
         case CVS_FST_MODIFIED:  
                 cvs_sendreq(root, CVS_REQ_ISMODIFIED, cf->cf_name);  
                 break;  
         default:  
                 break;  
         }  
   
         return (0);  
 }  
   
   
   
 static int  
 cvs_getlog_local(CVSFILE *cf, void *arg)  
 {  
         int nrev;  
         char rcspath[MAXPATHLEN], numbuf[64];  
         RCSFILE *rf;  
         struct rcs_sym *sym;          struct rcs_sym *sym;
           struct rcs_lock *lkp;
         struct rcs_delta *rdp;          struct rcs_delta *rdp;
         struct rcs_access *acp;          struct rcs_access *acp;
           char numb[32], timeb[32];
   
         nrev = 0;          cvs_file_classify(cf, 0);
   
         if (cf->cf_cvstat == CVS_FST_ADDED) {          if (cf->file_status == FILE_UNKNOWN) {
                 if (verbosity > 0)                  if (verbosity > 0)
                         cvs_log(LP_WARN, "%s has been added, but not committed",                          cvs_log(LP_ERR, "nothing known about %s",
                             cf->cf_name);                              cf->file_path);
                 return (0);                  return;
         }          } else if (cf->file_status == FILE_ADDED) {
   
         if (cf->cf_cvstat == CVS_FST_UNKNOWN) {  
                 if (verbosity > 0)                  if (verbosity > 0)
                         cvs_log(LP_WARN, "nothing known about %s", cf->cf_name);                          cvs_log(LP_ERR, "%s has been added, but not commited",
                 return (0);                              cf->file_path);
                   return;
         }          }
   
         if (cf->cf_type == DT_DIR) {          printf("\nRCS file: %s", cf->file_rpath);
                 if (verbosity > 1)          printf("\nWorking file: %s", cf->file_path);
                         cvs_log(LP_NOTICE, "Logging %s", cf->cf_name);          printf("\nhead:");
                 return (0);          if (cf->file_rcs->rf_head != NULL)
         }                  printf(" %s", rcsnum_tostr(cf->file_rcs->rf_head,
                       numb, sizeof(numb)));
   
         cvs_rcs_getpath(cf, rcspath, sizeof(rcspath));          printf("\nbranch:");
           if (rcs_branch_get(cf->file_rcs) != NULL) {
         if (runflags & GLOG_NAME) {                  printf(" %s", rcsnum_tostr(rcs_branch_get(cf->file_rcs),
                 cvs_printf("%s\n", rcspath);                      numb, sizeof(numb)));
                 return (0);  
         }          }
   
         if ((rf = rcs_open(rcspath, RCS_READ|RCS_PARSE_FULLY)) == NULL)          printf("\nlocks: %s", (cf->file_rcs->rf_flags & RCS_SLOCK)
                 fatal("cvs_getlog_local: rcs_open `%s': %s", rcspath,              ? "strict" : "");
                     rcs_errstr(rcs_errno));          TAILQ_FOREACH(lkp, &(cf->file_rcs->rf_locks), rl_list)
                   printf("\n\t%s: %s", lkp->rl_name,
                       rcsnum_tostr(lkp->rl_num, numb, sizeof(numb)));
   
         cvs_printf("\nRCS file: %s", rcspath);          printf("\naccess list:\n");
         cvs_printf("\nWorking file: %s", cf->cf_name);          TAILQ_FOREACH(acp, &(cf->file_rcs->rf_access), ra_list)
         cvs_printf("\nhead:");                  printf("\t%s\n", acp->ra_name);
         if (rcs_head_get(rf) != NULL) {  
                 cvs_printf(" %s",  
                     rcsnum_tostr(rcs_head_get(rf), numbuf, sizeof(numbuf)));  
         }  
         cvs_printf("\nbranch:");  
         if (rcs_branch_get(rf) != NULL) {  
                 cvs_printf(" %s",  
                     rcsnum_tostr(rcs_branch_get(rf), numbuf, sizeof(numbuf)));  
         }  
         cvs_printf("\nlocks:%s", (rf->rf_flags & RCS_SLOCK) ? " strict" : "");  
   
         cvs_printf("\naccess list:\n");          printf("symbolic names:\n");
         TAILQ_FOREACH(acp, &(rf->rf_access), ra_list)          TAILQ_FOREACH(sym, &(cf->file_rcs->rf_symbols), rs_list) {
                 cvs_printf("\t%s\n", acp->ra_name);                  printf("\t%s: %s\n", sym->rs_name,
                       rcsnum_tostr(sym->rs_num, numb, sizeof(numb)));
         if (!(runflags & GLOG_NOTAGS)) {  
                 cvs_printf("symbolic names:\n");  
                 TAILQ_FOREACH(sym, &(rf->rf_symbols), rs_list)  
                         cvs_printf("\t%s: %s\n", sym->rs_name,  
                             rcsnum_tostr(sym->rs_num, numbuf, sizeof(numbuf)));  
         }          }
   
         cvs_printf("keyword substitution: %s\n",          printf("keyword substitution: %s\n",
             rf->rf_expand == NULL ? "kv" : rf->rf_expand);              cf->file_rcs->rf_expand == NULL ? "kv" : cf->file_rcs->rf_expand);
   
         cvs_printf("total revisions: %u", rf->rf_ndelta);          printf("total revisions: %u", cf->file_rcs->rf_ndelta);
   
         if (!(runflags & GLOG_HEADER) && !(runflags & GLOG_HEADER_DESCR))          if (logrev != NULL)
                 cvs_printf(";\tselected revisions: %u", nrev);                  nrev = 1;
           else
                   nrev = cf->file_rcs->rf_ndelta;
   
         cvs_printf("\n");          printf(";\tselected revisions: %u", nrev);
           printf("\n");
           printf("description:\n%s", cf->file_rcs->rf_desc);
   
         if (!(runflags & GLOG_HEADER) || (runflags & GLOG_HEADER_DESCR))          TAILQ_FOREACH(rdp, &(cf->file_rcs->rf_delta), rd_list) {
                 cvs_printf("description:\n%s", rf->rf_desc);                  rcsnum_tostr(rdp->rd_num, numb, sizeof(numb));
   
         if (!(runflags & GLOG_HEADER) && !(runflags & GLOG_HEADER_DESCR)) {                  if (logrev != NULL &&
                 TAILQ_FOREACH(rdp, &(rf->rf_delta), rd_list) {                      strcmp(logrev, numb))
                         rcsnum_tostr(rdp->rd_num, numbuf, sizeof(numbuf));                          continue;
                         cvs_printf(CVS_GETLOG_REVSEP "\nrevision %s\n", numbuf);  
                         cvs_printf("date: %d/%02d/%02d %02d:%02d:%02d;"  
                             "  author: %s;  state: %s;\n",  
                             rdp->rd_date.tm_year + 1900,  
                             rdp->rd_date.tm_mon + 1,  
                             rdp->rd_date.tm_mday, rdp->rd_date.tm_hour,  
                             rdp->rd_date.tm_min, rdp->rd_date.tm_sec,  
                             rdp->rd_author, rdp->rd_state);  
                         cvs_printf("%s", rdp->rd_log);  
                 }  
         }  
   
         cvs_printf(CVS_GETLOG_REVEND "\n");                  printf("%s\n", LOG_REVSEP);
   
         rcs_close(rf);                  printf("revision %s", numb);
   
         return (0);                  strftime(timeb, sizeof(timeb), "%Y/%m/%d %H:%M:%S",
                       &rdp->rd_date);
                   printf("\ndate: %s;  author: %s;  state: %s;\n", timeb,
                       rdp->rd_author, rdp->rd_state);
                   printf("%s", rdp->rd_log);
           }
   
           printf("%s\n", LOG_REVEND);
 }  }
Legend:
Removed from v.1.56  
changed lines
  Added in v.1.57