/[CvsGraph]/cvsgraph/cvsgraph.c
ViewVC logotype

Diff of /cvsgraph/cvsgraph.c

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph | View Patch Patch

revision 1.17, Wed Dec 19 18:10:58 2001 UTC revision 1.18, Tue Jan 1 21:03:23 2002 UTC
# Line 34  Line 34 
34  #include <errno.h>  #include <errno.h>
35  #include <ctype.h>  #include <ctype.h>
36  #include <time.h>  #include <time.h>
37    #include <limits.h>
38    
39  #ifdef HAVE_GETOPT_H  #ifdef HAVE_GETOPT_H
40  # include <getopt.h>  # include <getopt.h>
# Line 54  Line 55 
55    
56  /*#define DEBUG         1*/  /*#define DEBUG         1*/
57    
 #define CONFFILENAME    "cvsgraph.conf"  
   
 #ifndef ETCDIR  
 # define ETCDIR         "/usr/local/etc"  
 #endif  
   
58  #ifndef MAX  #ifndef MAX
59  # define MAX(a,b)       ((a) > (b) ? (a) : (b))  # define MAX(a,b)       ((a) > (b) ? (a) : (b))
60  #endif  #endif
# Line 203  Line 198 
198          char *cmd = NULL;          char *cmd = NULL;
199          int rv;          int rv;
200    
201          cmd = xmalloc(strlen(cvsroot) + strlen(module) + strlen(file) + 1);          if(file)
         sprintf(cmd, "%s%s%s", cvsroot, module, file);  
         if(!(rcsin = fopen(cmd, "rb")))  
202          {          {
203                  perror(cmd);                  cmd = xmalloc(strlen(cvsroot) + strlen(module) + strlen(file) + 1);
204                  return NULL;                  sprintf(cmd, "%s%s%s", cvsroot, module, file);
205                    if(!(rcsin = fopen(cmd, "rb")))
206                    {
207                            perror(cmd);
208                            return NULL;
209                    }
210                    input_file = cmd;
211            }
212            else
213            {
214                    rcsin = stdin;
215                    input_file = "<stdin>";
216          }          }
         input_file = cmd;  
217          line_number = 1;          line_number = 1;
218          rv = rcsparse();          rv = rcsparse();
219          fclose(rcsin);          if(file)
220            {
221                    fclose(rcsin);
222                    xfree(cmd);
223            }
224          if(rv)          if(rv)
225                  return NULL;                  return NULL;
         xfree(cmd);  
226          input_file = NULL;          input_file = NULL;
227          rcsfile->root = xstrdup(cvsroot);          if(file)
228          rcsfile->module = xstrdup(module);          {
229          rcsfile->file = xstrdup(file);                  rcsfile->root = xstrdup(cvsroot);
230                    rcsfile->module = xstrdup(module);
231                    rcsfile->file = xstrdup(file);
232            }
233            else
234            {
235                    rcsfile->root = xstrdup("");
236                    rcsfile->module = xstrdup("");
237                    rcsfile->file = xstrdup("<stdin>");
238            }
239          return rcsfile;          return rcsfile;
240  }  }
241    
# Line 932  Line 947 
947          }          }
948          if(r)          if(r)
949          {          {
950                    /* FIXME: Pixelization is not perfect */
951                  gdImageArc(im, x1+r, y1+r, r2, r2, 180, 270, color->id);                  gdImageArc(im, x1+r, y1+r, r2, r2, 180, 270, color->id);
952                  gdImageArc(im, x2-r, y1+r, r2, r2, 270, 360, color->id);                  gdImageArc(im, x2-r, y1+r, r2, r2, 270, 360, color->id);
953                  gdImageArc(im, x1+r, y2-r, r2, r2,  90, 180, color->id);                  gdImageArc(im, x1+r, y2-r, r2, r2,  90, 180, color->id);
                 gdImageArc(im, x2-r, y2-r, r2, r2,   0,  90, color->id);  
954                  if(conf.box_shadow)                  if(conf.box_shadow)
955                  {                  {
                         /* FIXME: Pixelization is not correct here */  
956                          gdImageArc(im, x2-r+1, y2-r+1, r2, r2,   0,  90, black_color.id);                          gdImageArc(im, x2-r+1, y2-r+1, r2, r2,   0,  90, black_color.id);
957                            gdImageArc(im, x2-r+1, y2-r, r2, r2,   0,  90, black_color.id);
958                            gdImageArc(im, x2-r, y2-r+1, r2, r2,   0,  90, black_color.id);
959                  }                  }
960                    gdImageArc(im, x2-r, y2-r, r2, r2,   0,  90, color->id);
961          }          }
962          gdImageFillToBorder(im, (x1+x2)/2, (y1+y2)/2, color->id, bgcolor->id);          gdImageFillToBorder(im, (x1+x2)/2, (y1+y2)/2, color->id, bgcolor->id);
963  }  }
# Line 1140  Line 1157 
1157          }          }
1158  }  }
1159    
1160  void reposition_branch(revision_t *r, int *x, int *w)  void initial_reposition_branch(revision_t *r, int *x, int *w)
1161  {  {
1162          int i, j;          int i, j;
1163          for(j = 0; j < r->nbranches; j++)          for(j = 0; j < r->nbranches; j++)
# Line 1153  Line 1170 
1170                  /* Recurse to move branches of branched revisions */                  /* Recurse to move branches of branched revisions */
1171                  for(i = b->nrevs-1; i >= 0; i--)                  for(i = b->nrevs-1; i >= 0; i--)
1172                  {                  {
1173                          reposition_branch(b->revs[i], x, w);                          initial_reposition_branch(b->revs[i], x, w);
1174                  }                  }
1175          }          }
1176  }  }
# Line 1214  Line 1231 
1231          return 0;          return 0;
1232  }  }
1233    
1234    void kern_tree(rcsfile_t *rcs)
1235    {
1236            int i;
1237            int moved;
1238            for(moved = 1; moved; )
1239            {
1240                    moved = 0;
1241                    for(i = 1; i < rcs->nbranches; i++)
1242                    {
1243                            moved += kern_branch(rcs, rcs->branches[i]);
1244                    }
1245    #ifdef DEBUG
1246                    fprintf(stderr, "kern_tree: moved=%d\n", moved);
1247    #endif
1248            }
1249    }
1250    
1251    void move_yr_branch(revision_t *r, int dy)
1252    {
1253            int i, j;
1254    #ifdef DEBUG
1255            fprintf(stderr, "move_yr_branch: r=%s, dy=%d\n", r->rev->rev, dy);
1256    #endif
1257            for(i = 0; i < r->nbranches; i++)
1258            {
1259                    branch_t *b = r->branches[i];
1260                    b->y += dy;
1261                    for(j = 0; j < b->nrevs; j++)
1262                    {
1263                            b->revs[j]->y += dy;
1264                            move_yr_branch(b->revs[j], dy);
1265                    }
1266            }
1267    }
1268    
1269    int index_of_revision(revision_t *r)
1270    {
1271            branch_t *b = r->branch;
1272            int i;
1273            for(i = 0; i < b->nrevs; i++)
1274            {
1275                    if(r == b->revs[i])
1276                            return i;
1277            }
1278            fprintf(stderr, "index_of_revision: Cannot find revision in branch\n");
1279            return 0;
1280    }
1281    
1282    int has_space_below(rcsfile_t *rcs, branch_t *b, int recurse)
1283    {
1284            int i;
1285            int space = INT_MAX;
1286            for(i = 0; i < rcs->nbranches; i++)
1287            {
1288                    int bl;
1289                    int br;
1290                    int tbl;
1291                    int tbr;
1292                    branch_t *tb = rcs->branches[i];
1293                    if(tb == b)
1294                            continue;
1295                    bl = b->cx - b->tw/2;
1296                    br = b->cx + b->tw/2;
1297                    tbl = tb->cx - tb->tw/2;
1298                    tbr = tb->cx + tb->tw/2;
1299                    if(b->y < tb->y && ((bl >= tbl && bl <= tbr) || (br <= tbr && br >= tbl)))
1300                    {
1301                            int s = tb->y - conf.branch_connect - conf.branch_margin - (b->y + b->th);
1302                            if(s < space)
1303                                    space = s;
1304                    }
1305                    if(recurse)
1306                    {
1307                            int j, k;
1308                            for(j = 0; j < b->nrevs; j++)
1309                            {
1310                                    for(k = 0; k < b->revs[j]->nbranches; k++)
1311                                    {
1312                                            int s = has_space_below(rcs, b->revs[j]->branches[k], recurse);
1313                                            if(s < space)
1314                                                    space = s;
1315                                    }
1316                            }
1317                    }
1318            }
1319            return space;
1320    }
1321    
1322    /* Stretch a branch from the top til revision r */
1323    void stretch_branch(rcsfile_t *rcs, revision_t *r, int spaceneeded)
1324    {
1325            branch_t *b = r->branch;
1326            int rtag = index_of_revision(r);
1327            int hasspace = has_space_below(rcs, b, 0);
1328            int i, j;
1329            for(i = rtag; i < b->nrevs; i++)
1330            {
1331                    for(j = 0; j < b->revs[i]->nbranches; j++)
1332                    {
1333                            int s = has_space_below(rcs, b->revs[i]->branches[j], 1);
1334                            if(s < hasspace)
1335                                    hasspace = s;
1336                    }
1337            }
1338            if(hasspace >= spaceneeded)
1339            {
1340                    int ext = spaceneeded / (rtag + 1);
1341                    int rest = spaceneeded - ext * (rtag + 1);
1342                    for(i = 0; i < rtag; i++)
1343                    {
1344                            /* FIXME: conf.rev_maxline */
1345                            move_yr_branch(b->revs[i], ext);
1346                    }
1347                    move_yr_branch(b->revs[rtag], ext+rest);
1348            }
1349    }
1350    
1351    branch_t *get_rightmost_branch(rcsfile_t *rcs)
1352    {
1353            branch_t *b = NULL;
1354            int i;
1355            for(i = 0; i < rcs->nbranches; i++)
1356            {
1357                    if(rcs->branches[i]->flag)
1358                            continue;
1359                    if(!b || rcs->branches[i]->cx > b->cx)
1360                            b = rcs->branches[i];
1361            }
1362            if(b)
1363                    b->flag = 1;
1364    #ifdef DEBUG
1365            fprintf(stderr, "get_rightmost_branch: %s\n", b ? b->branch->rev : "<none>");
1366    #endif
1367            return b;
1368    }
1369    
1370    branch_t *find_left_colission_branch(rcsfile_t *rcs, branch_t *b)
1371    {
1372            int i;
1373            branch_t *lcb = NULL;
1374            for(i = 0; i < rcs->nbranches; i++)
1375            {
1376                    branch_t *tag = rcs->branches[i];
1377                    if(tag == b)
1378                            continue;
1379                    /* FIXME branch_margins */
1380                    if((b->y >= tag->y && b->y <= tag->y + tag->th)
1381                    || (tag->y >= b->y && tag->y <= b->y + b->th))
1382                    {
1383                            if(!lcb || lcb->cx < tag->cx)
1384                                    lcb = tag;
1385                    }
1386            }
1387            return lcb;
1388    }
1389    
1390    void auto_kern(rcsfile_t *rcs)
1391    {
1392            /* Initially move branches left if there is room */
1393            kern_tree(rcs);
1394    
1395            if(conf.auto_kern)
1396            {
1397                    branch_t *b;
1398                    /* Stretch each branch's revision spacing and try to kern more */
1399                    while((b = get_rightmost_branch(rcs)))
1400                    {
1401                            int spaceneeded;
1402                            branch_t *lcb = find_left_colission_branch(rcs, b);
1403                            if(!lcb || !b->branchpoint || lcb == b->branchpoint->branch)
1404                                    continue;
1405                            spaceneeded = b->y + b->th + conf.branch_margin + conf.branch_connect - lcb->y;
1406                            if(spaceneeded)
1407                            {
1408                                    stretch_branch(rcs, lcb->branchpoint, spaceneeded);
1409                                    kern_tree(rcs);
1410                            }
1411                    }
1412            }
1413    }
1414    
1415  void make_layout(rcsfile_t *rcs)  void make_layout(rcsfile_t *rcs)
1416  {  {
1417          int i, j;          int i, j;
1418          int x, y;          int x, y;
1419          int w, h;          int w, h;
1420          int w2;          int w2;
         int moved;  
1421    
1422          /* Remove all unwanted revisions */          /* Remove all unwanted revisions */
1423          if(conf.strip_untagged)          if(conf.strip_untagged)
1424          {          {
1425                    int fr = conf.strip_first_rev ? 1 : 0;
1426                  for(i = 0; i < rcs->nbranches; i++)                  for(i = 0; i < rcs->nbranches; i++)
1427                  {                  {
1428                          branch_t *bp = rcs->branches[i];                          branch_t *bp = rcs->branches[i];
1429                          for(j = 0; j < bp->nrevs-1; j++)                          for(j = fr; j < bp->nrevs-1; j++)
1430                          {                          {
1431                                  if(!bp->revs[j]->ntags && !bp->revs[j]->nbranches)                                  if(!bp->revs[j]->ntags && !bp->revs[j]->nbranches)
1432                                  {                                  {
# Line 1311  Line 1509 
1509                  }                  }
1510          }          }
1511    
1512          /* Reposition the branches */          /* Initially reposition the branches from bottom to top progressively right */
1513          x = rcs->branches[0]->cx;          x = rcs->branches[0]->cx;
1514          w2 = rcs->branches[0]->tw / 2;          w2 = rcs->branches[0]->tw / 2;
1515          for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)          for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)
1516          {          {
1517                  reposition_branch(rcs->branches[0]->revs[i], &x, &w2);                  initial_reposition_branch(rcs->branches[0]->revs[i], &x, &w2);
1518          }          }
1519    
1520          /* Try to move branches left if there is room (kerning) */          /* Try to kern the branches more by expanding the inter-revision spacing */
1521          for(moved = 1; moved; )          auto_kern(rcs);
         {  
                 moved = 0;  
                 for(i = 1; i < rcs->nbranches; i++)  
                 {  
                         moved += kern_branch(rcs, rcs->branches[i]);  
                 }  
         }  
1522    
1523          /* Move everything w.r.t. the top-left margin */          /* Move everything w.r.t. the top-left margin */
1524          for(i = 0; i < rcs->nbranches; i++)          for(i = 0; i < rcs->nbranches; i++)
# Line 1447  Line 1638 
1638    
1639  /*  /*
1640   **************************************************************************   **************************************************************************
  * Configuration  
  **************************************************************************  
  */  
 int read_config(const char *path)  
 {  
         FILE *fp;  
         int r;  
   
         if(path)  
         {  
                 if((fp = fopen(path, "r")) == NULL)  
                 {  
                         return 0;  
                 }  
                 else  
                         input_file = path;  
         }  
         else  
         {  
                 if((fp = fopen("./" CONFFILENAME, "r")) == NULL)  
                 {  
                         if((fp = fopen(ETCDIR "/" CONFFILENAME, "r")) == NULL)  
                         {  
                                 return 0;  
                         }  
                         else  
                                 input_file = ETCDIR "/" CONFFILENAME;  
                 }  
                 else  
                         input_file = "./" CONFFILENAME;  
         }  
   
         yyin = fp;  
         r = yyparse();  
         fclose(fp);  
         input_file = NULL;  
         return r == 0;  
 }  
   
 /*  
  **************************************************************************  
1641   * Program entry   * Program entry
1642   **************************************************************************   **************************************************************************
1643   */   */
# Line 1498  Line 1648 
1648          "  -d <level>   Enable debug mode at <level>\n"          "  -d <level>   Enable debug mode at <level>\n"
1649          "  -h           This message\n"          "  -h           This message\n"
1650          "  -i           Generate an imagemap instead of image\n"          "  -i           Generate an imagemap instead of image\n"
1651            "  -I <file>    Also write the imagemap to <file>\n"
1652            "  -k           Autokern the tree (config value is negated)\n"
1653          "  -M <name>    Use <name> as imagemap name\n"          "  -M <name>    Use <name> as imagemap name\n"
1654          "  -m <mod>     Use <mod> as cvs module\n"          "  -m <mod>     Use <mod> as cvs module\n"
1655          "  -o <file>    Output to <file>\n"          "  -o <file>    Output to <file>\n"
1656            "  -O <opt=val> Set option opt to value val\n"
1657          "  -q           Be quiet (i.e. no warnings)\n"          "  -q           Be quiet (i.e. no warnings)\n"
1658          "  -r <path>    Use <path> as cvsroot path\n"          "  -r <path>    Use <path> as cvsroot path\n"
1659          "  -s           Strip untagged revisions (config value is negated)\n"          "  -s           Strip untagged revisions (config value is negated)\n"
1660            "  -S           Also strip the first revision (config value is negated)\n"
1661          "  -u           Upside down image (mirror vertically; config value is negated)\n"          "  -u           Upside down image (mirror vertically; config value is negated)\n"
1662          "  -V           Print version and exit\n"          "  -V           Print version and exit\n"
1663          "  -[0-9] <txt> Use <txt> for expansion\n"          "  -[0-9] <txt> Use <txt> for expansion\n"
1664          ;          ;
1665    
1666  #define VERSION_STR     "1.1.4"  #define VERSION_STR     "1.2.0"
1667  #define NOTICE_STR      "Copyright (c) 2001 B.Stultiens"  #define NOTICE_STR      "Copyright (c) 2001-2002 B.Stultiens"
1668    
1669  void append_slash(char **path)  void append_slash(char **path)
1670  {  {
# Line 1526  Line 1680 
1680    
1681  int main(int argc, char *argv[])  int main(int argc, char *argv[])
1682  {  {
         extern int yy_flex_debug;  
1683          extern int rcs_flex_debug;          extern int rcs_flex_debug;
         extern int yydebug;  
1684          extern int rcsdebug;          extern int rcsdebug;
1685          int optc;          int optc;
1686          char *confpath = NULL;          char *confpath = NULL;
# Line 1539  Line 1691 
1691          int upsidedown = 0;          int upsidedown = 0;
1692          int bdupbox = 0;          int bdupbox = 0;
1693          int stripuntag = 0;          int stripuntag = 0;
1694            int stripfirst = 0;
1695            int autokern = 0;
1696          char *imgmapname = NULL;          char *imgmapname = NULL;
1697            char *imgmapfile = NULL;
1698          int lose = 0;          int lose = 0;
1699          FILE *fp;          FILE *fp;
1700            char *rcsfilename;
1701          rcsfile_t *rcs;          rcsfile_t *rcs;
1702          gdImagePtr im;          gdImagePtr im;
1703    
1704          while((optc = getopt(argc, argv, "0:1:2:3:4:5:6:7:8:9:bc:d:hiM:m:o:qr:suV")) != EOF)          while((optc = getopt(argc, argv, "0:1:2:3:4:5:6:7:8:9:bc:d:hI:ikM:m:O:o:qr:SsuV")) != EOF)
1705          {          {
1706                  switch(optc)                  switch(optc)
1707                  {                  {
# Line 1558  Line 1714 
1714                  case 'd':                  case 'd':
1715                          debuglevel = strtol(optarg, NULL, 0);                          debuglevel = strtol(optarg, NULL, 0);
1716                          break;                          break;
1717                    case 'I':
1718                            imgmapfile = xstrdup(optarg);
1719                            break;
1720                  case 'i':                  case 'i':
1721                          imagemap = 1;                          imagemap = 1;
1722                          break;                          break;
1723                    case 'k':
1724                            autokern = 1;
1725                            break;
1726                  case 'M':                  case 'M':
1727                          imgmapname = xstrdup(optarg);                          imgmapname = xstrdup(optarg);
1728                          break;                          break;
1729                  case 'm':                  case 'm':
1730                          cvsmodule = xstrdup(optarg);                          cvsmodule = xstrdup(optarg);
1731                          break;                          break;
1732                    case 'O':
1733                            stack_option(optarg);
1734                            break;
1735                  case 'o':                  case 'o':
1736                          outfile = xstrdup(optarg);                          outfile = xstrdup(optarg);
1737                          break;                          break;
# Line 1576  Line 1741 
1741                  case 'r':                  case 'r':
1742                          cvsroot = xstrdup(optarg);                          cvsroot = xstrdup(optarg);
1743                          break;                          break;
1744                    case 'S':
1745                            stripfirst = 1;
1746                            break;
1747                  case 's':                  case 's':
1748                          stripuntag = 1;                          stripuntag = 1;
1749                          break;                          break;
# Line 1598  Line 1766 
1766                  }                  }
1767          }          }
1768    
         if(optind >= argc)  
         {  
                 fprintf(stderr, "Missing inputfile\n");  
                 lose++;  
         }  
   
1769          if(lose)          if(lose)
1770          {          {
1771                  fprintf(stderr, "%s", usage_str);                  fprintf(stderr, "%s", usage_str);
# Line 1615  Line 1777 
1777                  setvbuf(stdout, NULL, 0, _IONBF);                  setvbuf(stdout, NULL, 0, _IONBF);
1778                  setvbuf(stderr, NULL, 0, _IONBF);                  setvbuf(stderr, NULL, 0, _IONBF);
1779          }          }
         yy_flex_debug = (debuglevel & DEBUG_CONF_LEX) != 0;  
1780          rcs_flex_debug = (debuglevel & DEBUG_RCS_LEX) != 0;          rcs_flex_debug = (debuglevel & DEBUG_RCS_LEX) != 0;
         yydebug = (debuglevel & DEBUG_CONF_YACC) != 0;  
1781          rcsdebug = (debuglevel & DEBUG_RCS_YACC) != 0;          rcsdebug = (debuglevel & DEBUG_RCS_YACC) != 0;
1782    
1783          /* Set defaults */          /* Set defaults */
# Line 1650  Line 1810 
1810          conf.rev_text_color     = black_color;          conf.rev_text_color     = black_color;
1811    
1812          conf.image_quality      = 100;          conf.image_quality      = 100;
1813            conf.rev_maxline        = -1;   /* Checked later to set to default */
1814    
1815          if(!read_config(confpath))          read_config(confpath);
1816          {  
1817                  fprintf(stderr, "Error reading config file\n");          if(conf.rev_maxline == -1)      conf.rev_maxline = 5 * conf.rev_minline;
                 return 1;  
         }  
1818    
1819          /* Set overrides */          /* Set overrides */
1820          if(cvsroot)     conf.cvsroot = cvsroot;          if(cvsroot)     conf.cvsroot = cvsroot;
# Line 1664  Line 1823 
1823          if(upsidedown)  conf.upside_down = !conf.upside_down;          if(upsidedown)  conf.upside_down = !conf.upside_down;
1824          if(bdupbox)     conf.branch_dupbox = !conf.branch_dupbox;          if(bdupbox)     conf.branch_dupbox = !conf.branch_dupbox;
1825          if(stripuntag)  conf.strip_untagged = !conf.strip_untagged;          if(stripuntag)  conf.strip_untagged = !conf.strip_untagged;
1826            if(stripfirst)  conf.strip_first_rev = !conf.strip_first_rev;
1827            if(autokern)    conf.auto_kern = !conf.auto_kern;
1828    
1829            if(conf.rev_minline >= conf.rev_maxline)
1830            {
1831                    if(conf.auto_kern && !quiet)
1832                            fprintf(stderr, "Autokern is only possible if rev_minline < rev_maxline\n");
1833                    conf.auto_kern = 0;
1834            }
1835    
1836          append_slash(&conf.cvsroot);          append_slash(&conf.cvsroot);
1837          append_slash(&conf.cvsmodule);          append_slash(&conf.cvsmodule);
1838    
1839          rcs = get_rcsfile(conf.cvsroot, conf.cvsmodule, argv[optind]);          if(optind >= argc)
1840            {
1841    #ifdef __WIN32__
1842                    /* Bad hack for DOS/Windows */
1843                    if(setmode(fileno(stdin), O_BINARY) == -1)
1844                    {
1845                            perror("Set binary mode for stdin");
1846                            return 1;
1847                    }
1848    #endif
1849                    rcsfilename = NULL;
1850            }
1851            else
1852                    rcsfilename = argv[optind];
1853    
1854            rcs = get_rcsfile(conf.cvsroot, conf.cvsmodule, rcsfilename);
1855          if(!rcs)          if(!rcs)
1856                  return 1;                  return 1;
1857    
# Line 1743  Line 1926 
1926                  make_imagemap(rcs, fp);                  make_imagemap(rcs, fp);
1927          }          }
1928    
1929            /* Also create imagemap to file if requested */
1930            if(imgmapfile)
1931            {
1932                    FILE *ifp = fopen(imgmapfile, "wb");
1933                    if(!ifp)
1934                    {
1935                            perror(imgmapfile);
1936                            return 1;
1937                    }
1938                    make_imagemap(rcs, ifp);
1939                    fclose(ifp);
1940            }
1941    
1942          if(outfile)          if(outfile)
1943                  fclose(fp);                  fclose(fp);
1944    

Legend:
Removed from v.1.17  
changed lines
  Added in v.1.18

  ViewVC Help
Powered by ViewVC 1.1.0 with CvsGraph 1.7.0