[BACK]Return to dba.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/dba.c between version 1.1 and 1.7

version 1.1, 2016/07/19 21:31:55 version 1.7, 2016/08/17 18:59:37
Line 17 
Line 17 
  * Allocation-based version of the mandoc database, for read-write access.   * Allocation-based version of the mandoc database, for read-write access.
  * The interface is defined in "dba.h".   * The interface is defined in "dba.h".
  */   */
   #include "config.h"
   
 #include <sys/types.h>  #include <sys/types.h>
   #if HAVE_ENDIAN
   #include <endian.h>
   #elif HAVE_SYS_ENDIAN
   #include <sys/endian.h>
   #elif HAVE_NTOHL
   #include <arpa/inet.h>
   #endif
 #include <errno.h>  #include <errno.h>
 #include <stdint.h>  #include <stdint.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 33 
Line 42 
 static void     *prepend(const char *, char);  static void     *prepend(const char *, char);
 static void      dba_pages_write(struct dba_array *);  static void      dba_pages_write(struct dba_array *);
 static int       compare_names(const void *, const void *);  static int       compare_names(const void *, const void *);
   static int       compare_strings(const void *, const void *);
 static void      dba_macros_write(struct dba_array *);  static void      dba_macros_write(struct dba_array *);
 static void      dba_macro_write(struct dba_array *);  static void      dba_macro_write(struct dba_array *);
   
Line 133  dba_page_new(struct dba_array *pages, const char *name
Line 143  dba_page_new(struct dba_array *pages, const char *name
   
         page = dba_array_new(DBP_MAX, 0);          page = dba_array_new(DBP_MAX, 0);
         entry = dba_array_new(1, DBA_STR | DBA_GROW);          entry = dba_array_new(1, DBA_STR | DBA_GROW);
         dba_array_add(entry, prepend(name, NAME_FILE & NAME_MASK));          if (name != NULL)
                   dba_array_add(entry, prepend(name, NAME_FILE & NAME_MASK));
         dba_array_add(page, entry);          dba_array_add(page, entry);
         entry = dba_array_new(1, DBA_STR | DBA_GROW);          entry = dba_array_new(1, DBA_STR | DBA_GROW);
         dba_array_add(entry, (void *)sect);          dba_array_add(entry, (void *)sect);
Line 167  dba_page_add(struct dba_array *page, int32_t ie, const
Line 178  dba_page_add(struct dba_array *page, int32_t ie, const
         if (ie == DBP_ARCH) {          if (ie == DBP_ARCH) {
                 if (entries == NULL)                  if (entries == NULL)
                         return;                          return;
                 if (str == NULL) {                  if (str == NULL || *str == '\0') {
                         dba_array_free(entries);                          dba_array_free(entries);
                         dba_array_set(page, DBP_ARCH, NULL);                          dba_array_set(page, DBP_ARCH, NULL);
                         return;                          return;
Line 175  dba_page_add(struct dba_array *page, int32_t ie, const
Line 186  dba_page_add(struct dba_array *page, int32_t ie, const
         }          }
         if (*str == '\0')          if (*str == '\0')
                 return;                  return;
         dba_array_FOREACH(entries, entry)          dba_array_FOREACH(entries, entry) {
                   if (ie == DBP_FILE && *entry < ' ')
                           entry++;
                 if (strcmp(entry, str) == 0)                  if (strcmp(entry, str) == 0)
                         return;                          return;
           }
         dba_array_add(entries, (void *)str);          dba_array_add(entries, (void *)str);
 }  }
   
Line 240  prepend(const char *instr, char inbyte)
Line 254  prepend(const char *instr, char inbyte)
 static void  static void
 dba_pages_write(struct dba_array *pages)  dba_pages_write(struct dba_array *pages)
 {  {
         struct dba_array        *page, *names;          struct dba_array        *page, *entry;
         void                    *entry;  
         int32_t                  pos_pages, pos_end;          int32_t                  pos_pages, pos_end;
   
         pos_pages = dba_array_writelen(pages, 5);          pos_pages = dba_array_writelen(pages, 5);
         dba_array_FOREACH(pages, page) {          dba_array_FOREACH(pages, page) {
                 dba_array_setpos(page, DBP_NAME, dba_tell());                  dba_array_setpos(page, DBP_NAME, dba_tell());
                 names = dba_array_get(page, DBP_NAME);                  entry = dba_array_get(page, DBP_NAME);
                 dba_array_sort(names, compare_names);                  dba_array_sort(entry, compare_names);
                 dba_array_writelst(names);                  dba_array_writelst(entry);
         }          }
         dba_array_FOREACH(pages, page) {          dba_array_FOREACH(pages, page) {
                 dba_array_setpos(page, DBP_SECT, dba_tell());                  dba_array_setpos(page, DBP_SECT, dba_tell());
                 dba_array_writelst(dba_array_get(page, DBP_SECT));                  entry = dba_array_get(page, DBP_SECT);
                   dba_array_sort(entry, compare_strings);
                   dba_array_writelst(entry);
         }          }
         dba_array_FOREACH(pages, page) {          dba_array_FOREACH(pages, page) {
                 if ((entry = dba_array_get(page, DBP_ARCH)) != NULL) {                  if ((entry = dba_array_get(page, DBP_ARCH)) != NULL) {
                         dba_array_setpos(page, DBP_ARCH, dba_tell());                          dba_array_setpos(page, DBP_ARCH, dba_tell());
                           dba_array_sort(entry, compare_strings);
                         dba_array_writelst(entry);                          dba_array_writelst(entry);
                 } else                  } else
                         dba_array_setpos(page, DBP_ARCH, 0);                          dba_array_setpos(page, DBP_ARCH, 0);
Line 289  compare_names(const void *vp1, const void *vp2)
Line 305  compare_names(const void *vp1, const void *vp2)
             strcasecmp(cp1 + 1, cp2 + 1);              strcasecmp(cp1 + 1, cp2 + 1);
 }  }
   
   static int
   compare_strings(const void *vp1, const void *vp2)
   {
           const char      *cp1, *cp2;
   
           cp1 = *(char **)vp1;
           cp2 = *(char **)vp2;
           return strcmp(cp1, cp2);
   }
   
 /*** functions for handling macros ************************************/  /*** functions for handling macros ************************************/
   

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.7

CVSweb