Small refactorings

- move language code into poollang.c
- cleanup poolvendor.c a bit

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4bdc2e18c9c79e0e2ddc4af4a142f8ee9af992b4..66ff8b5c06aae62f6f4f8cfd8909107a9c7a9a2a 100644 (file)
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -14,7 +14,7 @@ ENDIF (HAVE___QSORT_R)
 ADD_DEFINITIONS (-DLIBSOLV_INTERNAL=1)
 
 SET (libsolv_SRCS
-    bitmap.c poolarch.c poolvendor.c poolid.c pooldep.c
+    bitmap.c poolarch.c poolvendor.c poolid.c pooldep.c poollang.c
     poolwhatprovides.c pool.c strpool.c dirpool.c
     solver.c solverdebug.c repo_solv.c repo_write.c evr.c
     queue.c repo.c repodata.c repopage.c util.c policy.c solvable.c

diff --git a/src/pool.c b/src/pool.c
index f6b0e6fe57660de2294e75f7f14c184d8ad5cb1a..658cd31cc985ad3d337b1d2fcae00aa3934f9d92 100644 (file)
--- a/src/pool.c
+++ b/src/pool.c
@@ -111,10 +111,7 @@ pool_free(Pool *pool)
   queue_free(&pool->lazywhatprovidesq);
   for (i = 0; i < POOL_TMPSPACEBUF; i++)
     solv_free(pool->tmpspace.buf[i]);
-  for (i = 0; i < pool->nlanguages; i++)
-    free((char *)pool->languages[i]);
-  solv_free((void *)pool->languages);
-  solv_free(pool->languagecache);
+  pool_set_languages(pool, 0, 0);
   solv_free(pool->errstr);
   solv_free(pool->rootdir);
   solv_free(pool->nonstd_ids);
@@ -427,47 +424,6 @@ pool_clear_pos(Pool *pool)
   memset(&pool->pos, 0, sizeof(pool->pos));
 }
 
-void
-pool_set_languages(Pool *pool, const char **languages, int nlanguages)
-{
-  int i;
-
-  pool->languagecache = solv_free(pool->languagecache);
-  for (i = 0; i < pool->nlanguages; i++)
-    free((char *)pool->languages[i]);
-  pool->languages = solv_free((void *)pool->languages);
-  if (nlanguages < 0 || nlanguages >= 1024)
-    solv_ovfl("language count overflow");
-  pool->nlanguages = nlanguages;
-  if (!nlanguages)
-    return;
-  pool->languages = solv_calloc(nlanguages, sizeof(const char **));
-  for (i = 0; i < pool->nlanguages; i++)
-    pool->languages[i] = solv_strdup(languages[i]);
-}
-
-Id
-pool_id2langid(Pool *pool, Id id, const char *lang, int create)
-{
-  const char *n;
-  char buf[256], *p;
-  size_t l;
-
-  if (!lang || !*lang)
-    return id;
-  n = pool_id2str(pool, id);
-  l = strlen(n) + strlen(lang) + 2;
-  if (l > sizeof(buf))
-    p = solv_malloc(l);
-  else
-    p = buf;
-  sprintf(p, "%s:%s", n, lang);
-  id = pool_str2id(pool, p, create);
-  if (p != buf)
-    free(p);
-  return id;
-}
-
 char *
 pool_alloctmpspace(Pool *pool, int len)
 {

diff --git a/src/pool.h b/src/pool.h
index d994256409964165e1fe9df9c02e960f8c49610d..fda87abf0968b2c2fbc682ac5ce3532d868cebd5 100644 (file)
--- a/src/pool.h
+++ b/src/pool.h
@@ -398,6 +398,10 @@ long long pool_calc_installsizechange(Pool *pool, Map *installedmap);
 
 void pool_add_fileconflicts_deps(Pool *pool, Queue *conflicts);
 
+#ifdef LIBSOLV_INTERNAL
+Id *pool_lookup_languagecache_row(Pool *pool, Id keyname);
+#endif
+
 
 
 /* loop over all providers of d */

diff --git a/src/poollang.c b/src/poollang.c
new file mode 100644 (file)
index 0000000..38bb625
--- /dev/null
+++ b/src/poollang.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026 SUSE LLC
+ *
+ * This program is licensed under the BSD license, read LICENSE.BSD
+ * for further information
+ */
+
+/*
+ * poollang.c
+ *
+ * handle language dependent lookups
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "pool.h"
+#include "util.h"
+
+static void
+pool_free_languages(Pool *pool)
+{
+  int i;
+
+  pool->languagecache = solv_free(pool->languagecache);
+  for (i = 0; i < pool->nlanguages; i++)
+    free((char *)pool->languages[i]);
+  pool->languages = solv_free((void *)pool->languages);
+}
+
+void
+pool_set_languages(Pool *pool, const char **languages, int nlanguages)
+{
+  int i;
+
+  pool_free_languages(pool);
+  if (nlanguages < 0 || nlanguages >= 1024)
+    solv_ovfl("language count overflow");
+  pool->nlanguages = nlanguages;
+  if (!nlanguages)
+    return;
+  pool->languages = solv_calloc(nlanguages, sizeof(const char **));
+  for (i = 0; i < pool->nlanguages; i++)
+    pool->languages[i] = solv_strdup(languages[i]);
+}
+
+Id
+pool_id2langid(Pool *pool, Id id, const char *lang, int create)
+{
+  const char *n;
+  char buf[256], *p;
+  size_t l;
+
+  if (!lang || !*lang)
+    return id;
+  n = pool_id2str(pool, id);
+  l = strlen(n) + strlen(lang) + 2;
+  if (l > sizeof(buf))
+    p = solv_malloc(l);
+  else
+    p = buf;
+  sprintf(p, "%s:%s", n, lang);
+  id = pool_str2id(pool, p, create);
+  if (p != buf)
+    free(p);
+  return id;
+}
+
+/* 
+ * The languagecache is used to cache the result of pool_id2langid().
+ * It returns space for nlanguages Id elements for a given keyname.
+ */
+Id *
+pool_lookup_languagecache_row(Pool *pool, Id keyname)
+{
+  int cols = pool->nlanguages + 1;
+  Id *row;
+  if (!pool->languagecache)
+    {
+      pool->languagecache = solv_calloc(ID_NUM_INTERNAL + cols + 1, sizeof(Id));
+      pool->languagecache[0] = ID_NUM_INTERNAL;                /* current size */
+    }
+  if (keyname > 0 && keyname < ID_NUM_INTERNAL)
+    {
+      if (cols == 2)
+       return pool->languagecache + keyname;           /* special case for just one language */
+      if (pool->languagecache[keyname])
+       return pool->languagecache + pool->languagecache[keyname];
+    }
+  else
+    {
+      /* find our row, terminate if we reach the trailing zero */
+      for (row = pool->languagecache + ID_NUM_INTERNAL; *row; row += cols)
+       if (*row == keyname)
+         return row + 1;
+    }
+  /* we need to add a new row (plus the trailing zero) */
+  if (pool->languagecache[0] + cols + 1 >= SOLV_MAX_INDEX)
+    solv_ovfl("languagecache size overflow");
+  pool->languagecache = solv_realloc2(pool->languagecache, pool->languagecache[0] + cols + 1, sizeof(Id));
+  if (keyname < ID_NUM_INTERNAL)
+    pool->languagecache[keyname] = pool->languagecache[0] + 1;
+  row = pool->languagecache + pool->languagecache[0];
+  pool->languagecache[0] += cols;
+  memset(row, 0, (cols + 1) * sizeof(Id));     /* +1 for the trailing zero */
+  *row = keyname;
+  return row + 1;
+}

diff --git a/src/poolvendor.c b/src/poolvendor.c
index 83ee15bdcbebb15f8e54f59e5555e569040036de..4c3c25776d7bfede484451d984e7992e1db73a8c 100644 (file)
--- a/src/poolvendor.c
+++ b/src/poolvendor.c
@@ -20,6 +20,8 @@
 #include "poolvendor.h"
 #include "util.h"
 
+#define MAX_VENDORCLASSES 0x1000000
+
 /*
  *  const char *vendorsclasses[] = {
  *    "!openSUSE Build Service*",
@@ -78,22 +80,31 @@ Id pool_vendor2mask(Pool *pool, Id vendor)
   return mask;
 }
 
-void
-pool_setvendorclasses(Pool *pool, const char **vendorclasses)
+static void
+pool_freevendorclasses(Pool *pool)
 {
-  int i;
   const char **v;
-
   if (pool->vendorclasses)
     {
       for (v = pool->vendorclasses; v[0] || v[1]; v++)
        solv_free((void *)*v);
       pool->vendorclasses = solv_free((void *)pool->vendorclasses);
     }
+}
+
+void
+pool_setvendorclasses(Pool *pool, const char **vendorclasses)
+{
+  int i;
+  const char **v;
+
+  pool_freevendorclasses(pool);
   if (!vendorclasses || !vendorclasses[0])
     return;
   for (v = vendorclasses; v[0] || v[1]; v++)
     ;
+  if (v - vendorclasses + 2 >= MAX_VENDORCLASSES)
+    solv_ovfl("vendorclass size overflow");
   pool->vendorclasses = solv_calloc(v - vendorclasses + 2, sizeof(const char *));
   for (v = vendorclasses, i = 0; v[0] || v[1]; v++, i++)
     pool->vendorclasses[i] = *v ? solv_strdup(*v) : 0;
@@ -105,7 +116,7 @@ pool_setvendorclasses(Pool *pool, const char **vendorclasses)
 void
 pool_addvendorclass(Pool *pool, const char **vendorclass)
 {
-  int i, j;
+  size_t i, j;
 
   if (!vendorclass || !vendorclass[0])
     return;
@@ -119,6 +130,8 @@ pool_addvendorclass(Pool *pool, const char **vendorclass)
       if (i)
         i++;
     }
+  if (i + j + 2 >= MAX_VENDORCLASSES)
+    solv_ovfl("vendorclass size overflow");
   pool->vendorclasses = solv_realloc2((void *)pool->vendorclasses, i + j + 2, sizeof(const char *));
   for (j = 0; vendorclass[j]; j++)
     pool->vendorclasses[i++] = solv_strdup(vendorclass[j]);

diff --git a/src/solvable.c b/src/solvable.c
index 7c4177dd00a9022d6ee72f70ebaa329defdbc56c..07da4324c45b715555addf00eea4c496c9368b07 100644 (file)
--- a/src/solvable.c
+++ b/src/solvable.c
@@ -200,42 +200,6 @@ solvable_lookup_str_base(Solvable *s, Id keyname, Id basekeyname, int usebase)
   return usebase ? basestr : 0;
 }
 
-static Id *
-pool_lookup_languagecache_row(Pool *pool, Id keyname)
-{
-  int cols = pool->nlanguages + 1;
-  Id *row;
-  if (!pool->languagecache)
-    {
-      pool->languagecache = solv_calloc(ID_NUM_INTERNAL + cols + 1, sizeof(Id));
-      pool->languagecache[0] = ID_NUM_INTERNAL;                /* current size */
-    }
-  if (keyname > 0 && keyname < ID_NUM_INTERNAL)
-    {
-      if (cols == 2)
-       return pool->languagecache + keyname;           /* special case for just one language */
-      if (pool->languagecache[keyname])
-       return pool->languagecache + pool->languagecache[keyname];
-    }
-  else
-    {
-      /* find our row, terminate if we reach the trailing zero */
-      for (row = pool->languagecache + ID_NUM_INTERNAL; *row; row += cols)
-       if (*row == keyname)
-         return row + 1;
-    }
-  /* we need to add a new row (plus the trailing zero) */
-  if (pool->languagecache[0] + cols + 1 >= SOLV_MAX_INDEX)
-    solv_ovfl("languagecache size overflow");
-  pool->languagecache = solv_realloc2(pool->languagecache, pool->languagecache[0] + cols + 1, sizeof(Id));
-  if (keyname < ID_NUM_INTERNAL)
-    pool->languagecache[keyname] = pool->languagecache[0] + 1;
-  row = pool->languagecache + pool->languagecache[0];
-  pool->languagecache[0] += cols;
-  memset(row, 0, (cols + 1) * sizeof(Id));     /* +1 for the trailing zero */
-  *row = keyname;
-  return row + 1;
-}
 
 const char *
 solvable_lookup_str_poollang(Solvable *s, Id keyname)