#include <stdio.h>

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <stdbool.h>
#include <ctype.h>
#include <libgen.h>
#include <regex.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxslt/transform.h>
#include "s1kd_tools.h"
#include "xslt.h"
#include "elems.h"

#define PROG_NAME "s1kd-ref"
#define VERSION "3.8.0"

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

#define EXIT_MISSING_FILE 1
#define EXIT_BAD_INPUT 2
#define EXIT_BAD_ISSUE 3
#define EXIT_BAD_XPATH 4

#define OPT_TITLE (int) 0x001
#define OPT_ISSUE (int) 0x002
#define OPT_LANG (int) 0x004
#define OPT_DATE (int) 0x008
#define OPT_SRCID (int) 0x010
#define OPT_CIRID (int) 0x020
#define OPT_INS (int) 0x040
#define OPT_URL (int) 0x080
#define OPT_CONTENT (int) 0x100
#define OPT_NONSTRICT (int) 0x200

/* Regular expressions to match references. */

/* Common components */
#define ISSNO_REGEX "(_[0-9]{3}-[0-9]{2})?"
#define LANG_REGEX "(_[A-Z]{2}-[A-Z]{2})?"

/* Optional prefix */
#define DME_REGEX "(DME-)?[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT](-[0-9A-Z]{4})?" ISSNO_REGEX LANG_REGEX
#define DMC_REGEX "(DMC-)?[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT](-[0-9A-Z]{4})?" ISSNO_REGEX LANG_REGEX
#define CSN_REGEX "(CSN-)?[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT]"
#define PME_REGEX "(PME-)?[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define PMC_REGEX "(PMC-)?[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define SME_REGEX "(SME-)?[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define SMC_REGEX "(SMC-)?[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define COM_REGEX "(COM-)?[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9]{4}-[0-9]{5}-[QIR]" LANG_REGEX
#define DML_REGEX "(DML-)?[0-9A-Z]{2,14}-[0-9A-Z]{5}-[CPS]-[0-9]{4}-[0-9]{5}" ISSNO_REGEX

/* Mandatory prefix */
#define DME_REGEX_STRICT "DME-[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT](-[0-9A-Z]{4})?" ISSNO_REGEX LANG_REGEX
#define DMC_REGEX_STRICT "DMC-[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT](-[0-9A-Z]{4})?" ISSNO_REGEX LANG_REGEX
#define CSN_REGEX_STRICT "CSN-[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT]"
#define PME_REGEX_STRICT "PME-[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define PMC_REGEX_STRICT "PMC-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define SME_REGEX_STRICT "SME-[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define SMC_REGEX_STRICT "SMC-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX
#define COM_REGEX_STRICT "COM-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9]{4}-[0-9]{5}-[QIR]" LANG_REGEX
#define DML_REGEX_STRICT "DML-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[CPS]-[0-9]{4}-[0-9]{5}" ISSNO_REGEX
#define ICN_REGEX "(ICN-[A-Z0-9]{5}-[A-Z0-9]{5,10}-[0-9]{3}-[0-9]{2})|(ICN-[A-Z0-9]{2,14}-[A-Z0-9]{1,4}-[A-Z0-9]{6,9}-[A-Z0-9]{1}-[A-Z0-9]{5}-[A-Z0-9]{5}-[A-Z]{1}-[0-9]{2,3}-[0-9]{1,2})"

/* No prefix */
#define DME_REGEX_NOPRE "^[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT](-[0-9A-Z]{4})?" ISSNO_REGEX LANG_REGEX "$"
#define DMC_REGEX_NOPRE "^[0-9A-Z]{2,14}-[0-9A-Z]{1,4}-[0-9A-Z]{2,3}-[0-9A-Z]{2}-[0-9A-Z]{2,4}-[0-9A-Z]{3,5}-[0-9A-Z]{4}-[ABCDT](-[0-9A-Z]{4})?" ISSNO_REGEX LANG_REGEX "$"
#define PME_REGEX_NOPRE "^[0-9A-Z]+-[0-9A-Z]+-[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX "$"
#define PMC_REGEX_NOPRE "^[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9A-Z]{5}-[0-9]{2}" ISSNO_REGEX LANG_REGEX "$"
#define COM_REGEX_NOPRE "^[0-9A-Z]{2,14}-[0-9A-Z]{5}-[0-9]{4}-[0-9]{5}-[QIR]" LANG_REGEX "$"
#define DML_REGEX_NOPRE "^[0-9A-Z]{2,14}-[0-9A-Z]{5}-[CPS]-[0-9]{4}-[0-9]{5}" ISSNO_REGEX "$"

/* Issue of the S1000D specification to create references for. */
enum issue { ISS_20, ISS_21, ISS_22, ISS_23, ISS_30, ISS_40, ISS_41, ISS_42, ISS_50 };

#define DEFAULT_S1000D_ISSUE ISS_50

/* Verbosity of the program's output. */
static enum verbosity { QUIET, NORMAL, VERBOSE, DEBUG } verbosity = NORMAL;

/* Function for creating a new reference node. */
typedef xmlNodePtr (*newref_t)(const char *, const char *, int);

static xmlNode *find_child(xmlNode *parent, char *name)
{
xmlNode *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 xmlNodePtr first_xpath_node(xmlDocPtr doc, xmlNodePtr node, xmlChar *xpath)
{
xmlXPathContextPtr ctx;
xmlXPathObjectPtr obj;
xmlNodePtr first;

ctx = xmlXPathNewContext(doc ? doc : node->doc);
ctx->node = node;
obj = xmlXPathEvalExpression(xpath, ctx);

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

xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);

return first;
}

static xmlChar *first_xpath_value(xmlDocPtr doc, xmlNodePtr node, xmlChar *xpath)
{
return xmlNodeGetContent(first_xpath_node(doc, node, xpath));
}

static xmlNodePtr find_or_create_refs(xmlDocPtr doc)
{
xmlNodePtr refs;

refs = first_xpath_node(doc, NULL, BAD_CAST "//content//refs");

if (!refs) {
xmlNodePtr content, child;
content = first_xpath_node(doc, NULL, BAD_CAST "//content");
child = xmlFirstElementChild(content);
refs = xmlNewNode(NULL, BAD_CAST "refs");
if (child) {
refs = xmlAddPrevSibling(child, refs);
} else {
refs = xmlAddChild(content ,refs);
}
}

return refs;
}

static void dump_node(xmlNodePtr node, const char *dst)
{
xmlBufferPtr buf;
buf = xmlBufferCreate();
xmlNodeDump(buf, NULL, node, 0, 0);
if (strcmp(dst, "-") == 0) {
puts((char *) buf->content);
} else {
FILE *f;
f = fopen(dst, "w");
fputs((char *) buf->content, f);
fclose(f);
}
xmlBufferFree(buf);
}

static xmlNodePtr new_issue_info(char *s)
{
char n[4], w[3];
xmlNodePtr issue_info;

if (sscanf(s, "_%3[^-]-%2s", n, w) != 2) {
return NULL;
}

issue_info = xmlNewNode(NULL, BAD_CAST "issueInfo");
xmlSetProp(issue_info, BAD_CAST "issueNumber", BAD_CAST n);
xmlSetProp(issue_info, BAD_CAST "inWork", BAD_CAST w);

return issue_info;
}

static xmlNodePtr new_language(char *s)
{
char l[4], c[3];
xmlNodePtr language;

if (sscanf(s, "_%3[^-]-%2s", l, c) != 2) {
return NULL;
}

lowercase(l);

language = xmlNewNode(NULL, BAD_CAST "language");
xmlSetProp(language, BAD_CAST "languageIsoCode", BAD_CAST l);
xmlSetProp(language, BAD_CAST "countryIsoCode", BAD_CAST c);

return language;
}

static void set_xlink(xmlNodePtr node, const char *href)
{
xmlNsPtr xlink;
xlink = xmlNewNs(node, BAD_CAST "http://www.w3.org/1999/xlink", BAD_CAST "xlink");
xmlSetNsProp(node, xlink, BAD_CAST "href", BAD_CAST href);
}

#define SME_FMT "SME-%255[^-]-%255[^-]-%14[^-]-%5s-%5s-%2s"
#define SMC_FMT "SMC-%14[^-]-%5s-%5s-%2s"

static xmlNodePtr new_smc_ref(const char *ref, const char *fname, int opts)
{
char extension_producer[256] = "";
char extension_code[256] = "";
char model_ident_code[15] = "";
char smc_issuer[6] = "";
char smc_number[6] = "";
char smc_volume[3] = "";
xmlNode *smc_ref;
xmlNode *smc_ref_ident;
xmlNode *smc_code;
bool is_extended;
int n;

is_extended = strncmp(ref, "SME-", 4) == 0;

if (is_extended) {
n = sscanf(ref, SME_FMT,
extension_producer,
extension_code,
model_ident_code,
smc_issuer,
smc_number,
smc_volume);
if (n != 6) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "SCORM content package extended code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}
} else {
n = sscanf(ref, SMC_FMT,
model_ident_code,
smc_issuer,
smc_number,
smc_volume);
if (n != 4) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "SCORM content package code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}
}

smc_ref = xmlNewNode(NULL, BAD_CAST "scormContentPackageRef");
smc_ref_ident = xmlNewChild(smc_ref, NULL, BAD_CAST "scormContentPackageRefIdent", NULL);

if (is_extended) {
xmlNode *ident_extension;
ident_extension = xmlNewChild(smc_ref_ident, NULL, BAD_CAST "identExtension", NULL);
xmlSetProp(ident_extension, BAD_CAST "extensionProducer", BAD_CAST extension_producer);
xmlSetProp(ident_extension, BAD_CAST "extensionCode", BAD_CAST extension_code);
}

smc_code = xmlNewChild(smc_ref_ident, NULL, BAD_CAST "scormContentPackageCode", NULL);

xmlSetProp(smc_code, BAD_CAST "modelIdentCode", BAD_CAST model_ident_code);
xmlSetProp(smc_code, BAD_CAST "scormContentPackageIssuer", BAD_CAST smc_issuer);
xmlSetProp(smc_code, BAD_CAST "scormContentPackageNumber", BAD_CAST smc_number);
xmlSetProp(smc_code, BAD_CAST "scormContentPackageVolume", BAD_CAST smc_volume);

if (opts) {
xmlDocPtr doc;
xmlNodePtr ref_smc_address = NULL;
xmlNodePtr ref_smc_ident = NULL;
xmlNodePtr ref_smc_address_items = NULL;
xmlNodePtr ref_smc_title = NULL;
xmlNodePtr ref_smc_issue_date = NULL;
xmlNodePtr issue_info = NULL;
xmlNodePtr language = NULL;
char *s;

if ((doc = read_xml_doc(fname))) {
ref_smc_address = first_xpath_node(doc, NULL, BAD_CAST "//scormContentPackageAddress");
ref_smc_ident = find_child(ref_smc_address, "scormContentPackageIdent");
ref_smc_address_items = find_child(ref_smc_address, "scormContentPackageAddressItems");
ref_smc_title = find_child(ref_smc_address_items, "scormContentPackageTitle");
ref_smc_issue_date = find_child(ref_smc_address_items, "issueDate");
}

s = strchr(ref, '_');

if (optset(opts, OPT_ISSUE)) {
if (doc) {
issue_info = xmlCopyNode(find_child(ref_smc_ident, "issueInfo"), 1);
} else if (s && isdigit((unsigned char) s[1])) {
issue_info = new_issue_info(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read issue info from SCORM content package: %s\n", ref);
}
issue_info = NULL;
}

xmlAddChild(smc_ref_ident, issue_info);
}

if (optset(opts, OPT_LANG)) {
if (doc) {
language = xmlCopyNode(find_child(ref_smc_ident, "language"), 1);
} else if (s && (s = strchr(s + 1, '_'))) {
language = new_language(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read language from SCORM content package: %s\n", ref);
}
language = NULL;
}

xmlAddChild(smc_ref_ident, language);
}

if (optset(opts, OPT_TITLE) || optset(opts, OPT_DATE)) {
xmlNodePtr smc_ref_address_items = NULL, smc_title, issue_date;

if (doc) {
smc_ref_address_items = xmlNewChild(smc_ref, NULL, BAD_CAST "scormContentPackageRefAddressItems", NULL);
smc_title = ref_smc_title;
issue_date = ref_smc_issue_date;
} else {
smc_title = NULL;
issue_date = NULL;
}

if (optset(opts, OPT_TITLE)) {
if (smc_title) {
xmlAddChild(smc_ref_address_items, xmlCopyNode(smc_title, 1));
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read title from SCORM content package: %s\n", ref);
}
}
}
if (optset(opts, OPT_DATE)) {
if (issue_date) {
xmlAddChild(smc_ref_address_items, xmlCopyNode(issue_date, 1));
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read date from SCORM content package: %s\n", ref);
}
}
}
}

xmlFreeDoc(doc);

if (optset(opts, OPT_SRCID)) {
xmlNodePtr smc, issno, lang, src;

smc = xmlCopyNode(smc_code, 1);
issno = xmlCopyNode(issue_info, 1);
lang = xmlCopyNode(language, 1);

src = xmlNewNode(NULL, BAD_CAST "sourceScormContentPackageIdent");
xmlAddChild(src, smc);
xmlAddChild(src, lang);
xmlAddChild(src, issno);

xmlFreeNode(smc_ref);
smc_ref = src;
}

if (optset(opts, OPT_URL)) {
set_xlink(smc_ref, fname);
}
}

return smc_ref;
}

#define PME_FMT "PME-%255[^-]-%255[^-]-%14[^-]-%5s-%5s-%2s"
#define PMC_FMT "PMC-%14[^-]-%5s-%5s-%2s"

static xmlNodePtr new_pm_ref(const char *ref, const char *fname, int opts)
{
char extension_producer[256] = "";
char extension_code[256] = "";
char model_ident_code[15] = "";
char pm_issuer[6] = "";
char pm_number[6] = "";
char pm_volume[3] = "";
xmlNode *pm_ref;
xmlNode *pm_ref_ident;
xmlNode *pm_code;
bool is_extended;
int n;

is_extended = strncmp(ref, "PME-", 4) == 0;

if (is_extended) {
n = sscanf(ref, PME_FMT,
extension_producer,
extension_code,
model_ident_code,
pm_issuer,
pm_number,
pm_volume);
if (n != 6) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Publication module extended code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}
} else {
n = sscanf(ref, PMC_FMT,
model_ident_code,
pm_issuer,
pm_number,
pm_volume);
if (n != 4) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Publication module code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}
}

pm_ref = xmlNewNode(NULL, BAD_CAST "pmRef");
pm_ref_ident = xmlNewChild(pm_ref, NULL, BAD_CAST "pmRefIdent", NULL);

if (is_extended) {
xmlNode *ident_extension;
ident_extension = xmlNewChild(pm_ref_ident, NULL, BAD_CAST "identExtension", NULL);
xmlSetProp(ident_extension, BAD_CAST "extensionProducer", BAD_CAST extension_producer);
xmlSetProp(ident_extension, BAD_CAST "extensionCode", BAD_CAST extension_code);
}

pm_code = xmlNewChild(pm_ref_ident, NULL, BAD_CAST "pmCode", NULL);

xmlSetProp(pm_code, BAD_CAST "modelIdentCode", BAD_CAST model_ident_code);
xmlSetProp(pm_code, BAD_CAST "pmIssuer", BAD_CAST pm_issuer);
xmlSetProp(pm_code, BAD_CAST "pmNumber", BAD_CAST pm_number);
xmlSetProp(pm_code, BAD_CAST "pmVolume", BAD_CAST pm_volume);

if (opts) {
xmlDocPtr doc;
xmlNodePtr ref_pm_address = NULL;
xmlNodePtr ref_pm_ident = NULL;
xmlNodePtr ref_pm_address_items = NULL;
xmlNodePtr ref_pm_title = NULL;
xmlNodePtr ref_pm_issue_date = NULL;
xmlNodePtr issue_info = NULL;
xmlNodePtr language = NULL;
char *s;

if ((doc = read_xml_doc(fname))) {
ref_pm_address = first_xpath_node(doc, NULL, BAD_CAST "//pmAddress|//pmaddres");

if (xmlStrcmp(ref_pm_address->name, BAD_CAST "pmaddres") == 0) {
ref_pm_ident = ref_pm_address;
ref_pm_address_items = ref_pm_address;
ref_pm_title = find_child(ref_pm_address_items, "pmtitle");
ref_pm_issue_date = find_child(ref_pm_address_items, "issdate");
} else {
ref_pm_ident = find_child(ref_pm_address, "pmIdent");
ref_pm_address_items = find_child(ref_pm_address, "pmAddressItems");
ref_pm_title = find_child(ref_pm_address_items, "pmTitle");
ref_pm_issue_date = find_child(ref_pm_address_items, "issueDate");
}
}

s = strchr(ref, '_');

if (optset(opts, OPT_ISSUE)) {
if (doc) {
xmlNodePtr node;
xmlChar *issno, *inwork;

node = first_xpath_node(doc, ref_pm_ident, BAD_CAST "issueInfo|issno");
issno = first_xpath_value(doc, node, BAD_CAST "@issueNumber|@issno");
inwork = first_xpath_value(doc, node, BAD_CAST "@inWork|@inwork");
if (!inwork) inwork = xmlStrdup(BAD_CAST "00");

issue_info = xmlNewNode(NULL, BAD_CAST "issueInfo");
xmlSetProp(issue_info, BAD_CAST "issueNumber", issno);
xmlSetProp(issue_info, BAD_CAST "inWork", inwork);

xmlFree(issno);
xmlFree(inwork);
} else if (s && isdigit((unsigned char) s[1])) {
issue_info = new_issue_info(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read issue info from publication module: %s\n", ref);
}
issue_info = NULL;
}

xmlAddChild(pm_ref_ident, issue_info);
}

if (optset(opts, OPT_LANG)) {
if (doc) {
xmlNodePtr node;
xmlChar *l, *c;

node = find_child(ref_pm_ident, "language");
l = first_xpath_value(doc, node, BAD_CAST "@languageIsoCode|@language");
c = first_xpath_value(doc, node, BAD_CAST "@countryIsoCode|@country");

language = xmlNewNode(NULL, BAD_CAST "language");
xmlSetProp(language, BAD_CAST "languageIsoCode", l);
xmlSetProp(language, BAD_CAST "countryIsoCode", c);

xmlFree(l);
xmlFree(c);
} else if (s && (s = strchr(s + 1, '_'))) {
language = new_language(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read language from publication module: %s\n", ref);
}
language = NULL;
}

xmlAddChild(pm_ref_ident, language);
}

if (optset(opts, OPT_TITLE) || optset(opts, OPT_DATE)) {
xmlNodePtr pm_ref_address_items = NULL, pm_title, issue_date;

if (doc) {
pm_ref_address_items = xmlNewChild(pm_ref, NULL, BAD_CAST "pmRefAddressItems", NULL);
pm_title = ref_pm_title;
issue_date = ref_pm_issue_date;
} else {
pm_title = NULL;
issue_date = NULL;
}

if (optset(opts, OPT_TITLE)) {
if (pm_title) {
pm_title = xmlAddChild(pm_ref_address_items, xmlCopyNode(pm_title, 1));
xmlNodeSetName(pm_title, BAD_CAST "pmTitle");
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read title from publication module: %s\n", ref);
}
}
}
if (optset(opts, OPT_DATE)) {
if (issue_date) {
issue_date = xmlAddChild(pm_ref_address_items, xmlCopyNode(issue_date, 1));
xmlNodeSetName(issue_date, BAD_CAST "issueDate");
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read date from publication module: %s\n", ref);
}
}
}
}

xmlFreeDoc(doc);

if (optset(opts, OPT_SRCID)) {
xmlNodePtr pmc, issno, lang, src;

pmc = xmlCopyNode(pm_code, 1);
issno = xmlCopyNode(issue_info, 1);
lang = xmlCopyNode(language, 1);

src = xmlNewNode(NULL, BAD_CAST "sourcePmIdent");
xmlAddChild(src, pmc);
xmlAddChild(src, lang);
xmlAddChild(src, issno);

xmlFreeNode(pm_ref);
pm_ref = src;
}

if (optset(opts, OPT_URL)) {
set_xlink(pm_ref, fname);
}
}

return pm_ref;
}

#define DME_FMT "DME-%255[^-]-%255[^-]-%14[^-]-%4[^-]-%3[^-]-%1s%1s-%4[^-]-%2s%3[^-]-%3s%1s-%1s-%3s%1s"
#define DMC_FMT "DMC-%14[^-]-%4[^-]-%3[^-]-%1s%1s-%4[^-]-%2s%3[^-]-%3s%1s-%1s-%3s%1s"

static xmlNodePtr new_dm_ref(const char *ref, const char *fname, int opts)
{
char extension_producer[256] = "";
char extension_code[256] = "";
char model_ident_code[15] = "";
char system_diff_code[5] = "";
char system_code[4] = "";
char assy_code[5] = "";
char item_location_code[2] = "";
char learn_code[4] = "";
char learn_event_code[2] = "";
char sub_system_code[2] = "";
char sub_sub_system_code[2] = "";
char disassy_code[3] = "";
char disassy_code_variant[4] = "";
char info_code[4] = "";
char info_code_variant[2] = "";
xmlNode *dm_ref;
xmlNode *dm_ref_ident;
xmlNode *dm_code;
bool is_extended;
bool has_learn;
int n;

is_extended = strncmp(ref, "DME-", 4) == 0;

if (is_extended) {
n = sscanf(ref, DME_FMT,
extension_producer,
extension_code,
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_code,
learn_event_code);
if (n != 15 && n != 13) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Data module extended code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}
has_learn = n == 15;
} else {
n = sscanf(ref, DMC_FMT,
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_code,
learn_event_code);
if (n != 13 && n != 11) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Data module code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}
has_learn = n == 13;
}

dm_ref = xmlNewNode(NULL, BAD_CAST "dmRef");
dm_ref_ident = xmlNewChild(dm_ref, NULL, BAD_CAST "dmRefIdent", NULL);

if (is_extended) {
xmlNode *ident_extension;
ident_extension = xmlNewChild(dm_ref_ident, NULL, BAD_CAST "identExtension", NULL);
xmlSetProp(ident_extension, BAD_CAST "extensionProducer", BAD_CAST extension_producer);
xmlSetProp(ident_extension, BAD_CAST "extensionCode", BAD_CAST extension_code);
}

dm_code = xmlNewChild(dm_ref_ident, NULL, BAD_CAST "dmCode", NULL);

xmlSetProp(dm_code, BAD_CAST "modelIdentCode", BAD_CAST model_ident_code);
xmlSetProp(dm_code, BAD_CAST "systemDiffCode", BAD_CAST system_diff_code);
xmlSetProp(dm_code, BAD_CAST "systemCode", BAD_CAST system_code);
xmlSetProp(dm_code, BAD_CAST "subSystemCode", BAD_CAST sub_system_code);
xmlSetProp(dm_code, BAD_CAST "subSubSystemCode", BAD_CAST sub_sub_system_code);
xmlSetProp(dm_code, BAD_CAST "assyCode", BAD_CAST assy_code);
xmlSetProp(dm_code, BAD_CAST "disassyCode", BAD_CAST disassy_code);
xmlSetProp(dm_code, BAD_CAST "disassyCodeVariant", BAD_CAST disassy_code_variant);
xmlSetProp(dm_code, BAD_CAST "infoCode", BAD_CAST info_code);
xmlSetProp(dm_code, BAD_CAST "infoCodeVariant", BAD_CAST info_code_variant);
xmlSetProp(dm_code, BAD_CAST "itemLocationCode", BAD_CAST item_location_code);
if (has_learn) {
xmlSetProp(dm_code, BAD_CAST "learnCode", BAD_CAST learn_code);
xmlSetProp(dm_code, BAD_CAST "learnEventCode", BAD_CAST learn_event_code);
}

if (opts) {
xmlDocPtr doc;
xmlNodePtr ref_dm_address = NULL;
xmlNodePtr ref_dm_ident = NULL;
xmlNodePtr ref_dm_address_items = NULL;
xmlNodePtr ref_dm_title = NULL;
xmlNodePtr ref_dm_issue_date = NULL;
xmlNodePtr issue_info = NULL;
xmlNodePtr language = NULL;
char *s;

if ((doc = read_xml_doc(fname))) {
ref_dm_address = first_xpath_node(doc, NULL, BAD_CAST "//dmAddress|//dmaddres");

if (xmlStrcmp(ref_dm_address->name, BAD_CAST "dmaddres") == 0) {
ref_dm_ident = ref_dm_address;
ref_dm_address_items = ref_dm_address;
ref_dm_title = find_child(ref_dm_address_items, "dmtitle");
ref_dm_issue_date = find_child(ref_dm_address_items, "issdate");
} else {
ref_dm_ident = find_child(ref_dm_address, "dmIdent");
ref_dm_address_items = find_child(ref_dm_address, "dmAddressItems");
ref_dm_title = find_child(ref_dm_address_items, "dmTitle");
ref_dm_issue_date = find_child(ref_dm_address_items, "issueDate");
}
}

s = strchr(ref, '_');

if (optset(opts, OPT_ISSUE)) {
if (doc) {
xmlNodePtr node;
xmlChar *issno, *inwork;

node = first_xpath_node(doc, ref_dm_ident, BAD_CAST "issueInfo|issno");
issno = first_xpath_value(doc, node, BAD_CAST "@issueNumber|@issno");
inwork = first_xpath_value(doc, node, BAD_CAST "@inWork|@inwork");
if (!inwork) inwork = xmlStrdup(BAD_CAST "00");

issue_info = xmlNewNode(NULL, BAD_CAST "issueInfo");
xmlSetProp(issue_info, BAD_CAST "issueNumber", issno);
xmlSetProp(issue_info, BAD_CAST "inWork", inwork);

xmlFree(issno);
xmlFree(inwork);
} else if (s && isdigit((unsigned char) s[1])) {
issue_info = new_issue_info(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read issue info from data module: %s\n", ref);
}
issue_info = NULL;
}

xmlAddChild(dm_ref_ident, issue_info);
}

if (optset(opts, OPT_LANG)) {
if (doc) {
xmlNodePtr node;
xmlChar *l, *c;

node = find_child(ref_dm_ident, "language");
l = first_xpath_value(doc, node, BAD_CAST "@languageIsoCode|@language");
c = first_xpath_value(doc, node, BAD_CAST "@countryIsoCode|@country");

language = xmlNewNode(NULL, BAD_CAST "language");
xmlSetProp(language, BAD_CAST "languageIsoCode", l);
xmlSetProp(language, BAD_CAST "countryIsoCode", c);

xmlFree(l);
xmlFree(c);
} else if (s && (s = strchr(s + 1, '_'))) {
language = new_language(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read language from data module: %s\n", ref);
}
language = NULL;
}

xmlAddChild(dm_ref_ident, language);
}

if (optset(opts, OPT_TITLE) || optset(opts, OPT_DATE)) {
xmlNodePtr dm_ref_address_items = NULL, dm_title = NULL, issue_date = NULL;

if (doc) {
dm_ref_address_items = xmlNewChild(dm_ref, NULL, BAD_CAST "dmRefAddressItems", NULL);

if (optset(opts, OPT_TITLE)) {
xmlChar *tech, *info, *infv;

tech = first_xpath_value(doc, ref_dm_title, BAD_CAST "techName|techname");
info = first_xpath_value(doc, ref_dm_title, BAD_CAST "infoName|infoname");
infv = first_xpath_value(doc, ref_dm_title, BAD_CAST "infoNameVariant");

dm_title = xmlNewNode(NULL, BAD_CAST "dmTitle");
xmlNewTextChild(dm_title, NULL, BAD_CAST "techName", tech);
if (info) xmlNewTextChild(dm_title, NULL, BAD_CAST "infoName", info);
if (infv) xmlNewTextChild(dm_title, NULL, BAD_CAST "infoNameVariant", infv);

xmlFree(tech);
xmlFree(info);
xmlFree(infv);
}

if (optset(opts, OPT_DATE)) {
issue_date = xmlCopyNode(ref_dm_issue_date, 1);
xmlNodeSetName(issue_date, BAD_CAST "issueDate");
}

}

if (optset(opts, OPT_TITLE)) {
if (dm_title) {
xmlAddChild(dm_ref_address_items, dm_title);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read title from data module: %s\n", ref);
}
}
}
if (optset(opts, OPT_DATE)) {
if (issue_date) {
xmlAddChild(dm_ref_address_items, issue_date);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read issue date from data module: %s\n", ref);
}
}
}
}

xmlFreeDoc(doc);

if (optset(opts, OPT_SRCID)) {
xmlNodePtr dmc, issno, lang, src;

dmc = xmlCopyNode(dm_code, 1);
issno = xmlCopyNode(issue_info, 1);
lang = xmlCopyNode(language, 1);

src = xmlNewNode(NULL, BAD_CAST (optset(opts, OPT_CIRID) ? "repositorySourceDmIdent" : "sourceDmIdent"));
xmlAddChild(src, dmc);
xmlAddChild(src, lang);
xmlAddChild(src, issno);

xmlFreeNode(dm_ref);
dm_ref = src;
}

if (optset(opts, OPT_URL)) {
set_xlink(dm_ref, fname);
}
}

return dm_ref;
}

#define COM_FMT "COM-%14[^-]-%5s-%4s-%5s-%1s"

static xmlNodePtr new_com_ref(const char *ref, const char *fname, int opts)
{
char model_ident_code[15] = "";
char sender_ident[6] = "";
char year_of_data_issue[5] = "";
char seq_number[6] = "";
char comment_type[2] = "";

int n;

xmlNodePtr comment_ref, comment_ref_ident, comment_code;

n = sscanf(ref, COM_FMT,
model_ident_code,
sender_ident,
year_of_data_issue,
seq_number,
comment_type);
if (n != 5) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Comment code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}

lowercase(comment_type);

comment_ref = xmlNewNode(NULL, BAD_CAST "commentRef");
comment_ref_ident = xmlNewChild(comment_ref, NULL, BAD_CAST "commentRefIdent", NULL);
comment_code = xmlNewChild(comment_ref_ident, NULL, BAD_CAST "commentCode", NULL);

xmlSetProp(comment_code, BAD_CAST "modelIdentCode", BAD_CAST model_ident_code);
xmlSetProp(comment_code, BAD_CAST "senderIdent", BAD_CAST sender_ident);
xmlSetProp(comment_code, BAD_CAST "yearOfDataIssue", BAD_CAST year_of_data_issue);
xmlSetProp(comment_code, BAD_CAST "seqNumber", BAD_CAST seq_number);
xmlSetProp(comment_code, BAD_CAST "commentType", BAD_CAST comment_type);

if (opts) {
xmlDocPtr doc;
xmlNodePtr ref_comment_address;
xmlNodePtr ref_comment_ident;
char *s;

if ((doc = read_xml_doc(fname))) {
ref_comment_address = first_xpath_node(doc, NULL, BAD_CAST "//commentAddress");
ref_comment_ident = find_child(ref_comment_address, "commentIdent");
}

s = strchr(ref, '_');

if (optset(opts, OPT_LANG)) {
xmlNodePtr language;

if (doc) {
language = xmlCopyNode(find_child(ref_comment_ident, "language"), 1);
} else if (s && (s = strchr(s + 1, '_'))) {
language = new_language(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read language from comment: %s\n", ref);
}
language = NULL;
}

xmlAddChild(comment_ref_ident, language);
}

xmlFreeDoc(doc);

if (optset(opts, OPT_URL)) {
set_xlink(comment_ref, fname);
}
}

return comment_ref;
}

#define DML_FMT "DML-%14[^-]-%5s-%1s-%4s-%5s"

static xmlNodePtr new_dml_ref(const char *ref, const char *fname, int opts)
{
char model_ident_code[15] = "";
char sender_ident[6] = "";
char dml_type[2] = "";
char year_of_data_issue[5] = "";
char seq_number[6] = "";

int n;

xmlNodePtr dml_ref, dml_ref_ident, dml_code;

n = sscanf(ref, DML_FMT,
model_ident_code,
sender_ident,
dml_type,
year_of_data_issue,
seq_number);
if (n != 5) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "DML code invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}

lowercase(dml_type);

dml_ref = xmlNewNode(NULL, BAD_CAST "dmlRef");
dml_ref_ident = xmlNewChild(dml_ref, NULL, BAD_CAST "dmlRefIdent", NULL);
dml_code = xmlNewChild(dml_ref_ident, NULL, BAD_CAST "dmlCode", NULL);

xmlSetProp(dml_code, BAD_CAST "modelIdentCode", BAD_CAST model_ident_code);
xmlSetProp(dml_code, BAD_CAST "senderIdent", BAD_CAST sender_ident);
xmlSetProp(dml_code, BAD_CAST "dmlType", BAD_CAST dml_type);
xmlSetProp(dml_code, BAD_CAST "yearOfDataIssue", BAD_CAST year_of_data_issue);
xmlSetProp(dml_code, BAD_CAST "seqNumber", BAD_CAST seq_number);

if (opts) {
xmlDocPtr doc;
xmlNodePtr ref_dml_address;
xmlNodePtr ref_dml_ident;
char *s;

if ((doc = read_xml_doc(fname))) {
ref_dml_address = first_xpath_node(doc, NULL, BAD_CAST "//dmlAddress");
ref_dml_ident = find_child(ref_dml_address, "dmlIdent");
}

s = strchr(ref, '_');

if (optset(opts, OPT_ISSUE)) {
xmlNodePtr issue_info;

if (doc) {
issue_info = xmlCopyNode(find_child(ref_dml_ident, "issueInfo"), 1);
} else if (s && isdigit((unsigned char) s[1])) {
issue_info = new_issue_info(s);
} else {
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Could not read issue info from DML: %s\n", ref);
}
issue_info = NULL;
}

xmlAddChild(dml_ref_ident, issue_info);
}

xmlFreeDoc(doc);

if (optset(opts, OPT_URL)) {
set_xlink(dml_ref, fname);
}
}

return dml_ref;
}

static xmlNodePtr new_icn_ref(const char *ref, const char *fname, int opts)
{
xmlNodePtr info_entity_ref;

info_entity_ref = xmlNewNode(NULL, BAD_CAST "infoEntityRef");

xmlSetProp(info_entity_ref, BAD_CAST "infoEntityRefIdent", BAD_CAST ref);

return info_entity_ref;
}

#define CSN_FMT "CSN-%14[^-]-%4[^-]-%3[^-]-%1s%1s-%4[^-]-%2s%3[^-]-%3s%1s-%1s"

static xmlNodePtr new_csn_ref(const char *ref, const char *fname, int opts)
{
char model_ident_code[15] = "";
char system_diff_code[5] = "";
char system_code[4] = "";
char assy_code[5] = "";
char item_location_code[2] = "";
char sub_system_code[2] = "";
char sub_sub_system_code[2] = "";
char figure_number[3] = "";
char figure_number_variant[4] = "";
char item[4] = "";
char item_variant[2] = "";
xmlNode *csn_ref;
int n;

n = sscanf(ref, CSN_FMT,
model_ident_code,
system_diff_code,
system_code,
sub_system_code,
sub_sub_system_code,
assy_code,
figure_number,
figure_number_variant,
item,
item_variant,
item_location_code);
if (n != 11) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "CSN invalid: %s\n", ref);
}
exit(EXIT_BAD_INPUT);
}

csn_ref = xmlNewNode(NULL, BAD_CAST "catalogSeqNumberRef");

xmlSetProp(csn_ref, BAD_CAST "modelIdentCode", BAD_CAST model_ident_code);
xmlSetProp(csn_ref, BAD_CAST "systemDiffCode", BAD_CAST system_diff_code);
xmlSetProp(csn_ref, BAD_CAST "systemCode", BAD_CAST system_code);
xmlSetProp(csn_ref, BAD_CAST "subSystemCode", BAD_CAST sub_system_code);
xmlSetProp(csn_ref, BAD_CAST "subSubSystemCode", BAD_CAST sub_sub_system_code);
xmlSetProp(csn_ref, BAD_CAST "assyCode", BAD_CAST assy_code);
xmlSetProp(csn_ref, BAD_CAST "figureNumber", BAD_CAST figure_number);
if (strcmp(figure_number_variant, "*") != 0) {
xmlSetProp(csn_ref, BAD_CAST "figureNumberVariant", BAD_CAST figure_number_variant);
}
xmlSetProp(csn_ref, BAD_CAST "item", BAD_CAST item);
if (strcmp(item_variant, "*") != 0) {
xmlSetProp(csn_ref, BAD_CAST "itemVariant", BAD_CAST item_variant);
}
xmlSetProp(csn_ref, BAD_CAST "itemLocationCode", BAD_CAST item_location_code);

if (optset(opts, OPT_URL)) {
set_xlink(csn_ref, fname);
}

return csn_ref;
}

static bool is_smc_ref(const char *ref)
{
return strncmp(ref, "SMC-", 4) == 0 || strncmp(ref, "SME-", 4) == 0;
}

static bool is_pm_ref(const char *ref)
{
return strncmp(ref, "PMC-", 4) == 0 || strncmp(ref, "PME-", 4) == 0;
}

static bool is_dm_ref(const char *ref)
{
return strncmp(ref, "DMC-", 4) == 0 || strncmp(ref, "DME-", 4) == 0;
}

static bool is_com_ref(const char *ref)
{
return strncmp(ref, "COM-", 4) == 0;
}

static bool is_dml_ref(const char *ref)
{
return strncmp(ref, "DML-", 4) == 0;
}

static bool is_icn_ref(const char *ref)
{
return strncmp(ref, "ICN-", 4) == 0;
}

static bool is_csn_ref(const char *ref)
{
return strncmp(ref, "CSN-", 4) == 0;
}

static void add_ref(const char *src, const char *dst, xmlNodePtr ref, int opts)
{
xmlDocPtr doc;
xmlNodePtr refs;

if (!(doc = read_xml_doc(src))) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Could not read source data module: %s\n", src);
}
exit(EXIT_MISSING_FILE);
}

if (optset(opts, OPT_SRCID)) {
xmlNodePtr src, node;

src = first_xpath_node(doc, NULL, BAD_CAST "//dmStatus/sourceDmIdent|//pmStatus/sourcePmIdent|//status/srcdmaddres");
node = first_xpath_node(doc, NULL, BAD_CAST "(//dmStatus/repositorySourceDmIdent|//dmStatus/security|//pmStatus/security|//status/security)[1]");
if (node) {
if (src) {
xmlUnlinkNode(src);
xmlFreeNode(src);
}
xmlAddPrevSibling(node, xmlCopyNode(ref, 1));
}
} else {
refs = find_or_create_refs(doc);
xmlAddChild(refs, xmlCopyNode(ref, 1));
}

save_xml_doc(doc, dst);

xmlFreeDoc(doc);
}

/* Apply a built-in XSLT transform to a doc in place. */
static void transform_doc(xmlDocPtr doc, unsigned char *xsl, unsigned int len)
{
xmlDocPtr styledoc, src, res;
xsltStylesheetPtr style;
xmlNodePtr old;

src = xmlCopyDoc(doc, 1);

styledoc = read_xml_mem((const char *) xsl, len);
style = xsltParseStylesheetDoc(styledoc);

res = xsltApplyStylesheet(style, src, NULL);

old = xmlDocSetRootElement(doc, xmlCopyNode(xmlDocGetRootElement(res), 1));
xmlFreeNode(old);

xmlFreeDoc(src);
xmlFreeDoc(res);
xsltFreeStylesheet(style);
}

static xmlNodePtr find_ext_pub(xmlDocPtr extpubs, const char *ref)
{
xmlChar xpath[512];
xmlNodePtr node;

/* Attempt to match an exact code (e.g., "ABC") */
xmlStrPrintf(xpath, 512, "//externalPubRef[externalPubRefIdent/externalPubCode='%s']", ref);
node = first_xpath_node(extpubs, NULL, xpath);

/* Attempt to match a file name (e.g., "ABC.PDF") */
if (!node) {
xmlStrPrintf(xpath, 512, "//externalPubRef[starts-with('%s', externalPubRefIdent/externalPubCode)]", ref);
node = first_xpath_node(extpubs, NULL, xpath);
}

return xmlCopyNode(node, 1);
}

static xmlNodePtr new_ext_pub(const char *ref, const char *fname, int opts)
{
xmlNodePtr epr, epr_ident;

epr = xmlNewNode(NULL, BAD_CAST "externalPubRef");
epr_ident = xmlNewChild(epr, NULL, BAD_CAST "externalPubRefIdent", NULL);

if (optset(opts, OPT_TITLE)) {
xmlNewTextChild(epr_ident, NULL, BAD_CAST "externalPubTitle", BAD_CAST ref);
} else {
xmlNewTextChild(epr_ident, NULL, BAD_CAST "externalPubCode", BAD_CAST ref);
}

if (optset(opts, OPT_URL)) {
set_xlink(epr, fname);
}

return epr;
}

static xmlNodePtr find_ref_type(const char *fname, int opts)
{
xmlDocPtr doc, styledoc, res;
xsltStylesheetPtr style;
xmlNodePtr node = NULL;

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

styledoc = read_xml_mem((const char *) ref_xsl, ref_xsl_len);
style = xsltParseStylesheetDoc(styledoc);

res = xsltApplyStylesheet(style, doc, NULL);

if (res->children) {
const char *ref;
xmlNodePtr (*f)(const char *, const char *, int) = NULL;

ref = (char *) res->children->content;

if (is_dm_ref(ref)) {
f = new_dm_ref;
} else if (is_pm_ref(ref)) {
f = new_pm_ref;
} else if (is_smc_ref(ref)) {
f = new_smc_ref;
} else if (is_com_ref(ref)) {
f = new_com_ref;
} else if (is_dml_ref(ref)) {
f = new_dml_ref;
} else if (is_icn_ref(ref)) {
f = new_icn_ref;
}

if (f) {
node = f(ref, fname, opts);
}
}

xmlFreeDoc(res);
xsltFreeStylesheet(style);

xmlFreeDoc(doc);

return node;
}

/* Determine whether a string is matched by a regular expression. */
static bool matches_regex(const char *s, const char *regex)
{
regex_t re;
bool match;
regcomp(&re, regex, REG_EXTENDED);
match = regexec(&re, s, 0, NULL, 0) == 0;
regfree(&re);
return match;
}

/* Attempt to automatically add the prefix to a ref. */
static char *add_prefix(const char *ref)
{
int n = strlen(ref) + 5;
char *s = malloc(n);

/* Notes:
* Check against extended variants (DME, PME, SME) before
* non-extended variants (DMC, PMC, SMC).
*
* There is no need to check for CSN, SME or SMC, as these are
* indistinguishable from DMC, PME and PMC without a prefix or an
* XML context.
*/
if (matches_regex(ref, DME_REGEX_NOPRE)) {
snprintf(s, n, "DME-%s", ref);
} else if (matches_regex(ref, DMC_REGEX_NOPRE)) {
snprintf(s, n, "DMC-%s", ref);
} else if (matches_regex(ref, PME_REGEX_NOPRE)) {
snprintf(s, n, "PME-%s", ref);
} else if (matches_regex(ref, PMC_REGEX_NOPRE)) {
snprintf(s, n, "PMC-%s", ref);
} else if (matches_regex(ref, COM_REGEX_NOPRE)) {
snprintf(s, n, "COM-%s", ref);
} else if (matches_regex(ref, DML_REGEX_NOPRE)) {
snprintf(s, n, "DML-%s", ref);
} else {
snprintf(s, n, "%s", ref);
}

return s;
}

static void print_ref(const char *src, const char *dst, const char *ref,
const char *fname, int opts, bool overwrite, enum issue iss,
xmlDocPtr extpubs)
{
xmlNodePtr node;
xmlNodePtr (*f)(const char *, const char *, int);
char *fullref;

/* If -p is given, try automatically adding the prefix. */
if (optset(opts, OPT_NONSTRICT)) {
fullref = add_prefix(ref);
/* Otherwise, just copy the ref as-is. */
} else {
fullref = strdup(ref);
}

if (is_dm_ref(fullref)) {
f = new_dm_ref;
} else if (is_pm_ref(fullref)) {
f = new_pm_ref;
} else if (is_smc_ref(fullref)) {
f = new_smc_ref;
} else if (is_com_ref(fullref)) {
f = new_com_ref;
} else if (is_dml_ref(fullref)) {
f = new_dml_ref;
} else if (is_icn_ref(fullref)) {
f = new_icn_ref;
} else if (is_csn_ref(fullref)) {
f = new_csn_ref;
} else if (extpubs && (node = find_ext_pub(extpubs, fullref))) {
f = NULL;
} else if ((node = find_ref_type(fname, opts))) {
f = NULL;
} else {
f = new_ext_pub;
}

if (f) {
node = f(fullref, fname, opts);
}

if (iss < DEFAULT_S1000D_ISSUE) {
unsigned char *xsl;
unsigned int len;
xmlDocPtr doc;

switch (iss) {
case ISS_20:
xsl = ___common_to20_xsl;
len = ___common_to20_xsl_len;
break;
case ISS_21:
xsl = ___common_to21_xsl;
len = ___common_to21_xsl_len;
break;
case ISS_22:
xsl = ___common_to22_xsl;
len = ___common_to22_xsl_len;
break;
case ISS_23:
xsl = ___common_to23_xsl;
len = ___common_to23_xsl_len;
break;
case ISS_30:
xsl = ___common_to30_xsl;
len = ___common_to30_xsl_len;
break;
case ISS_40:
xsl = ___common_to40_xsl;
len = ___common_to40_xsl_len;
break;
case ISS_41:
xsl = ___common_to41_xsl;
len = ___common_to41_xsl_len;
break;
case ISS_42:
xsl = ___common_to42_xsl;
len = ___common_to42_xsl_len;
break;
default:
xsl = NULL;
len = 0;
break;
}

doc = xmlNewDoc(BAD_CAST "1.0");
xmlDocSetRootElement(doc, node);

transform_doc(doc, xsl, len);

node = xmlCopyNode(xmlDocGetRootElement(doc), 1);

xmlFreeDoc(doc);
}

if (optset(opts, OPT_INS)) {
if (verbosity >= VERBOSE) {
fprintf(stderr, INF_PREFIX "Adding reference %s to %s...\n", fullref, src);
}

if (overwrite) {
add_ref(src, src, node, opts);
} else {
add_ref(src, dst, node, opts);
}
} else {
dump_node(node, dst);
}

xmlFreeNode(node);
free(fullref);
}

static char *trim(char *str)
{
char *end;

while (isspace((unsigned char) *str)) str++;

if (*str == 0) return str;

end = str + strlen(str) - 1;
while (end > str && isspace((unsigned char) *end)) end--;

*(end + 1) = 0;

return str;
}

static enum issue spec_issue(const char *s)
{
if (strcmp(s, "2.0") == 0) {
return ISS_20;
} else if (strcmp(s, "2.1") == 0) {
return ISS_21;
} else if (strcmp(s, "2.2") == 0) {
return ISS_22;
} else if (strcmp(s, "2.3") == 0) {
return ISS_23;
} else if (strcmp(s, "3.0") == 0) {
return ISS_30;
} else if (strcmp(s, "4.0") == 0) {
return ISS_40;
} else if (strcmp(s, "4.1") == 0) {
return ISS_41;
} else if (strcmp(s, "4.2") == 0) {
return ISS_42;
} else if (strcmp(s, "5.0") == 0) {
return ISS_50;
}

if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Unsupported issue: %s\n", s);
}
exit(EXIT_BAD_ISSUE);
}

/* Skip a reference if it has a conflicting prefix. */
static bool skip_confl_ref(xmlNodePtr *node, xmlChar **content, regoff_t so, regoff_t eo, const char *pre)
{
xmlChar *p = (*content) + so - 4;

if (p > (*content) && (xmlStrncmp(p, BAD_CAST pre, 4) == 0)) {
xmlChar *s1, *s2;

s1 = xmlStrndup((*content), eo);
s2 = xmlStrdup((*content) + eo);

xmlFree(*content);
xmlNodeSetContent(*node, s1);
xmlFree(s1);

*node = xmlAddNextSibling(*node, xmlNewText(s2));
*content = s2;

return true;
}

return false;
}

/* Replace a textual reference with XML. */
static void transform_ref(xmlNodePtr *node, const char *path, xmlChar **content, regoff_t so, regoff_t eo, const char *prefix, newref_t f, int opts)
{
xmlChar *r, *s1, *s2;
xmlNodePtr ref;

if (verbosity >= DEBUG) {
const char *type;

if (f == new_dm_ref) {
type = "DM";
} else if (f == new_pm_ref) {
type = "PM";
} else if (f == new_csn_ref) {
type = "CSN";
} else if (f == new_icn_ref) {
type = "ICN";
} else if (f == new_dml_ref) {
type = "DML";
} else if (f == new_smc_ref) {
type = "SMC";
} else if (f == new_ext_pub) {
type = "external pub";
} else {
type = "unknown";
}

fprintf(stderr, INF_PREFIX "%s: Found %s ref %.*s\n", path, type, (int) (eo - so), (*content) + so);
}

/* If prefixes are not required, some types of references have
* overlapping formats. This will look backwards to determine if a
* reference has a conflicting prefix.
*
* FIXME: Does not account for extended variants (DME, PME, SME). */
if (optset(opts, OPT_NONSTRICT)) {
if (f == new_dm_ref && skip_confl_ref(node, content, so, eo, "CSN-")) return;
if (f == new_csn_ref && skip_confl_ref(node, content, so, eo, "DMC-")) return;
if (f == new_pm_ref && skip_confl_ref(node, content, so, eo, "SMC-")) return;
if (f == new_smc_ref && skip_confl_ref(node, content, so, eo, "PMC-")) return;
}

if (prefix && xmlStrncmp((*content) + so, BAD_CAST prefix, 4) != 0) {
r = xmlStrdup(BAD_CAST prefix);
} else {
r = xmlStrdup(BAD_CAST "");
}
r = xmlStrncat(r, (*content) + so, eo - so);

s1 = xmlStrndup((*content), so);
s2 = xmlStrdup((*content) + eo);

xmlFree(*content);

xmlNodeSetContent(*node, s1);
xmlFree(s1);

ref = xmlAddNextSibling(*node, f((char *) r, NULL, opts));

xmlFree(r);

*node = xmlAddNextSibling(ref, xmlNewText(s2));

*content = s2;
}

/* Transform all textual references in a particular node. */
static void transform_refs_in_node(xmlNodePtr node, const char *path, const char *regex, const char *prefix, newref_t f, const int opts)
{
xmlChar *content;
regex_t re;
regmatch_t pmatch[1];

content = xmlNodeGetContent(node);

regcomp(&re, regex, REG_EXTENDED);

while (regexec(&re, (char *) content, 1, pmatch, 0) == 0) {
transform_ref(&node, path, &content, pmatch[0].rm_so, pmatch[0].rm_eo, prefix, f, opts);
}

regfree(&re);
xmlFree(content);
}

/* Transform all textual references in text nodes in an XML document. */
static void transform_refs_in_doc(const xmlDocPtr doc, const char *path, const xmlChar *xpath, const char *regex, const char *prefix, newref_t f, const int opts)
{
xmlXPathContextPtr ctx;
xmlXPathObjectPtr obj;

ctx = xmlXPathNewContext(doc);

/* If the -c option is given, only transform refs in the content section. */
if (optset(opts, OPT_CONTENT)) {
xmlXPathSetContextNode(first_xpath_node(doc, NULL, BAD_CAST "//content"), ctx);
} else {
xmlXPathSetContextNode(xmlDocGetRootElement(doc), ctx);
}

/* Use the user-specified XPath. */
if (xpath) {
if (!(obj = xmlXPathEvalExpression(xpath, ctx))) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Invalid XPath expression: %s\n", (char *) xpath);
}
exit(EXIT_BAD_XPATH);
}
/* Use the appropriate built-in XPath based on ref type. */
} else {
unsigned char *els;
unsigned int len;
xmlChar *s;
int n;

if (f == new_dm_ref) {
els = elems_dmc_txt;
len = elems_dmc_txt_len;
} else if (f == new_pm_ref) {
els = elems_pmc_txt;
len = elems_pmc_txt_len;
} else if (f == new_csn_ref) {
els = elems_csn_txt;
len = elems_csn_txt_len;
} else if (f == new_dml_ref) {
els = elems_dml_txt;
len = elems_dml_txt_len;
} else if (f == new_icn_ref) {
els = elems_icn_txt;
len = elems_icn_txt_len;
} else if (f == new_smc_ref) {
els = elems_smc_txt;
len = elems_smc_txt_len;
} else if (f == new_ext_pub) {
els = elems_epr_txt;
len = elems_epr_txt_len;
} else {
els = BAD_CAST "descendant-or-self::*/text()";
len = 11;
}

n = len + 1;

s = malloc(n * sizeof(xmlChar));
xmlStrPrintf(s, n, "%.*s", len, els);

if (!(obj = xmlXPathEvalExpression(s, ctx))) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Invalid XPath expression: %s\n", (char *) s);
}
exit(EXIT_BAD_XPATH);
}

xmlFree(s);
}

if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
int i;

for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
transform_refs_in_node(obj->nodesetval->nodeTab[i], path, regex, prefix, f, opts);
}
}

xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);
}

/* Build a regex pattern to match a string. */
static char *regex_esc(const char *s)
{
int i, j;
char *esc;

/* At most, the resulting pattern will be twice the length of the original string. */
esc = malloc(strlen(s) * 2 + 1);

for (i = 0, j = 0; s[i]; ++i, ++j) {
switch (s[i]) {
/* These special characters must be escaped. */
case '.':
case '[':
case '{':
case '}':
case '(':
case ')':
case '\\':
case '*':
case '+':
case '?':
case '|':
case '^':
case '$':
esc[j++] = '\\';
/* All other characters match themselves. */
default:
esc[j] = s[i];
break;
}
}

/* Ensure the pattern is null-terminated. */
esc[j] = '\0';

return esc;
}

/* Transform all external pub refs in an XML document. */
static void transform_extpub_refs_in_doc(const xmlDocPtr doc, const char *path, const xmlChar *xpath, const xmlDocPtr extpubs, int opts)
{
xmlXPathContextPtr ctx;
xmlXPathObjectPtr obj;

ctx = xmlXPathNewContext(extpubs);
obj = xmlXPathEvalExpression(BAD_CAST "//externalPubCode", ctx);

if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
int i;

for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
char *code, *code_esc;

code = (char *) xmlNodeGetContent(obj->nodesetval->nodeTab[i]);
code_esc = regex_esc(code);
xmlFree(code);

transform_refs_in_doc(doc, path, xpath, (char *) code_esc, NULL, new_ext_pub, opts);

free(code_esc);
}
}

xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);
}

/* Transform all textual references in a file. */
static void transform_refs_in_file(const char *path, const char *transform, const xmlChar *xpath, const xmlDocPtr extpubs, bool overwrite, const int opts)
{
xmlDocPtr doc;
int i;
bool nonstrict = optset(opts, OPT_NONSTRICT);

if (!(doc = read_xml_doc(path))) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Could not read object: %s\n", path);
}
exit(EXIT_MISSING_FILE);
}

if (verbosity >= VERBOSE) {
fprintf(stderr, INF_PREFIX "Transforming textual references in %s...\n", path);
}

for (i = 0; transform[i]; ++i) {
switch (transform[i]) {
case 'C':
transform_refs_in_doc(doc, path, xpath,
nonstrict ? COM_REGEX : COM_REGEX_STRICT,
"COM-", new_com_ref, opts);
break;
case 'D':
transform_refs_in_doc(doc, path, xpath,
nonstrict ? DME_REGEX : DME_REGEX_STRICT,
"DME-", new_dm_ref, opts);
transform_refs_in_doc(doc, path, xpath,
nonstrict ? DMC_REGEX : DMC_REGEX_STRICT,
"DMC-", new_dm_ref, opts);
break;
case 'E':
if (extpubs) {
transform_extpub_refs_in_doc(doc, path, xpath, extpubs, opts);
}
break;
case 'G':
transform_refs_in_doc(doc, path, xpath, ICN_REGEX, NULL, new_icn_ref, opts);
break;
case 'L':
transform_refs_in_doc(doc, path, xpath,
nonstrict ? DML_REGEX : DML_REGEX_STRICT,
"DML-", new_dml_ref, opts);
break;
case 'P':
transform_refs_in_doc(doc, path, xpath,
nonstrict ? PME_REGEX : PME_REGEX_STRICT,
"PME-", new_pm_ref, opts);
transform_refs_in_doc(doc, path, xpath,
nonstrict ? PMC_REGEX : PMC_REGEX_STRICT,
"PMC-", new_pm_ref, opts);
break;
case 'S':
transform_refs_in_doc(doc, path, xpath,
nonstrict ? SME_REGEX : SME_REGEX_STRICT,
"SME-", new_smc_ref, opts);
transform_refs_in_doc(doc, path, xpath,
nonstrict ? SMC_REGEX : SMC_REGEX_STRICT,
"SMC-", new_smc_ref, opts);
break;
case 'Y':
transform_refs_in_doc(doc, path, xpath,
nonstrict ? CSN_REGEX : CSN_REGEX_STRICT,
"CSN-", new_csn_ref, opts);
break;
default:
if (verbosity > QUIET) {
fprintf(stderr, WRN_PREFIX "Unknown reference type: %c\n", transform[i]);
}
break;
}
}

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

xmlFreeDoc(doc);
}

/* Transform all textual references in all files in a list. */
static void transform_refs_in_list(const char *path, const char *transform, const xmlChar *xpath, const xmlDocPtr extpubs, bool overwrite, const int opts)
{
FILE *f;
char line[PATH_MAX];

if (path) {
if (!(f = fopen(path, "r"))) {
if (verbosity > QUIET) {
fprintf(stderr, ERR_PREFIX "Could not read list: %s\n", path);
}
return;
}
} else {
f = stdin;
}

while (fgets(line, PATH_MAX, f)) {
strtok(line, "\t\r\n");
transform_refs_in_file(line, transform, xpath, extpubs, overwrite, opts);
}

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

/* Show usage message. */
static void show_help(void)
{
puts("Usage: " PROG_NAME " [-cdfgiLlqRrStuvh?] [-$ <issue>] [-s <src>] [-T <opts>] [-o <dst>] [-x <xpath>] [-3 <file>] [<code>|<file> ...]");
puts("");
puts("Options:");
puts(" -$, --issue <issue> Output XML for the specified issue of S1000D.");
puts(" -c, --content Only transform textual references in the content section.");
puts(" -d, --include-date Include issue date (target must be file).");
puts(" -f, --overwrite Overwrite source data module instead of writing to stdout.");
puts(" -h, -?, --help Show this help message.");
puts(" -i, --include-issue Include issue info.");
puts(" -L, --list Treat input as a list of CSDB objects.");
puts(" -l, --include-lang Include language.");
puts(" -o, --out <dst> Output to <dst> instead of stdout.");
puts(" -g, --guess-prefix Accept references without a prefix.");
puts(" -q, --quiet Quiet mode. Do not print errors.");
puts(" -R, --repository-id Generate a <repositorySourceDmIdent>.");
puts(" -r, --add Add reference to data module's <refs> table.");
puts(" -S, --source-id Generate a <sourceDmIdent> or <sourcePmIdent>.");
puts(" -s, --source <src> Source data module to add references to.");
puts(" -T, --transform <opts> Transform textual references to XML in objects.");
puts(" -t, --include-title Include title (target must be file)");
puts(" -u, --include-url Include xlink:href to the full URL/filename.");
puts(" -v, --verbose Verbose output.");
puts(" -x, --xpath <xpath> Transform textual references using <xpath>.");
puts(" -3, --externalpubs <file> Use a custom .externalpubs file.");
puts(" --version Show version information.");
puts(" <code> The code of the reference (must include prefix DMC/PMC/etc.).");
puts(" <file> A file to reference, or transform references in (-T).");
LIBXML2_PARSE_LONGOPT_HELP
}

/* Show version information. */
static void show_version(void)
{
printf("%s (s1kd-tools) %s\n", PROG_NAME, VERSION);
printf("Using libxml %s and libxslt %s\n", xmlParserVersion, xsltEngineVersion);
}

int main(int argc, char **argv)
{
char scratch[PATH_MAX];
int i;
int opts = 0;
char src[PATH_MAX] = "-";
char dst[PATH_MAX] = "-";
bool overwrite = false;
enum issue iss = DEFAULT_S1000D_ISSUE;
char extpubs_fname[PATH_MAX] = "";
xmlDocPtr extpubs = NULL;
char *transform = NULL;
xmlChar *transform_xpath = NULL;
bool is_list = false;

const char *sopts = "3:cfgiLlo:qRrSs:T:tvd$:ux:h?";
struct option lopts[] = {
{"version" , no_argument , 0, 0},
{"help" , no_argument , 0, 'h'},
{"externalpubs" , required_argument, 0, '3'},
{"content" , no_argument , 0, 'c'},
{"overwrite" , no_argument , 0, 'f'},
{"guess-prefix" , no_argument , 0, 'g'},
{"include-issue", no_argument , 0, 'i'},
{"include-lang" , no_argument , 0, 'l'},
{"out" , required_argument, 0, 'o'},
{"quiet" , no_argument , 0, 'q'},
{"add" , no_argument , 0, 'r'},
{"repository-id", no_argument , 0, 'R'},
{"source-id" , no_argument , 0, 'S'},
{"source" , required_argument, 0, 's'},
{"transform" , required_argument, 0, 'T'},
{"include-title", no_argument , 0, 't'},
{"verbose" , no_argument , 0, 'v'},
{"include-date" , no_argument , 0, 'd'},
{"issue" , required_argument, 0, '$'},
{"include-url" , no_argument , 0, 'u'},
{"xpath" , required_argument, 0, 'x'},
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();
goto cleanup;
}
LIBXML2_PARSE_LONGOPT_HANDLE(lopts, loptind, optarg)
break;
case '3':
strncpy(extpubs_fname, optarg, PATH_MAX - 1);
break;
case 'c':
opts |= OPT_CONTENT;
break;
case 'f':
overwrite = true;
break;
case 'g':
opts |= OPT_NONSTRICT;
break;
case 'i':
opts |= OPT_ISSUE;
break;
case 'L':
is_list = true;
break;
case 'l':
opts |= OPT_LANG;
break;
case 'o':
strcpy(dst, optarg);
break;
case 'q':
--verbosity;
break;
case 'r':
opts |= OPT_INS;
break;
case 'R':
opts |= OPT_CIRID;
case 'S':
opts |= OPT_SRCID;
opts |= OPT_ISSUE;
opts |= OPT_LANG;
break;
case 's':
strcpy(src, optarg);
break;
case 'T':
free(transform);
if (strcmp(optarg, "all") == 0) {
transform = strdup("CDEGLPSY");
} else {
transform = strdup(optarg);
}
break;
case 't':
opts |= OPT_TITLE;
break;
case 'v':
++verbosity;
break;
case 'd':
opts |= OPT_DATE;
break;
case '$':
iss = spec_issue(optarg);
break;
case 'u':
opts |= OPT_URL;
break;
case 'x':
free(transform_xpath);
transform_xpath = xmlCharStrdup(optarg);
break;
case '?':
case 'h': show_help(); goto cleanup;
}
}

/* Load .externalpubs config file. */
if (strcmp(extpubs_fname, "") != 0 || find_config(extpubs_fname, DEFAULT_EXTPUBS_FNAME)) {
extpubs = read_xml_doc(extpubs_fname);
}

if (optind < argc) {
for (i = optind; i < argc; ++i) {
if (transform) {
if (is_list) {
transform_refs_in_list(argv[i], transform, transform_xpath, extpubs, overwrite, opts);
} else {
transform_refs_in_file(argv[i], transform, transform_xpath, extpubs, overwrite, opts);
}
} else {
char *base;

if (strncmp(argv[i], "URN:S1000D:", 11) == 0) {
base = argv[i] + 11;
} else {
strcpy(scratch, argv[i]);
base = basename(scratch);
}

print_ref(src, dst, base, argv[i], opts, overwrite, iss, extpubs);
}
}
} else if (transform) {
if (is_list) {
transform_refs_in_list(NULL, transform, transform_xpath, extpubs, overwrite, opts);
} else {
transform_refs_in_file("-", transform, transform_xpath, extpubs, overwrite, opts);
}
} else {
while (fgets(scratch, PATH_MAX, stdin)) {
print_ref(src, dst, trim(scratch), NULL, opts, overwrite, iss, extpubs);
}
}

cleanup:
xmlFreeDoc(extpubs);
free(transform);
xmlFree(transform_xpath);
xsltCleanupGlobals();
xmlCleanupParser();

return 0;
}