Exemplo n.º 1
0
/* parses compile options of a port through scan for all
   .if defined or .if !defined in port's Makefile */
List *
parse_options(char *mkfile) {
   FILE *fd;
   char line[MAX_TOKEN];
   char option[MAX_PATH];
   char *start;
   char *end;
   List *l;
   TNode *t = NULL;
   extern void *exists;
   int i;

   if ((fd = fopen(mkfile, "r")) == NULL)
      return NULL; /* error */

   /* init */
   l = (List *)malloc(sizeof(List));
   l->head = NULL;
   l->tail = NULL;
   l->num_of_items = 0;

   while (fgets(line, MAX_TOKEN, fd) != NULL) {
      if ((strstr(line, ".if") != NULL) &&
            (strstr(line, "defined") != NULL)) {
         Option *opt = (Option *)malloc(sizeof(Option));
         opt->type = OPTION;
         opt->state = STATE_NOT_SELECTED;
         i = 0;
         start = strpbrk(line, "({");
         start++;
         end = strpbrk(line, ")}");
         while (start != end)
            option[i++] = *start++;
         option[i] = '\0';
         sprintf(line, "%-.50s (port specific compile option)", option);
         opt->name = strdup(line);
         sprintf(line, "%s=yes", option);
         opt->arg = strdup(line);
         exists = NULL;
         t = add_tree_item(t, opt, cmp_name);
         if (exists != NULL) { /* option does exist */
            /* clean up */
            free(opt->name);
            free(opt->arg);
            free(opt);
         }
      }
   }
   fclose(fd);

   create_inorder_list(l, t);
   return l;
}
Exemplo n.º 2
0
static void update_node(tree** t, tree* p,
                        int (*compare_keys)(const void* key1, const void* key2)) {

    /*overwrite existing node item with new node item */
    add_tree_item(*t, p->item, p->item_sz);

    /*copy node key then delete old key*/
    void* key = malloc(p->key_sz);
    int key_sz = p->key_sz;
    memcpy(key, p->key, p->key_sz);

    delete_tree(t, p->key, compare_keys);  /*delete before re-assignment of key*/

    free((*t)->key);
    (*t)->key = key;
    (*t)->key_sz = key_sz;
}
Exemplo n.º 3
0
/* adds a category in sorted order if it does not already exist,
   returns pointer of the new or existing category with name
   "name" */
Category *
add_category(char *name, List *lpdir) {
   extern TNode *tcat;
   extern void *exists;
   Category *newcat = NULL;

   newcat = (Category *)malloc(sizeof(Category));
   newcat->type = CATEGORY;
   newcat->name = strdup(name); 

   exists = NULL;
   tcat = add_tree_item(tcat, newcat, cmp_name);
   if (exists != NULL) { /* category does exist */
      /* clean up */
      free(newcat->name);
      free(newcat);
      /* use existing pointer for return */
      newcat = (Category *)((TNode *)exists)->item;
   } else { /* category does not exist yet */
      /* check, if this category is a meta category or not */
      Iter itr = lpdir->head;
      while (itr != NULL) {
         if (strcmp((char *)itr->item, name) == 0)
            /* physically existing */
            break;
         itr = itr->next;
      }
      newcat->meta = (itr == NULL) ? TRUE : FALSE;
      newcat->num_of_ports = 0;
      newcat->num_of_inst_ports = 0;
      newcat->num_of_marked_ports = 0;
      newcat->num_of_inst_ports = 0;
      newcat->num_of_deinst_ports = 0;
      newcat->lprts = (List *)malloc(sizeof(List));
      newcat->lprts->num_of_items = 0;
      newcat->lprts->head = NULL;
      newcat->lprts->tail = NULL;
   }

   return newcat;
}
Exemplo n.º 4
0
/* creates linear list of dir names,
   returns list of directories */
TNode *
parse_dir(char *path) {
   struct dirent *dp;
   DIR *dfd;
   TNode *t = NULL;
 
   /* if the directory doesn't exist or there is another reason,
      it returns NULL */
   if ((dfd = opendir(path)) == NULL) return NULL;

   /* generates entries */
   while ((dp = readdir(dfd)) != NULL) {
      /* exlude hidden files or "." and ".." */
      if ((dp->d_name)[0] != '.') {
         t = add_tree_item(t, strdup(dp->d_name), cmp_str);
      }
   }
   closedir(dfd);
   /* finished */

   /* number of entries */
   return t;
}
Exemplo n.º 5
0
/* parses the FreeBSD ports INDEX file and creates a
   list of categories with dedicated ports, it also creates
   a meta-category "all", all lists and categories are
   sorted ascending. */
int
parse_index()
{
   FILE *fd;
   int c, i, readyToken;
   int pipes = 0;
   char tok[MAX_TOKEN];
   extern Config config;
   extern List *lprts;
   extern List *lcats;
   extern void *exists;
   extern TNode *tcat;
   TNode *tdirs;
   TNode *tprt = NULL;
   List *lpdir = (List *)malloc(sizeof(List));
   Port *p, *dprt;
   int num_of_inst_ports = 0;

   /* init */
   p = NULL;
   tcat = NULL;
   lpdir->num_of_items = 0;
   lpdir->head = NULL;
   lpdir->tail = NULL;

   if ((fd = fopen(config.index_file, "r")) == NULL)
      return ERROR_OPEN_INDEX; /* error */

   /* parse installed pkgs */
   tdirs = parse_dir(config.inst_pkg_dir);
   /* parse ports dir and create list */
   create_inorder_list(lpdir, parse_dir(config.ports_dir));

   i = 0;
   readyToken = 0; /* token not ready */
   while (feof(fd) == 0) {
      c = fgetc(fd); /* get next char */
      switch (c) {
         case '|': /* next token */
            readyToken = 1; /* ready token */
            break;
         case '\n': /* end of port */
#if defined(__FreeBSD__)
            if (pipes != PORT_URL) /* seems to be some strange INDEX */ 
               return ERROR_CORRUPT_INDEX;
#endif
            readyToken = 1; /* tail token of port ready */
            break;
         default:
            if ((pipes != PORT_CATEGORY) && (pipes != PORT_BUILD_DEPENDENCY)
                  && (pipes != PORT_RUN_DEPENDENCY))
               /* default, no port category, build dep or run dep modus */
               tok[i++] = (char)c;
            break;
      }

      /* to speed up the parsing, we also parse categories here,
         I guessed if it'll be senseful to also parse BDEP and RDEP,
         but this makes no sense until there aren't all entries
         scanned */
      if (pipes == PORT_CATEGORY) { /* port category mode */
         if ((c == ' ') || (c == '|')) {
            if (i > 0) { /* maybe there're ports without a category */
               tok[i] = '\0'; /* terminate current cat token */
               add_list_item(p->lcats, add_category(tok, lpdir));
               i = 0; /* reset i */
            }
         } else { /* inside a token */
            tok[i++] = (char)c;
         }
      } else if ((pipes == PORT_BUILD_DEPENDENCY) ||
            (pipes == PORT_RUN_DEPENDENCY)) { /* port build/run dep mode */
         if ((c == ' ') || (c == '|')) {
            if (i > 0) { /* maybe there're ports without a build dep */
               tok[i] = '\0';
               dprt = create_port(tok, tdirs);
               exists = NULL;
               tprt = add_tree_item(tprt, dprt, cmp_name);
               if (exists != NULL) {
                  free_port(dprt);
                  dprt = (Port *)((TNode *)exists)->item;
               } else {
                  if (dprt->state >= STATE_INSTALLED)
                     num_of_inst_ports++;
               }
               if (pipes == PORT_BUILD_DEPENDENCY) {
                  add_list_item(p->lbdep, dprt);
               } else if (pipes == PORT_RUN_DEPENDENCY) {
                  add_list_item(p->lrdep, dprt);
               }
               /* add also p to dprt->ldep, so that dprt knows
                  the port for which dprt is a dependency, this
                  helps seeking for unused ports */
               add_list_item(dprt->ldep, p);
               i = 0; /* reset i */
            }
         } else { /* inside a token */
            tok[i++] = (char)c;
         }
      }

      if (readyToken == 1) { /* a new token is ready */
         tok[i] = '\0'; /* terminate current token */
         switch (pipes) {
            case PORT_NAME_VERSION:
               p = create_port(tok, tdirs);
               /* add the port */
               exists = NULL;
               tprt = add_tree_item(tprt, p, cmp_name);
               if (exists != NULL) {
                  free_port(p);
                  p = (Port *)((TNode *)exists)->item;
               } else {
                  if (p->state >= STATE_INSTALLED)
                     num_of_inst_ports++;
               }
               break;
            case PORT_PATH:
               p->path = strdup(tok);
               break;
#if defined(__FreeBSD__)
            case PORT_INSTALL_PREFIX:
               p->instpfx = strdup(tok);
               break;
#endif
            case PORT_DESCR:
               p->descr = strdup(tok);
               break;
            case PORT_PKGDESCR:
               p->pathpkgdesc = strdup(tok);
               break;
            case PORT_MAINTAINER:
               p->maintainer = strdup(tok);
               break;
#if defined(__FreeBSD__)
            case PORT_URL:
               p->url = strdup(tok);
               pipes = -1;
               break;
#endif
         }
         readyToken = i = 0; /* token processed, not ready token anymore */
         pipes++;
      }
   }
   fclose(fd); /* close INDEX file */

   create_inorder_list(lcats, tcat);
   create_inorder_list(lprts, tprt);
   create_categories(num_of_inst_ports);
   free_tree(tdirs);

   /* finished */
   return (0);
}