[BACK]Return to rdf.c CVS log [TXT] [DIR] Up to [Public] / rpm2html

Diff for /rpm2html/rdf.c between versions 1.27 and 1.28

version 1.27, 1998/09/09 15:49:32 version 1.28, 1998/09/14 14:46:11
Line 59  rpmDataPtr rpmOpenRdf(char *nameRdf, rpm Line 59  rpmDataPtr rpmOpenRdf(char *nameRdf, rpm
             rpm->subdir = NULL;              rpm->subdir = NULL;
   
         /* Add the package files to the real filesystem tree if asked for */          /* Add the package files to the real filesystem tree if asked for */
         if ((dir->build_tree != 0) && (rpm->filelist != NULL)) {          if ((dir->build_tree != 0) && (rpm->extra->filelist != NULL)) {
             char *cur, *filename;              char *cur, *filename;
                           
             cur = rpm->filelist;              cur = rpm->extra->filelist;
             while ((*cur != '\0') && (*cur != '/')) cur++;              while ((*cur != '\0') && (*cur != '/')) cur++;
             filename = cur;              filename = cur;
             while (*cur != '\0') {              while (*cur != '\0') {
Line 88  rpmDataPtr rpmOpenRdf(char *nameRdf, rpm Line 88  rpmDataPtr rpmOpenRdf(char *nameRdf, rpm
             dumpRpmRdf(rpm, tree);              dumpRpmRdf(rpm, tree);
   
         /* free large amount of data not used later */          /* free large amount of data not used later */
         if (rpm->filelist) free(rpm->filelist);          rpmFreeExtraData(rpm);
         rpm->filelist = NULL;  
         if (rpm->copyright) free(rpm->copyright);  
         rpm->copyright = NULL;  
         if (rpm->changelog) free(rpm->changelog);  
         rpm->changelog = NULL;  
         if (rpm->description) free(rpm->description);  
         rpm->description = NULL;  
   
         /* increment the counters */          /* increment the counters */
         rpm2html_files++;          rpm2html_files++;
Line 149  rpmDataPtr rpmOpenRdfFile(char *file) { Line 142  rpmDataPtr rpmOpenRdfFile(char *file) {
   
     /*      /*
      * We are pretty sure that it will be a valid schema,       * We are pretty sure that it will be a valid schema,
      * Allocate the rpmData structure, initialize it.       * allocate a new rpmData block, and an rpmExtraData block fill them
      */       */
     rpm = (rpmDataPtr) malloc(sizeof(rpmData));      rpm = (rpmDataPtr) malloc(sizeof(rpmData));
     if (rpm == NULL) {      if (rpm == NULL) {
         fprintf(stderr, "rpmOpenRdf : out of memory !\n");          fprintf(stderr, "cannot allocate %d bytes: %s\n", sizeof(rpmData),
         rdfDestroySchema(rdf);                  strerror(errno));
         return(NULL);          return(NULL);
     }      }
     memset(rpm, 0, sizeof(rpmData));      memset(rpm, 0, sizeof(rpmData));
       rpm->extra = (rpmExtraDataPtr) malloc(sizeof(rpmExtraData));
       if (rpm == NULL) {
           fprintf(stderr, "cannot allocate %d bytes: %s\n", sizeof(rpmExtraData),
                   strerror(errno));
           return(NULL);
       }
       memset(rpm->extra, 0, sizeof(rpmExtraData));
   
     stat(file, &buf);      stat(file, &buf);
     rpm->stamp = buf.st_mtime;      rpm->extra->stamp = buf.st_mtime;
   
     /*      /*
      * Now extract all the metadata informations from the RDF tree       * Now extract all the metadata informations from the RDF tree
Line 207  rpmDataPtr rpmOpenRdfFile(char *file) { Line 207  rpmDataPtr rpmOpenRdfFile(char *file) {
     else rpm->vendor = strdup(localizedStrings[LANG_UNKNOWN]);      else rpm->vendor = strdup(localizedStrings[LANG_UNKNOWN]);
   
     rdfGetValue(desc, "Packager", rpmNs, &value, NULL);      rdfGetValue(desc, "Packager", rpmNs, &value, NULL);
     if (value != NULL) rpm->packager = strdup(value);      if (value != NULL) rpm->extra->packager = strdup(value);
     else rpm->packager = NULL;      else rpm->extra->packager = NULL;
   
     rdfGetValue(desc, "Group", rpmNs, &value, NULL);      rdfGetValue(desc, "Group", rpmNs, &value, NULL);
     if (value != NULL) rpm->group = strdup(value);      if (value != NULL) rpm->group = strdup(value);
Line 219  rpmDataPtr rpmOpenRdfFile(char *file) { Line 219  rpmDataPtr rpmOpenRdfFile(char *file) {
     else rpm->summary = strdup(localizedStrings[LANG_NO_SUMMARY]);      else rpm->summary = strdup(localizedStrings[LANG_NO_SUMMARY]);
   
     rdfGetValue(desc, "Description", rpmNs, &value, NULL);      rdfGetValue(desc, "Description", rpmNs, &value, NULL);
     if (value != NULL) rpm->description = strdup(value);      if (value != NULL) rpm->extra->description = strdup(value);
     else rpm->description = strdup(localizedStrings[LANG_NO_DESCRIPTION]);      else rpm->extra->description = strdup(localizedStrings[LANG_NO_DESCRIPTION]);
   
     rdfGetValue(desc, "Copyright", rpmNs, &value, NULL);      rdfGetValue(desc, "Copyright", rpmNs, &value, NULL);
     if (value != NULL) rpm->copyright = strdup(value);      if (value != NULL) rpm->extra->copyright = strdup(value);
     else rpm->copyright = NULL;      else rpm->extra->copyright = NULL;
   
     rdfGetValue(desc, "Changelog", rpmNs, &value, NULL);      rdfGetValue(desc, "Changelog", rpmNs, &value, NULL);
     if (value != NULL) rpm->changelog = strdup(value);      if (value != NULL) rpm->extra->changelog = strdup(value);
     else rpm->changelog = NULL;      else rpm->extra->changelog = NULL;
   
     rdfGetValue(desc, "Sources", rpmNs, &value, NULL);      rdfGetValue(desc, "Sources", rpmNs, &value, NULL);
     if (value != NULL) {      if (value != NULL) {
         rpm->srcrpm = strdup(value);          rpm->extra->srcrpm = strdup(value);
     } else rpm->srcrpm = strdup("");      } else rpm->extra->srcrpm = strdup("");
   
     rdfGetValue(desc, "Size", rpmNs, &value, NULL);      rdfGetValue(desc, "Size", rpmNs, &value, NULL);
     if (value != NULL) {      if (value != NULL) {
Line 250  rpmDataPtr rpmOpenRdfFile(char *file) { Line 250  rpmDataPtr rpmOpenRdfFile(char *file) {
     } else rpm->date = 0;      } else rpm->date = 0;
   
     rdfGetValue(desc, "BuildHost", rpmNs, &value, NULL);      rdfGetValue(desc, "BuildHost", rpmNs, &value, NULL);
     if (value != NULL) rpm->host = strdup(value);      if (value != NULL) rpm->extra->host = strdup(value);
     else rpm->host = strdup(localizedStrings[LANG_NO_HOST]);      else rpm->extra->host = strdup(localizedStrings[LANG_NO_HOST]);
   
     rdfGetValue(desc, "Files", rpmNs, &value, NULL);      rdfGetValue(desc, "Files", rpmNs, &value, NULL);
     if (value != NULL) rpm->filelist = strdup(value);      if (value != NULL) rpm->extra->filelist = strdup(value);
     else rpm->filelist = NULL;      else rpm->extra->filelist = NULL;
   
     /*      /*
      * Fetching packages provided is a bit more tricky, one have to       * Fetching packages provided is a bit more tricky, one have to
      * find the RDF Bag, and scan it's values.       * find the RDF Bag, and scan it's values.
      */       */
     rpm->nb_resources = 0;      rpm->extra->nb_resources = 0;
     rdfGetValue(desc, "Provides", rpmNs, NULL, &bag);      rdfGetValue(desc, "Provides", rpmNs, NULL, &bag);
     if (bag != NULL) {      if (bag != NULL) {
         elem = rdfFirstChild(bag);          elem = rdfFirstChild(bag);
         rpm->max_resources = 5;          rpm->extra->max_resources = 5;
         rpm->resources = (rpmRessPtr *) malloc(rpm->max_resources *          rpm->extra->resources = (rpmRessPtr *) malloc(rpm->extra->max_resources *
                                                sizeof(rpmRessPtr));                                                 sizeof(rpmRessPtr));
         if (rpm->resources == NULL) {          if (rpm->extra->resources == NULL) {
             fprintf(stderr, "rpmOpenRdf : ran out of memory\n");              fprintf(stderr, "rpmOpenRdf : ran out of memory\n");
             exit(1);              exit(1);
         }          }
         i = 0;          i = 0;
         while (elem != NULL) {          while (elem != NULL) {
             if (i >= rpm->max_resources) {              if (i >= rpm->extra->max_resources) {
                 rpm->max_resources *= 2;                  rpm->extra->max_resources *= 2;
                 rpm->resources = (rpmRessPtr *) realloc(rpm->resources,                  rpm->extra->resources = (rpmRessPtr *) realloc(rpm->extra->resources,
                                    rpm->max_resources * sizeof(rpmRessPtr));                                     rpm->extra->max_resources * sizeof(rpmRessPtr));
                 if (rpm->resources == NULL) {                  if (rpm->extra->resources == NULL) {
                     fprintf(stderr, "rpmOpenRdf : ran out of memory\n");                      fprintf(stderr, "rpmOpenRdf : ran out of memory\n");
                     exit(1);                      exit(1);
                 }                  }
Line 290  rpmDataPtr rpmOpenRdfFile(char *file) { Line 290  rpmDataPtr rpmOpenRdfFile(char *file) {
                 (rdfElemGetNamespace(elem) == rpmNs)) {                  (rdfElemGetNamespace(elem) == rpmNs)) {
                 value = rdfElemGetValue(elem);                  value = rdfElemGetValue(elem);
                 if (value != NULL) {                  if (value != NULL) {
                     rpm->resources[i] = rpmRessAdd(value, rpm, 0);                      rpm->extra->resources[i] = rpmRessAdd(value, rpm, 0);
                     i++;                      i++;
                     rpm->nb_resources++;                      rpm->extra->nb_resources++;
                 } else if (rpm2htmlVerbose > 1) {                  } else if (rpm2htmlVerbose > 1) {
                     fprintf(stderr, "%s : malformed Resource element !\n", file);                      fprintf(stderr, "%s : malformed Resource element !\n", file);
                 }                  }
Line 308  rpmDataPtr rpmOpenRdfFile(char *file) { Line 308  rpmDataPtr rpmOpenRdfFile(char *file) {
     /*      /*
      * idem for the dependencies.       * idem for the dependencies.
      */       */
     rpm->nb_requires = 0;      rpm->extra->nb_requires = 0;
     rdfGetValue(desc, "Requires", rpmNs, NULL, &bag);      rdfGetValue(desc, "Requires", rpmNs, NULL, &bag);
     if (bag != NULL) {      if (bag != NULL) {
         elem = rdfFirstChild(bag);          elem = rdfFirstChild(bag);
         rpm->max_requires = 5;          rpm->extra->max_requires = 5;
         rpm->requires = (rpmRessPtr *) malloc(rpm->max_requires *          rpm->extra->requires = (rpmRessPtr *) malloc(rpm->extra->max_requires *
                                                sizeof(rpmRessPtr));                                                 sizeof(rpmRessPtr));
         if (rpm->requires == NULL) {          if (rpm->extra->requires == NULL) {
             fprintf(stderr, "rpmOpenRdf : ran out of memory\n");              fprintf(stderr, "rpmOpenRdf : ran out of memory\n");
             exit(1);              exit(1);
         }          }
         i = 0;          i = 0;
         while (elem != NULL) {          while (elem != NULL) {
             if (i >= rpm->max_requires) {              if (i >= rpm->extra->max_requires) {
                 rpm->max_requires *= 2;                  rpm->extra->max_requires *= 2;
                 rpm->requires = (rpmRessPtr *) realloc(rpm->requires,                  rpm->extra->requires = (rpmRessPtr *) realloc(rpm->extra->requires,
                                    rpm->max_requires * sizeof(rpmRessPtr));                                     rpm->extra->max_requires * sizeof(rpmRessPtr));
                 if (rpm->requires == NULL) {                  if (rpm->extra->requires == NULL) {
                     fprintf(stderr, "rpmOpenRdf : ran out of memory\n");                      fprintf(stderr, "rpmOpenRdf : ran out of memory\n");
                     exit(1);                      exit(1);
                 }                  }
Line 337  rpmDataPtr rpmOpenRdfFile(char *file) { Line 337  rpmDataPtr rpmOpenRdfFile(char *file) {
                 (rdfElemGetNamespace(elem) == rpmNs)) {                  (rdfElemGetNamespace(elem) == rpmNs)) {
                 value = rdfElemGetValue(elem);                  value = rdfElemGetValue(elem);
                 if (value != NULL) {                  if (value != NULL) {
                     rpm->requires[i] = rpmRequAdd(value, rpm, 0);                      rpm->extra->requires[i] = rpmRequAdd(value, rpm, 0);
                     i++;                      i++;
                     rpm->nb_requires++;                      rpm->extra->nb_requires++;
                 } else if (rpm2htmlVerbose > 1) {                  } else if (rpm2htmlVerbose > 1) {
                     fprintf(stderr, "%s : malformed Resource element !\n", file);                      fprintf(stderr, "%s : malformed Resource element !\n", file);
                 }                  }
Line 469  void dumpRpmRdf(rpmDataPtr rpm, rpmSubdi Line 469  void dumpRpmRdf(rpmDataPtr rpm, rpmSubdi
         rdfSetValue(desc, "Distribution", rpmNs, rpm->distribution);          rdfSetValue(desc, "Distribution", rpmNs, rpm->distribution);
     if (rpm->vendor)      if (rpm->vendor)
         rdfSetValue(desc, "Vendor", rpmNs, rpm->vendor);          rdfSetValue(desc, "Vendor", rpmNs, rpm->vendor);
     if (rpm->packager)      if (rpm->extra->packager)
         rdfSetValue(desc, "Packager", rpmNs, rpm->packager);          rdfSetValue(desc, "Packager", rpmNs, rpm->extra->packager);
     if (rpm->group)      if (rpm->group)
         rdfSetValue(desc, "Group", rpmNs, rpm->group);          rdfSetValue(desc, "Group", rpmNs, rpm->group);
     if (rpm->summary)      if (rpm->summary)
         rdfSetValue(desc, "Summary", rpmNs, rpm->summary);          rdfSetValue(desc, "Summary", rpmNs, rpm->summary);
     if (rpm->description)      if (rpm->extra->description)
         rdfSetValue(desc, "Description", rpmNs, rpm->description);          rdfSetValue(desc, "Description", rpmNs, rpm->extra->description);
     if (rpm->copyright)      if (rpm->extra->copyright)
         rdfSetValue(desc, "Copyright", rpmNs, rpm->copyright);          rdfSetValue(desc, "Copyright", rpmNs, rpm->extra->copyright);
     if (rpm->changelog)      if (rpm->extra->changelog)
         rdfSetValue(desc, "Changelog", rpmNs, rpm->changelog);          rdfSetValue(desc, "Changelog", rpmNs, rpm->extra->changelog);
     if (rpm->srcrpm) {      if (rpm->extra->srcrpm) {
         rdfSetValue(desc, "Sources", rpmNs, rpm->srcrpm);          rdfSetValue(desc, "Sources", rpmNs, rpm->extra->srcrpm);
         if (dir->ftpsrc) {          if (dir->ftpsrc) {
             rdfSetValue(desc, "SourcesFtp", rpmNs, dir->ftpsrc);              rdfSetValue(desc, "SourcesFtp", rpmNs, dir->ftpsrc);
         }          }
Line 498  void dumpRpmRdf(rpmDataPtr rpm, rpmSubdi Line 498  void dumpRpmRdf(rpmDataPtr rpm, rpmSubdi
     rdfSetValue(desc, "Date", rpmNs, buf);      rdfSetValue(desc, "Date", rpmNs, buf);
     sprintf(buf, "%d", rpm->size);      sprintf(buf, "%d", rpm->size);
     rdfSetValue(desc, "Size", rpmNs, buf);      rdfSetValue(desc, "Size", rpmNs, buf);
     if (rpm->host)      if (rpm->extra->host)
         rdfSetValue(desc, "BuildHost", rpmNs, rpm->host);          rdfSetValue(desc, "BuildHost", rpmNs, rpm->extra->host);
     if (rpm->nb_resources > 0) {      if (rpm->extra->nb_resources > 0) {
         /** !!!!!          /** !!!!!
         sprintf(buf, "%d", rpm->nb_resources);          sprintf(buf, "%d", rpm->nb_resources);
         rdfSetValue(desc, "NbProvides", rpmNs, buf);          rdfSetValue(desc, "NbProvides", rpmNs, buf);
          */           */
         bag = rdfBagCreate(rdf, desc, "Provides", rpmNs);          bag = rdfBagCreate(rdf, desc, "Provides", rpmNs);
         for (i = 0;i < rpm->nb_resources;i++) {          for (i = 0;i < rpm->extra->nb_resources;i++) {
             rdfBagAddValue(bag, "Resource", rpmNs,              rdfBagAddValue(bag, "Resource", rpmNs,
                            rpm->resources[i]->name, NULL);                             rpm->extra->resources[i]->name, NULL);
         }          }
     }      }
     if (rpm->nb_requires > 0) {      if (rpm->extra->nb_requires > 0) {
         /** !!!!!          /** !!!!!
         sprintf(buf, "%d", rpm->nb_requires);          sprintf(buf, "%d", rpm->nb_requires);
         rdfSetValue(desc, "NbRequires", rpmNs, buf);          rdfSetValue(desc, "NbRequires", rpmNs, buf);
          */           */
         bag = rdfBagCreate(rdf, desc, "Requires", rpmNs);          bag = rdfBagCreate(rdf, desc, "Requires", rpmNs);
         for (i = 0;i < rpm->nb_requires;i++) {          for (i = 0;i < rpm->extra->nb_requires;i++) {
             rdfBagAddValue(bag, "Resource", rpmNs,              rdfBagAddValue(bag, "Resource", rpmNs,
                            rpm->requires[i]->name, NULL);                             rpm->extra->requires[i]->name, NULL);
         }          }
     }      }
     if (rpm->filelist)      if (rpm->extra->filelist)
         rdfSetValue(desc, "Files", rpmNs, rpm->filelist);          rdfSetValue(desc, "Files", rpmNs, rpm->extra->filelist);
   
     /*      /*
      * Save the RDF to a buffer, remove the tree.       * Save the RDF to a buffer, remove the tree.
Removed from v.1.27  
changed lines
  Added in v.1.28

Webmaster