name cleanup for x86 model strings and intel pci device strings

x86 CPU:
* Remove (R), (TM), etc
* AMD: remove redundant "X2 Dual Core", "X4 Quad Core", etc
* Move vendor to front if not already
* Remove speed, as the actual speed is usually right next to it
* Remove "CPU", "APU", "Processor" to shorten
* Compress space

Intel GPU:
* Remove (R)
* Abbreviate "Generation": "Gen"
* Remove "Processor", "Controller", and "Device" to shorten
* Compress space

Some examples:
x86 CPU:
'AMD Turion(tm) 64 Mobile Technology ML-32' ---> 'AMD Turion 64 Mobile ML-32'
'Cyrix MediaGXtm MMXtm Enhanced' ---> 'Cyrix MediaGX MMX Enhanced'
'Transmeta(tm) Crusoe(tm) Processor TM5800' ---> 'Transmeta Crusoe TM5800'
'VIA Nano X2 L4350 @ 1.6+ GHz' ---> 'VIA Nano X2 L4350'
'AMD Athlon(tm) 64 X2 Dual-Core Processor TK-53' ---> 'AMD Athlon 64 X2 TK-53'
'Embedded AMD Opteron(tm) Processor 23KS EE' ---> 'AMD Embedded Opteron 23KS EE'
'Intel(R) Atom(TM) x5-Z8300 CPU @ 1.44GHz' ---> 'Intel Atom x5-Z8300'
'Intel(R) Pentium(R) III CPU - S         1400MHz' ---> 'Intel Pentium III - S'
'Dual Core AMD Opteron(tm) Processor 165' ---> 'AMD Dual Core Opteron 165'
'Genuine Intel(R) CPU T1350 @ 1.86GHz' ---> 'Intel T1350'
'AMD Phenom(tm) 9350e Quad-Core Processor' ---> 'AMD Phenom 9350e Quad-Core'
Intel GPU:
'Atom/Celeron/Pentium Processor x5-E8000/J3xxx/N3xxx Integrated Graphics Controller' ---> 'Atom/Celeron/Pentium x5-E8000/J3xxx/N3xxx Integrated Graphics'
'4th Generation Core Processor Family Integrated Graphics Controller' ---> '4th Gen Core Family Integrated Graphics'
'Mobile GM965/GL960 Integrated Graphics Controller (secondary)' ---> 'Mobile GM965/GL960 Integrated Graphics (secondary)'
'Mobile 915GM/GMS/910GML Express Graphics Controller' ---> 'Mobile 915GM/GMS/910GML Express Graphics'

Also:
Fix/replace the appf() and SEQ() that were peppered about.

Signed-off-by: Burt P <pburt0@gmail.com>

3 files changed, 523 insertions, 0 deletions

diff --git a/deps/sysobj_early/src/appf.c b/deps/sysobj_early/src/appf.c
new file mode 100644
index 00000000..432e0f30
--- /dev/null
+++ b/deps/sysobj_early/src/appf.c
@@ -0,0 +1,63 @@
+/*
+ * sysobj - https://github.com/bp0/verbose-spork
+ * Copyright (C) 2018  Burt P. <pburt0@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#include "appf.h"
+#define _GNU_SOURCE /* for vasprintf() */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+char *appf(char *str, const char *sep, const char *fmt, ...) {
+    char *buf = NULL;
+    int inlen, seplen, len;
+    va_list args;
+    va_start(args, fmt);
+    len = vasprintf(&buf, fmt, args);
+    va_end(args);
+    if (len < 0) return str;
+    if (!str) return buf;
+    inlen = strlen(str);
+    seplen = (inlen && sep) ? strlen(sep) : 0;
+    str = realloc(str, inlen + seplen + len + 1);
+    if (seplen) strcpy(str + inlen, sep);
+    strcpy(str + inlen + seplen, buf);
+    free(buf);
+    return str;
+}
+
+char *appfdup(const char *str, const char *sep, const char *fmt, ...) {
+    char *buf = NULL, *ret = NULL;
+    int inlen, seplen, len;
+    va_list args;
+    va_start(args, fmt);
+    len = vasprintf(&buf, fmt, args);
+    va_end(args);
+    if (len < 0) return NULL;
+    if (!str) return buf;
+    inlen = strlen(str);
+    seplen = (inlen && sep) ? strlen(sep) : 0;
+    ret = malloc(inlen + seplen + len + 1);
+    strcpy(ret, str);
+    if (seplen) strcpy(ret + inlen, sep);
+    strcpy(ret + inlen + seplen, buf);
+    free(buf);
+    return ret;
+}
diff --git a/deps/sysobj_early/src/nice_name.c b/deps/sysobj_early/src/nice_name.c
new file mode 100644
index 00000000..c3c8d3ce
--- /dev/null
+++ b/deps/sysobj_early/src/nice_name.c
@@ -0,0 +1,157 @@
+/*
+ * sysobj - https://github.com/bp0/verbose-spork
+ * Copyright (C) 2018  Burt P. <pburt0@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <ctype.h>
+
+#include "nice_name.h"
+#include "util_sysobj.h"
+
+/* export */
+/* replaces the extra chars with spaces, then when done with a series of
+ * str_shorten()s, use util_compress_space() to squeeze. */
+gboolean str_shorten(gchar *str, const gchar *find, const gchar *replace) {
+    if (!str || !find || !replace) return FALSE;
+    long unsigned lf = strlen(find);
+    long unsigned lr = strlen(replace);
+    gchar *p = strstr(str, find);
+    if (p) {
+        if (lr > lf) lr = lf;
+        gchar *buff = g_strnfill(lf, ' ');
+        strncpy(buff, replace, lr);
+        strncpy(p, buff, lf);
+        g_free(buff);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void nice_name_x86_cpuid_model_string(char *cpuid_model_string) {
+    static gboolean move_vendor_to_front = TRUE;
+    static gboolean remove_amd_compute_cores = FALSE;
+    static gboolean remove_amd_xn_ncore_redundancy = TRUE;
+    static gboolean remove_processor_cpu_apu_etc = TRUE;
+    static gboolean remove_mhz_ghz = TRUE;
+
+    if (!cpuid_model_string) return;
+    g_strstrip(cpuid_model_string);
+
+    while(str_shorten(cpuid_model_string, "Genuine Intel", "Intel")) {};
+    while(str_shorten(cpuid_model_string, "(R)", "")) {};
+    while(str_shorten(cpuid_model_string, "(r)", "")) {};
+    while(str_shorten(cpuid_model_string, "(TM)", "")) {};
+    while(str_shorten(cpuid_model_string, "(tm)", "")) {};
+    while(str_shorten(cpuid_model_string, "(c)", "")) {};
+    while(str_shorten(cpuid_model_string, "(C)", "")) {};
+    while(str_shorten(cpuid_model_string, "@", "")) {};
+
+    if (move_vendor_to_front) {
+        /* vendor not at the beginning, try to move there.
+         * ex: Mobile AMD Sempron(tm) Processor 3600+
+         * ex: Dual Core AMD Opteron(tm) Processor 165 */
+        char *intel = strstr(cpuid_model_string, "Intel ");
+        char *amd = strstr(cpuid_model_string, "AMD ");
+        if (amd || intel) {
+            if (amd && !intel) {
+                if (amd != cpuid_model_string) {
+                    int l = amd - cpuid_model_string;
+                    memmove(cpuid_model_string+4, cpuid_model_string, l);
+                    memcpy(cpuid_model_string, "AMD ", 4);
+                }
+            } else if (intel && !amd) {
+                int l = intel - cpuid_model_string;
+                memmove(cpuid_model_string+6, cpuid_model_string, l);
+                memcpy(cpuid_model_string, "Intel ", 6);
+            }
+        }
+    }
+
+    if (g_str_has_prefix(cpuid_model_string, "AMD")) {
+        while(str_shorten(cpuid_model_string, "Mobile Technology", "Mobile")) {};
+
+        if (remove_amd_compute_cores) {
+            if (strcasestr(cpuid_model_string, " COMPUTE CORES ")) {
+                /* ex: AMD FX-9800P RADEON R7, 12 COMPUTE CORES 4C+8G */
+                char *comma = strchr(cpuid_model_string, ',');
+                if (comma) *comma = 0;
+            }
+        }
+
+        if (remove_amd_xn_ncore_redundancy) {
+            /* remove Xn n-core redundancy */
+            if (strstr(cpuid_model_string, "X2")) {
+                str_shorten(cpuid_model_string, "Dual Core", "");
+                str_shorten(cpuid_model_string, "Dual-Core", "");
+            }
+            if (strstr(cpuid_model_string, "X3"))
+                str_shorten(cpuid_model_string, "Triple-Core", "");
+            if (strstr(cpuid_model_string, "X4"))
+                str_shorten(cpuid_model_string, "Quad-Core", "");
+        }
+    }
+
+    if (g_str_has_prefix(cpuid_model_string, "Cyrix")) {
+        while(str_shorten(cpuid_model_string, "tm ", "")) {};
+    }
+
+    if (remove_processor_cpu_apu_etc) {
+        while(str_shorten(cpuid_model_string, " CPU", "")) {};
+        while(str_shorten(cpuid_model_string, " APU", "")) {};
+        while(str_shorten(cpuid_model_string, " Integrated Processor", "")) {};
+        while(str_shorten(cpuid_model_string, " Processor", "")) {};
+        while(str_shorten(cpuid_model_string, " processor", "")) {};
+    } else {
+        while(str_shorten(cpuid_model_string, " processor", " Processor")) {};
+    }
+
+    if (remove_mhz_ghz) {
+        /* 1400MHz, 1.6+ GHz, etc */
+        char *u = NULL;
+        while((u = strcasestr(cpuid_model_string, "GHz"))
+            || (u = strcasestr(cpuid_model_string, "MHz")) ) {
+            if (u[3] == '+') u[3] = ' ';
+            strncpy(u, " ", 3);
+            while(isspace(*u)) {u--;}
+            while (isdigit(*u) || *u == '.' || *u == '+')
+                { *u = ' '; u--;}
+        }
+    }
+
+    /* finalize */
+    util_compress_space(cpuid_model_string);
+    g_strstrip(cpuid_model_string);
+}
+
+/* Intel Graphics may have very long names,
+ * like "Intel Corporation Seventh Generation Something Core Something Something Integrated Graphics Processor Revision Ninety-four" */
+void nice_name_intel_gpu_device(char *pci_ids_device_string) {
+    while(str_shorten(pci_ids_device_string, "(R)", "")) {}; /* Intel(R) -> Intel */
+    str_shorten(pci_ids_device_string, "Graphics Controller", "Graphics");
+    str_shorten(pci_ids_device_string, "Graphics Device", "Graphics");
+    str_shorten(pci_ids_device_string, "Generation", "Gen");
+    str_shorten(pci_ids_device_string, "Core Processor", "Core");
+    str_shorten(pci_ids_device_string, "Atom Processor", "Atom");
+    str_shorten(pci_ids_device_string, "Xeon Processor", "Xeon");
+    str_shorten(pci_ids_device_string, "Celeron Processor", "Celeron");
+    str_shorten(pci_ids_device_string, "Pentium Processor", "Pentium");
+    util_compress_space(pci_ids_device_string);
+    g_strstrip(pci_ids_device_string);
+}
diff --git a/deps/sysobj_early/src/util_sysobj.c b/deps/sysobj_early/src/util_sysobj.c
new file mode 100644
index 00000000..de3ec8b2
--- /dev/null
+++ b/deps/sysobj_early/src/util_sysobj.c
@@ -0,0 +1,303 @@
+/*
+ * sysobj - https://github.com/bp0/verbose-spork
+ * Copyright (C) 2018  Burt P. <pburt0@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>  /* for realpath() */
+#include <unistd.h>  /* for getuid() */
+#include <ctype.h>   /* for isxdigit(), etc. */
+
+#include "util_sysobj.h"
+
+gchar *util_build_fn(const gchar *base, const gchar *name) {
+    gchar *ret = NULL;
+    gboolean slash = TRUE;
+
+    if (!base) return NULL;
+    if (base[strlen(base)-1] == '/')
+        slash = FALSE;
+
+    if (name) {
+        if (*name == '/') slash = FALSE;
+        ret = g_strdup_printf("%s%s%s", base, slash ? "/" : "", name);
+    } else
+        ret = g_strdup(base);
+
+    util_null_trailing_slash(ret);
+    return ret;
+}
+
+gboolean util_have_root() {
+    return (getuid() == 0) ? TRUE : FALSE;
+}
+
+void util_compress_space(gchar *str) {
+    gchar *p = str, *t = str;
+    if (str && *str) {
+        int n = 0;
+        while(*p) {
+            if (isspace(*p) ) {
+                if (!n)
+                    *t++ = ' ';
+                n++;
+            } else {
+                n = 0;
+                if (t != p)
+                    *t = *p;
+                t++;
+            }
+            p++;
+        }
+    }
+    if (t != p)
+        *t = 0;
+}
+
+void util_null_trailing_slash(gchar *str) {
+    if (str && *str) {
+        if (str[strlen(str)-1] == '/' )
+            str[strlen(str)-1] = 0;
+    }
+}
+
+gsize util_count_lines(const gchar *str) {
+    gchar **lines = NULL;
+    gsize count = 0;
+
+    if (str) {
+        lines = g_strsplit(str, "\n", 0);
+        count = g_strv_length(lines);
+        if (count && *lines[count-1] == 0) {
+            /* if the last line is empty, don't count it */
+            count--;
+        }
+        g_strfreev(lines);
+    }
+
+    return count;
+}
+
+int util_get_did(gchar *str, const gchar *lbl) {
+    int id = -2;
+    gchar tmpfmt[128] = "";
+    gchar tmpchk[128] = "";
+    sprintf(tmpfmt, "%s%s", lbl, "%d");
+    if ( sscanf(str, tmpfmt, &id) ) {
+        sprintf(tmpchk, tmpfmt, id);
+        if ( SEQ(str, tmpchk) )
+            return id;
+    }
+    return -1;
+}
+
+gchar *util_escape_markup(gchar *v, gboolean replacing) {
+    gchar *clean, *tmp;
+    gchar **vl;
+    if (v == NULL) return NULL;
+
+    vl = g_strsplit(v, "&", -1);
+    if (g_strv_length(vl) > 1)
+        clean = g_strjoinv("&amp;", vl);
+    else
+        clean = g_strdup(v);
+    g_strfreev(vl);
+
+    vl = g_strsplit(clean, "<", -1);
+    if (g_strv_length(vl) > 1) {
+        tmp = g_strjoinv("&lt;", vl);
+        g_free(clean);
+        clean = tmp;
+    }
+    g_strfreev(vl);
+
+    vl = g_strsplit(clean, ">", -1);
+    if (g_strv_length(vl) > 1) {
+        tmp = g_strjoinv("&gt;", vl);
+        g_free(clean);
+        clean = tmp;
+    }
+    g_strfreev(vl);
+
+    if (replacing)
+        g_free((gpointer)v);
+    return clean;
+}
+
+void util_strstrip_double_quotes_dumb(gchar *str) {
+    if (!str) return;
+    g_strstrip(str);
+    gchar *front = str, *back = str + strlen(str) - 1;
+    if (back <= front) return;
+    while(*front == '"') { *front = 'X'; front++; }
+    while(*back == '"') { *back = 0; back--; }
+    int nl = strlen(front);
+    memmove(str, front, nl);
+    str[nl] = 0;
+}
+
+/* "194.110 MHz" -> "194.11 MHz"
+ * "5,0 golden rings" -> "5 golden rings" */
+gchar *util_strchomp_float(gchar* str_float) {
+    if (!str_float) return NULL;
+    char *dot = strchr(str_float, '.');
+    char *comma = strchr(str_float, ',');
+    char *p = NULL, *dec = NULL, *src = NULL, *target = NULL;
+    if (!dot && !comma) return str_float;
+    if (dot > comma)
+        dec = dot;
+    else
+        dec = comma;
+    p = dec + 1;
+    while(isdigit(*p)) p++;
+    target = src = p;
+    p--;
+    while(*p == '0') { target = p; p--; };
+    if (target == dec + 1)
+        target = dec;
+    if (target != src)
+        memmove(target, src, strlen(src)+1);
+    return str_float;
+}
+
+/* resolve . and .., but not symlinks */
+gchar *util_normalize_path(const gchar *path, const gchar *relto) {
+    gchar *resolved = NULL;
+#if GLIB_CHECK_VERSION(2, 58, 0)
+    resolved = g_canonicalize_filename(path, relto);
+#else
+    /* burt's hack version */
+    gchar *frt = relto ? g_strdup(relto) : NULL;
+    util_null_trailing_slash(frt);
+    gchar *fpath = frt
+        ? g_strdup_printf("%s%s%s", frt, (*path == '/') ? "" : "/", path)
+        : g_strdup(path);
+    g_free(frt);
+
+    /* note: **parts will own all the part strings throughout */
+    gchar **parts = g_strsplit(fpath, "/", -1);
+    gsize i, pn = g_strv_length(parts);
+    GList *lparts = NULL, *l = NULL, *n = NULL, *p = NULL;
+    for (i = 0; i < pn; i++)
+        lparts = g_list_append(lparts, parts[i]);
+
+    i = 0;
+    gchar *part = NULL;
+    l = lparts;
+    while(l) {
+        n = l->next; p = l->prev;
+        part = l->data;
+
+        if (SEQ(part, ".") )
+            lparts = g_list_delete_link(lparts, l);
+
+        if (SEQ(part, "..") ) {
+            if (p)
+                lparts = g_list_delete_link(lparts, p);
+            lparts = g_list_delete_link(lparts, l);
+        }
+
+        l = n;
+    }
+
+    resolved = g_strdup("");
+    l = lparts;
+    while(l) {
+        resolved = g_strdup_printf("%s%s/", resolved, (gchar*)l->data );
+        l = l->next;
+    }
+    g_list_free(lparts);
+    util_null_trailing_slash(resolved);
+    g_free(fpath);
+
+    g_strfreev(parts);
+#endif
+
+    return resolved;
+}
+
+/* resolve . and .. and symlinks */
+gchar *util_canonicalize_path(const gchar *path) {
+    char *resolved = realpath(path, NULL);
+    gchar *ret = g_strdup(resolved); /* free with g_free() instead of free() */
+    free(resolved);
+    return ret;
+}
+
+int util_maybe_num(gchar *str) {
+    int r = 10, i = 0, l = (str) ? strlen(str) : 0;
+    if (!l || l > 32) return 0;
+    gchar *chk = g_strdup(str);
+    g_strstrip(chk);
+    l = strlen(chk);
+    if (l > 2 && !strncmp(chk, "0x", 2)) {
+        i = 2; r = 16;
+    }
+    for (; i < l; i++) {
+        if (isxdigit(chk[i]))  {
+            if (!isdigit(chk[i]))
+                r = 16;
+        } else {
+            r = 0;
+            break;
+        }
+    }
+    g_free(chk);
+    return r;
+}
+
+gchar *util_safe_name(const gchar *name, gboolean lower_case) {
+    if (!name) return NULL;
+    const gchar *p = name;
+    gchar *buff = g_new0(gchar, strlen(name) + 1);
+    gchar *t = buff;
+    while(*p) {
+        gboolean ok = g_ascii_isalnum(*p);
+        if (*p == '.' || *p == '-') ok = TRUE;
+        if (*p == '/') ok = FALSE;
+        *t = ok ? *p : '_';
+        t++;
+        p = g_utf8_next_char(p);
+    }
+    gchar *ret = lower_case ? g_ascii_strdown(buff, -1) : g_strdup(buff);
+    g_free(buff);
+    return ret;
+}
+
+gchar *util_find_line_value(gchar *data, gchar *key, gchar delim) {
+    gchar *ret = NULL;
+    gchar **lines = g_strsplit(data, "\n", -1);
+    gsize line_count = g_strv_length(lines);
+    gsize i = 0;
+    for (i = 0; i < line_count; i++) {
+        gchar *line = lines[i];
+        gchar *value = g_utf8_strchr(line, -1, delim);
+        if (!value) continue;
+        *value = 0;
+        value = g_strstrip(value+1);
+        gchar *lkey = g_strstrip(line);
+
+        if (SEQ(lkey, key) ) {
+            ret = g_strdup(value);
+        }
+    }
+    g_strfreev(lines);
+    return ret;
+}