#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#include <libgen.h>
#include <sys/stat.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/debugXML.h>
#include <libxml/xpathInternals.h>
#include "s1kd_tools.h"

#define PROG_NAME "s1kd-refs"
#define VERSION "4.17.2"

#define ERR_PREFIX PROG_NAME ": ERROR: "
#define SUCC_PREFIX PROG_NAME ": SUCCESS: "
#define FAIL_PREFIX PROG_NAME ": FAILURE: "
#define INF_PREFIX PROG_NAME ": INFO: "

#define E_BAD_LIST ERR_PREFIX "Could not read list: %s\n"
#define E_OUT_OF_MEMORY ERR_PREFIX "Too many files in recursive listing.\n"
#define E_BAD_STDIN ERR_PREFIX "stdin does not contain valid XML.\n"
#define E_BAD_CSN_CODE ERR_PREFIX "Invalid non-chapterized IPD SNS: %s\n"

#define S_UNMATCHED SUCC_PREFIX "No unmatched references in %s\n"
#define F_UNMATCHED FAIL_PREFIX "Unmatched references in %s\n"

#define I_WHEREUSED INF_PREFIX "Searching for references to %s...\n"
#define I_UPDATE_REF INF_PREFIX "%s: Updating reference %s to match %s...\n"

#define EXIT_UNMATCHED_REF 1
#define EXIT_OUT_OF_MEMORY 2
#define EXIT_BAD_STDIN 3
#define EXIT_BAD_CSN_CODE 4

/* List only references found in the content section. */
static bool contentOnly = false;

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

/* Assume objects were created with the -N option. */
static bool noIssue = false;

/* Show unmatched references instead of an error. */
static bool showUnmatched = false;

/* Show references which are matched in the filesystem. */
static bool showMatched = true;

/* Recurse in to child directories. */
static bool recursive = false;

/* Directory to start search in. */
static char *directory;

/* Ignore issue info when matching. */
static bool ignoreIss = false;

/* Include the source object as a reference. */
static bool listSrc = false;

/* List references in matched objects recursively. */
static bool listRecursively = false;

/* Update the address information of references. */
static bool updateRefs = false;

/* Update the ident and address info from the latest matched issue. */
static bool updateRefIdent = false;

/* Overwrite updated input objects. */
static bool overwriteUpdated = false;

/* Remove unmatched references from the input objects. */
static bool tagUnmatched = false;

/* Command string to execute with the -e option. */
static char *execStr = NULL;

/* Non-chapterized IPD SNS. */
static bool nonChapIpdSns = false;
static char nonChapIpdSystemCode[4] = "";
static char nonChapIpdSubSystemCode[2] = "";
static char nonChapIpdSubSubSystemCode[2] = "";
static char nonChapIpdAssyCode[5] = "";

/* Figure number variant format string. */
static xmlChar *figNumVarFormat;

/* When listing references recursively, keep track of files which have already
 * been listed to avoid loops.
 */
static char (*listedFiles)[PATH_MAX] = NULL;
static int numListedFiles = 0;
static long unsigned maxListedFiles = 1;

/* Possible objects to list references to. */
#define SHOW_COM 0x0001 /* Comments */
#define SHOW_DMC 0x0002 /* Data modules */
#define SHOW_ICN 0x0004 /* ICNs */
#define SHOW_PMC 0x0008 /* Publication modules */
#define SHOW_EPR 0x0010 /* External publications */
#define SHOW_HOT 0x0020 /* Hotspots */
#define SHOW_FRG 0x0040 /* Fragments */
#define SHOW_DML 0x0080 /* DMLs */
#define SHOW_SMC 0x0100 /* SCORM content packages */
#define SHOW_SRC 0x0200 /* Source ident */
#define SHOW_REP 0x0400 /* Repository source ident */
#define SHOW_IPD 0x0800 /* IPD data modules */
#define SHOW_CSN 0x1000 /* CSN items */

/* All possible objects. */
#define SHOW_ALL \
	SHOW_COM | \
	SHOW_DMC | \
	SHOW_ICN | \
	SHOW_PMC | \
	SHOW_EPR | \
	SHOW_HOT | \
	SHOW_FRG | \
	SHOW_DML | \
	SHOW_SMC | \
	SHOW_SRC | \
	SHOW_REP | \
	SHOW_IPD | \
	SHOW_CSN

/* All objects relevant to -w mode. */
#define SHOW_WHERE_USED \
	SHOW_COM | \
	SHOW_DMC | \
	SHOW_PMC | \
	SHOW_DML | \
	SHOW_SMC | \
	SHOW_ICN | \
	SHOW_SRC | \
	SHOW_REP | \
	SHOW_IPD | \
        SHOW_EPR

/* Write valid CSDB objects to stdout. */
static bool outputTree = false;

/* External pub list. */
static xmlDocPtr externalPubs = NULL;

/* Allow matching of filenames which only start with the code.
 *
 * If this is false, then the filenames must match the exact code up to the
 * extension (last .)
 *
 * For example, with loose matching a code of ABC would match a file named
 * ABC_001.PDF, while without loose matching it will not.
 */
static bool looseMatch = true;

/* XPath for matching hotspots. */
#define DEFAULT_HOTSPOT_XPATH BAD_CAST "/X3D//*[@DEF=$id]|//*[@id=$id]"
static xmlChar *hotspotXPath = NULL;
static xmlNodePtr hotspotNs = NULL;

/* Delimiter for the format string. */
#define FMTSTR_DELIM '%'
/* Custom format for printed references. */
static char *printFormat = NULL;

/* Remove elements marked as "delete". */
static bool remDelete = false;

/* Return the first node matching an XPath expression. */
static xmlNodePtr firstXPathNode(xmlDocPtr doc, xmlNodePtr root, const xmlChar *path)
{
	xmlNodePtr node;

	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;

	if (!doc && root)
		doc = root->doc;

	if (!doc)
		return NULL;

	ctx = xmlXPathNewContext(doc);

	if (root)
		ctx->node = root;

	obj = xmlXPathEvalExpression(BAD_CAST path, ctx);

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

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);

	return node;
}

/* Return the value of the first node matching an XPath expression. */
static xmlChar *firstXPathValue(xmlDocPtr doc, xmlNodePtr root, const xmlChar *path)
{
	return xmlNodeGetContent(firstXPathNode(doc, root, path));
}

/* Process and print info based on a format string. */
static void processFormatStr(FILE *f, xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	int i;

	for (i = 0; printFormat[i]; ++i) {
		if (printFormat[i] == FMTSTR_DELIM) {
			if (printFormat[i + 1] == FMTSTR_DELIM) {
				fputc(FMTSTR_DELIM, f);
				++i;
			} else {
				const char *k, *e;
				int n;

				k = printFormat + i + 1;
				e = strchr(k, FMTSTR_DELIM);
				if (!e) break;
				n = e - k;

				if (strncmp(k, "src", n) == 0) {
					fprintf(f, "%s", src);
				} else if (strncmp(k, "ref", n) == 0) {
					fprintf(f, "%s", ref);
				} else if (strncmp(k, "file", n) == 0 && fname) {
					fprintf(f, "%s", fname);
				} else if (strncmp(k, "line", n) == 0) {
					fprintf(f, "%ld", xmlGetLineNo(node));
				} else if (strncmp(k, "xpath", n) == 0) {
					xmlChar *xpath = xpath_of(node);
					fprintf(f, "%s", (char *) xpath);
					xmlFree(xpath);
				}

				i += n + 1;
			}
		} else if (printFormat[i] == '\\') {
			switch (printFormat[i + 1]) {
				case 'n': fputc('\n', f); i++; break;
				case 't': fputc('\t', f); i++; break;
				case '0': fputc('\0', f); i++; break;
				default:  fputc(printFormat[i], f);
			}
		} else {
			fputc(printFormat[i], f);
		}
	}

	fputc('\n', f);
}

/* Print a reference which is matched in the filesystem. */
static void printMatched(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	puts(ref);
}
static void printMatchedSrc(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	printf("%s: %s\n", src, ref);
}
static void printMatchedSrcLine(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	printf("%s (%ld): %s\n", src, xmlGetLineNo(node), ref);
}
static void printMatchedXml(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	xmlChar *s, *r, *f, *xpath;
	xmlDocPtr doc;

	if (!node) {
		return;
	}

	s = xmlEncodeEntitiesReentrant(node->doc, BAD_CAST src);
	r = xmlEncodeEntitiesReentrant(node->doc, BAD_CAST ref);
	f = xmlEncodeEntitiesReentrant(node->doc, BAD_CAST fname);
	xpath = xpath_of(node);

	printf("<found>");

	printf("<ref>");
	doc = xmlNewDoc(BAD_CAST "1.0");
	if (node->type == XML_ATTRIBUTE_NODE) {
		xmlDocSetRootElement(doc, xmlCopyNode(node->parent, 1));
	} else {
		xmlDocSetRootElement(doc, xmlCopyNode(node, 1));
	}
	xmlShellPrintNode(xmlDocGetRootElement(doc));
	xmlFreeDoc(doc);
	printf("</ref>");

	printf("<source line=\"%ld\" xpath=\"%s\">%s</source>", xmlGetLineNo(node), xpath, s);
	printf("<code>%s</code>", r);
	if (f) {
		printf("<filename>%s</filename>", f);
	}

	printf("</found>");

	xmlFree(s);
	xmlFree(r);
	xmlFree(xpath);
}
static void printMatchedWhereUsed(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	printf("%s\n", src);
}
static void printMatchedCustom(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	processFormatStr(stdout, node, src, ref, fname);
}

static void execMatched(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	execfile(execStr, fname);
}

/* Print an error for references which are unmatched. */
static void printUnmatched(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	fprintf(stderr, ERR_PREFIX "Unmatched reference: %s\n", ref);
}
static void printUnmatchedSrc(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	fprintf(stderr, ERR_PREFIX "%s: Unmatched reference: %s\n", src, ref);
}
static void printUnmatchedSrcLine(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	fprintf(stderr, ERR_PREFIX "%s (%ld): Unmatched reference: %s\n", src, xmlGetLineNo(node), ref);
}
static void printUnmatchedXml(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	xmlChar *s, *r, *f, *xpath;
	xmlDocPtr doc;

	s = xmlEncodeEntitiesReentrant(node->doc, BAD_CAST src);
	r = xmlEncodeEntitiesReentrant(node->doc, BAD_CAST ref);
	f = xmlEncodeEntitiesReentrant(node->doc, BAD_CAST fname);
	xpath = xpath_of(node);

	printf("<missing>");

	printf("<ref>");
	doc = xmlNewDoc(BAD_CAST "1.0");
	if (node->type == XML_ATTRIBUTE_NODE) {
		xmlDocSetRootElement(doc, xmlCopyNode(node->parent, 1));
	} else {
		xmlDocSetRootElement(doc, xmlCopyNode(node, 1));
	}
	xmlShellPrintNode(xmlDocGetRootElement(doc));
	xmlFreeDoc(doc);
	printf("</ref>");

	printf("<source line=\"%ld\" xpath=\"%s\">%s</source>", xmlGetLineNo(node), xpath, s);
	printf("<code>%s</code>", r);
	if (f) {
		printf("<filename>%s</filename>", f);
	}

	printf("</missing>");

	xmlFree(s);
	xmlFree(r);
	xmlFree(xpath);
}
static void printUnmatchedCustom(xmlNodePtr node, const char *src, const char *ref, const char *fname)
{
	fputs(ERR_PREFIX "Unmatched reference: ", stderr);
	processFormatStr(stderr, node, src, ref, fname);
}

static void (*printMatchedFn)(xmlNodePtr, const char *, const char *, const char *) = printMatched;
static void (*printUnmatchedFn)(xmlNodePtr, const char *, const char*, const char *) = printUnmatched;

static bool exact_match(char *dst, const char *code)
{
	char *s, *base;
	bool match;

	s = strdup(dst);
	base = basename(s);

	match = strrchr(base, '.') - base == strlen(code);

	free(s);

	return match;
}

/* Match a code to a file name. */
static bool find_object_fname(char *dst, const char *dir, const char *code, bool recursive)
{
	return find_csdb_object(dst, dir, code, NULL, recursive) && (looseMatch || exact_match(dst, code));
}

/* Tag unmatched references in the source object. */
static void tagUnmatchedRef(xmlNodePtr ref)
{
	add_first_child(ref, xmlNewPI(BAD_CAST "unmatched", NULL));
}

/* Get the DMC as a string from a dmRef. */
static void getDmCode(char *dst, xmlNodePtr dmRef)
{
	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;

	xmlNodePtr identExtension, dmCode, issueInfo, language;

	identExtension = firstXPathNode(NULL, dmRef, BAD_CAST "dmRefIdent/identExtension|dmcextension");
	dmCode = firstXPathNode(NULL, dmRef, BAD_CAST "dmRefIdent/dmCode|dmc/avee|avee");

	if (ignoreIss) {
		issueInfo = NULL;
	} else {
		issueInfo = firstXPathNode(NULL, dmRef, BAD_CAST "dmRefIdent/issueInfo|issno");
	}

	language = firstXPathNode(NULL, dmRef, BAD_CAST "dmRefIdent/language|language");

	strcpy(dst, "");

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

		extensionProducer = (char *) firstXPathValue(NULL, identExtension, BAD_CAST "@extensionProducer|dmeproducer");
		extensionCode     = (char *) firstXPathValue(NULL, identExtension, BAD_CAST "@extensionCode|dmecode");

		strcat(dst, "DME-");

		strcat(dst, extensionProducer);
		strcat(dst, "-");
		strcat(dst, extensionCode);
		strcat(dst, "-");

		xmlFree(extensionProducer);
		xmlFree(extensionCode);
	} else {
		strcat(dst, "DMC-");
	}

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

	if (modelIdentCode) {
		strcat(dst, modelIdentCode);
		strcat(dst, "-");
		strcat(dst, systemDiffCode);
		strcat(dst, "-");
		strcat(dst, systemCode);
		strcat(dst, "-");
		strcat(dst, subSystemCode);
		strcat(dst, subSubSystemCode);
		strcat(dst, "-");
		strcat(dst, assyCode);
		strcat(dst, "-");
		strcat(dst, disassyCode);
		strcat(dst, disassyCodeVariant);
		strcat(dst, "-");
		strcat(dst, infoCode);
		strcat(dst, infoCodeVariant);
		strcat(dst, "-");
		strcat(dst, itemLocationCode);

		if (learnCode) {
			strcat(dst, "-");
			strcat(dst, learnCode);
			strcat(dst, learnEventCode);
		}
	}

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

	if (!noIssue) {
		if (issueInfo) {
			char *issueNumber, *inWork;

			issueNumber = (char *) firstXPathValue(NULL, issueInfo, BAD_CAST "@issueNumber|@issno");
			inWork      = (char *) firstXPathValue(NULL, issueInfo, BAD_CAST "@inWork|@inwork");

			if (!inWork) {
				inWork = strdup("00");
			}

			strcat(dst, "_");
			strcat(dst, issueNumber);
			strcat(dst, "-");
			strcat(dst, inWork);

			xmlFree(issueNumber);
			xmlFree(inWork);
		} else if (language) {
			strcat(dst, "_\?\?\?-\?\?");
		}
	}

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

		languageIsoCode = (char *) firstXPathValue(NULL, language, BAD_CAST "@languageIsoCode|@language");
		countryIsoCode  = (char *) firstXPathValue(NULL, language, BAD_CAST "@countryIsoCode|@country");

		uppercase(languageIsoCode);

		strcat(dst, "_");
		strcat(dst, languageIsoCode);
		strcat(dst, "-");
		strcat(dst, countryIsoCode);

		xmlFree(languageIsoCode);
		xmlFree(countryIsoCode);
	}
}

/* Get the PMC as a string from a pmRef. */
static void getPmCode(char *dst, xmlNodePtr pmRef)
{
	xmlNodePtr identExtension, pmCode, issueInfo, language;

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

	identExtension = firstXPathNode(NULL, pmRef, BAD_CAST "pmRefIdent/identExtension");
	pmCode         = firstXPathNode(NULL, pmRef, BAD_CAST "pmRefIdent/pmCode|pmc");

	if (ignoreIss) {
		issueInfo = NULL;
	} else {
		issueInfo = firstXPathNode(NULL, pmRef, BAD_CAST "pmRefIdent/issueInfo|issno");
	}

	language = firstXPathNode(NULL, pmRef, BAD_CAST "pmRefIdent/language|language");

	strcpy(dst, "");

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

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

		strcat(dst, "PME-");

		strcat(dst, extensionProducer);
		strcat(dst, "-");
		strcat(dst, extensionCode);
		strcat(dst, "-");

		xmlFree(extensionProducer);
		xmlFree(extensionCode);
	} else {
		strcat(dst, "PMC-");
	}

	modelIdentCode = (char *) firstXPathValue(NULL, pmCode, BAD_CAST "@modelIdentCode|modelic");
	pmIssuer       = (char *) firstXPathValue(NULL, pmCode, BAD_CAST "@pmIssuer|pmissuer");
	pmNumber       = (char *) firstXPathValue(NULL, pmCode, BAD_CAST "@pmNumber|pmnumber");
	pmVolume       = (char *) firstXPathValue(NULL, pmCode, BAD_CAST "@pmVolume|pmvolume");

	strcat(dst, modelIdentCode);
	strcat(dst, "-");
	strcat(dst, pmIssuer);
	strcat(dst, "-");
	strcat(dst, pmNumber);
	strcat(dst, "-");
	strcat(dst, pmVolume);

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

	if (!noIssue) {
		if (issueInfo) {
			char *issueNumber, *inWork;

			issueNumber = (char *) firstXPathValue(NULL, issueInfo, BAD_CAST "@issueNumber|@issno");
			inWork      = (char *) firstXPathValue(NULL, issueInfo, BAD_CAST "@inWork|@inwork");

			strcat(dst, "_");
			strcat(dst, issueNumber);
			strcat(dst, "-");
			strcat(dst, inWork);

			xmlFree(issueNumber);
			xmlFree(inWork);
		} else if (language) {
			strcat(dst, "_\?\?\?-\?\?");
		}
	}

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

		languageIsoCode = (char *) firstXPathValue(NULL, language, BAD_CAST "@languageIsoCode|@language");
		countryIsoCode  = (char *) firstXPathValue(NULL, language, BAD_CAST "@countryIsoCode|@country");

		uppercase(languageIsoCode);

		strcat(dst, "_");
		strcat(dst, languageIsoCode);
		strcat(dst, "-");
		strcat(dst, countryIsoCode);

		xmlFree(languageIsoCode);
		xmlFree(countryIsoCode);
	}
}

/* Get the code of the source DM or PM. */
static void getSourceIdent(char *dst, xmlNodePtr sourceIdent)
{
	xmlDocPtr refdoc;
	xmlNodePtr ref, ident;

	refdoc = xmlNewDoc(BAD_CAST "1.0");
	ident = xmlCopyNode(sourceIdent, 1);

	if (xmlStrcmp(sourceIdent->name, BAD_CAST "sourcePmIdent") == 0) {
		ref = xmlNewNode(NULL, BAD_CAST "pmRef");
		xmlDocSetRootElement(refdoc, ref);
		xmlNodeSetName(ident, BAD_CAST "pmRefIdent");
		ident = xmlAddChild(ref, ident);

		getPmCode(dst, ref);
	} else {
		ref = xmlNewNode(NULL, BAD_CAST "dmRef");
		xmlDocSetRootElement(refdoc, ref);
		xmlNodeSetName(ident, BAD_CAST "dmRefIdent");
		ident = xmlAddChild(ref, ident);

		getDmCode(dst, ref);
	}

	xmlFreeDoc(refdoc);
}

/* Get the SMC as a string from a scormContentPackageRef. */
static void getSmcCode(char *dst, xmlNodePtr smcRef)
{
	xmlNodePtr identExtension, smcCode, issueInfo, language;

	char *modelIdentCode;
	char *smcIssuer;
	char *smcNumber;
	char *smcVolume;

	identExtension = firstXPathNode(NULL, smcRef, BAD_CAST "scormContentPackageRefIdent/identExtension");
	smcCode        = firstXPathNode(NULL, smcRef, BAD_CAST "scormContentPackageRefIdent/scormContentPackageCode");

	if (ignoreIss) {
		issueInfo = NULL;
	} else {
		issueInfo = firstXPathNode(NULL, smcRef, BAD_CAST "scormContentPackageRefIdent/issueInfo");
	}

	language = firstXPathNode(NULL, smcRef, BAD_CAST "scormContentPackageRefIdent/language");

	strcpy(dst, "");

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

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

		strcat(dst, "SME-");

		if (extensionProducer && extensionCode) {
			strcat(dst, extensionProducer);
			strcat(dst, "-");
			strcat(dst, extensionCode);
			strcat(dst, "-");
		}

		xmlFree(extensionProducer);
		xmlFree(extensionCode);
	} else {
		strcat(dst, "SMC-");
	}

	modelIdentCode = (char *) xmlGetProp(smcCode, BAD_CAST "modelIdentCode");
	smcIssuer      = (char *) xmlGetProp(smcCode, BAD_CAST "scormContentPackageIssuer");
	smcNumber      = (char *) xmlGetProp(smcCode, BAD_CAST "scormContentPackageNumber");
	smcVolume      = (char *) xmlGetProp(smcCode, BAD_CAST "scormContentPackageVolume");

	if (modelIdentCode && smcIssuer && smcNumber && smcVolume) {
		strcat(dst, modelIdentCode);
		strcat(dst, "-");
		strcat(dst, smcIssuer);
		strcat(dst, "-");
		strcat(dst, smcNumber);
		strcat(dst, "-");
		strcat(dst, smcVolume);
	}

	xmlFree(modelIdentCode);
	xmlFree(smcIssuer);
	xmlFree(smcNumber);
	xmlFree(smcVolume);

	if (!noIssue) {
		if (issueInfo) {
			char *issueNumber, *inWork;

			issueNumber = (char *) xmlGetProp(issueInfo, BAD_CAST "issueNumber");
			inWork      = (char *) xmlGetProp(issueInfo, BAD_CAST "inWork");

			if (issueNumber && inWork) {
				strcat(dst, "_");
				strcat(dst, issueNumber);
				strcat(dst, "-");
				strcat(dst, inWork);
			}

			xmlFree(issueNumber);
			xmlFree(inWork);
		} else if (language) {
			strcat(dst, "_\?\?\?-\?\?");
		}
	}

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

		languageIsoCode = (char *) xmlGetProp(language, BAD_CAST "languageIsoCode");
		countryIsoCode  = (char *) xmlGetProp(language, BAD_CAST "countryIsoCode");

		if (languageIsoCode && countryIsoCode) {
			uppercase(languageIsoCode);

			strcat(dst, "_");
			strcat(dst, languageIsoCode);
			strcat(dst, "-");
			strcat(dst, countryIsoCode);
		}

		xmlFree(languageIsoCode);
		xmlFree(countryIsoCode);
	}
}

/* Get the ICN as a string from an ICN reference. */
static void getICN(char *dst, xmlNodePtr ref)
{
	char *icn;
	icn = (char *) xmlGetProp(ref, BAD_CAST "infoEntityRefIdent");
	strcpy(dst, icn);
	xmlFree(icn);
}

/* Get the ICN as a string from an ICN entity reference. */
static void getICNAttr(char *dst, xmlNodePtr ref)
{
	xmlChar *icn;
	xmlEntityPtr ent;
	icn = xmlNodeGetContent(ref);
	if ((ent = xmlGetDocEntity(ref->doc, icn)) && ent->URI) {
		char uri[PATH_MAX], *base;
		strcpy(uri, (char *) ent->URI);
		base = basename(uri);
		strcpy(dst, base);
	} else {
		strcpy(dst, (char *) icn);
	}

	/* Remove issue number when not doing a full match. */
	if (ignoreIss) {
		char *e = strrchr(dst, '-');
		char *s = e - 3;

		if (e && s >= dst) {
			*s = 0;
		}
	}

	xmlFree(icn);
}

/* Match each hotspot against the ICN. */
static int matchHotspot(xmlNodePtr ref, xmlDocPtr doc, const char *code, const char *fname, const char *src)
{
	xmlChar *apsid;
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	xmlNodePtr node;
	char *s;
	int err = doc == NULL;

	apsid = xmlNodeGetContent(ref);

	if (doc) {
		xmlNodePtr cur;

		ctx = xmlXPathNewContext(doc);

		/* Register namespaces for the hotspot XPath. */
		for (cur = hotspotNs->children; cur; cur = cur->next) {
			xmlChar *prefix, *uri;

			prefix = xmlGetProp(cur, BAD_CAST "prefix");
			uri = xmlGetProp(cur, BAD_CAST "uri");

			xmlXPathRegisterNs(ctx, prefix, uri);

			xmlFree(prefix);
			xmlFree(uri);
		}

		xmlXPathRegisterVariable(ctx, BAD_CAST "id", xmlXPathNewString(apsid));
		obj = xmlXPathEvalExpression(hotspotXPath, ctx);

		if (!obj || xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
			node = NULL;
		} else {
			node = obj->nodesetval->nodeTab[0];
		}

		xmlXPathFreeObject(obj);
		xmlXPathFreeContext(ctx);

		if (node) {
			if (showMatched && !tagUnmatched) {
				s = malloc(strlen(fname) + strlen((char *) apsid) + 2);
				strcpy(s, fname);
				strcat(s, "#");
				strcat(s, (char *) apsid);
				printMatchedFn(ref, src, s, fname);
				free(s);
			}
		} else {
			++err;
		}
	}

	if (err) {
		s = malloc(strlen(code) + strlen((char *) apsid) + 2);
		strcpy(s, code);
		strcat(s, "#");
		strcat(s, (char *) apsid);

		if (tagUnmatched) {
			tagUnmatchedRef(ref);
		} else if (showUnmatched) {
			printMatchedFn(ref, src, s, fname);
		} else if (verbosity >= NORMAL) {
			printUnmatchedFn(ref, src, s, fname);
		}

		free(s);
	}

	xmlFree(apsid);
	return err;
}

/* Match the hotspots for an XML-based ICN. */
static int getHotspots(xmlNodePtr ref, const char *src)
{
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	int err = 0;

	ctx = xmlXPathNewContext(ref->doc);
	xmlXPathSetContextNode(ref, ctx);

	/* Select all hotspots that have an APS ID, meaning they point to some
	 * object in the ICN (vs. using coordinates).
	 */
	obj = xmlXPathEvalExpression(BAD_CAST ".//hotspot/@applicationStructureIdent|.//hotspot/@apsid", ctx);

	if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
		xmlNodePtr icn;
		char code[PATH_MAX], fname[PATH_MAX];
		int i;
		xmlDocPtr doc;

		icn = firstXPathNode(ref->doc, ref, BAD_CAST "@infoEntityIdent|@boardno");

		getICNAttr(code, icn);

		if (find_object_fname(fname, directory, code, recursive)) {
			doc = read_xml_doc(fname);
		} else {
			doc = NULL;
		}

		if (remDelete) {
			rem_delete_elems(doc);
		}

		for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
			err += matchHotspot(obj->nodesetval->nodeTab[i], doc, code, doc ? fname : code, src);
		}

		xmlFreeDoc(doc);
	}

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);

	return err;
}

/* Match a single referred fragment in another DM. */
static int matchFragment(xmlDocPtr doc, xmlNodePtr ref, const char *code, const char *fname, const char *src)
{
	xmlChar *id;
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	xmlNodePtr node;
	char *s;
	int err = doc == NULL;

	id = xmlNodeGetContent(ref);

	if (doc) {
		ctx = xmlXPathNewContext(doc);
		xmlXPathRegisterVariable(ctx, BAD_CAST "id", xmlXPathNewString(id));
		obj = xmlXPathEvalExpression(BAD_CAST "//*[@id=$id]", ctx);

		if (!obj || xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
			node = NULL;
		} else {
			node = obj->nodesetval->nodeTab[0];
		}

		xmlXPathFreeObject(obj);
		xmlXPathFreeContext(ctx);

		if (node) {
			if (showMatched && !tagUnmatched) {
				s = malloc(strlen(fname) + strlen((char *) id) + 2);
				strcpy(s, fname);
				strcat(s, "#");
				strcat(s, (char *) id);
				printMatchedFn(ref, src, s, fname);
				free(s);
			}
		} else {
			++err;
		}
	}

	if (err) {
		s = malloc(strlen(doc ? fname : code) + strlen((char *) id) + 2);
		strcpy(s, doc ? fname : code);
		strcat(s, "#");
		strcat(s, (char *) id);

		if (tagUnmatched) {
			tagUnmatchedRef(ref);
		} else if (showUnmatched) {
			printMatchedFn(ref, src, s, doc ? fname : NULL);
		} else if (verbosity >= NORMAL) {
			printUnmatchedFn(ref, src, s, doc ? fname : NULL);
		}

		free(s);
	}

	xmlFree(id);
	return err;

}

/* Match the referred fragments in another DM. */
static int getFragment(xmlNodePtr ref, const char *src)
{
	xmlNodePtr dmref;
	char code[PATH_MAX], fname[PATH_MAX];
	xmlDocPtr doc;
	int err;

	dmref = firstXPathNode(ref->doc, ref, BAD_CAST "ancestor::dmRef");

	getDmCode(code, dmref);

	if (find_object_fname(fname, directory, code, recursive)) {
		doc = read_xml_doc(fname);
	} else {
		doc = NULL;
	}

	if (remDelete) {
		rem_delete_elems(doc);
	}

	err = matchFragment(doc, ref, code, doc ? fname : code, src);

	xmlFreeDoc(doc);

	return err;
}

/* Get the comment code as a string from a commentRef. */
static void getComCode(char *dst, xmlNodePtr ref)
{
	xmlNodePtr commentCode, language;

	char *modelIdentCode;
	char *senderIdent;
	char *yearOfDataIssue;
	char *seqNumber;
	char *commentType;

	commentCode = firstXPathNode(NULL, ref, BAD_CAST "commentRefIdent/commentCode");

	language = firstXPathNode(NULL, ref, BAD_CAST "commentRefIdent/language");

	modelIdentCode  = (char *) xmlGetProp(commentCode, BAD_CAST "modelIdentCode");
	senderIdent     = (char *) xmlGetProp(commentCode, BAD_CAST "senderIdent");
	yearOfDataIssue = (char *) xmlGetProp(commentCode, BAD_CAST "yearOfDataIssue");
	seqNumber       = (char *) xmlGetProp(commentCode, BAD_CAST "seqNumber");
	commentType     = (char *) xmlGetProp(commentCode, BAD_CAST "commentType");

	strcpy(dst, "COM-");
	strcat(dst, modelIdentCode);
	strcat(dst, "-");
	strcat(dst, senderIdent);
	strcat(dst, "-");
	strcat(dst, yearOfDataIssue);
	strcat(dst, "-");
	strcat(dst, seqNumber);
	strcat(dst, "-");
	strcat(dst, commentType);

	xmlFree(modelIdentCode);
	xmlFree(senderIdent);
	xmlFree(yearOfDataIssue);
	xmlFree(seqNumber);
	xmlFree(commentType);

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

		languageIsoCode = (char *) xmlGetProp(language, BAD_CAST "languageIsoCode");
		countryIsoCode  = (char *) xmlGetProp(language, BAD_CAST "countryIsoCode");

		uppercase(languageIsoCode);

		strcat(dst, "_");
		strcat(dst, languageIsoCode);
		strcat(dst, "-");
		strcat(dst, countryIsoCode);

		xmlFree(languageIsoCode);
		xmlFree(countryIsoCode);
	}
}

/* Get the DML code as a string from a dmlRef. */
static void getDmlCode(char *dst, xmlNodePtr ref)
{
	xmlNodePtr dmlCode, issueInfo;

	char *modelIdentCode;
	char *senderIdent;
	char *dmlType;
	char *yearOfDataIssue;
	char *seqNumber;

	dmlCode   = firstXPathNode(NULL, ref, BAD_CAST "dmlRefIdent/dmlCode");
	issueInfo = firstXPathNode(NULL, ref, BAD_CAST "dmlRefIdent/issueInfo");

	modelIdentCode  = (char *) xmlGetProp(dmlCode, BAD_CAST "modelIdentCode");
	senderIdent     = (char *) xmlGetProp(dmlCode, BAD_CAST "senderIdent");
	dmlType         = (char *) xmlGetProp(dmlCode, BAD_CAST "dmlType");
	yearOfDataIssue = (char *) xmlGetProp(dmlCode, BAD_CAST "yearOfDataIssue");
	seqNumber       = (char *) xmlGetProp(dmlCode, BAD_CAST "seqNumber");

	uppercase(dmlType);

	strcpy(dst, "DML-");
	strcat(dst, modelIdentCode);
	strcat(dst, "-");
	strcat(dst, senderIdent);
	strcat(dst, "-");
	strcat(dst, dmlType);
	strcat(dst, "-");
	strcat(dst, yearOfDataIssue);
	strcat(dst, "-");
	strcat(dst, seqNumber);

	xmlFree(modelIdentCode);
	xmlFree(senderIdent);
	xmlFree(dmlType);
	xmlFree(yearOfDataIssue);
	xmlFree(seqNumber);

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

		issueNumber = (char *) xmlGetProp(issueInfo, BAD_CAST "issueNumber");
		inWork      = (char *) xmlGetProp(issueInfo, BAD_CAST "inWork");

		strcat(dst, "_");
		strcat(dst, issueNumber);
		strcat(dst, "-");
		strcat(dst, inWork);

		xmlFree(issueNumber);
		xmlFree(inWork);
	}
}

/* Get the external pub code as a string from an externalPubRef. */
static void getExternalPubCode(char *dst, xmlNodePtr ref)
{
	xmlNodePtr externalPubCode;
	char *code;

	externalPubCode = firstXPathNode(NULL, ref,
		BAD_CAST "externalPubRefIdent/externalPubCode|externalPubRefIdent/externalPubTitle|pubcode");

	if (externalPubCode) {
		code = (char *) xmlNodeGetContent(externalPubCode);
	} else {
		code = (char *) xmlNodeGetContent(ref);
	}

	strcpy(dst, code);

	xmlFree(code);
}

/* Get filename from DDN item. */
static void getDispatchFileName(char *dst, xmlNodePtr ref)
{
	char *fname;
	fname = (char *) xmlNodeGetContent(ref);
	strcpy(dst, fname);
	xmlFree(fname);
}

/* Get the disassembly code variant pattern using the figure number variant and
 * the specified format string. */
static xmlChar *formatFigNumVar(const xmlChar *figureNumberVariant)
{
	int i;
	xmlChar *disassyCodeVariant;

	disassyCodeVariant = xmlStrdup(figNumVarFormat);

	for (i = 0; disassyCodeVariant[i]; ++i) {
		switch (disassyCodeVariant[i]) {
			case '%':
				disassyCodeVariant[i] = figureNumberVariant[0];
				break;
			default:
				break;
		}
	}

	return disassyCodeVariant;
}

/* Parse an old (< 4.1) style CSN reference.
 *
 * refcsn (2.0-3.0)/catalogSeqNumberValue (4.0) is a 13-16 digit code:
 *
 * 13:  YY|Y|Y|  YY|YY|Y|NNN|Y (2-character system, 2-character assembly)
 * 14: YYY|Y|Y|  YY|YY|Y|NNN|Y (3-character system, 2-character assembly)
 * 15:  YY|Y|Y|YYYY|YY|Y|NNN|Y (2-character system, 4-character assembly)
 * 16: YYY|Y|Y|YYYY|YY|Y|NNN|Y (3-character system, 4-character assembly)
 *
 * Y = [A-Z0-9 ] (alphanumeric + space)
 * N = [0-9]     (numeric)
 */
#define CSN_VALUE_PATTERN_16 "%3[A-Z0-9 ]%1[A-Z0-9 ]%1[A-Z0-9 ]%4[A-Z0-9 ]%2[A-Z0-9]%1[A-Z0-9 ]%3[0-9]%1[A-Z0-9 ]"
#define CSN_VALUE_PATTERN_15 "%2[A-Z0-9 ]%1[A-Z0-9 ]%1[A-Z0-9 ]%4[A-Z0-9 ]%2[A-Z0-9]%1[A-Z0-9 ]%3[0-9]%1[A-Z0-9 ]"
#define CSN_VALUE_PATTERN_14 "%3[A-Z0-9 ]%1[A-Z0-9 ]%1[A-Z0-9 ]%2[A-Z0-9 ]%2[A-Z0-9]%1[A-Z0-9 ]%3[0-9]%1[A-Z0-9 ]"
#define CSN_VALUE_PATTERN_13 "%2[A-Z0-9 ]%1[A-Z0-9 ]%1[A-Z0-9 ]%2[A-Z0-9 ]%2[A-Z0-9]%1[A-Z0-9 ]%3[0-9]%1[A-Z0-9 ]"

static int str_is_blank(const char *s) {
	int i;
	for (i = 0; s[i]; ++i) {
		if (!isspace((unsigned char) s[i])) {
			return 0;
		}
	}
	return 1;
}

static void parseCsnValue(const xmlChar *csnValue,
	xmlChar **systemCode,
	xmlChar **subSystemCode,
	xmlChar **subSubSystemCode,
	xmlChar **assyCode,
	xmlChar **figureNumber,
	xmlChar **figureNumberVariant,
	xmlChar **item,
	xmlChar **itemVariant)
{
	char system[4];
	char subsys[2];
	char subsub[2];
	char assemb[5];
	char fignum[3];
	char figvar[2];
	char itemno[4];
	char itemva[2];
	const char *pattern;

	switch (xmlStrlen(csnValue)) {
		case 16: pattern = CSN_VALUE_PATTERN_16; break;
		case 15: pattern = CSN_VALUE_PATTERN_15; break;
		case 14: pattern = CSN_VALUE_PATTERN_14; break;
		case 13: pattern = CSN_VALUE_PATTERN_13; break;
		default: pattern = NULL; break;
	}

	if (pattern && sscanf((char *) csnValue, pattern,
			system,
			subsys,
			subsub,
			assemb,
			fignum,
			figvar,
			itemno,
			itemva) == 8) {
		*systemCode          = str_is_blank(system) ? NULL : xmlCharStrdup(system);
		*subSystemCode       = str_is_blank(subsys) ? NULL : xmlCharStrdup(subsys);
		*subSubSystemCode    = str_is_blank(subsub) ? NULL : xmlCharStrdup(subsub);
		*assyCode            = str_is_blank(assemb) ? NULL : xmlCharStrdup(assemb);
		*figureNumber        = xmlCharStrdup(fignum);
		*figureNumberVariant = str_is_blank(figvar) ? NULL : xmlCharStrdup(figvar);
		*item                = xmlCharStrdup(itemno);
		*itemVariant         = str_is_blank(itemva) ? NULL : xmlCharStrdup(itemva);
	} else {
		*systemCode          = NULL;
		*subSystemCode       = NULL;
		*subSubSystemCode    = NULL;
		*assyCode            = NULL;
		*figureNumber        = NULL;
		*figureNumberVariant = NULL;
		*item                = NULL;
		*itemVariant         = NULL;
	}
}

/* Get the code of a CSN ref, including IPD data module code, CSN and item number. */
static void getCsnCode(char *dst, xmlNodePtr ref, xmlChar **csnValue, xmlChar **item, xmlChar **itemVariant)
{
	xmlChar *modelIdentCode;
	xmlChar *systemDiffCode;
	xmlChar *systemCode;
	xmlChar *subSystemCode;
	xmlChar *subSubSystemCode;
	xmlChar *assyCode;
	xmlChar *figureNumber;
	xmlChar *figureNumberVariant;
	xmlChar *itemLocationCode;

	*csnValue = firstXPathValue(NULL, ref, BAD_CAST "@catalogSeqNumberValue|@refcsn");

	if (*csnValue) {
		modelIdentCode = NULL;
		systemDiffCode = NULL;
		itemLocationCode = NULL;

		parseCsnValue(*csnValue,
			&systemCode,
			&subSystemCode,
			&subSubSystemCode,
			&assyCode,
			&figureNumber,
			&figureNumberVariant,
			item,
			itemVariant);
	} else {
		modelIdentCode      = xmlGetProp(ref, BAD_CAST "modelIdentCode");
		systemDiffCode      = xmlGetProp(ref, BAD_CAST "systemDiffCode");
		systemCode          = xmlGetProp(ref, BAD_CAST "systemCode");
		subSystemCode       = xmlGetProp(ref, BAD_CAST "subSystemCode");
		subSubSystemCode    = xmlGetProp(ref, BAD_CAST "subSubSystemCode");
		assyCode            = xmlGetProp(ref, BAD_CAST "assyCode");
		figureNumber        = xmlGetProp(ref, BAD_CAST "figureNumber");
		figureNumberVariant = xmlGetProp(ref, BAD_CAST "figureNumberVariant");
		itemLocationCode    = xmlGetProp(ref, BAD_CAST "itemLocationCode");

		*item               = xmlGetProp(ref, BAD_CAST "item");
		*itemVariant        = xmlGetProp(ref, BAD_CAST "itemVariant");
	}

	/* Apply attributes to non-chapterized or old style CSN refs. */
	if (nonChapIpdSns || *csnValue) {
		xmlNodePtr dmCode = firstXPathNode(NULL, ref, BAD_CAST "ancestor::dmodule/identAndStatusSection/dmAddress/dmIdent/dmCode|ancestor::dmodule/idstatus/dmaddres/dmc/avee");

		if (dmCode) {
			/* These attributes are always interpreted as relative to the current DM. */
			if (!modelIdentCode) {
				modelIdentCode = firstXPathValue(NULL, dmCode, BAD_CAST "@modelIdentCode|modelic");
			}
			if (!systemDiffCode) {
				systemDiffCode = firstXPathValue(NULL, dmCode, BAD_CAST "@systemDiffCode|sdc");
			}

			/* Use wildcard for itemLocationCode if not given. */
			if (!itemLocationCode) {
				itemLocationCode = xmlCharStrdup("?");
			}

			/* If a non-chapterized IPD SNS is given, apply it. */
			if (nonChapIpdSns) {
				/* "-" indicates the SNS is also relative to the current DM. */
				if (strcmp(nonChapIpdSystemCode, "-") == 0) {
					if (!systemCode) {
						systemCode = firstXPathValue(NULL, dmCode,
							BAD_CAST "@systemCode|chapnum");
					}
					if (!subSystemCode) {
						subSystemCode = firstXPathValue(NULL, dmCode,
							BAD_CAST "@subSystemCode|section");
					}
					if (!subSubSystemCode) {
						subSubSystemCode = firstXPathValue(NULL, dmCode,
							BAD_CAST "@subSubSystemCode|subsect");
					}
					if (!assyCode) {
						assyCode = firstXPathValue(NULL, dmCode,
							BAD_CAST "@assyCode|subject");
					}
				/* Otherwise, construct the SNS from the given code. */
				} else {
					if (!systemCode) {
						systemCode = xmlCharStrdup(nonChapIpdSystemCode);
					}
					if (!subSystemCode) {
						subSystemCode = xmlCharStrdup(nonChapIpdSubSystemCode);
					}
					if (!subSubSystemCode) {
						subSubSystemCode = xmlCharStrdup(nonChapIpdSubSubSystemCode);
					}
					if (!assyCode) {
						assyCode = xmlCharStrdup(nonChapIpdAssyCode);
					}
				}
			}
		}
	}

	/* If CSN is chapterized, attempt to match it to a DMC. */
	if (modelIdentCode && systemDiffCode && systemCode && subSystemCode && subSubSystemCode && assyCode && figureNumber) {
		xmlDocPtr tmp;
		xmlNodePtr dmRef, dmRefIdent, dmCode;
		xmlChar *disassyCodeVariant;

		tmp = xmlNewDoc(BAD_CAST "1.0");

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

		xmlDocSetRootElement(tmp, dmRef);

		if (!figureNumberVariant) {
			figureNumberVariant = xmlCharStrdup("0");
		}

		/* The figure number variant alone cannot fully determine the
		 * disassembly code variant of the IPD data module (for example,
		 * in projects where the disassembly code variant is more than 1
		 * character). Therefore, the figNumVarFormat pattern is used to
		 * construct the full disassemby code variant. */
		disassyCodeVariant = formatFigNumVar(figureNumberVariant);

		if (!itemLocationCode) {
			itemLocationCode = xmlCharStrdup("?");
		}

		xmlSetProp(dmCode, BAD_CAST "modelIdentCode", modelIdentCode);
		xmlSetProp(dmCode, BAD_CAST "systemDiffCode", systemDiffCode);
		xmlSetProp(dmCode, BAD_CAST "systemCode", systemCode);
		xmlSetProp(dmCode, BAD_CAST "subSystemCode", subSystemCode);
		xmlSetProp(dmCode, BAD_CAST "subSubSystemCode", subSubSystemCode);
		xmlSetProp(dmCode, BAD_CAST "assyCode", assyCode);
		xmlSetProp(dmCode, BAD_CAST "disassyCode", figureNumber);
		xmlSetProp(dmCode, BAD_CAST "disassyCodeVariant", disassyCodeVariant);
		xmlSetProp(dmCode, BAD_CAST "infoCode", BAD_CAST "941");
		xmlSetProp(dmCode, BAD_CAST "infoCodeVariant", BAD_CAST "A");
		xmlSetProp(dmCode, BAD_CAST "itemLocationCode", itemLocationCode);

		getDmCode(dst, dmRef);

		xmlFree(disassyCodeVariant);
		xmlFreeDoc(tmp);
	/* Otherwise, just return a generic IPD figure name. */
	} else {
		strcpy(dst, "Fig ");
		if (figureNumber) {
			strcat(dst, (char *) figureNumber);
		} else {
			strcat(dst, "??");
		}
		if (figureNumberVariant) {
			strcat(dst, (char *) figureNumberVariant);
		}
	}

	xmlFree(modelIdentCode);
	xmlFree(systemDiffCode);
	xmlFree(systemCode);
	xmlFree(subSystemCode);
	xmlFree(subSubSystemCode);
	xmlFree(assyCode);
	xmlFree(figureNumber);
	xmlFree(figureNumberVariant);
	xmlFree(itemLocationCode);
}

/* Get the code of an IPD data module only, discarding item number. */
static void getIpdCode(char *dst, xmlNodePtr ref)
{
	xmlChar *csn;
	xmlChar *item;
	xmlChar *itemVariant;

	getCsnCode(dst, ref, &csn, &item, &itemVariant);

	xmlFree(csn);
	xmlFree(item);
	xmlFree(itemVariant);
}

/* Match a CSN item in an IPD. */
static int matchCsnItem(xmlDocPtr doc, xmlNodePtr ref, xmlChar *csn,
	xmlChar *item, xmlChar *itemVariant, const char *code,
	const char *fname, const char *src)
{
	xmlChar *itemSeqNumberValue, *id;
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	xmlNodePtr node;
	char *s;
	int err = doc == NULL;

	itemSeqNumberValue = firstXPathValue(NULL, ref, BAD_CAST "@itemSeqNumberValue|@refisn");

	id = xmlCharStrdup("Item ");
	id = xmlStrcat(id, item);
	id = xmlStrcat(id, itemVariant);
	if (itemSeqNumberValue) {
		id = xmlStrcat(id, BAD_CAST " ISN ");
		id = xmlStrcat(id, itemSeqNumberValue);
	}

	if (doc) {
		ctx = xmlXPathNewContext(doc);
		xmlXPathRegisterVariable(ctx, BAD_CAST "item", xmlXPathNewString(item));
		xmlXPathRegisterVariable(ctx, BAD_CAST "itemVariant", xmlXPathNewString(itemVariant));
		xmlXPathRegisterVariable(ctx, BAD_CAST "csn", xmlXPathNewString(csn));

		if (itemSeqNumberValue) {
			xmlXPathRegisterVariable(ctx, BAD_CAST "isn", xmlXPathNewString(itemSeqNumberValue));
			obj = xmlXPathEvalExpression(BAD_CAST
				/* 4.1+ */ "//catalogSeqNumber[@item=$item and (not(@itemVariant) or not($itemVariant) or @itemVariant=$itemVariant)]/itemSeqNumber[@itemSeqNumberValue=$isn]|"
				/* 4.0  */ "//catalogSeqNumber[@catalogSeqNumberValue=$csn]/itemSequenceNumber[@itemSeqNumberValue=$isn]|"
				/* 3.0- */ "//csn[@csn=$csn]/isn[@isn=$isn]",
				ctx);
		} else {
			obj = xmlXPathEvalExpression(BAD_CAST
				/* 4.1+ */ "//catalogSeqNumber[@item=$item and (not(@itemVariant) or not($itemVariant) or @itemVariant=$itemVariant)]|"
				/* 4.0  */ "//catalogSeqNumber[@catalogSeqNumberValue=$csn]|"
				/* 3.0- */ "//csn[@csn=$csn]",
				ctx);
		}

		if (!obj || xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
			node = NULL;
		} else {
			node = obj->nodesetval->nodeTab[0];
		}

		xmlXPathFreeObject(obj);
		xmlXPathFreeContext(ctx);

		if (node) {
			if (showMatched && !tagUnmatched) {
				s = malloc(strlen(fname) + strlen((char *) id) + 2);

				strcpy(s, fname);
				strcat(s, " ");
				strcat(s, (char *) id);

				printMatchedFn(ref, src, s, fname);

				free(s);
			}
		} else {
			++err;
		}
	}

	if (err) {
		s = malloc(strlen(doc ? fname : code) + strlen((char *) id) + 2);
		strcpy(s, doc ? fname : code);
		strcat(s, " ");
		strcat(s, (char *) id);

		if (tagUnmatched) {
			tagUnmatchedRef(ref);
		} else if (showUnmatched) {
			printMatchedFn(ref, src, s, doc ? fname : NULL);
		} else if (verbosity >= NORMAL) {
			printUnmatchedFn(ref, src, s, doc ? fname : NULL);
		}

		free(s);
	}

	xmlFree(itemSeqNumberValue);
	xmlFree(id);

	return err;

}

/* Match the CSN items in another DM. */
static int getCsnItem(xmlNodePtr ref, const char *src)
{
	xmlNodePtr csnref;
	char code[PATH_MAX], fname[PATH_MAX];
	xmlDocPtr doc;
	int err;
	xmlChar *csn;
	xmlChar *item;
	xmlChar *itemVariant;

	csnref = ref->parent;

	getCsnCode(code, csnref, &csn, &item, &itemVariant);

	if (find_object_fname(fname, directory, code, recursive)) {
		doc = read_xml_doc(fname);
	} else {
		doc = NULL;
	}

	if (remDelete) {
		rem_delete_elems(doc);
	}

	err = matchCsnItem(doc, csnref, csn, item, itemVariant, code, doc ? fname : code, src);

	xmlFree(csn);
	xmlFree(item);
	xmlFree(itemVariant);

	xmlFreeDoc(doc);

	return err;
}

/* Update address items using the matched referenced object. */
static void updateRef(xmlNodePtr *refptr, const char *src, const char *code, const char *fname)
{
	xmlNodePtr ref = *refptr;

	if (verbosity >= DEBUG) {
		fprintf(stderr, I_UPDATE_REF, src, code, fname);
	}

	if (xmlStrcmp(ref->name, BAD_CAST "dmRef") == 0) {
		xmlDocPtr doc;
		xmlNodePtr dmRefAddressItems, dmTitle;
		xmlChar *techName, *infoName, *infoNameVariant;

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

		if (updateRefIdent) {
			xmlNodePtr dmRefIdent, refIssueInfo, refLanguage, issueInfo, language;

			dmRefIdent   = firstXPathNode(NULL, ref, BAD_CAST "dmRefIdent");
			refIssueInfo = firstXPathNode(NULL, dmRefIdent, BAD_CAST "issueInfo");
			refLanguage  = firstXPathNode(NULL, dmRefIdent, BAD_CAST "language");

			issueInfo = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//issueInfo|//issno"), 1);
			language  = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//language"), 1);

			/* 4.x references a 3.0 DM */
			if (xmlStrcmp(issueInfo->name, BAD_CAST "issno") == 0) {
				xmlNodeSetName(issueInfo, BAD_CAST "issueInfo");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(issueInfo,
					BAD_CAST "issno"),
					BAD_CAST "issueNumber");
				if (xmlHasProp(issueInfo, BAD_CAST "inwork")) {
					xmlNodeSetName((xmlNodePtr) xmlHasProp(issueInfo,
						BAD_CAST "inwork"),
						BAD_CAST "inWork");
				} else {
					xmlSetProp(issueInfo, BAD_CAST "inWork", BAD_CAST "00");
				}
				xmlUnsetProp(issueInfo, BAD_CAST "type");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(language,
					BAD_CAST "language"),
					BAD_CAST "languageIsoCode");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(language,
					BAD_CAST "country"),
					BAD_CAST "countryIsoCode");
			}

			if (refIssueInfo) {
				xmlUnlinkNode(refIssueInfo);
				xmlFreeNode(refIssueInfo);
			}
			if (refLanguage) {
				xmlUnlinkNode(refLanguage);
				xmlFreeNode(refLanguage);
			}

			xmlAddChild(dmRefIdent, issueInfo);
			xmlAddChild(dmRefIdent, language);
		}

		if ((dmRefAddressItems = firstXPathNode(NULL, ref, BAD_CAST "dmRefAddressItems"))) {
			xmlUnlinkNode(dmRefAddressItems);
			xmlFreeNode(dmRefAddressItems);
		}
		dmRefAddressItems = xmlNewChild(ref, NULL, BAD_CAST "dmRefAddressItems", NULL);

		techName = firstXPathValue(doc, NULL, BAD_CAST "//techName|//techname");
		infoName = firstXPathValue(doc, NULL, BAD_CAST "//infoName|//infoname");
		infoNameVariant = firstXPathValue(doc, NULL, BAD_CAST "//infoNameVariant");

		dmTitle = xmlNewChild(dmRefAddressItems, NULL, BAD_CAST "dmTitle", NULL);
		xmlNewTextChild(dmTitle, NULL, BAD_CAST "techName", techName);
		if (infoName) {
			xmlNewTextChild(dmTitle, NULL, BAD_CAST "infoName", infoName);
		}
		if (infoNameVariant) {
			xmlNewTextChild(dmTitle, NULL, BAD_CAST "infoNameVariant", infoNameVariant);
		}

		xmlFree(techName);
		xmlFree(infoName);

		if (updateRefIdent) {
			xmlNodePtr issueDate;

			issueDate = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//issueDate|//issdate"), 1);

			if (xmlStrcmp(issueDate->name, BAD_CAST "issdate")) {
				xmlNodeSetName(issueDate, BAD_CAST "issueDate");
			}

			xmlAddChild(dmRefAddressItems, issueDate);
		}

		xmlFreeDoc(doc);
	} else if (xmlStrcmp(ref->name, BAD_CAST "pmRef") == 0) {
		xmlDocPtr doc;
		xmlNodePtr pmRefAddressItems;
		xmlChar *pmTitle;

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

		if (updateRefIdent) {
			xmlNodePtr pmRefIdent, refIssueInfo, refLanguage, issueInfo, language;

			pmRefIdent   = firstXPathNode(NULL, ref, BAD_CAST "pmRefIdent");
			refIssueInfo = firstXPathNode(NULL, pmRefIdent, BAD_CAST "issueInfo");
			refLanguage  = firstXPathNode(NULL, pmRefIdent, BAD_CAST "language");
			issueInfo    = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//issueInfo|//issno"), 1);
			language     = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//language"), 1);

			/* 4.x references a 3.0 DM */
			if (xmlStrcmp(issueInfo->name, BAD_CAST "issno") == 0) {
				xmlNodeSetName(issueInfo, BAD_CAST "issueInfo");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(issueInfo,
					BAD_CAST "issno"),
					BAD_CAST "issueNumber");
				if (xmlHasProp(issueInfo, BAD_CAST "inwork")) {
					xmlNodeSetName((xmlNodePtr) xmlHasProp(issueInfo,
						BAD_CAST "inwork"),
						BAD_CAST "inWork");
				} else {
					xmlSetProp(issueInfo, BAD_CAST "inWork", BAD_CAST "00");
				}
				xmlUnsetProp(issueInfo, BAD_CAST "type");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(language,
					BAD_CAST "language"),
					BAD_CAST "languageIsoCode");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(language,
					BAD_CAST "country"),
					BAD_CAST "countryIsoCode");
			}

			if (refIssueInfo) {
				xmlUnlinkNode(refIssueInfo);
				xmlFreeNode(refIssueInfo);
			}
			if (refLanguage) {
				xmlUnlinkNode(refLanguage);
				xmlFreeNode(refLanguage);
			}

			xmlAddChild(pmRefIdent, issueInfo);
			xmlAddChild(pmRefIdent, language);
		}

		if ((pmRefAddressItems = firstXPathNode(NULL, ref, BAD_CAST "pmRefAddressItems"))) {
			xmlUnlinkNode(pmRefAddressItems);
			xmlFreeNode(pmRefAddressItems);
		}
		pmRefAddressItems = xmlNewChild(ref, NULL, BAD_CAST "pmRefAddressItems", NULL);

		pmTitle = firstXPathValue(doc, NULL, BAD_CAST "//pmTitle|//pmtitle");

		xmlNewTextChild(pmRefAddressItems, NULL, BAD_CAST "pmTitle", pmTitle);

		xmlFree(pmTitle);

		if (updateRefIdent) {
			xmlNodePtr issueDate;

			issueDate = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//issueDate|//issdate"), 1);

			if (xmlStrcmp(issueDate->name, BAD_CAST "issdate")) {
				xmlNodeSetName(issueDate, BAD_CAST "issueDate");
			}

			xmlAddChild(pmRefAddressItems, issueDate);
		}

		xmlFreeDoc(doc);
	} else if (xmlStrcmp(ref->name, BAD_CAST "refdm") == 0) {
		xmlDocPtr doc;
		xmlNodePtr oldtitle, newtitle;
		xmlChar *techname, *infoname;

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

		if (updateRefIdent) {
			xmlNodePtr oldissno, newissno, oldlanguage, newlanguage;

			newissno    = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//issueInfo|//issno"), 1);
			newlanguage = xmlCopyNode(firstXPathNode(doc, NULL, BAD_CAST "//language"), 1);

			/* 3.0 references a 4.x DM */
			if (xmlStrcmp(newissno->name, BAD_CAST "issueInfo") == 0) {
				xmlNodeSetName(newissno, BAD_CAST "issno");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(newissno,
					BAD_CAST "issueNumber"),
					BAD_CAST "issno");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(newissno,
					BAD_CAST "inWork"),
					BAD_CAST "inwork");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(newlanguage,
					BAD_CAST "languageIsoCode"),
					BAD_CAST "language");
				xmlNodeSetName((xmlNodePtr) xmlHasProp(newlanguage,
					BAD_CAST "countryIsoCode"),
					BAD_CAST "country");
			}

			if ((oldissno = firstXPathNode(NULL, ref, BAD_CAST "issno"))) {
				newissno = xmlAddNextSibling(oldissno, newissno);
			} else {
				newissno = xmlAddNextSibling(firstXPathNode(NULL, ref, BAD_CAST "avee"), newissno);
			}
			xmlUnlinkNode(oldissno);
			xmlFreeNode(oldissno);

			if ((oldlanguage = firstXPathNode(NULL, ref, BAD_CAST "language"))) {
				newlanguage = xmlAddNextSibling(oldlanguage, newlanguage);
			} else {
				newlanguage = xmlAddNextSibling(firstXPathNode(NULL, ref, BAD_CAST "issno"), newlanguage);
			}
			xmlUnlinkNode(oldlanguage);
			xmlFreeNode(oldlanguage);
		}

		techname = firstXPathValue(doc, NULL, BAD_CAST "//techName|//techname");
		infoname = firstXPathValue(doc, NULL, BAD_CAST "//infoName|//infoname");

		newtitle = xmlNewNode(NULL, BAD_CAST "dmtitle");

		if ((oldtitle = firstXPathNode(NULL, ref, BAD_CAST "dmtitle"))) {
			newtitle = xmlAddNextSibling(oldtitle, newtitle);
		} else {
			newtitle = xmlAddNextSibling(firstXPathNode(NULL, ref, BAD_CAST "(avee|issno)[last()]"), newtitle);
		}

		xmlNewTextChild(newtitle, NULL, BAD_CAST "techname", techname);
		if (infoname) {
			xmlNewTextChild(newtitle, NULL, BAD_CAST "infoname", infoname);
		}

		xmlFree(techname);
		xmlFree(infoname);

		xmlUnlinkNode(oldtitle);
		xmlFreeNode(oldtitle);
		xmlFreeDoc(doc);
	} else if (xmlStrcmp(ref->name, BAD_CAST "infoEntityIdent") == 0) {
		xmlChar *icn;
		xmlEntityPtr e;

		/* Remove old ICN entity. */
		icn = xmlNodeGetContent(ref);
		if ((e = xmlGetDocEntity(ref->doc, icn))) {
			xmlUnlinkNode((xmlNodePtr) e);
			xmlFreeEntity(e);
		}
		xmlFree(icn);

		/* Add new ICN entity. */
		e = add_icn(ref->doc, fname, false);
		xmlNodeSetContent(ref, e->name);
	} else if (xmlStrcmp(ref->name, BAD_CAST "externalPubRef") == 0) {
		xmlNodePtr new;
		xmlChar xpath[512];

		xmlStrPrintf(xpath, 512, "//externalPubRef[externalPubRefIdent/externalPubCode='%s']", code);

		if (!(new = firstXPathNode(externalPubs, NULL, xpath))) {
			return;
		}

		xmlAddNextSibling(ref, xmlCopyNode(new, 1));

		xmlUnlinkNode(ref);
		xmlFreeNode(ref);
		*refptr = NULL;
	}
}

static int listReferences(const char *path, int show, const char *targetRef, int targetShow);
static int listWhereUsed(const char *path, int show);

/* Print a reference found in an object. */
static int printReference(xmlNodePtr *refptr, const char *src, int show, const char *targetRef, int targetShow)
{
	char code[PATH_MAX];
	char fname[PATH_MAX];
	xmlNodePtr ref = *refptr;

	if ((show & SHOW_DMC) == SHOW_DMC &&
	    (xmlStrcmp(ref->name, BAD_CAST "dmRef") == 0 ||
	     xmlStrcmp(ref->name, BAD_CAST "refdm") == 0 ||
	     xmlStrcmp(ref->name, BAD_CAST "addresdm") == 0))
		getDmCode(code, ref);
	else if ((show & SHOW_PMC) == SHOW_PMC &&
		 (xmlStrcmp(ref->name, BAD_CAST "pmRef") == 0 ||
	          xmlStrcmp(ref->name, BAD_CAST "refpm") == 0))
		getPmCode(code, ref);
	else if ((show & SHOW_SMC) == SHOW_SMC && xmlStrcmp(ref->name, BAD_CAST "scormContentPackageRef") == 0)
		getSmcCode(code, ref);
	else if ((show & SHOW_ICN) == SHOW_ICN &&
	         (xmlStrcmp(ref->name, BAD_CAST "infoEntityRef") == 0))
		getICN(code, ref);
	else if ((show & SHOW_COM) == SHOW_COM && (xmlStrcmp(ref->name, BAD_CAST "commentRef") == 0))
		getComCode(code, ref);
	else if ((show & SHOW_DML) == SHOW_DML && (xmlStrcmp(ref->name, BAD_CAST "dmlRef") == 0))
		getDmlCode(code, ref);
	else if ((show & SHOW_ICN) == SHOW_ICN &&
		 (xmlStrcmp(ref->name, BAD_CAST "infoEntityIdent") == 0 ||
	          xmlStrcmp(ref->name, BAD_CAST "boardno") == 0))
		getICNAttr(code, ref);
	else if ((show & SHOW_EPR) == SHOW_EPR &&
	         (xmlStrcmp(ref->name, BAD_CAST "externalPubRef") == 0 ||
		  xmlStrcmp(ref->name, BAD_CAST "reftp") == 0))
		getExternalPubCode(code, ref);
	else if (xmlStrcmp(ref->name, BAD_CAST "dispatchFileName") == 0 ||
	         xmlStrcmp(ref->name, BAD_CAST "ddnfilen") == 0)
		getDispatchFileName(code, ref);
	else if ((show & SHOW_SRC) == SHOW_SRC &&
		(xmlStrcmp(ref->name, BAD_CAST "sourceDmIdent") == 0 ||
		 xmlStrcmp(ref->name, BAD_CAST "sourcePmIdent") == 0))
		getSourceIdent(code, ref);
	else if ((show & SHOW_REP) == SHOW_REP &&
		xmlStrcmp(ref->name, BAD_CAST "repositorySourceDmIdent") == 0)
		getSourceIdent(code, ref);
	else if ((show & SHOW_HOT) == SHOW_HOT &&
		 xmlStrcmp(ref->name, BAD_CAST "graphic") == 0)
		return getHotspots(ref, src);
	else if ((show & SHOW_FRG) == SHOW_FRG &&
		 (xmlStrcmp(ref->name, BAD_CAST "referredFragment") == 0 ||
		  xmlStrcmp(ref->name, BAD_CAST "target") == 0))
		return getFragment(ref, src);
	else if ((show & SHOW_IPD) == SHOW_IPD &&
		 (xmlStrcmp(ref->name, BAD_CAST "catalogSeqNumberRef") == 0 ||
		  xmlStrcmp(ref->name, BAD_CAST "csnref") == 0))
		getIpdCode(code, ref);
	else if ((show & SHOW_CSN) == SHOW_CSN &&
		 (xmlStrcmp(ref->name, BAD_CAST "item") == 0 ||
		  xmlStrcmp(ref->name, BAD_CAST "catalogSeqNumberValue") == 0 ||
		  xmlStrcmp(ref->name, BAD_CAST "refcsn") == 0))
		return getCsnItem(ref, src);
	else
		return 0;

	if (targetRef) {
		/* If looking for a particular ref in -w mode, skip any others. */
		if (!strnmatch(targetRef, code, strlen(code))) {
			return 0;
		}

		/* Replace the code with the target ref so as to match that
		 * specific object rather than the latest object with the same
		 * code. */
		strcpy(code, targetRef);
	}

	if (find_object_fname(fname, directory, code, recursive)) {
		if (updateRefs) {
			updateRef(refptr, src, code, fname);
		} else if (!tagUnmatched) {
			if (showMatched) {
				printMatchedFn(ref, src, fname, fname);
			}

			if (listRecursively) {
				if (targetRef) {
					listWhereUsed(src, targetShow);
				} else {
					listReferences(fname, show, NULL, 0);
				}
			}
		}
		return 0;
	} else if (tagUnmatched) {
		tagUnmatchedRef(ref);
	} else if (showUnmatched) {
		printMatchedFn(ref, src, code, NULL);
	} else if (verbosity >= NORMAL) {
		printUnmatchedFn(ref, src, code, NULL);
	}

	/* Update metadata for unmatched external pubs. */
	if (updateRefs && externalPubs && xmlStrcmp(ref->name, BAD_CAST "externalPubRef") == 0) {
		updateRef(refptr, src, code, fname);
	}

	return 1;
}

/* Check if a file has already been listed when listing recursively. */
static bool listedFile(const char *path)
{
	int i;
	for (i = 0; i < numListedFiles; ++i) {
		if (strcmp(listedFiles[i], path) == 0) {
			return true;
		}
	}
	return false;
}

/* Add a file to the list of files already checked. */
static void addFile(const char *path)
{
	if (!listedFiles || numListedFiles == maxListedFiles) {
		if (!(listedFiles = realloc(listedFiles, (maxListedFiles *= 2) * PATH_MAX))) {
			fprintf(stderr, E_OUT_OF_MEMORY);
			exit(EXIT_OUT_OF_MEMORY);
		}
	}

	strcpy(listedFiles[numListedFiles++], path);
}

/* XPath to select all possible types of references. */
#define REFS_XPATH BAD_CAST \
	".//dmRef|.//refdm|.//addresdm|" \
	".//pmRef|.//refpm|" \
	".//infoEntityRef|//@infoEntityIdent|//@boardno|" \
	".//commentRef|" \
	".//dmlRef|" \
	".//externalPubRef|.//reftp|" \
	".//dispatchFileName|.//ddnfilen|" \
	".//graphic[hotspot]|" \
	".//dmRef/@referredFragment|.//refdm/@target|" \
	".//scormContentPackageRef|" \
	".//sourceDmIdent|.//sourcePmIdent|.//repositorySourceDmIdent|" \
	".//catalogSeqNumberRef|.//csnref|" \
	".//catalogSeqNumberRef/@item|.//catalogSeqNumberRef/@catalogSeqNumberValue|.//@refcsn"

/* List all references in the given object. */
static int listReferences(const char *path, int show, const char *targetRef, int targetShow)
{
	xmlDocPtr doc;
	xmlXPathContextPtr ctx;
	xmlXPathObjectPtr obj;
	int unmatched = 0;
	xmlDocPtr validTree = NULL;

	/* In recursive mode, keep a record of which files have been listed
	 * to avoid infinite loops.
	 *
	 * If this is invoked in -w mode (targetRef != NULL), don't update the
	 * record, as that is handled by listWhereUsed.
	 */
	if (listRecursively && targetRef == NULL) {
		if (listedFile(path)) {
			return 0;
		}

		addFile(path);
	}

	if (listSrc) {
		printMatchedFn(NULL, path, path, path);
	}

	if (!(doc = read_xml_doc(path))) {
		if (strcmp(path, "-") == 0) {
			fprintf(stderr, E_BAD_STDIN);
			exit(EXIT_BAD_STDIN);
		}

		return 0;
	}

	/* Make a copy of the XML tree before performing extra
	 * processing on it. */
	if (outputTree) {
		validTree = xmlCopyDoc(doc, 1);
	}

	/* Remove elements marked as "delete". */
	if (remDelete) {
		rem_delete_elems(doc);
	}

	ctx = xmlXPathNewContext(doc);

	if (contentOnly)
		ctx->node = firstXPathNode(doc, NULL,
			BAD_CAST "//content|//dmlContent|//dml|//ddnContent|//delivlst");
	else
		ctx->node = xmlDocGetRootElement(doc);

	obj = xmlXPathEvalExpression(REFS_XPATH, ctx);

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

		for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
			unmatched += printReference(&(obj->nodesetval->nodeTab[i]), path, show, targetRef, targetShow);
		}
	}

	/* Write valid CSDB object to stdout. */
	if (outputTree) {
		if (unmatched == 0) {
			save_xml_doc(validTree, "-");
		}
		xmlFreeDoc(validTree);
	}

	/* If the given object was modified by updating matched refs or
	 * tagging unmatched refs, write the changes.
	 */
	if (updateRefs || tagUnmatched) {
		if (overwriteUpdated) {
			save_xml_doc(doc, path);
		} else {
			save_xml_doc(doc, "-");
		}
	}

	xmlXPathFreeObject(obj);
	xmlXPathFreeContext(ctx);
	xmlFreeDoc(doc);

	if (verbosity >= VERBOSE && !targetRef) {
		fprintf(stderr, unmatched ? F_UNMATCHED : S_UNMATCHED, path);
	}

	return unmatched;
}

/* Parse a list of filenames as input. */
static int listReferencesInList(const char *path, int show)
{
	FILE *f;
	char line[PATH_MAX];
	int unmatched = 0;

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

	while (fgets(line, PATH_MAX, f)) {
		strtok(line, "\t\r\n");
		unmatched += listReferences(line, show, NULL, 0);
	}

	if (path) {
		fclose(f);
	}

	return unmatched;
}

/* Register a NS for the hotspot XPath expression. */
static void addHotspotNs(char *s)
{
	char *prefix, *uri;
	xmlNodePtr node;

	prefix = strtok(s, "=");
	uri = strtok(NULL, "");

	node = xmlNewChild(hotspotNs, NULL, BAD_CAST "ns", NULL);
	xmlSetProp(node, BAD_CAST "prefix", BAD_CAST prefix);
	xmlSetProp(node, BAD_CAST "uri", BAD_CAST uri);
}

/* Determine if an object is a type that may contain references to other
 * objects. */
static bool isUsedTarget(const char *name, int show)
{
	return
		(optset(show, SHOW_COM) && is_com(name)) ||
		(optset(show, SHOW_DMC) && is_dm(name))  ||
		(optset(show, SHOW_DML) && is_dml(name)) ||
		(optset(show, SHOW_PMC) && is_pm(name))  ||
		(optset(show, SHOW_SMC) && is_smc(name));
}

/* Search objects in a given directory for references to a target object. */
static int findWhereUsed(const char *dpath, const char *ref, int show)
{
	DIR *dir;
	struct dirent *cur;
	char fpath[PATH_MAX], cpath[PATH_MAX];
	int unmatched = 0;

	if (!(dir = opendir(dpath))) {
		return 1;
	}

	if (strcmp(dpath, ".") == 0) {
		strcpy(fpath, "");
	} else if (dpath[strlen(dpath) - 1] != '/') {
		strcpy(fpath, dpath);
		strcat(fpath, "/");
	} else {
		strcpy(fpath, dpath);
	}

	while ((cur = readdir(dir))) {
		strcpy(cpath, fpath);
		strcat(cpath, cur->d_name);

		if (recursive && isdir(cpath, true)) {
			unmatched += findWhereUsed(cpath, ref, show);
		} else if (isUsedTarget(cur->d_name, show)) {
			unmatched += listReferences(cpath, SHOW_WHERE_USED, ref, show);
		}
	}

	closedir(dir);

	return unmatched;
}

/* List objects that reference a target object. */
static int listWhereUsed(const char *path, int show)
{
	char code[PATH_MAX] = "";
	xmlDocPtr doc;

	/* In recursive mode, keep a record of which objects have been listed
	 * to avoid infinite loops. */
	if (listRecursively) {
		if (listedFile(path)) {
			return 0;
		}

		addFile(path);
	}

	if (verbosity >= VERBOSE) {
		fprintf(stderr, I_WHEREUSED, path);
	}

	/* If the target object is an ICN, get the ICN from the file name. */
	if (is_icn(path)) {
		strcpy(code, path);
		strtok(code, ".");
	/* If the target object is an XML file, read the object and get the
	 * appropriate code from the IDSTATUS section. */
	} else if ((doc = read_xml_doc(path))) {
		xmlDocPtr tmp;
		xmlNodePtr ident, node;

		if (remDelete) {
			rem_delete_elems(doc);
		}

		ident = firstXPathNode(doc, NULL, BAD_CAST "//dmIdent|//pmIdent|//commentIdent|//dmlIdent|//scormContentPackageIdent");
		node  = xmlNewNode(NULL, BAD_CAST "ref");
		ident = xmlAddChild(node, xmlCopyNode(ident, 1));
		tmp   = xmlNewDoc(BAD_CAST "1.0");
		xmlDocSetRootElement(tmp, node);

		if (xmlStrcmp(ident->name, BAD_CAST "commentIdent") == 0) {
			xmlNodeSetName(ident, BAD_CAST "commentRefIdent");
			xmlNodeSetName(ident, BAD_CAST "commentRef");
			getComCode(code, node);
		} else if (xmlStrcmp(ident->name, BAD_CAST "dmIdent") == 0) {
			xmlNodeSetName(ident, BAD_CAST "dmRefIdent");
			xmlNodeSetName(node , BAD_CAST "dmRef");
			getDmCode(code, node);
		} else if (xmlStrcmp(ident->name, BAD_CAST "dmlIdent") == 0) {
			xmlNodeSetName(ident, BAD_CAST "dmlRefIdent");
			xmlNodeSetName(node , BAD_CAST "dmlRef");
			getDmlCode(code, node);
		} else if (xmlStrcmp(ident->name, BAD_CAST "pmIdent") == 0) {
			xmlNodeSetName(ident, BAD_CAST "pmRefIdent");
			xmlNodeSetName(node , BAD_CAST "pmRef");
			getPmCode(code, node);
		} else if (xmlStrcmp(ident->name, BAD_CAST "scormContentPackageIdent") == 0) {
			xmlNodeSetName(ident, BAD_CAST "scormContentPackageRefIdent");
			xmlNodeSetName(node , BAD_CAST "scormContentPackageRef");
			getSmcCode(code, node);
		} else if (xmlStrcmp(ident->name, BAD_CAST "sourceDmIdent") == 0 ||
			   xmlStrcmp(ident->name, BAD_CAST "sourcePmIdent") == 0 ||
			   xmlStrcmp(ident->name, BAD_CAST "repositorySourceDmIdent") == 0) {
			getSourceIdent(code, ident);
		}

		xmlFreeDoc(tmp);
		xmlFreeDoc(doc);
	/* Otherwise, interpret the path as a literal code. */
	} else {
		strcpy(code, path);
	}

	/* If no code could be determined, give up. */
	if (strcmp(code, "") == 0) {
		return 1;
	}

	return findWhereUsed(directory, code, show);
}

/* List objects that reference any of a list of target objects. */
static int listWhereUsedList(const char *path, int show)
{
	FILE *f;
	char line[PATH_MAX];
	int unmatched = 0;

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

	while (fgets(line, PATH_MAX, f)) {
		strtok(line, "\t\r\n");
		unmatched += listWhereUsed(line, show);
	}

	if (path) {
		fclose(f);
	}

	return unmatched;
}

/* Read a non-chapterized IPD SNS code. */
static void readnonChapIpdSns(const char *s)
{
	if (strcmp(s, "-") == 0) {
		strcpy(nonChapIpdSystemCode, s);
	} else {
		int n;

		n = sscanf(s, "%3[0-9A-Z]-%1[0-9A-Z]%1[0-9A-Z]-%4[0-9A-Z]",
			nonChapIpdSystemCode,
			nonChapIpdSubSystemCode,
			nonChapIpdSubSubSystemCode,
			nonChapIpdAssyCode);

		if (n != 4) {
			fprintf(stderr, E_BAD_CSN_CODE, s);
			exit(EXIT_BAD_CSN_CODE);
		}
	}
}

/* Display the usage message. */
static void show_help(void)
{
	puts("Usage: s1kd-refs [-aBCcDEFfGHIiKLlmNnoPqrSsTUuvwXxYZ^h?] [-b <SNS>] [-d <dir>] [-e <cmd>] [-J <ns=URL> ...] [-j <xpath>] [-k <pattern>] [-t <fmt>] [-3 <file>] [<object>...]");
	puts("");
	puts("Options:");
	puts("  -a, --all                    Print unmatched codes.");
	puts("  -B, --ipd                    List IPD references.");
	puts("  -b, --ipd-sns <SNS>          The SNS for non-chapterized IPDs.");
	puts("  -C, --com                    List comment references.");
	puts("  -c, --content                Only show references in content section.");
	puts("  -D, --dm                     List data module references.");
	puts("  -d, --dir                    Directory to search for matches in.");
	puts("  -E, --epr                    List external pub refs.");
	puts("  -e, --exec <cmd>             Execute <cmd> for each CSDB object matched.");
	puts("  -F, --overwrite              Overwrite updated (-U) or tagged (-X) objects.");
	puts("  -f, --filename               Print the source filename for each reference.");
	puts("  -G, --icn                    List ICN references.");
	puts("  -H, --hotspot                List hotspot matches in ICNs.");
	puts("  -h, -?, --help               Show help/usage message.");
	puts("  -I, --update-issue           Update references to point to the latest matched object.");
	puts("  -i, --ignore-issue           Ignore issue info when matching.");
	puts("  -J, --namespace <ns=URL>     Register a namespace for the hotspot XPath.");
	puts("  -j, --hotspot-xpath <xpath>  XPath to use for matching hotspots (-H).");
	puts("  -K, --csn                    List CSN references.");
	puts("  -k, --ipd-dcv <pattern>      Pattern for IPD disassembly code variant.");
	puts("  -L, --dml                    List DML references.");
	puts("  -l, --list                   Treat input as list of CSDB objects.");
	puts("  -m, --strict-match           Be more strict when matching filenames of objects.");
	puts("  -N, --omit-issue             Assume filenames omit issue info.");
	puts("  -n, --lineno                 Print the source filename and line number for each reference.");
	puts("  -o, --output-valid           Output valid CSDB objects to stdout.");
	puts("  -P, --pm                     List publication module references.");
	puts("  -q, --quiet                  Quiet mode.");
	puts("  -R, --recursively            List references in matched objects recursively.");
	puts("  -r, --recursive              Search for matches in directories recursively.");
	puts("  -S, --smc                    List SCORM content package references.");
	puts("  -s, --include-src            Include the source object as a reference.");
	puts("  -T, --fragment               List referred fragments in other DMs.");
	puts("  -t, --format <fmt>           The format to use when printing references.");
	puts("  -U, --update                 Update address items in matched references.");
	puts("  -u, --unmatched              Show only unmatched references.");
	puts("  -v, --verbose                Verbose output.");
	puts("  -w, --where-used             List places where an object is referenced.");
	puts("  -X, --tag-unmatched          Tag unmatched references.");
	puts("  -x, --xml                    Output XML report.");
	puts("  -Y, --repository             List repository source DMs.");
	puts("  -Z, --source                 List source DM or PM.");
	puts("  -3, --externalpubs <file>    Use custom .externalpubs file.");
	puts("  -^, --remove-deleted         List refs with elements marked as \"delete\" removed.");
	puts("  --version                    Show version information.");
	puts("  <object>                     CSDB object to list references in.");
	LIBXML2_PARSE_LONGOPT_HELP
}

/* Display version information. */
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, unmatched = 0;

	bool isList = false;
	bool xmlOutput = false;
	bool inclSrcFname = false;
	bool inclLineNum = false;
	char extpubsFname[PATH_MAX] = "";
	bool findUsed = false;

	/* Which types of object references will be listed. */
	int showObjects = 0;

	const char *sopts = "qcNaFfLlUuCDGPRrd:IinEXxSsove:mHj:J:Tt:3:wYZBKb:k:^h?";
	struct option lopts[] = {
		{"version"       , no_argument      , 0, 0},
		{"help"          , no_argument      , 0, 'h'},
		{"quiet"         , no_argument      , 0, 'q'},
		{"content"       , no_argument      , 0, 'c'},
		{"externalpubs"  , required_argument, 0, '3'},
		{"omit-issue"    , no_argument      , 0, 'N'},
		{"all"           , no_argument      , 0, 'a'},
		{"overwrite"     , no_argument      , 0, 'F'},
		{"filename"      , no_argument      , 0, 'f'},
		{"dml"           , no_argument      , 0, 'L'},
		{"list"          , no_argument      , 0, 'l'},
		{"update"        , no_argument      , 0, 'U'},
		{"unmatched"     , no_argument      , 0, 'u'},
		{"com"           , no_argument      , 0, 'C'},
		{"dm"            , no_argument      , 0, 'D'},
		{"icn"           , no_argument      , 0, 'G'},
		{"pm"            , no_argument      , 0, 'P'},
		{"recursively"   , no_argument      , 0, 'R'},
		{"recursive"     , no_argument      , 0, 'r'},
		{"dir"           , required_argument, 0, 'd'},
		{"update-issue"  , no_argument      , 0, 'I'},
		{"ignore-issue"  , no_argument      , 0, 'i'},
		{"lineno"        , no_argument      , 0, 'n'},
		{"epr"           , no_argument      , 0, 'E'},
		{"exec"          , required_argument, 0, 'e'},
		{"tag-unmatched" , no_argument      , 0, 'X'},
		{"xml"           , no_argument      , 0, 'x'},
		{"smc"           , no_argument      , 0, 'S'},
		{"include-src"   , no_argument      , 0, 's'},
		{"output-valid"  , no_argument      , 0, 'o'},
		{"verbose"       , no_argument      , 0, 'v'},
		{"strict-match"  , no_argument      , 0, 'm'},
		{"hotspot"       , no_argument      , 0, 'H'},
		{"hotspot-xpath" , required_argument, 0, 'j'},
		{"namespace"     , required_argument, 0, 'J'},
		{"fragment"      , no_argument      , 0, 'T'},
		{"format"        , required_argument, 0, 't'},
		{"where-used"    , no_argument      , 0, 'w'},
		{"repository"    , no_argument      , 0, 'Y'},
		{"source"        , no_argument      , 0, 'Z'},
		{"ipd"           , no_argument      , 0, 'B'},
		{"csn"           , no_argument      , 0, 'K'},
		{"ipd-sns"       , required_argument, 0, 'b'},
		{"ipd-dcv"       , required_argument, 0, 'k'},
		{"remove-deleted", no_argument      , 0, '^'},
		LIBXML2_PARSE_LONGOPT_DEFS
		{0, 0, 0, 0}
	};
	int loptind = 0;

	directory = strdup(".");
	hotspotXPath = xmlStrdup(DEFAULT_HOTSPOT_XPATH);
	hotspotNs = xmlNewNode(NULL, BAD_CAST "hotspotNs");

	figNumVarFormat = xmlCharStrdup("%");

	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 'q':
				--verbosity;
				break;
			case 'c':
				contentOnly = true;
				break;
			case '3':
				strncpy(extpubsFname, optarg, PATH_MAX - 1);
				break;
			case 'N':
				noIssue = true;
				break;
			case 'a':
				showUnmatched = true;
				break;
			case 'F':
				overwriteUpdated = true;
				break;
			case 'f':
				inclSrcFname = true;
				break;
			case 'H':
				showObjects |= SHOW_HOT;
				break;
			case 'L':
				showObjects |= SHOW_DML;
				break;
			case 'l':
				isList = true;
				break;
			case 'U':
				updateRefs = true;
				break;
			case 'u':
				showMatched = false;
				break;
			case 'C':
				showObjects |= SHOW_COM;
				break;
			case 'D':
				showObjects |= SHOW_DMC;
				break;
			case 'G':
				showObjects |= SHOW_ICN;
				break;
			case 'P':
				showObjects |= SHOW_PMC;
				break;
			case 'R':
				listRecursively = true;
				break;
			case 'r':
				recursive = true;
				break;
			case 'd':
				free(directory);
				directory = strdup(optarg);
				break;
			case 'I':
				updateRefs = true;
				ignoreIss = true;
				updateRefIdent = true;
				break;
			case 'i':
				ignoreIss = true;
				break;
			case 'n':
				inclSrcFname = true;
				inclLineNum = true;
				break;
			case 'E':
				showObjects |= SHOW_EPR;
				break;
			case 'X':
				tagUnmatched = true;
				break;
			case 'x':
				xmlOutput = true;
				break;
			case 'S':
				showObjects |= SHOW_SMC;
				break;
			case 's':
				listSrc = true;
				break;
			case 'o':
				outputTree = true;
				break;
			case 'v':
				++verbosity;
				break;
			case 'm':
				looseMatch = false;
				break;
			case 'j':
				xmlFree(hotspotXPath);
				hotspotXPath = xmlStrdup(BAD_CAST optarg);
				break;
			case 'J':
				addHotspotNs(optarg);
				break;
			case 'T':
				showObjects |= SHOW_FRG;
				break;
			case 't':
				printFormat = strdup(optarg);
				break;
			case 'e':
				execStr = strdup(optarg);
				break;
			case 'w':
				findUsed = true;
				printMatchedFn = printMatchedWhereUsed;
				printUnmatchedFn = printUnmatchedSrc;
				break;
			case 'Y':
				showObjects |= SHOW_REP;
				break;
			case 'Z':
				showObjects |= SHOW_SRC;
				break;
			case 'B':
				showObjects |= SHOW_IPD;
				break;
			case 'K':
				showObjects |= SHOW_CSN;
				break;
			case 'b':
				readnonChapIpdSns(optarg);
				nonChapIpdSns = true;
				break;
			case 'k':
				xmlFree(figNumVarFormat);
				figNumVarFormat = xmlCharStrdup(optarg);
				break;
			case '^':
				remDelete = true;
				break;
			case 'h':
			case '?':
				show_help();
				return 0;
		}
	}

	/* If none of -CDEGHLPST are given, show all types of objects. */
	if (!showObjects) {
		showObjects = SHOW_ALL;
	}

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

	/* Print opening of XML report. */
	if (xmlOutput) {
		puts("<?xml version=\"1.0\"?>");
		printf("<results>");
	}

	/* Set the functions for printing matched/unmatched refs. */
	if (execStr) {
		printMatchedFn = execMatched;
	} else if (printFormat) {
		printMatchedFn   = printMatchedCustom;
		printUnmatchedFn = printUnmatchedCustom;
	} else if (xmlOutput) {
		printMatchedFn = printMatchedXml;
		printUnmatchedFn = printUnmatchedXml;
	} else if (inclSrcFname) {
		if (inclLineNum) {
			printMatchedFn = printMatchedSrcLine;
			printUnmatchedFn = printUnmatchedSrcLine;
		} else {
			printMatchedFn = printMatchedSrc;
			printUnmatchedFn = printUnmatchedSrc;
		}
	}

	if (optind < argc) {
		for (i = optind; i < argc; ++i) {
			if (isList) {
				if (findUsed) {
					unmatched += listWhereUsedList(argv[i], showObjects);
				} else {
					unmatched += listReferencesInList(argv[i], showObjects);
				}
			} else {
				if (findUsed) {
					unmatched += listWhereUsed(argv[i], showObjects);
				} else {
					unmatched += listReferences(argv[i], showObjects, NULL, 0);
				}
			}
		}
	} else if (isList) {
		if (findUsed) {
			unmatched += listWhereUsedList(NULL, showObjects);
		} else {
			unmatched += listReferencesInList(NULL, showObjects);
		}
	} else {
		if (findUsed) {
			unmatched += listWhereUsed("-", showObjects);
		} else {
			unmatched += listReferences("-", showObjects, NULL, 0);
		}
	}

	if (xmlOutput) {
		printf("</results>\n");
	}

	free(directory);
	xmlFree(hotspotXPath);
	xmlFreeNode(hotspotNs);
	free(listedFiles);
	free(execStr);
	free(printFormat);
	xmlFree(figNumVarFormat);
	xmlFreeDoc(externalPubs);
	xmlCleanupParser();

	return unmatched > 0 ? EXIT_UNMATCHED_REF : EXIT_SUCCESS;
}