tools/hiddtool/hiddtool.c

   1 /* Hiddtool
   2    Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3
   4 This file is part of Hiddtool
   5
   6 Hiddtool is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 Hiddtool is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20 /* Includes */
  21 // #include "config.h"
  22
  23
  24 #include <stdio.h>
  25 #include <unistd.h>
  26 #include <assert.h>
  27 #include <errno.h>
  28 #include <ctype.h>
  29 #include <stdlib.h>
  30 #include <time.h>
  31 #include <string.h>
  32 #include <strings.h>
  33 #include <sys/types.h>
  34
  35 #define TRUE 1
  36 #define FALSE 0
  37
  38 /* Types */
  39 typedef struct _Node Node;
  40
  41 struct _Node
  42 {
  43     Node * next,
  44          * prev;
  45     char * name;
  46 };
  47
  48 typedef struct
  49 {
  50     Node * first,
  51          * last,
  52          * prelast;
  53 }
  54 List;
  55
  56 typedef struct
  57 {
  58     Node   node;
  59     char * value;
  60 }
  61 Var;
  62
  63 typedef struct
  64 {
  65     Node node;
  66     List deps;
  67     int circularcheck; /* Used when checking for circular dependencies */
  68
  69 } Item;
  70
  71 typedef struct {
  72
  73     List items;
  74 } DepsDB;
  75
  76 typedef struct {
  77     Node node;
  78     int opt;
  79 } Conf;
  80
  81 enum {
  82     OPT_KERNEL,
  83     OPT_DISK
  84 };
  85
  86 /* Macros */
  87 #   define NewList(l)       (((List *)l)->prelast = (Node *)(l), \
  88                             ((List *)l)->last = 0, \
  89                             ((List *)l)->first = (Node *)&(((List *)l)->last))
  90
  91 #   define AddHead(l,n)     ((void)(\
  92         ((Node *)n)->next        = ((List *)l)->first, \
  93         ((Node *)n)->prev        = (Node *)&((List *)l)->first, \
  94         ((List *)l)->first->prev = ((Node *)n), \
  95         ((List *)l)->first       = ((Node *)n)))
  96
  97 #   define AddTail(l,n)     ((void)(\
  98         ((Node *)n)->next          = (Node *)&((List *)l)->last, \
  99         ((Node *)n)->prev          = ((List *)l)->prelast, \
 100         ((List *)l)->prelast->next = ((Node *)n), \
 101         ((List *)l)->prelast       = ((Node *)n) ))
 102
 103 #   define Remove(n)        ((void)(\
 104         ((Node *)n)->prev->next = ((Node *)n)->next,\
 105         ((Node *)n)->next->prev = ((Node *)n)->prev ))
 106
 107 #   define GetHead(l)       (void *)(((List *)l)->first->next \
 108                                 ? ((List *)l)->first \
 109                                 : (Node *)0)
 110 #   define GetTail(l)       (void *)(((List *)l)->prelast->prev \
 111                                 ? ((List *)l)->prelast \
 112                                 : (Node *)0)
 113 #   define GetNext(n)       (void *)(((Node *)n)->next->next \
 114                                 ? ((Node *)n)->next \
 115                                 : (Node *)0)
 116 #   define GetPrev(n)       (void *)(((Node *)n)->prev->prev \
 117                                 ? ((Node *)n)->prev \
 118                                 : (Node *)0)
 119
 120 #define InsertBefore(n, before)         \
 121         ((Node *)before)->prev->next = n;               \
 122         ((Node *)n)->prev = ((Node *)before)->prev;     \
 123         ((Node *)before)->prev = n;                     \
 124         ((Node *)n)->next       = before;
 125
 126 #   define ForeachNode(l,n) \
 127         for (n=(void *)(((List *)(l))->first); \
 128             ((Node *)(n))->next; \
 129             n=(void *)(((Node *)(n))->next))
 130 #   define ForeachNodeSafe(l,node,nextnode) \
 131         for (node=(void *)(((List *)(l))->first); \
 132             ((nextnode)=(void*)((Node *)(node))->next); \
 133             (node)=(void *)(nextnode))
 134
 135 #define cfree(x)        if (x) free (x)
 136 #define SETSTR(str,val) \
 137     cfree (str); \
 138     str = val ? xstrdup (val) : NULL
 139
 140 #define xstrdup(str)        _xstrdup(str,__FILE__,__LINE__)
 141 #define xmalloc(size)       _xmalloc(size,__FILE__,__LINE__)
 142 #define xfree(ptr)          _xfree(ptr,__FILE__,__LINE__)
 143 #define new(x)              ((x *) xmalloc (sizeof (x)))
 144
 145
 146 /* Functions */
 147 char *
 148 _xstrdup (const char * str, const char * file, int line)
 149 {
 150     char * nstr;
 151
 152     assert (str);
 153
 154     nstr = strdup (str);
 155
 156     if (!nstr)
 157     {
 158         fprintf (stderr, "Out of memory in %s:%d", file, line);
 159         exit (20);
 160     }
 161
 162     return nstr;
 163 }
 164
 165 void *
 166 _xmalloc (size_t size, const char * file, int line)
 167 {
 168     void * ptr;
 169
 170     ptr = malloc (size);
 171
 172     if (size && !ptr)
 173     {
 174         fprintf (stderr, "Out of memory in %s:%d", file, line);
 175         exit (20);
 176     }
 177
 178     return ptr;
 179 }
 180
 181 void
 182 _xfree (void * ptr, const char * file, int line)
 183 {
 184     if (ptr)
 185         free (ptr);
 186     else
 187         fprintf (stderr, "Illegal free(NULL) in %s:%d", file, line);
 188 }
 189
 190 Node *
 191 findnode (const List * l, const char * name)
 192 {
 193     Node * n;
 194
 195     ForeachNode (l, n)
 196     {
 197         if (!strcmp (n->name, name))
 198             return n;
 199     }
 200
 201     return NULL;
 202 }
 203
 204
 205 void
 206 printlist (List * l)
 207 {
 208     Node * n;
 209
 210     ForeachNode (l,n)
 211     {
 212         printf ("    \"%s\"\n", n->name);
 213     }
 214 }
 215
 216
 217
 218
 219 void cleanup(int exitcode)
 220 {
 221      exit(exitcode);
 222 }
 223
 224 void usage()
 225 {
 226     fprintf(stderr, "Usage: hiddtool -k configfile: get list of all kernel hidds\n");
 227     fprintf(stderr, "       hiddtool -d configfile: get list of all disk hidds\n");
 228     fprintf(stderr, "       hiddtool -m configfile: generate metamake dependancies\n");
 229     cleanup(1);
 230 }
 231
 232 /* Returns pointer to next noblank car or NULL if end of buffer is reached */
 233 char *next_not_blank(char *s)
 234 {
 235     while (*s && isspace(*s)) {
 236         s ++;
 237     }
 238     if (0 == *s)
 239         s = NULL;
 240
 241     return s;
 242 }
 243
 244 /* Returns pointer to end of word or NULL on error */
 245 char *end_of_word(char *word)
 246 {
 247     char *s = word;
 248     while (*s && (isalpha(*s) || *s == '-')) {
 249         s ++;
 250     }
 251
 252     if (s == word)      /* Target was of length 0 ? */
 253         s = NULL;
 254
 255     return s;
 256 }
 257
 258 void print_deps_db(DepsDB *db)
 259 {
 260     Item *item;
 261
 262     ForeachNode(&db->items, item) {
 263         Node *depnode;
 264
 265         printf("%s :", item->node.name);
 266
 267         ForeachNode(&item->deps, depnode) {
 268             printf(" %s", depnode->name);
 269         }
 270
 271         printf("\n");
 272     }
 273 }
 274
 275 static inline void freenode(Node *n)
 276 {
 277     if (NULL != n->name) {
 278         xfree(n->name);
 279         n->name = NULL;
 280     }
 281
 282     xfree(n);
 283 }
 284
 285 void free_deps_db(DepsDB *db)
 286 {
 287     Item *item, *safeitem;
 288
 289     ForeachNodeSafe(&db->items, item, safeitem) {
 290         Node *depnode, *safedepnode;
 291
 292         ForeachNodeSafe(&item->deps, depnode, safedepnode) {
 293             freenode(depnode);
 294         }
 295         freenode((Node *)item);
 296     }
 297
 298     xfree(db);
 299 }
 300
 301
 302 DepsDB *build_deps_db(char *filename)
 303 {
 304     DepsDB *db;
 305     FILE *f;
 306     int ok = 1;
 307
 308     db = xmalloc(sizeof (*db));
 309     NewList(&db->items);
 310
 311     f = fopen(filename, "r");
 312     if (NULL == f) {
 313         fprintf(stderr, "Could not open dependancy db file %s\n", filename);
 314         ok = FALSE;
 315     } else {
 316         /* Read in all the dependancies */
 317         char buf[500];
 318         int line;
 319
 320         line = 0;
 321         while(ok) {
 322             char *s;
 323             char *target, *target_end;
 324             Item *item;
 325             int done = FALSE;
 326             if (NULL == fgets(buf, sizeof (buf), f))
 327                 break;
 328             line ++;
 329
 330             s = buf;
 331
 332             /* Parse the contents in the buffer */
 333             target = s = next_not_blank(s);
 334             if (NULL == target)
 335                 continue;
 336
 337             s = end_of_word(s);
 338             if (NULL == s) {
 339                 fprintf(stderr, "Malformed target at line %d in %s\n", line, filename);
 340                 ok = FALSE;
 341                 break;
 342             }
 343             target_end = s;
 344
 345             /* Go to next not blanke */
 346             s = next_not_blank(s);
 347             if (NULL == s) {
 348                 fprintf(stderr, "Missing colon at line %d in %s\n", line, filename);
 349                 ok = FALSE;
 350                 break;
 351             }
 352
 353             if (*s != ':') {
 354                 fprintf(stderr, "Rubbish instead of colon at line %d in %s\n", line, filename);
 355                 ok = FALSE;
 356                 break;
 357             }
 358
 359             s ++;
 360
 361             *target_end = 0;
 362             /* Now read all the targets dependancies */
 363
 364             /* Allocate a db item */
 365             item = xmalloc(sizeof (*item));
 366             item->node.name = xstrdup(target);
 367             item->circularcheck = 0;
 368
 369             NewList(&item->deps);
 370
 371             /* Add it to the db */
 372             AddTail(&db->items, item);
 373
 374
 375             /* Read all the dependencies */
 376
 377             while(!done && ok) {
 378                 Node *depnode;
 379
 380                 char *dep, *dep_end;
 381                 dep = s = next_not_blank(s);
 382                 if (NULL == dep) {
 383                     break;
 384                 }
 385                 dep_end = s = end_of_word(s);
 386                 if (NULL == dep_end) {
 387                     fprintf(stderr, "Malformed dependancy at line %d in %s\n", line, filename);
 388                     ok = 0;
 389                     break;
 390                 }
 391
 392
 393
 394                 if (*s == 0) {
 395                     done = 1;
 396                 } else {
 397                     s ++;
 398                 }
 399
 400                 *dep_end = 0;
 401
 402                 depnode = xmalloc(sizeof (*depnode));
 403                 depnode->name = xstrdup(dep);
 404
 405                 AddTail(&item->deps, depnode);
 406
 407             } /* while (parse deps) */
 408
 409         } /* while (parse lines) */
 410
 411         fclose(f);
 412     } /* if (file opened) */
 413
 414     if (!ok) {
 415         free_deps_db(db);
 416         db = NULL;
 417     }
 418     return db;
 419
 420 }
 421
 422 void free_list(List *conf)
 423 {
 424     Conf *cnode, *safe;
 425
 426     ForeachNodeSafe(conf, cnode, safe) {
 427         freenode((Node *)cnode);
 428     }
 429     xfree(conf);
 430 }
 431
 432 void print_conf(List *conf)
 433 {
 434     Conf *cnode;
 435
 436     ForeachNode(conf, cnode) {
 437         char *optstr;
 438         switch (cnode->opt) {
 439             case OPT_KERNEL:
 440                 optstr = "kernel";
 441                 break;
 442             case OPT_DISK:
 443                 optstr = "disk";
 444                 break;
 445
 446             default:
 447                 fprintf(stderr, "print_conf: unknown option %d\n", cnode->opt);
 448                 cleanup(1);
 449                 break;
 450         }
 451         printf("%s => %s\n", cnode->node.name, optstr);
 452     }
 453 }
 454
 455 List *get_conf(char *filename)
 456 {
 457     FILE *f;
 458     List *conf;
 459     int ok = TRUE;
 460     int line = 0;
 461
 462     conf = xmalloc(sizeof (*conf));
 463     NewList(conf);
 464
 465     f = fopen(filename, "r");
 466     if (NULL == f) {
 467         fprintf(stderr, "Could not open config file %s\n", filename);
 468         ok = FALSE;
 469     } else {
 470         while (ok) {
 471             char buf[500];
 472             char *s, *target, *target_end, *opt, *opt_end;
 473             Conf *cnode;
 474
 475             if (NULL == fgets(buf, sizeof(buf), f))
 476                 break;
 477
 478             s = buf;
 479             line ++;
 480
 481             target = s = next_not_blank(s);
 482             if (NULL == target)
 483                 continue; /* Handle blank lines */
 484
 485             target_end = s = end_of_word(s);
 486             if (NULL == s) {
 487                 fprintf(stderr, "Malformed target at line %d in %s\n", line, filename);
 488                 ok = FALSE;
 489                 break;
 490             }
 491
 492             opt = s = next_not_blank(s);
 493             if (NULL == opt) {
 494                 fprintf(stderr, "Missing option at line %d in %s\n", line, filename);
 495                 ok = FALSE;
 496                 break;
 497             }
 498
 499             if (opt == target_end) {
 500                 fprintf(stderr, "Malformed option at line %d in %s\n", line, filename);
 501                 ok = FALSE;
 502                 break;
 503             }
 504             *target_end = 0;
 505
 506             opt_end = s = end_of_word(s);
 507             if (NULL == opt_end) {
 508                 fprintf(stderr, "Malformed option at line %d in %s\n", line, filename);
 509                 ok = FALSE;
 510                 break;
 511             }
 512
 513             if (NULL != next_not_blank(s)) {
 514                 fprintf(stderr, "Rubbish at end of line %d in %s\n", line, filename);
 515                 ok = FALSE;
 516                 break;
 517             }
 518
 519             *opt_end = 0;
 520
 521             cnode = xmalloc(sizeof (*cnode));
 522             AddTail(conf, cnode);
 523             cnode->node.name = xstrdup(target);
 524
 525             if (0 == strcmp(opt, "kernel")) {
 526                 cnode->opt = OPT_KERNEL;
 527             } else if (0 == strcmp(opt, "disk")) {
 528                 cnode->opt = OPT_DISK;
 529             } else {
 530                 fprintf(stderr, "Unknown option %s at line %d in %s\n", opt, line, filename);
 531                 ok = FALSE;
 532                 break;
 533             }
 534         }
 535         fclose(f);
 536     }
 537
 538     if (!ok) {
 539         free_list(conf);
 540         conf = NULL;
 541     }
 542     return conf;
 543 }
 544
 545 int checkcircular(Item *cur, DepsDB *ddb, Item **circ_found)
 546 {
 547     Item *depnode;
 548
 549     if (cur->circularcheck) {
 550         fprintf(stderr, "Circular dependency detected:\n");
 551         fprintf(stderr, "%s depends on ", cur->node.name);
 552         *circ_found = cur;
 553         return FALSE;
 554     }
 555     cur->circularcheck = 1;
 556
 557     ForeachNode(&cur->deps, depnode) {
 558         Item *dep;
 559
 560         dep = (Item *)findnode(&ddb->items, depnode->node.name);
 561         if (NULL != dep) {
 562 /*fprintf(stderr, "checking cirular on dependcy of %s: %s\n", cur->node.name, dep->node.name);
 563 */          if (!checkcircular(dep, ddb, circ_found)) {
 564                 if (NULL != *circ_found) {
 565                     if (0 == strcmp(cur->node.name, (*circ_found)->node.name)) {
 566                         fprintf(stderr, "%s\n", cur->node.name);
 567                         *circ_found = NULL;
 568                     } else {
 569                         fprintf(stderr, "%s depends on ", cur->node.name);
 570                     }
 571                 }
 572                 return FALSE;
 573             }
 574
 575         }
 576     }
 577
 578     cur->circularcheck = 0;
 579
 580     return TRUE;
 581 }
 582
 583 int add_deps(List *l, Node *dependee, Item *item, DepsDB *ddb)
 584 {
 585     Node *n;
 586     Item *circ_found;
 587 /*fprintf(stderr, "Looking at dep %s\n", item->node.name);
 588 */
 589     if (!checkcircular(item, ddb, &circ_found))
 590         return FALSE;
 591
 592     /* Check if this item allredy exists in the list */
 593     n = findnode(l, item->node.name);
 594     if (NULL != n) {
 595 /*fprintf(stderr, "Allready existed in list\n");
 596 */  } else{
 597         Item *depnode;
 598
 599         n = xmalloc(sizeof (*n));
 600         n->name = xstrdup(item->node.name);
 601
 602         if (NULL != dependee) {
 603
 604             /* Insert before the dependee */
 605 /*fprintf(stderr, "Inserted before dependee %s\n", dependee->name);
 606 */          InsertBefore(n, dependee);
 607         } else {
 608
 609 /*fprintf(stderr, "Added at end of list\n");
 610 */          AddTail(l, n);
 611         }
 612
 613         /* Go through everything we depend on and add it to the list */
 614         ForeachNode(&item->deps, depnode) {
 615             Item *dep;
 616 /*fprintf(stderr, "Looking at dep in list: %s\n", depnode->node.name);
 617 */          /* Find the item in the deps DB */
 618             dep = (Item *)findnode(&ddb->items, depnode->node.name);
 619             if (NULL != dep) {
 620 /*fprintf(stderr, "Found dep for %s: %s\n", depnode->node.name, dep->node.name);
 621 */              /* This dependany has more under-dependancies. Check it out */
 622                 if (!add_deps(l, n, dep, ddb))
 623                     return FALSE;
 624             } else {
 625                 fprintf(stderr, "Non existing dependancy: %s\n", depnode->node.name);
 626                 return FALSE;
 627             }
 628         }
 629
 630     }
 631     return TRUE;
 632
 633 }
 634
 635 List *do_deps(List *conf, DepsDB *ddb, int opt)
 636 {
 637     Conf *cnode;
 638     List *deps;
 639     int ok = TRUE;
 640
 641     deps = xmalloc(sizeof (*deps));
 642     NewList(deps);
 643
 644     /* Go through all entries in the conf list */
 645     ForeachNode(conf, cnode) {
 646         Item *item;
 647         if (opt != cnode->opt)
 648             continue;
 649
 650         /* Find in the deps db */
 651         item = (Item *)findnode(&ddb->items, cnode->node.name);
 652         if (NULL == item) {
 653             fprintf(stderr, "Target %s could not be found in dependancy db\n", cnode->node.name);
 654             ok = FALSE;
 655             break;
 656         }
 657
 658         if (!add_deps(deps, NULL, item, ddb)) {
 659             ok = FALSE;
 660             break;
 661         }
 662     }
 663
 664     if (!ok) {
 665         free_list(deps);
 666         deps = NULL;
 667     }
 668
 669     return deps;
 670 }
 671
 672 void print_deps(List *deps, const char *pre)
 673 {
 674     Node *dnode;
 675
 676     ForeachNode(deps, dnode) {
 677         printf("%s%s ", pre, dnode->name);
 678     }
 679 }
 680
 681 #define get_kernel_deps(conf, ddb)      \
 682         do_deps(conf, ddb, OPT_KERNEL)
 683
 684 List *get_disk_deps(List *conf, DepsDB *ddb, List *supkdeps)
 685 {
 686     List *ddeps;
 687
 688     /* First get the disk deps */
 689     ddeps = do_deps(conf, ddb, OPT_DISK);
 690     if (NULL != ddeps) {
 691         List *kdeps = NULL;
 692         if (NULL == supkdeps) {
 693             kdeps = do_deps(conf, ddb, OPT_KERNEL);
 694         } else {
 695             kdeps = supkdeps;
 696         }
 697         if (NULL != kdeps) {
 698             Node *ddep, *ddepsafe;
 699             /* Go through all disk deps and see if it exists among the kernel deps. If so, remove it */
 700             ForeachNodeSafe(ddeps, ddep, ddepsafe) {
 701                 Node *kdep;
 702
 703                 kdep = findnode(kdeps, ddep->name);
 704                 if (NULL != kdep) {
 705                     /* Allready in kernel. Remove from disk */
 706                     Remove(ddep);
 707                     freenode(ddep);
 708                 }
 709
 710             }
 711
 712             if (NULL == supkdeps)
 713                 free_list(kdeps);       /* Dependancies were gotten incide here */
 714
 715             return ddeps;
 716         }
 717         free_list(ddeps);
 718     }
 719
 720
 721     return NULL;
 722 }
 723
 724 void print_meta_targets(List *deps, const char *text)
 725 {
 726     printf("#MM hidd-%s : ", text);
 727     print_deps(deps, "hidd-");
 728
 729     printf("\n");
 730     printf("hidd-%s : hidd-%s-local\n",text, text);
 731     printf("\t@(NOP)\n");
 732 }
 733
 734 int do_metamake(List *conf, DepsDB *ddb)
 735 {
 736     List *kdeps;
 737     int ret = FALSE;
 738
 739     kdeps = get_kernel_deps(conf, ddb);
 740     if (NULL != kdeps) {
 741         List *ddeps;
 742
 743         ddeps = get_disk_deps(conf, ddb, kdeps);
 744         if (NULL != ddeps) {
 745
 746             print_meta_targets(kdeps, "kernel");
 747             printf("\n");
 748             print_meta_targets(ddeps, "disk");
 749
 750             ret = TRUE;
 751
 752             free_list(ddeps);
 753         }
 754         free_list(kdeps);
 755     }
 756     return ret;
 757 }
 758
 759
 760
 761 #define DEPSFILE "./hidds.dep"
 762
 763 #define DO_DISK         0x01
 764 #define DO_KERNEL       0x02
 765 #define DO_METAMAKE     0x04
 766
 767
 768
 769 int main(int argc, char *argv[])
 770 {
 771     DepsDB *ddb;
 772     int exitcode = 0;
 773     int action = 0;
 774
 775
 776     char *configfile;
 777
 778     for (;;) {
 779         int c;
 780         c = getopt(argc, argv, "kdm");
 781         if (-1 == c)
 782             break;
 783         switch (c) {
 784             case 'k':
 785                 action |= DO_KERNEL;
 786                 break;
 787
 788             case 'd':
 789                 action |= DO_DISK;
 790                 break;
 791
 792             case 'm':
 793                 action |= DO_METAMAKE;
 794                 break;
 795
 796             default:
 797                 usage();
 798         }
 799
 800     }
 801
 802     if (optind + 1 != argc)
 803         usage();
 804
 805     configfile = argv[optind];
 806
 807
 808
 809 /* We used flags to get the options. This way we easily catch the case where
 810   the user has passed more than one option.
 811 */
 812     if (action != DO_KERNEL && action != DO_DISK && action != DO_METAMAKE)
 813         usage();
 814
 815
 816     ddb = build_deps_db(DEPSFILE);
 817     if (NULL != ddb) {
 818         List *conf;
 819
 820 //      print_deps_db(ddb);
 821
 822         conf = get_conf(configfile);
 823         if (NULL != conf) {
 824             List *deps = NULL;
 825             switch (action) {
 826                 case DO_DISK:
 827                     deps = get_disk_deps(conf, ddb, NULL);
 828                     break;
 829
 830                 case DO_KERNEL: {
 831                     deps = get_kernel_deps(conf, ddb);
 832                     break;
 833                 }
 834
 835                 case DO_METAMAKE:
 836                 if (!do_metamake(conf, ddb)) {
 837                     exitcode = 1;
 838                 }
 839                     break;
 840
 841             }
 842
 843
 844             /* Print and free stuff from DO_DISK and DO_KERNEL */
 845             if (action == DO_DISK || action == DO_KERNEL) {
 846                 if (NULL != deps) {
 847                     print_deps(deps, "");
 848                     free_list(deps);
 849                 } else {
 850                     exitcode = 1;
 851                 }
 852             }
 853
 854             free_list(conf);
 855
 856         } else {
 857             exitcode = 1;
 858         }
 859
 860         free_deps_db(ddb);
 861
 862     } else {
 863         exitcode = 1;
 864     }
 865
 866     return exitcode;
 867 }