[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.19 and 1.20

version 1.19, 2005/04/12 14:58:40 version 1.20, 2005/04/13 16:37:50
Line 47 
Line 47 
 #define CVS_GETLOG_REVEND \  #define CVS_GETLOG_REVEND \
  "============================================================================="   "============================================================================="
   
 #ifdef notyet  
 static void cvs_getlog_print   (const char *, RCSFILE *, u_int);  
 #endif  
 static int  cvs_getlog_file    (CVSFILE *, void *);  static int  cvs_getlog_file    (CVSFILE *, void *);
   static int  cvs_getlog_local   (CVSFILE *, void *);
   
 int cvs_getlog_options(char *, int, char **, int *);  int cvs_getlog_options(char *, int, char **, int *);
   
Line 117 
Line 115 
         repo = CVS_DIR_REPO(cf);          repo = CVS_DIR_REPO(cf);
   
         if (cf->cf_type == DT_DIR) {          if (cf->cf_type == DT_DIR) {
                 if (root->cr_method != CVS_METHOD_LOCAL) {                  if (cf->cf_cvstat == CVS_FST_UNKNOWN)
                         if (cf->cf_cvstat == CVS_FST_UNKNOWN)                          ret = cvs_sendreq(root, CVS_REQ_QUESTIONABLE,
                                 ret = cvs_sendreq(root, CVS_REQ_QUESTIONABLE,                              CVS_FILE_NAME(cf));
                                     CVS_FILE_NAME(cf));                  else
                         else                          ret = cvs_senddir(root, cf);
                                 ret = cvs_senddir(root, cf);  
                 }  
   
                 return (ret);                  return (ret);
         }          }
   
         cvs_file_getpath(cf, fpath, sizeof(fpath));          cvs_file_getpath(cf, fpath, sizeof(fpath));
         entp = cvs_ent_getent(fpath);          entp = cvs_ent_getent(fpath);
   
         if (root->cr_method != CVS_METHOD_LOCAL) {          if ((entp != NULL) && (cvs_sendentry(root, entp) < 0)) {
                 if ((entp != NULL) && (cvs_sendentry(root, entp) < 0)) {                  cvs_ent_free(entp);
                         cvs_ent_free(entp);                  return (-1);
                         return (CVS_EX_PROTO);          }
                 }  
   
                 switch (cf->cf_cvstat) {          switch (cf->cf_cvstat) {
                 case CVS_FST_UNKNOWN:          case CVS_FST_UNKNOWN:
                         ret = cvs_sendreq(root, CVS_REQ_QUESTIONABLE,                  ret = cvs_sendreq(root, CVS_REQ_QUESTIONABLE,
                             CVS_FILE_NAME(cf));                      CVS_FILE_NAME(cf));
                         break;                  break;
                 case CVS_FST_UPTODATE:          case CVS_FST_UPTODATE:
                         ret = cvs_sendreq(root, CVS_REQ_UNCHANGED,                  ret = cvs_sendreq(root, CVS_REQ_UNCHANGED,
                             CVS_FILE_NAME(cf));                      CVS_FILE_NAME(cf));
                         break;                  break;
                 case CVS_FST_ADDED:          case CVS_FST_ADDED:
                 case CVS_FST_MODIFIED:          case CVS_FST_MODIFIED:
                         ret = cvs_sendreq(root, CVS_REQ_ISMODIFIED,                  ret = cvs_sendreq(root, CVS_REQ_ISMODIFIED,
                             CVS_FILE_NAME(cf));                      CVS_FILE_NAME(cf));
                         break;                  break;
                 default:          default:
                         break;                  break;
                 }  
         } else {  
                 if (cf->cf_cvstat == CVS_FST_UNKNOWN) {  
                         cvs_printf("? %s\n", fpath);  
                         return (0);  
                 }  
   
                 snprintf(fpath, sizeof(fpath), "%s/%s/%s%s",  
                     root->cr_dir, repo, CVS_FILE_NAME(cf), RCS_FILE_EXT);  
   
                 rf = rcs_open(fpath, RCS_READ);  
                 if (rf == NULL) {  
                         if (entp != NULL)  
                                 cvs_ent_free(entp);  
                         return (CVS_EX_DATA);  
                 }  
   
                 rcs_close(rf);  
         }          }
   
         if (entp != NULL)          if (entp != NULL)
Line 178 
Line 154 
         return (ret);          return (ret);
 }  }
   
 #ifdef notyet  
 static void  
 cvs_getlog_print(const char *file, RCSFILE *rfp, u_int flags)  static int
   cvs_getlog_local(CVSFILE *cf, void *arg)
 {  {
         char numbuf[64], datebuf[64], *sp;          int nrev;
           char fpath[MAXPATHLEN], rcspath[MAXPATHLEN], numbuf[64];
           char *repo;
           RCSFILE *rf;
           struct rcs_sym *sym;
         struct rcs_delta *rdp;          struct rcs_delta *rdp;
           struct cvsroot *root;
   
         cvs_printf("RCS file: %s\nWorking file: %s\n",          cvs_file_getpath(cf, fpath, sizeof(fpath));
             rfp->rf_path, file);          if (cf->cf_cvstat == CVS_FST_UNKNOWN) {
         cvs_printf("Working file: %s\n", (char *)NULL);                  cvs_printf("? %s\n", fpath);
         cvs_printf("head: %s\nbranch:\nlocks:\naccess list:\n");                  return (0);
         cvs_printf("symbolic names:\nkeyword substitutions:\n");          }
         cvs_printf("total revisions: %u;\tselected revisions: %u\n", 1, 1);  
   
           if (cf->cf_type == DT_DIR)
                   return (0);
   
           nrev = 0;
           root = CVS_DIR_ROOT(cf);
           repo = CVS_DIR_REPO(cf);
   
           snprintf(rcspath, sizeof(rcspath), "%s/%s/%s%s",
               root->cr_dir, repo, CVS_FILE_NAME(cf), RCS_FILE_EXT);
   
           rf = rcs_open(rcspath, RCS_READ);
           if (rf == NULL)
                   return (-1);
   
           cvs_printf("\nRCS file: %s\nWorking file: %s\n", rcspath, cf->cf_name);
           cvs_printf("head: %s\n",
               rcsnum_tostr(rcs_head_get(rf), numbuf, sizeof(numbuf)));
           cvs_printf("branch: %s\n",
               rcsnum_tostr(rcs_branch_get(rf), numbuf, sizeof(numbuf)));
           cvs_printf("locks:\naccess list:\n");
   
           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", "");
           cvs_printf("total revisions: %u;\tselected revisions: %u\n",
               rf->rf_ndelta, nrev);
   
         cvs_printf("description:\n");          cvs_printf("description:\n");
   
         for (;;) {          TAILQ_FOREACH(rdp, &(rf->rf_delta), rd_list) {
                 cvs_printf(CVS_GETLOG_REVSEP "\n");  
                 rcsnum_tostr(rdp->rd_num, numbuf, sizeof(numbuf));                  rcsnum_tostr(rdp->rd_num, numbuf, sizeof(numbuf));
                 cvs_printf("revision %s\n", numbuf);                  cvs_printf(CVS_GETLOG_REVSEP "\nrevision %s\n", numbuf);
                 cvs_printf("date: %d/%02d/%d %02d:%02d:%02d;  author: %s;"                  cvs_printf("date: %d/%02d/%02d %02d:%02d:%02d;  author: %s;"
                     "  state: %s;  lines:",                      "  state: %s;\n",
                     rdp->rd_date.tm_year, rdp->rd_date.tm_mon + 1,                      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_mday, rdp->rd_date.tm_hour,
                     rdp->rd_date.tm_min, rdp->rd_date.tm_sec,                      rdp->rd_date.tm_min, rdp->rd_date.tm_sec,
                     rdp->rd_author, rdp->rd_state);                      rdp->rd_author, rdp->rd_state);
                   cvs_printf("%s", rdp->rd_log);
         }          }
   
         cvs_printf(CVS_GETLOG_REVEND "\n");          cvs_printf(CVS_GETLOG_REVEND "\n");
   
           rcs_close(rf);
   
           return (0);
 }  }
 #endif  
Legend:
Removed from v.1.19  
changed lines
  Added in v.1.20