#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include "s1kd_tools.h"

/* Order of references */
#define DM "0" /* dmRef */
#define PM "1" /* pmRef */
#define EP "2" /* externalPubRef */

#define PROG_NAME "s1kd-syncrefs"
#define VERSION "1.9.0"

#define ERR_PREFIX PROG_NAME ": ERROR: "
#define INF_PREFIX PROG_NAME ": INFO: "

#define E_BAD_LIST ERR_PREFIX "Could not read list: %s\n"
#define E_MAX_REFS ERR_PREFIX "Maximum references reached: %d\n"
#define I_SYNCREFS INF_PREFIX "Synchronizing references in %s...\n"
#define I_DELREFS  INF_PREFIX "Deleting refs table in %s...\n"

#define EXIT_INVALID_DM 1
#define EXIT_MAX_REFS 2

static unsigned MAX_REFS = 1;

struct ref {
       char code[256];
       xmlNodePtr ref;
};

static bool only_delete = false;
static enum verbosity { QUIET, NORMAL, VERBOSE } verbosity = NORMAL;

static struct ref *refs;
static int nrefs;

static bool contains_code(const char *code)
{
       int i;

       for (i = 0; i < nrefs; ++i) {
               if (strcmp(refs[i].code, code) == 0) {
                       return true;
               }
       }

       return false;
}

static xmlNodePtr find_child(xmlNodePtr parent, const char *child_name)
{
       xmlNodePtr cur;

       for (cur = parent->children; cur; cur = cur->next) {
               if (strcmp((char *) cur->name, child_name) == 0) {
                       return cur;
               }
       }

       return NULL;
}

static xmlNodePtr first_xpath_node(xmlDocPtr doc, xmlNodePtr node, const char *expr)
{
       xmlXPathContextPtr ctx;
       xmlXPathObjectPtr obj;
       xmlNodePtr first;

       ctx = xmlXPathNewContext(doc ? doc : node->doc);
       ctx->node = node;

       obj = xmlXPathEvalExpression(BAD_CAST expr, ctx);

       first = xmlXPathNodeSetIsEmpty(obj->nodesetval) ? NULL : obj->nodesetval->nodeTab[0];

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);

       return first;
}

static char *first_xpath_string(xmlDocPtr doc, xmlNodePtr node, const char *expr)
{
       return (char *) xmlNodeGetContent(first_xpath_node(doc, node, expr));
}

static bool is_ref(xmlNodePtr node)
{
       return node->type == XML_ELEMENT_NODE && (
               xmlStrcmp(node->name, BAD_CAST "dmRef") == 0 ||
               xmlStrcmp(node->name, BAD_CAST "refdm") == 0 ||
               xmlStrcmp(node->name, BAD_CAST "pmRef") == 0 ||
               xmlStrcmp(node->name, BAD_CAST "reftp") == 0 ||
               xmlStrcmp(node->name, BAD_CAST "externalPubRef") == 0);
}

static void copy_code(char *dst, xmlNodePtr ref)
{
       xmlNodePtr code;

       char *model_ident_code;

       if (xmlStrcmp(ref->name, BAD_CAST "dmRef") == 0 || xmlStrcmp(ref->name, BAD_CAST "refdm") == 0) {
               char *system_diff_code;
               char *system_code;
               char *sub_system_code;
               char *sub_sub_system_code;
               char *assy_code;
               char *disassy_code;
               char *disassy_code_variant;
               char *info_code;
               char *info_code_variant;
               char *item_location_code;
               char *learn_code;
               char *learn_event_code;

               char learn[6] = "";

               code = first_xpath_node(NULL, ref, ".//dmCode|.//avee");

               model_ident_code     = first_xpath_string(NULL, code, "@modelIdentCode|modelic");
               system_diff_code     = first_xpath_string(NULL, code, "@systemDiffCode|sdc");
               system_code          = first_xpath_string(NULL, code, "@systemCode|chapnum");
               sub_system_code      = first_xpath_string(NULL, code, "@subSystemCode|section");
               sub_sub_system_code  = first_xpath_string(NULL, code, "@subSubSystemCode|subsect");
               assy_code            = first_xpath_string(NULL, code, "@assyCode|subject");
               disassy_code         = first_xpath_string(NULL, code, "@disassyCode|discode");
               disassy_code_variant = first_xpath_string(NULL, code, "@disassyCodeVariant|discodev");
               info_code            = first_xpath_string(NULL, code, "@infoCode|incode");
               info_code_variant    = first_xpath_string(NULL, code, "@infoCodeVariant|incodev");
               item_location_code   = first_xpath_string(NULL, code, "@itemLocationCode|itemloc");
               learn_code           = first_xpath_string(NULL, code, "@learnCode");
               learn_event_code     = first_xpath_string(NULL, code, "@learnEventCode");

               if (learn_code && learn_event_code)
                       sprintf(learn, "-%s%s", learn_code, learn_event_code);

               sprintf(dst, DM"%s-%s-%s-%s%s-%s-%s%s-%s%s-%s%s",
                       model_ident_code,
                       system_diff_code,
                       system_code,
                       sub_system_code,
                       sub_sub_system_code,
                       assy_code,
                       disassy_code,
                       disassy_code_variant,
                       info_code,
                       info_code_variant,
                       item_location_code,
                       learn);

               xmlFree(model_ident_code);
               xmlFree(system_diff_code);
               xmlFree(system_code);
               xmlFree(sub_system_code);
               xmlFree(sub_sub_system_code);
               xmlFree(assy_code);
               xmlFree(disassy_code);
               xmlFree(disassy_code_variant);
               xmlFree(info_code);
               xmlFree(info_code_variant);
               xmlFree(item_location_code);
               xmlFree(learn_code);
               xmlFree(learn_event_code);
       } else if (xmlStrcmp(ref->name, BAD_CAST "pmRef") == 0 || xmlStrcmp(ref->name, BAD_CAST "reftp") == 0) {
               char *pm_issuer;
               char *pm_number;
               char *pm_volume;

               code = first_xpath_node(NULL, ref, ".//pmCode|.//pmc");

               model_ident_code = (char *) xmlGetProp(code, BAD_CAST "modelIdentCode");
               pm_issuer = (char *) xmlGetProp(code, BAD_CAST "pmIssuer");
               pm_number = (char *) xmlGetProp(code, BAD_CAST "pmNumber");
               pm_volume = (char *) xmlGetProp(code, BAD_CAST "pmVolume");

               sprintf(dst, PM"%s-%s-%s-%s",
                       model_ident_code,
                       pm_issuer,
                       pm_number,
                       pm_volume);

               xmlFree(model_ident_code);
               xmlFree(pm_issuer);
               xmlFree(pm_number);
               xmlFree(pm_volume);
       } else if (xmlStrcmp(ref->name, BAD_CAST "externalPubRef") == 0) {
               xmlNodePtr title;

               code  = first_xpath_node(NULL, ref, ".//externalPubCode");
               title = first_xpath_node(NULL, ref, ".//externalPubTitle");

               if (code) {
                       char *code_content;

                       code_content = (char *) xmlNodeGetContent(code);
                       sprintf(dst, EP"%s", code_content);
                       xmlFree(code_content);
               } else if (title) {
                       char *title_content;

                       title_content = (char *) xmlNodeGetContent(title);
                       sprintf(dst, EP"%s", title_content);
                       xmlFree(title_content);
               }
       } else {
               strcpy(dst, "");
       }
}

static void resize(void)
{
       if (!(refs = realloc(refs, (MAX_REFS *= 2) * sizeof(struct ref)))) {
               if (verbosity >= NORMAL) {
                       fprintf(stderr, E_MAX_REFS, nrefs);
               }
               exit(EXIT_MAX_REFS);
       }
}

static void find_refs(xmlNodePtr node)
{
       xmlNodePtr cur;

       if (is_ref(node)) {
               char code[256];

               copy_code(code, node);

               if (!contains_code(code)) {
                       if (nrefs == MAX_REFS) {
                               resize();
                       }

                       strcpy(refs[nrefs].code, code);
                       refs[nrefs].ref = node;
                       ++nrefs;
               }
       } else {
               for (cur = node->children; cur; cur = cur->next) {
                       find_refs(cur);
               }
       }
}

static int compare_refs(const void *a, const void *b)
{
       struct ref *ref1 = (struct ref *) a;
       struct ref *ref2 = (struct ref *) b;

       return strcmp(ref1->code, ref2->code);
}

static void sync_refs(xmlNodePtr dmodule)
{
       int i;

       xmlNodePtr content, old_refs, new_refs, searchable, new_node,
               refgrp = NULL, refdms = NULL, reftp = NULL, rdandrt = NULL;

       nrefs = 0;

       content = find_child(dmodule, "content");

       old_refs = find_child(content, "refs");

       if (old_refs) {
               refgrp = first_xpath_node(NULL, old_refs, "norefs|refdms|reftp|rdandrt");

               xmlUnlinkNode(old_refs);
               xmlFreeNode(old_refs);
       }

       if (only_delete) return;

       searchable = xmlLastElementChild(content);

       if (!searchable) {
               if (verbosity >= NORMAL) {
                       fprintf(stderr, ERR_PREFIX "Invalid data module.\n");
               }
               exit(EXIT_INVALID_DM);
       }

       find_refs(searchable);

       if (nrefs < 1) {
               return;
       }

       new_refs = xmlNewNode(NULL, BAD_CAST "refs");

       xmlAddPrevSibling(content->children, new_refs);

       if (refgrp) {
               refdms  = xmlNewChild(new_refs, NULL, BAD_CAST "refdms", NULL);
               reftp   = xmlNewChild(new_refs, NULL, BAD_CAST "reftp", NULL);
               rdandrt = xmlNewChild(new_refs, NULL, BAD_CAST "rdandrt", NULL);
       }

       qsort(refs, nrefs, sizeof(struct ref), compare_refs);

       for (i = 0; i < nrefs; ++i) {
               if (refgrp) {
                       if (xmlStrcmp(refs[i].ref->name, BAD_CAST "refdm") == 0) {
                               new_node = xmlAddChild(refdms, xmlCopyNode(refs[i].ref, 1));
                               xmlUnsetProp(new_node, BAD_CAST "id");
                               new_node = xmlAddChild(rdandrt, xmlCopyNode(refs[i].ref, 1));
                               xmlUnsetProp(new_node, BAD_CAST "id");
                       } else if (xmlStrcmp(refs[i].ref->name, BAD_CAST "reftp") == 0) {
                               new_node = xmlAddChild(reftp, xmlCopyNode(refs[i].ref, 1));
                               xmlUnsetProp(new_node, BAD_CAST "id");
                               new_node = xmlAddChild(reftp, xmlCopyNode(refs[i].ref, 1));
                               xmlUnsetProp(new_node, BAD_CAST "id");
                       }
               } else {
                       new_node = xmlAddChild(new_refs, xmlCopyNode(refs[i].ref, 1));
                       xmlUnsetProp(new_node, BAD_CAST "id");
               }
       }

       if (refgrp) {
               if (!refdms->children) {
                       xmlUnlinkNode(refdms);
                       xmlFreeNode(refdms);
                       xmlUnlinkNode(rdandrt);
                       xmlFreeNode(rdandrt);
               } else if (!reftp->children) {
                       xmlUnlinkNode(reftp);
                       xmlFreeNode(reftp);
                       xmlUnlinkNode(rdandrt);
                       xmlFreeNode(rdandrt);
               } else {
                       xmlUnlinkNode(rdandrt);
                       xmlFreeNode(rdandrt);
               }
       }
}

static void sync_refs_file(const char *path, const char *out, bool overwrite)
{
       xmlDocPtr dm;
       xmlNodePtr dmodule;

       if (verbosity >= VERBOSE) {
               if (only_delete) {
                       fprintf(stderr, I_DELREFS, path);
               } else {
                       fprintf(stderr, I_SYNCREFS, path);
               }
       }

       if (!(dm = read_xml_doc(path))) {
               return;
       }

       dmodule = xmlDocGetRootElement(dm);

       sync_refs(dmodule);

       if (overwrite) {
               save_xml_doc(dm, path);
       } else {
               save_xml_doc(dm, out);
       }

       xmlFreeDoc(dm);
}

static void sync_refs_list(const char *path, const char *out, bool overwrite)
{
       FILE *f;
       char line[PATH_MAX];

       if (path) {
               if (!(f = fopen(path, "r"))) {
                       if (verbosity >= NORMAL) {
                               fprintf(stderr, E_BAD_LIST, path);
                       }
                       return;
               }
       } else {
               f = stdin;
       }

       while (fgets(line, PATH_MAX, f)) {
               strtok(line, "\t\r\n");
               sync_refs_file(line, out, overwrite);
       }

       if (path) {
               fclose(f);
       }
}

static void show_help(void)
{
       puts("Usage: " PROG_NAME " [-dflqvh?] [-o <out>] [<dms>]");
       puts("");
       puts("Options:");
       puts("  -d, --delete     Delete the references table.");
       puts("  -f, --overwrite  Overwrite the data modules automatically.");
       puts("  -h, -?, --help   Show help/usage message.");
       puts("  -l, --list       Treat input as list of CSDB objects.");
       puts("  -o, --out <out>  Output to <out> instead of stdout.");
       puts("  -q, --quiet      Quiet mode.");
       puts("  -v, --verbose    Verbose output.");
       puts("  --version        Show version information.");
       puts("  <dms>            Any number of data modules. Otherwise, read from stdin.");
       LIBXML2_PARSE_LONGOPT_HELP
}

static void show_version(void)
{
       printf("%s (s1kd-tools) %s\n", PROG_NAME, VERSION);
       printf("Using libxml %s\n", xmlParserVersion);
}

int main(int argc, char *argv[])
{
       int i;

       char out[PATH_MAX] = "-";

       bool overwrite = false;
       bool islist = false;

       const char *sopts = "dflo:qvh?";
       struct option lopts[] = {
               {"version"  , no_argument      , 0, 0},
               {"help"     , no_argument      , 0, 'h'},
               {"delete"   , no_argument      , 0, 'd'},
               {"overwrite", no_argument      , 0, 'f'},
               {"list"     , no_argument      , 0, 'l'},
               {"out"      , required_argument, 0, 'o'},
               {"quiet"    , no_argument      , 0, 'q'},
               {"verbose"  , no_argument      , 0, 'v'},
               LIBXML2_PARSE_LONGOPT_DEFS
               {0, 0, 0, 0}
       };
       int loptind = 0;

       refs = malloc(MAX_REFS * sizeof(struct ref));

       while ((i = getopt_long(argc, argv, sopts, lopts, &loptind)) != -1) {
               switch (i) {
                       case 0:
                               if (strcmp(lopts[loptind].name, "version") == 0) {
                                       show_version();
                                       return 0;
                               }
                               LIBXML2_PARSE_LONGOPT_HANDLE(lopts, loptind, optarg)
                               break;
                       case 'd':
                               only_delete = true;
                               break;
                       case 'f':
                               overwrite = true;
                               break;
                       case 'l':
                               islist = true;
                               break;
                       case 'o':
                               strcpy(out, optarg);
                               break;
                       case 'q':
                               --verbosity;
                               break;
                       case 'v':
                               ++verbosity;
                               break;
                       case 'h':
                       case '?':
                               show_help();
                               return 0;
               }
       }

       if (optind < argc) {
               for (i = optind; i < argc; ++i) {
                       if (islist) {
                               sync_refs_list(argv[i], out, overwrite);
                       } else {
                               sync_refs_file(argv[i], out, overwrite);
                       }
               }
       } else if (islist) {
               sync_refs_list(NULL, out, overwrite);
       } else {
               sync_refs_file("-", out, false);
       }

       free(refs);

       xmlCleanupParser();

       return 0;
}

You are viewing proxied material from khzae.net. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.