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

#define PROG_NAME "s1kd-mvref"
#define VERSION "2.6.0"

#define ERR_PREFIX PROG_NAME ": ERROR: "

#define E_ENCODING_ERROR ERR_PREFIX "Error encoding path name.\n"
#define E_BAD_LIST ERR_PREFIX "Could not read list: %s\n"

#define EXIT_ENCODING_ERROR 1
#define EXIT_NO_FILE 2

#define ADDR_PATH     "//dmAddress|//dmaddres|//pmAddress|//pmaddres"
#define REFS_PATH_CONTENT BAD_CAST "//content//dmRef|//content//refdm[*]|//content//pmRef|//content/refpm"
#define REFS_PATH BAD_CAST "//dmRef|//pmRef|//refdm[*]|//refpm"

static enum verbosity { QUIET, NORMAL, VERBOSE } verbosity = NORMAL;

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

       if (doc) {
               ctx = xmlXPathNewContext(doc);
       } else if (node) {
               ctx = xmlXPathNewContext(node->doc);
       } else {
               return NULL;
       }

       ctx->node = node;

       obj = xmlXPathEvalExpression(BAD_CAST xpath, ctx);

       if (xmlXPathNodeSetIsEmpty(obj->nodesetval))
               first = NULL;
       else
               first = obj->nodesetval->nodeTab[0];

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);

       return first;
}

static char *firstXPathString(const char *xpath, xmlDocPtr doc, xmlNodePtr node)
{
       return (char *) xmlNodeGetContent(firstXPathNode(xpath, doc, node));
}

static xmlNodePtr findChild(xmlNodePtr parent, const char *name)
{
       xmlNodePtr cur;

       if (!parent) return NULL;

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

       return NULL;
}

static void replaceNode(xmlNodePtr a, xmlNodePtr b)
{
       xmlNodePtr c;
       c = xmlCopyNode(b, 1);
       xmlNodeSetName(c, a->name);
       xmlAddNextSibling(a, c);
       xmlUnlinkNode(a);
       xmlFreeNode(a);
}

static void getPmCode(char *dst, xmlNodePtr ident, bool withIssue, bool withLang)
{
       xmlNodePtr identExtension, pmCode, issueInfo, language;

       char *modelIdentCode, *pmIssuer, *pmNumber, *pmVolume;

       char cat[256];

       identExtension = findChild(ident, "identExtension");
       pmCode         = firstXPathNode("pmCode|pmc", NULL, ident);
       issueInfo      = firstXPathNode("issueInfo|issno", NULL, ident);
       language       = findChild(ident, "language");

       strcpy(dst, "");

       if (identExtension) {
               char *extensionProducer, *extensionCode;

               extensionProducer = (char *) xmlGetProp(identExtension, BAD_CAST "extensionProducer");
               extensionCode     = (char *) xmlGetProp(identExtension, BAD_CAST "extensionCode");

               snprintf(cat, 256, "%s-%s-", extensionProducer, extensionCode);

               xmlFree(extensionProducer);
               xmlFree(extensionCode);

               strcat(dst, cat);
       }

       modelIdentCode = firstXPathString("@modelIdentCode|modelic", NULL, pmCode);
       pmIssuer       = firstXPathString("@pmIssuer|pmissuer", NULL, pmCode);
       pmNumber       = firstXPathString("@pmNumber|pmnumber", NULL, pmCode);
       pmVolume       = firstXPathString("@pmVolume|pmvolume", NULL, pmCode);

       snprintf(cat, 256, "%s-%s-%s-%s", modelIdentCode, pmIssuer, pmNumber, pmVolume);

       xmlFree(modelIdentCode);
       xmlFree(pmIssuer);
       xmlFree(pmNumber);
       xmlFree(pmVolume);

       strcat(dst, cat);

       if (withIssue && issueInfo) {
               char *issueNumber, *inWork;

               issueNumber = firstXPathString("@issueNumber|@issno", NULL, issueInfo);
               inWork      = firstXPathString("@inWork|@inwork", NULL, issueInfo);

               snprintf(cat, 256, "_%s-%s", issueNumber, inWork ? inWork : "00");

               xmlFree(issueNumber);
               xmlFree(inWork);

               strcat(dst, cat);
       }

       if (withLang && language) {
               char *languageIsoCode, *countryIsoCode;

               languageIsoCode = firstXPathString("@languageIsoCode|@language", NULL, language);
               countryIsoCode  = firstXPathString("@countryIsoCode|@country", NULL, language);

               snprintf(cat, 256, "_%s-%s", languageIsoCode, countryIsoCode);

               xmlFree(languageIsoCode);
               xmlFree(countryIsoCode);

               strcat(dst, cat);
       }
}

static void getDmCode(char *dst, xmlNodePtr ident, bool withIssue, bool withLang)
{
       xmlNodePtr identExtension, dmCode, issueInfo, language;
       char *modelIdentCode;
       char *systemDiffCode;
       char *systemCode;
       char *subSystemCode;
       char *subSubSystemCode;
       char *assyCode;
       char *disassyCode;
       char *disassyCodeVariant;
       char *infoCode;
       char *infoCodeVariant;
       char *itemLocationCode;
       char *learnCode;
       char *learnEventCode;

       char cat[256];

       identExtension = firstXPathNode("identExtension|dmcextension", NULL, ident);
       dmCode         = firstXPathNode("dmCode|.//avee", NULL, ident);
       issueInfo      = firstXPathNode("issueInfo|issno", NULL, ident);
       language       = findChild(ident, "language");

       strcpy(dst, "");

       if (identExtension) {
               char *extensionProducer, *extensionCode;

               extensionProducer = firstXPathString("@extensionProducer|dmeproducer", NULL, identExtension);
               extensionCode     = firstXPathString("@extensionCode|dmecode", NULL, identExtension);

               snprintf(cat, 256, "%s-%s-", extensionProducer, extensionCode);

               xmlFree(extensionProducer);
               xmlFree(extensionCode);

               strcat(dst, cat);
       }

       modelIdentCode     = firstXPathString("@modelIdentCode|modelic", NULL, dmCode);
       systemDiffCode     = firstXPathString("@systemDiffCode|sdc", NULL, dmCode);
       systemCode         = firstXPathString("@systemCode|chapnum", NULL, dmCode);
       subSystemCode      = firstXPathString("@subSystemCode|section", NULL, dmCode);
       subSubSystemCode   = firstXPathString("@subSubSystemCode|subsect", NULL, dmCode);
       assyCode           = firstXPathString("@assyCode|subject", NULL, dmCode);
       disassyCode        = firstXPathString("@disassyCode|discode", NULL, dmCode);
       disassyCodeVariant = firstXPathString("@disassyCodeVariant|discodev", NULL, dmCode);
       infoCode           = firstXPathString("@infoCode|incode", NULL, dmCode);
       infoCodeVariant    = firstXPathString("@infoCodeVariant|incodev", NULL, dmCode);
       itemLocationCode   = firstXPathString("@itemLocationCode|itemloc", NULL, dmCode);
       learnCode          = firstXPathString("@learnCode", NULL, dmCode);
       learnEventCode     = firstXPathString("@learnEventCode", NULL, dmCode);

       snprintf(cat, 256, "%s-%s-%s-%s%s-%s-%s%s-%s%s-%s",
               modelIdentCode,
               systemDiffCode,
               systemCode,
               subSystemCode,
               subSubSystemCode,
               assyCode,
               disassyCode,
               disassyCodeVariant,
               infoCode,
               infoCodeVariant,
               itemLocationCode);

       xmlFree(modelIdentCode);
       xmlFree(systemDiffCode);
       xmlFree(systemCode);
       xmlFree(subSystemCode);
       xmlFree(subSubSystemCode);
       xmlFree(assyCode);
       xmlFree(disassyCode);
       xmlFree(disassyCodeVariant);
       xmlFree(infoCode);
       xmlFree(infoCodeVariant);
       xmlFree(itemLocationCode);

       strcat(dst, cat);

       if (learnCode && learnEventCode) {
               snprintf(cat, 256, "-%s%s", learnCode, learnEventCode);
               strcat(dst, cat);
       }

       xmlFree(learnCode);
       xmlFree(learnEventCode);

       if (withIssue && issueInfo) {
               char *issueNumber, *inWork;

               issueNumber = firstXPathString("@issueNumber|@issno", NULL, issueInfo);
               inWork      = firstXPathString("@inWork|@inwork", NULL, issueInfo);

               snprintf(cat, 256, "_%s-%s", issueNumber, inWork ? inWork : "00");

               xmlFree(issueNumber);
               xmlFree(inWork);

               strcat(dst, cat);
       }

       if (withLang && language) {
               char *languageIsoCode, *countryIsoCode;

               languageIsoCode = firstXPathString("@languageIsoCode|@language", NULL, language);
               countryIsoCode  = firstXPathString("@countryIsoCode|@country", NULL, language);

               snprintf(cat, 256, "_%s-%s", languageIsoCode, countryIsoCode);

               xmlFree(languageIsoCode);
               xmlFree(countryIsoCode);

               strcat(dst, cat);
       }
}

static bool isDmRef(xmlNodePtr ref)
{
       return xmlStrcmp(ref->name, BAD_CAST "dmRef") == 0 || xmlStrcmp(ref->name, BAD_CAST "refdm") == 0;
}

static bool isDmAddress(xmlNodePtr address)
{
       return xmlStrcmp(address->name, BAD_CAST "dmAddress") == 0 || xmlStrcmp(address->name, BAD_CAST "dmaddres") == 0;
}

static bool sameDm(xmlNodePtr ref, xmlNodePtr address)
{
       char refcode[256], addcode[256];
       bool withIssue, withLang;

       xmlNodePtr ref_dmIdent;
       xmlNodePtr add_dmIdent;

       if (!isDmRef(ref) || !isDmAddress(address))
               return false;

       ref_dmIdent = firstXPathNode("dmRefIdent|self::refdm", NULL, ref);
       add_dmIdent = firstXPathNode("dmIdent|self::dmaddres", NULL, address);

       withIssue = firstXPathNode(".//issueInfo|.//issno", NULL, ref);
       withLang  = firstXPathNode(".//language", NULL, ref);

       getDmCode(refcode, ref_dmIdent, withIssue, withLang);
       getDmCode(addcode, add_dmIdent, withIssue, withLang);

       if (verbosity >= VERBOSE && strcmp(refcode, addcode) == 0) {
               fprintf(stderr, "    Updating reference to data module %s...\n", addcode);
       }

       return strcmp(refcode, addcode) == 0;
}

static bool isPmRef(xmlNodePtr ref)
{
       return xmlStrcmp(ref->name, BAD_CAST "pmRef") == 0 || xmlStrcmp(ref->name, BAD_CAST "refpm") == 0;
}

static bool isPmAddress(xmlNodePtr address)
{
       return xmlStrcmp(address->name, BAD_CAST "pmAddress") == 0 || xmlStrcmp(address->name, BAD_CAST "pmaddres") == 0;
}

static bool samePm(xmlNodePtr ref, xmlNodePtr address)
{
       char refcode[256], addcode[256];
       bool withIssue, withLang;

       xmlNodePtr ref_pmIdent;
       xmlNodePtr add_pmIdent;

       if (!isPmRef(ref) || !isPmAddress(address))
               return false;

       ref_pmIdent = firstXPathNode("pmRefIdent|self::refpm", NULL, ref);
       add_pmIdent = firstXPathNode("pmIdent|self::pmaddres", NULL, address);

       withIssue = firstXPathNode("issueInfo|issno", NULL, ref_pmIdent);
       withLang  = findChild(ref_pmIdent, "language");

       getPmCode(refcode, ref_pmIdent, withIssue, withLang);
       getPmCode(addcode, add_pmIdent, withIssue, withLang);

       if (verbosity >= VERBOSE && strcmp(refcode, addcode) == 0) {
               fprintf(stderr, "    Updating reference to pub module %s...\n", addcode);
       }

       return strcmp(refcode, addcode) == 0;
}

static void updateRef(xmlNodePtr ref, xmlNodePtr addresses, const char *fname, xmlNodePtr recode)
{
       xmlNodePtr cur;

       for (cur = addresses->children; cur; cur = cur->next) {
               if (sameDm(ref, cur)) {
                       xmlNodePtr dmAddressItems, issueDate, dmTitle,
                                  dmRefAddressItems, dmRefIssueDate,
                                  dmRefTitle, dmIdent, dmCode, dmRefIdent,
                                  dmRefCode, issueInfo, refIssueInfo,
                                  language, refLanguage;

                       dmIdent = firstXPathNode("dmIdent|self::dmaddres", NULL, recode);
                       dmCode = firstXPathNode("dmCode|.//avee", NULL, dmIdent);
                       issueInfo = firstXPathNode("issueInfo|issno", NULL, dmIdent);
                       language = findChild(dmIdent, "language");

                       dmRefIdent = firstXPathNode("dmRefIdent|self::refdm", NULL, ref);
                       dmRefCode  = firstXPathNode("dmCode|.//avee", NULL, dmRefIdent);
                       refIssueInfo = firstXPathNode("issueInfo|issno", NULL, dmRefIdent);
                       refLanguage = findChild(dmRefIdent, "language");

                       if (verbosity >= VERBOSE) {
                               char code[256];
                               getDmCode(code, dmIdent, refIssueInfo, refLanguage);
                               fprintf(stderr, "      Recoding to %s...\n", code);
                       }

                       replaceNode(dmRefCode, dmCode);
                       if (refIssueInfo) replaceNode(refIssueInfo, issueInfo);
                       if (refLanguage) replaceNode(refLanguage, language);

                       dmAddressItems = firstXPathNode("dmAddressItems|self::dmaddres", NULL, recode);

                       issueDate           = findChild(dmAddressItems, "issueDate");
                       dmTitle             = firstXPathNode("dmTitle|dmtitle", NULL, dmAddressItems);

                       dmRefAddressItems   = firstXPathNode("dmRefAddressItems|self::refdm", NULL, ref);
                       dmRefIssueDate      = findChild(dmRefAddressItems, "issueDate");
                       dmRefTitle          = firstXPathNode("dmTitle|dmtitle", NULL, dmRefAddressItems);

                       if (dmRefIssueDate) replaceNode(dmRefIssueDate, issueDate);
                       if (dmRefTitle)     replaceNode(dmRefTitle, dmTitle);
               } else if (samePm(ref, cur)) {
                       xmlNodePtr pmAddressItems, issueDate, pmTitle,
                                  pmRefAddressItems, pmRefIssueDate,
                                  pmRefTitle, pmIdent, pmCode, pmRefIdent,
                                  pmRefCode, issueInfo, refIssueInfo,
                                  language, refLanguage;

                       pmIdent = firstXPathNode("pmIdent|self::pmaddres", NULL, recode);
                       pmCode  = firstXPathNode("pmCode|pmc", NULL, pmIdent);
                       issueInfo = firstXPathNode("issueInfo|issno", NULL, pmIdent);
                       language = findChild(pmIdent, "language");

                       pmRefIdent = firstXPathNode("pmRefIdent|self::refpm", NULL, ref);
                       pmRefCode  = firstXPathNode("pmCode|pmc", NULL, pmRefIdent);
                       refIssueInfo = firstXPathNode("issueInfo|issno", NULL, pmRefIdent);
                       refLanguage = findChild(pmRefIdent, "language");

                       if (verbosity >= VERBOSE) {
                               char code[256];
                               getPmCode(code, pmIdent, refIssueInfo, refLanguage);
                               fprintf(stderr, "      Recoding to %s...\n", code);
                       }

                       replaceNode(pmRefCode, pmCode);
                       if (refIssueInfo) replaceNode(refIssueInfo, issueInfo);
                       if (refLanguage) replaceNode(refLanguage, language);

                       pmAddressItems = firstXPathNode("pmAddressItems|self::pmaddres", NULL, recode);

                       issueDate           = firstXPathNode("issueDate|issdate", NULL, pmAddressItems);
                       pmTitle             = firstXPathNode("pmTitle|pmtitle", NULL, pmAddressItems);

                       pmRefAddressItems   = firstXPathNode("pmRefAddressItems|self::refpm", NULL, ref);
                       pmRefIssueDate      = firstXPathNode("issueDate|issdate", NULL, pmRefAddressItems);
                       pmRefTitle          = firstXPathNode("pmTitle|pmtitle", NULL, pmRefAddressItems);

                       if (pmRefIssueDate) replaceNode(pmRefIssueDate, issueDate);
                       if (pmRefTitle)     replaceNode(pmRefTitle, pmTitle);
               }
       }
}

static void updateRefs(xmlNodeSetPtr refs, xmlNodePtr addresses, const char *fname, xmlNodePtr recode)
{
       int i;

       for (i = 0; i < refs->nodeNr; ++i) {
               updateRef(refs->nodeTab[i], addresses, fname, recode);
       }
}

static void show_help(void)
{
       puts("Usage: " PROG_NAME " [-d <dir>] [-s <source>] [-t <target>] [-clqvh?] [<object>...]");
       puts("");
       puts("Options:");
       puts("  -c, --content          Only move references in content section of targets.");
       puts("  -d, --dir <dir>        Update data modules in directory <dir>.");
       puts("  -f, --overwrite        Overwrite input objects.");
       puts("  -h, -?, --help         Show help/usage message.");
       puts("  -l, --list             Input is a list of data module filenames.");
       puts("  -q, --quiet            Quiet mode.");
       puts("  -s, --source <source>  Source object.");
       puts("  -t, --target <target>  Change refs to <source> into refs to <target>.");
       puts("  -v, --verbose          Verbose output.");
       puts("  --version              Show version information.");
       puts("  <object>...            Objects to change refs in.");
       LIBXML2_PARSE_LONGOPT_HELP
}

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

static bool isS1000D(const char *fname)
{
       return (strncmp(fname, "DMC-", 4) == 0 ||
               strncmp(fname, "DME-", 4) == 0 ||
               strncmp(fname, "PMC-", 4) == 0 ||
               strncmp(fname, "PME-", 4) == 0 ||
               strncmp(fname, "COM-", 4) == 0 ||
               strncmp(fname, "IMF-", 4) == 0 ||
               strncmp(fname, "DDN-", 4) == 0 ||
               strncmp(fname, "DML-", 4) == 0 ||
               strncmp(fname, "UPF-", 4) == 0 ||
               strncmp(fname, "UPE-", 4) == 0 ||
               strncmp(fname, "SMC-", 4) == 0 ||
               strncmp(fname, "SME-", 4) == 0) && strncasecmp(fname + strlen(fname) - 4, ".XML", 4) == 0;
}

static void addAddress(const char *fname, xmlNodePtr addresses)
{
       xmlDocPtr doc;
       xmlNodePtr address;

       doc = read_xml_doc(fname);

       if (!doc)
               return;

       if (verbosity >= VERBOSE)
               fprintf(stderr, "Registering %s...\n", fname);

       address = firstXPathNode(ADDR_PATH, doc, NULL);

       if (address) {
               xmlAddChild(addresses, xmlCopyNode(address, 1));
       }

       xmlFreeDoc(doc);
}

static void updateRefsFile(const char *fname, xmlNodePtr addresses, bool contentOnly, const char *recode, bool overwrite)
{
       xmlDocPtr doc, recodeDoc;
       xmlXPathContextPtr ctx;
       xmlXPathObjectPtr obj;
       xmlNodePtr recodeIdent;

       if (!(doc = read_xml_doc(fname))) {
               return;
       }

       if (recode) {
               recodeDoc = read_xml_doc(recode);
               recodeIdent = firstXPathNode(ADDR_PATH, recodeDoc, NULL);
       } else {
               recodeIdent = NULL;
       }

       if (verbosity >= VERBOSE) {
               fprintf(stderr, "Checking refs in %s...\n", fname);
       }

       ctx = xmlXPathNewContext(doc);

       if (contentOnly) {
               obj = xmlXPathEvalExpression(REFS_PATH_CONTENT, ctx);
       } else {
               obj = xmlXPathEvalExpression(REFS_PATH, ctx);
       }

       if (!xmlXPathNodeSetIsEmpty(obj->nodesetval))
               updateRefs(obj->nodesetval, addresses, fname, recodeIdent);

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);

       if (overwrite) {
               save_xml_doc(doc, fname);
       } else {
               save_xml_doc(doc, "-");
       }

       xmlFreeDoc(doc);
}

static void addDirectory(const char *path, xmlNodePtr addresses)
{
       DIR *dir;
       struct dirent *cur;

       dir = opendir(path);

       if (!dir) {
               if (verbosity >= NORMAL) {
                       fprintf(stderr, ERR_PREFIX "Directory %s does not exist.\n", path);
               }
               exit(EXIT_NO_FILE);
       }

       while ((cur = readdir(dir))) {
               if (isS1000D(cur->d_name)) {
                       char fname[PATH_MAX];
                       if (snprintf(fname, PATH_MAX, "%s/%s", path, cur->d_name) < 0) {
                               if (verbosity >= NORMAL) {
                                       fprintf(stderr, E_ENCODING_ERROR);
                               }
                               exit(EXIT_ENCODING_ERROR);
                       }
                       addAddress(fname, addresses);
               }
       }

       closedir(dir);
}

static void updateRefsDirectory(const char *path, xmlNodePtr addresses, bool contentOnly, const char *recode, bool overwrite)
{
       DIR *dir;
       struct dirent *cur;

       dir = opendir(path);

       while ((cur = readdir(dir))) {
               if (isS1000D(cur->d_name)) {
                       char fname[PATH_MAX];
                       if (snprintf(fname, PATH_MAX, "%s/%s", path, cur->d_name) < 0) {
                               if (verbosity >= NORMAL) {
                                       fprintf(stderr, E_ENCODING_ERROR);
                               }
                               exit(EXIT_ENCODING_ERROR);
                       }
                       updateRefsFile(fname, addresses, contentOnly, recode, overwrite);
               }
       }

       closedir(dir);
}

static xmlNodePtr addAddressList(const char *fname, xmlNodePtr addresses, xmlNodePtr paths)
{
       FILE *f;
       char path[PATH_MAX];

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

       while (fgets(path, PATH_MAX, f)) {
               strtok(path, "\t\r\n");
               addAddress(path, addresses);
               xmlNewChild(paths, NULL, BAD_CAST "path", BAD_CAST path);
       }

       if (fname) {
               fclose(f);
       }

       return paths;
}

static void updateRefsList(xmlNodePtr addresses, xmlNodePtr paths, bool contentOnly, const char *recode, bool overwrite)
{
       xmlNodePtr cur;
       for (cur = paths->children; cur; cur = cur->next) {
               char *path;
               path = (char *) xmlNodeGetContent(cur);
               updateRefsFile(path, addresses, contentOnly, recode, overwrite);
               xmlFree(path);
       }
}

int main(int argc, char **argv)
{
       xmlNodePtr addresses, paths;

       int i;

       bool contentOnly = false;
       char *source = NULL;
       char *directory = NULL;
       bool isList = false;
       char *recode = NULL;
       bool overwrite = false;

       const char *sopts = "s:cfqvd:lt:qh?";
       struct option lopts[] = {
               {"version"  , no_argument      , 0, 0},
               {"help"     , no_argument      , 0, 'h'},
               {"source"   , required_argument, 0, 's'},
               {"content"  , no_argument      , 0, 'c'},
               {"overwrite", no_argument      , 0, 'f'},
               {"quiet"    , no_argument      , 0, 'q'},
               {"verbose"  , no_argument      , 0, 'v'},
               {"dir"      , required_argument, 0, 'd'},
               {"list"     , no_argument      , 0, 'l'},
               {"target"   , required_argument, 0, 't'},
               LIBXML2_PARSE_LONGOPT_DEFS
               {0, 0, 0, 0}
       };
       int loptind = 0;

       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 's':
                               if (!source) source = strdup(optarg);
                               break;
                       case 'c':
                               contentOnly = true;
                               break;
                       case 'f':
                               overwrite = true;
                               break;
                       case 'q':
                               --verbosity;
                               break;
                       case 'v':
                               ++verbosity;
                               break;
                       case 'd':
                               if (!directory) directory = strdup(optarg);
                               break;
                       case 'l':
                               isList = true;
                               break;
                       case 't':
                               if (!recode) recode = strdup(optarg);
                               break;
                       case 'h':
                       case '?':
                               show_help();
                               return 0;
               }
       }

       if (recode && !source) {
               if (verbosity >= NORMAL) {
                       fprintf(stderr, ERR_PREFIX "Source object must be specified with -s to be moved with -m.\n");
               }
               exit(EXIT_NO_FILE);
       }

       addresses = xmlNewNode(NULL, BAD_CAST "addresses");
       paths = xmlNewNode(NULL, BAD_CAST "paths");

       if (directory) {
               addDirectory(directory, addresses);
       }

       if (source) {
               addAddress(source, addresses);
       } else if (optind < argc) {
               for (i = optind; i < argc; ++i) {
                       if (isList) {
                               addAddressList(argv[i], addresses, paths);
                       } else {
                               addAddress(argv[i], addresses);
                       }
               }
       } else if (isList) {
               addAddressList(NULL, addresses, paths);
       }

       if (directory) {
               updateRefsDirectory(directory, addresses, contentOnly, recode, overwrite);
       } else if (optind < argc) {
               for (i = optind; i < argc; ++i) {
                       if (isList) {
                               updateRefsList(addresses, paths, contentOnly, recode, overwrite);
                       } else {
                               updateRefsFile(argv[i], addresses, contentOnly, recode, overwrite);
                       }
               }
       } else if (isList) {
               updateRefsList(addresses, paths, contentOnly, recode, overwrite);
       }

       free(source);
       free(directory);
       free(recode);

       xmlFreeNode(addresses);
       xmlFreeNode(paths);

       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.