#include <stdio.h>

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <getopt.h>
#include <stdbool.h>
#include <ctype.h>
#include <dirent.h>
#include <libgen.h>
#include <errno.h>
#include <sys/stat.h>

#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include <libxslt/xsltInternals.h>
#include <libxslt/transform.h>

#include "templates.h"
#include "dmtypes.h"
#include "sns.h"
#include "s1kd_tools.h"

#define PROG_NAME "s1kd-newdm"
#define VERSION "4.0.0"

#define ERR_PREFIX PROG_NAME ": ERROR: "

#define E_BREX_NOT_FOUND ERR_PREFIX "Could not find BREX: %s\n"
#define E_BAD_TEMPL_DIR ERR_PREFIX "Cannot dump templates in directory: %s\n"
#define E_ENCODING_ERROR ERR_PREFIX "Error encoding path name.\n"
#define E_NO_SCHEMA ERR_PREFIX "No schema defined for information type %s%s-%s\n"
#define E_NO_SCHEMA_LEARN ERR_PREFIX "No schema defined for information type %s%s-%s-%s%s\n"

#define MAX_MODEL_IDENT_CODE 14 + 2
#define MAX_SYSTEM_DIFF_CODE 4 + 2
#define MAX_SYSTEM_CODE 3 + 2
#define MAX_SUB_SYSTEM_CODE 1 + 2
#define MAX_SUB_SUB_SYSTEM_CODE 1 + 2
#define MAX_ASSY_CODE 4 + 2
#define MAX_DISASSY_CODE 2 + 2
#define MAX_DISASSY_CODE_VARIANT 3 + 2
#define MAX_INFO_CODE 3 + 2
#define MAX_INFO_CODE_VARIANT 1 + 2
#define MAX_ITEM_LOCATION_CODE 1 + 2
#define MAX_LEARN_CODE 3 + 2
#define MAX_LEARN_EVENT_CODE 1 + 2
#define MAX_LANGUAGE_ISO_CODE 3 + 2
#define MAX_COUNTRY_ISO_CODE 2 + 2
#define MAX_ISSUE_NUMBER 5 + 2
#define MAX_IN_WORK 2 + 2
#define MAX_SECURITY_CLASSIFICATION 2 + 2

#define MAX_DATAMODULE_CODE 256

#define MAX_ENTERPRISE_NAME 256
#define MAX_ENTERPRISE_CODE 7

#define MAX_TECH_NAME 256
#define MAX_INFO_NAME 256

#define EXIT_DM_EXISTS 1
#define EXIT_UNKNOWN_DMTYPE 2
#define EXIT_BAD_DMC 3
#define EXIT_BAD_BREX_DMC 4
#define EXIT_BAD_DATE 5
#define EXIT_BAD_ISSUE 6
#define EXIT_BAD_TEMPL_DIR 7
#define EXIT_ENCODING_ERROR 8
#define EXIT_OS_ERROR 9

static char modelIdentCode[MAX_MODEL_IDENT_CODE] = "";
static char systemDiffCode[MAX_SYSTEM_DIFF_CODE] = "";
static char systemCode[MAX_SYSTEM_CODE] = "";
static char subSystemCode[MAX_SUB_SYSTEM_CODE] = "";
static char subSubSystemCode[MAX_SUB_SUB_SYSTEM_CODE] = "";
static char assyCode[MAX_ASSY_CODE] = "";
static char disassyCode[MAX_DISASSY_CODE] = "";
static char disassyCodeVariant[MAX_DISASSY_CODE_VARIANT] = "";
static char infoCode[MAX_INFO_CODE] = "";
static char infoCodeVariant[MAX_INFO_CODE_VARIANT] = "";
static char itemLocationCode[MAX_ITEM_LOCATION_CODE] = "";
static char learnCode[MAX_LEARN_CODE] = "";
static char learnEventCode[MAX_LEARN_EVENT_CODE] = "";

static char languageIsoCode[MAX_LANGUAGE_ISO_CODE] = "";
static char countryIsoCode[MAX_COUNTRY_ISO_CODE] = "";

static char securityClassification[MAX_SECURITY_CLASSIFICATION] = "";

static char issueNumber[MAX_ISSUE_NUMBER] = "";
static char inWork[MAX_IN_WORK] = "";

static char responsiblePartnerCompany_enterpriseName[MAX_ENTERPRISE_NAME] = "";
static char originator_enterpriseName[MAX_ENTERPRISE_NAME] = "";

static char responsiblePartnerCompany_enterpriseCode[MAX_ENTERPRISE_CODE] = "";
static char originator_enterpriseCode[MAX_ENTERPRISE_CODE] = "";

static char techName_content[MAX_TECH_NAME] = "";
static char infoName_content[MAX_INFO_NAME] = "";
static xmlChar *info_name_variant = NULL;

static char dmtype[32] = "";

static char schema[PATH_MAX] = "";
static char brex_dmcode[PATH_MAX] = "";
static char *sns_fname = NULL;
static char *maint_sns = NULL;
static char issue_date[16] = "";
static xmlChar *issue_type = NULL;

static xmlChar *remarks = NULL;
static xmlChar *skill_level_code = NULL;

/* Omit the issue information from the object filename. */
static bool no_issue = false;
static bool no_issue_set = false;

static enum issue { NO_ISS, ISS_20, ISS_21, ISS_22, ISS_23, ISS_30, ISS_40, ISS_41, ISS_42, ISS_50 } issue = NO_ISS;

#define DEFAULT_S1000D_ISSUE ISS_50

#define ISS_22_DEFAULT_BREX "AE-A-04-10-0301-00A-022A-D"
#define ISS_23_DEFAULT_BREX "AE-A-04-10-0301-00A-022A-D"
#define ISS_30_DEFAULT_BREX "AE-A-04-10-0301-00A-022A-D"
#define ISS_40_DEFAULT_BREX "S1000D-A-04-10-0301-00A-022A-D"
#define ISS_41_DEFAULT_BREX "S1000D-E-04-10-0301-00A-022A-D"
#define ISS_42_DEFAULT_BREX "S1000D-F-04-10-0301-00A-022A-D"

/* ISO language and country codes if none can be determined. */
#define DEFAULT_LANGUAGE_ISO_CODE "und"
#define DEFAULT_COUNTRY_ISO_CODE "ZZ"

static char *template_dir = NULL;

/* Include the previous level of SNS title in a tech name. */
static int sns_title_levels = 0;

static bool no_info_name = false;

static char *act_dmcode = NULL;

#define BREX_INFOCODE_USE BAD_CAST "The information code used is not in the allowed set."

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

fprintf(stderr, ERR_PREFIX "Unsupported issue: %s\n", iss);
exit(EXIT_BAD_ISSUE);

return NO_ISS;
}

static const char *issue_name(enum issue iss)
{
switch (iss) {
case ISS_50: return "5.0";
case ISS_42: return "4.2";
case ISS_41: return "4.1";
case ISS_40: return "4.0";
case ISS_30: return "3.0";
case ISS_23: return "2.3";
case ISS_22: return "2.2";
case ISS_21: return "2.1";
case ISS_20: return "2.0";
default: return "";
}
}

static void prompt(const char *prompt, char *str, int n)
{
if (strcmp(str, "") == 0) {
printf("%s: ", prompt);

while (!strchr(fgets(str, n, stdin), '\n')) {
fprintf(stderr, ERR_PREFIX "Bad input for \"%s\".\n", prompt);
while (getchar() != '\n');
printf("%s: ", prompt);
}

*(strchr(str, '\n')) = '\0';
} else {
char temp[512] = "";

printf("%s [%s]: ", prompt, str);

while (!strchr(fgets(temp, n, stdin), '\n')) {
fprintf(stderr, ERR_PREFIX "Bad input for \"%s\".\n", prompt);
while (getchar() != '\n');
printf("%s [%s]: ", prompt, str);
}

*(strchr(temp, '\n')) = '\0';

if (strcmp(temp, "") != 0) {
memcpy(str, temp, n - 1);
}
}
}

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

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

return NULL;
}

static void show_help(void)
{
puts("Usage: " PROG_NAME " [options]");
puts("");
puts("Options:");
puts(" -$, --issue <issue> Specify which S1000D issue to use.");
puts(" -@, --out <path> Output to specified file or directory.");
puts(" -%, --templates <dir> Use templates in specified directory.");
puts(" -~, --dump-templates <dir> Dump default templates to a directory.");
puts(" -,, --dump-dmtypes-xml Dump default dmtypes XML.");
puts(" -., --dump-dmtypes Dump default dmtypes text file.");
puts(" -!, --no-infoname Do not include an info name.");
puts(" -B, --generate-brex-rules Generate BREX rules from .defaults file.");
puts(" -D, --dmtypes <dmtypes> Specify .dmtypes file name.");
puts(" -d, --defaults <defaults> Specify .defaults file name.");
puts(" -f, --overwrite Overwrite existing file.");
puts(" -j, --brexmap <map> Use a custom .brexmap file.");
puts(" -M, --maintained-sns <SNS> Use one of the maintained SNS.");
puts(" -N, --omit-issue Omit issue/inwork from filename.");
puts(" -P, --sns-levels <levels> Levels of SNS to include in tech name.");
puts(" -p, --prompt Prompt the user for each value.");
puts(" -q, --quiet Don't report an error if file exists.");
puts(" -S, --sns <BREX> Get tech name from BREX SNS.");
puts(" -v, --verbose Print file name of new data module.");
puts(" --version Show version information.");
puts("");
puts("In addition, the following pieces of meta data can be set:");
puts(" -#, --code <code> Data module code");
puts(" -a, --act <ACT> ACT data module code");
puts(" -b, --brex <BREX> BREX data module code");
puts(" -C, --country <country> Country ISO code");
puts(" -c, --security <sec> Security classification");
puts(" -I, --date <date> Issue date");
puts(" -i, --infoname <info> Info name");
puts(" -k, --skill <skill> Skill level");
puts(" -L, --language <lang> Language ISO code");
puts(" -m, --remarks <remarks> Remarks");
puts(" -n, --issno <iss> Issue number");
puts(" -O, --origcode <CAGE> Originator CAGE code.");
puts(" -o, --origname <orig> Originator enterprise name");
puts(" -R, --rpccode <CAGE> Responsible partner company CAGE code.");
puts(" -r, --rpcname <RPC> Responsible partner company enterprise name");
puts(" -s, --schema <schema> Schema");
puts(" -T, --type <type> DM type (descript, proced, frontmatter, etc.)");
puts(" -t, --techname <tech> Tech name");
puts(" -V, --infoname-variant <variant> Info name variant");
puts(" -w, --inwork <inwork> Inwork issue");
puts(" -z, --issue-type <type> Issue type");
LIBXML2_PARSE_LONGOPT_HELP
}

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

static void copy_default_value(const char *key, const char *val)
{
if (strcmp(key, "modelIdentCode") == 0 && strcmp(modelIdentCode, "") == 0)
strncpy(modelIdentCode, val, MAX_MODEL_IDENT_CODE - 2);
else if (strcmp(key, "systemDiffCode") == 0 && strcmp(systemDiffCode, "") == 0)
strncpy(systemDiffCode, val, MAX_SYSTEM_DIFF_CODE - 2);
else if (strcmp(key, "systemCode") == 0 && strcmp(systemCode, "") == 0)
strncpy(systemCode, val, MAX_SYSTEM_CODE - 2);
else if (strcmp(key, "subSystemCode") == 0 && strcmp(subSystemCode, "") == 0)
strncpy(subSystemCode, val, MAX_SUB_SYSTEM_CODE - 2);
else if (strcmp(key, "subSubSystemCode") == 0 && strcmp(subSubSystemCode, "") == 0)
strncpy(subSubSystemCode, val, MAX_SUB_SUB_SYSTEM_CODE - 2);
else if (strcmp(key, "assyCode") == 0 && strcmp(assyCode, "") == 0)
strncpy(assyCode, val, MAX_ASSY_CODE - 2);
else if (strcmp(key, "disassyCode") == 0 && strcmp(disassyCode, "") == 0)
strncpy(disassyCode, val, MAX_DISASSY_CODE - 2);
else if (strcmp(key, "disassyCodeVariant") == 0 && strcmp(disassyCodeVariant, "") == 0)
strncpy(disassyCodeVariant, val, MAX_DISASSY_CODE_VARIANT - 2);
else if (strcmp(key, "infoCode") == 0 && strcmp(infoCode, "") == 0)
strncpy(infoCode, val, MAX_INFO_CODE - 2);
else if (strcmp(key, "infoCodeVariant") == 0 && strcmp(infoCodeVariant, "") == 0)
strncpy(infoCodeVariant, val, MAX_INFO_CODE_VARIANT - 2);
else if (strcmp(key, "itemLocationCode") == 0 && strcmp(itemLocationCode, "") == 0)
strncpy(itemLocationCode, val, MAX_ITEM_LOCATION_CODE - 2);
else if (strcmp(key, "learnCode") == 0 && strcmp(learnCode, "") == 0)
strncpy(learnCode, val, MAX_LEARN_CODE - 2);
else if (strcmp(key, "learnEventCode") == 0 && strcmp(learnEventCode, "") == 0)
strncpy(learnEventCode, val, MAX_LEARN_EVENT_CODE - 2);
else if (strcmp(key, "languageIsoCode") == 0 && strcmp(languageIsoCode, "") == 0)
strncpy(languageIsoCode, val, MAX_LANGUAGE_ISO_CODE - 2);
else if (strcmp(key, "countryIsoCode") == 0 && strcmp(countryIsoCode, "") == 0)
strncpy(countryIsoCode, val, MAX_COUNTRY_ISO_CODE - 2);
else if (strcmp(key, "issueNumber") == 0 && strcmp(issueNumber, "") == 0)
strncpy(issueNumber, val, MAX_ISSUE_NUMBER - 2);
else if (strcmp(key, "inWork") == 0 && strcmp(inWork, "") == 0)
strncpy(inWork, val, MAX_IN_WORK - 2);
else if (strcmp(key, "securityClassification") == 0 && strcmp(securityClassification, "") == 0)
strncpy(securityClassification, val, MAX_SECURITY_CLASSIFICATION - 2);
else if (strcmp(key, "responsiblePartnerCompany") == 0 && strcmp(responsiblePartnerCompany_enterpriseName, "") == 0)
strncpy(responsiblePartnerCompany_enterpriseName, val, MAX_ENTERPRISE_NAME - 2);
else if (strcmp(key, "responsiblePartnerCompanyCode") == 0 && strcmp(responsiblePartnerCompany_enterpriseCode, "") == 0)
strncpy(responsiblePartnerCompany_enterpriseCode, val, MAX_ENTERPRISE_CODE - 2);
else if (strcmp(key, "originator") == 0 && strcmp(originator_enterpriseName, "") == 0)
strncpy(originator_enterpriseName, val, MAX_ENTERPRISE_NAME - 2);
else if (strcmp(key, "originatorCode") == 0 && strcmp(originator_enterpriseCode, "") == 0)
strncpy(originator_enterpriseCode, val, MAX_ENTERPRISE_CODE - 2);
else if (strcmp(key, "techName") == 0 && strcmp(techName_content, "") == 0)
strncpy(techName_content, val, MAX_TECH_NAME - 2);
else if (strcmp(key, "infoName") == 0 && strcmp(infoName_content, "") == 0 && !no_info_name)
strncpy(infoName_content, val, MAX_INFO_CODE - 2);
else if (strcmp(key, "infoNameVariant") == 0 && !info_name_variant)
info_name_variant = xmlStrdup(BAD_CAST val);
else if (strcmp(key, "schema") == 0 && strcmp(schema, "") == 0)
strncpy(schema, val, PATH_MAX - 1);
else if (strcmp(key, "brex") == 0 && strcmp(brex_dmcode, "") == 0)
strncpy(brex_dmcode, val, 255);
else if (strcmp(key, "sns") == 0 && !sns_fname)
sns_fname = strdup(val);
else if (strcmp(key, "issue") == 0 && issue == NO_ISS)
issue = get_issue(val);
else if (strcmp(key, "remarks") == 0 && !remarks)
remarks = xmlStrdup(BAD_CAST val);
else if (strcmp(key, "templates") == 0 && !template_dir)
template_dir = strdup(val);
else if (strcmp(key, "maintainedSns") == 0 && !maint_sns)
maint_sns = strdup(val);
else if (strcmp(key, "snsLevels") == 0 && sns_title_levels == 0)
sns_title_levels = atoi(val);
else if (strcmp(key, "skillLevelCode") == 0 && !skill_level_code)
skill_level_code = xmlStrdup(BAD_CAST val);
else if (strcmp(key, "act") == 0 && !act_dmcode)
act_dmcode = strdup(val);
else if (strcmp(key, "issueType") == 0 && !issue_type)
issue_type = xmlStrdup(BAD_CAST val);
}

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

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

obj = xmlXPathEvalExpression(BAD_CAST xpath, ctx);

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

xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);

return first;
}

static void set_dmcode(xmlNodePtr dmCode, const char *fname)
{
int n, offset;
char *path, *code;

char modelIdentCode[MAX_MODEL_IDENT_CODE] = "";
char systemDiffCode[MAX_SYSTEM_DIFF_CODE] = "";
char systemCode[MAX_SYSTEM_CODE] = "";
char subSystemCode[MAX_SUB_SYSTEM_CODE] = "";
char subSubSystemCode[MAX_SUB_SUB_SYSTEM_CODE] = "";
char assyCode[MAX_ASSY_CODE] = "";
char disassyCode[MAX_DISASSY_CODE] = "";
char disassyCodeVariant[MAX_DISASSY_CODE_VARIANT] = "";
char infoCode[MAX_INFO_CODE] = "";
char infoCodeVariant[MAX_INFO_CODE_VARIANT] = "";
char itemLocationCode[MAX_ITEM_LOCATION_CODE] = "";
char learnCode[MAX_LEARN_CODE] = "";
char learnEventCode[MAX_LEARN_EVENT_CODE] = "";

path = strdup(fname);
code = basename(path);

offset = strncmp(code, "DMC-", 4) == 0 ? 4 : 0;

n = sscanf(code + offset, "%14[^-]-%4[^-]-%3[^-]-%c%c-%4[^-]-%2s%3[^-]-%3s%c-%c-%3s%1s",
modelIdentCode,
systemDiffCode,
systemCode,
subSystemCode,
subSubSystemCode,
assyCode,
disassyCode,
disassyCodeVariant,
infoCode,
infoCodeVariant,
itemLocationCode,
learnCode,
learnEventCode);

if (n != 11 && n != 13) {
fprintf(stderr, ERR_PREFIX "Bad BREX data module code.\n");
exit(EXIT_BAD_BREX_DMC);
}

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

if (strcmp(learnCode, "") != 0) xmlSetProp(dmCode, BAD_CAST "learnCode", BAD_CAST learnCode);
if (strcmp(learnEventCode, "") != 0) xmlSetProp(dmCode, BAD_CAST "learnEventCode", BAD_CAST learnEventCode);

free(path);
}

static void set_brex(xmlDocPtr doc, const char *fname)
{
xmlNodePtr dmCode;
dmCode = firstXPathNode(doc, NULL, "//brexDmRef/dmRef/dmRefIdent/dmCode");
set_dmcode(dmCode, fname);
}

static void set_act(xmlDocPtr doc, const char *fname)
{
xmlNodePtr dmCode;
dmCode = firstXPathNode(doc, NULL, "//applicCrossRefTableRef/dmRef/dmRefIdent/dmCode");
set_dmcode(dmCode, fname);
}

static void unset_act(xmlDocPtr doc)
{
xmlNodePtr dmCode;
dmCode = firstXPathNode(doc, NULL, "//applicCrossRefTableRef");
xmlUnlinkNode(dmCode);
xmlFreeNode(dmCode);
}

#define SNS_XPATH_1 "//snsSystem[snsCode='%s']/snsSubSystem[snsCode='%s']/snsSubSubSystem[snsCode='%s']/snsAssy[snsCode='%s']/snsTitle"
#define SNS_XPATH_2 "//snsSystem[snsCode='%s']/snsSubSystem[snsCode='%s']/snsSubSubSystem[snsCode='%s']/snsTitle"
#define SNS_XPATH_3 "//snsSystem[snsCode='%s']/snsSubSystem[snsCode='%s']/snsTitle"
#define SNS_XPATH_4 "//snsSystem[snsCode='%s']/snsTitle"

static void set_sns_title(xmlNodePtr snsTitle)
{
xmlChar *title, *last;
int n;
xmlNodePtr cur;

title = xmlNodeGetContent(snsTitle);
last = xmlStrdup(title);

strcpy(techName_content, "");

for (n = sns_title_levels, cur = snsTitle; n > 1 && cur; --n, cur = cur->parent) {
xmlNodePtr prev;

if ((prev = firstXPathNode(NULL, cur, "parent::*/parent::*/snsTitle"))) {
xmlChar *p;

p = xmlNodeGetContent(prev);

if (xmlStrcmp(p, last) != 0) {
char *s;

s = strdup(techName_content);
strcpy(techName_content, (char *) p);
strcat(techName_content, " - ");
strcat(techName_content, s);

free(s);
}

xmlFree(last);
last = xmlStrdup(p);

xmlFree(p);
} else {
break;
}
}

strcat(techName_content, (char *) title);

xmlFree(title);
xmlFree(last);
}

/* Find the filename of the latest version of a BREX DM by its code. */
static bool find_brex_file(char *dst, const char *dir, const char *code)
{
char s[PATH_MAX];

if (strncmp(code, "DMC-", 4) == 0) {
if (snprintf(s, PATH_MAX, "%s", code) < 0) {
fprintf(stderr, E_ENCODING_ERROR);
exit(EXIT_ENCODING_ERROR);
}
} else {
if (snprintf(s, PATH_MAX, "DMC-%s", code) < 0) {
fprintf(stderr, E_ENCODING_ERROR);
exit(EXIT_ENCODING_ERROR);
}
}

return find_csdb_object(dst, dir, s, NULL, true);
}

struct inmem_xml {
unsigned char *xml;
unsigned int len;
};

/* Map maintained SNS title to XML template. */
static struct inmem_xml maint_sns_xml(void)
{
struct inmem_xml res;

if (strcasecmp(maint_sns, "Generic") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0100_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0100_00A_022A_D_EN_CA_XML_len;
} else if (strcasecmp(maint_sns, "Support and training equipment") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0200_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0200_00A_022A_D_EN_CA_XML_len;
} else if (strcasecmp(maint_sns, "Ordnance") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0300_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0300_00A_022A_D_EN_CA_XML_len;
} else if (strcasecmp(maint_sns, "General communications") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0400_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0400_00A_022A_D_EN_CA_XML_len;
} else if (strcasecmp(maint_sns, "Air vehicle, engines and equipment") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0500_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0500_00A_022A_D_EN_CA_XML_len;
} else if (strcasecmp(maint_sns, "Tactical missiles") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0600_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0600_00A_022A_D_EN_CA_XML_len;
} else if (strcasecmp(maint_sns, "General surface vehicles") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0700_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0700_00A_022A_D_EN_CA_XML_len;
} else if (strcasecmp(maint_sns, "General sea vehicles") == 0) {
res.xml = sns_DMC_S1000D_A_08_02_0800_00A_022A_D_EN_CA_XML;
res.len = sns_DMC_S1000D_A_08_02_0800_00A_022A_D_EN_CA_XML_len;
} else {
fprintf(stderr, ERR_PREFIX "No maintained SNS: %s\n", maint_sns);
res.xml = NULL;
res.len = 0;
}

return res;
}

static xmlDocPtr maint_sns_doc(void)
{
struct inmem_xml xml;

xml = maint_sns_xml();

return read_xml_mem((const char *) xml.xml, xml.len);
}

static xmlDocPtr set_tech_from_sns(const char *dir)
{
xmlDocPtr brex = NULL;
char xpath[256];
xmlNodePtr snsTitle;
char fname[PATH_MAX];

if (maint_sns) {
brex = maint_sns_doc();
} else if (sns_fname && find_brex_file(fname, dir, sns_fname)) {
brex = read_xml_doc(fname);
} else if (strcmp(brex_dmcode, "") != 0 && find_brex_file(fname, dir, brex_dmcode)) {
brex = read_xml_doc(fname);
}

if (!brex) {
return NULL;
}

sprintf(xpath, SNS_XPATH_1, systemCode, subSystemCode, subSubSystemCode, assyCode);
if ((snsTitle = firstXPathNode(brex, NULL, xpath))) {
set_sns_title(snsTitle);
return brex;
}

sprintf(xpath, SNS_XPATH_2, systemCode, subSystemCode, subSubSystemCode);
if ((snsTitle = firstXPathNode(brex, NULL, xpath))) {
set_sns_title(snsTitle);
return brex;
}

sprintf(xpath, SNS_XPATH_3, systemCode, subSystemCode);
if ((snsTitle = firstXPathNode(brex, NULL, xpath))) {
set_sns_title(snsTitle);
return brex;
}

sprintf(xpath, SNS_XPATH_4, systemCode);
if ((snsTitle = firstXPathNode(brex, NULL, xpath))) {
set_sns_title(snsTitle);
return brex;
}

return brex;
}

static void set_issue_date(xmlNodePtr issueDate)
{
char year_s[5], month_s[3], day_s[3];

if (strcmp(issue_date, "") == 0) {
time_t now;
struct tm *local;
unsigned short year, month, day;

time(&now);
local = localtime(&now);

year = local->tm_year + 1900;
month = local->tm_mon + 1;
day = local->tm_mday;

if (snprintf(day_s, 3, "%.2u", day) < 0 ||
snprintf(month_s, 3, "%.2u", month) < 0 ||
snprintf(year_s, 5, "%u", year) < 0)
exit(EXIT_BAD_DATE);
} else {
if (sscanf(issue_date, "%4s-%2s-%2s", year_s, month_s, day_s) != 3) {
fprintf(stderr, ERR_PREFIX "Bad issue date: %s\n", issue_date);
exit(EXIT_BAD_DATE);
}
}

xmlSetProp(issueDate, BAD_CAST "year", BAD_CAST year_s);
xmlSetProp(issueDate, BAD_CAST "month", BAD_CAST month_s);
xmlSetProp(issueDate, BAD_CAST "day", BAD_CAST day_s);
}

static xmlDocPtr xml_skeleton(const char *dmtype, enum issue iss)
{
unsigned char *xml = NULL;
unsigned int len;

if (strcmp(dmtype, "") == 0) {
if (strcmp(learnCode, "") == 0) {
fprintf(stderr, E_NO_SCHEMA, infoCode, infoCodeVariant,
itemLocationCode);
} else {
fprintf(stderr, E_NO_SCHEMA_LEARN, infoCode, infoCodeVariant,
itemLocationCode, learnCode, learnEventCode);
}
exit(EXIT_UNKNOWN_DMTYPE);
} else if (template_dir) {
char src[PATH_MAX];
sprintf(src, "%s/%s.xml", template_dir, dmtype);

if (access(src, F_OK) == -1) {
fprintf(stderr, ERR_PREFIX "No schema %s in template directory \"%s\".\n", dmtype, template_dir);
exit(EXIT_UNKNOWN_DMTYPE);
}

return read_xml_doc(src);
} else if (strcmp(dmtype, "descript") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_descript_xml;
len = templates_descript_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "proced") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_proced_xml;
len = templates_proced_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "frontmatter") == 0) {
switch (iss) {
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_frontmatter_xml;
len = templates_frontmatter_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "brex") == 0) {
switch (iss) {
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
if (maint_sns) {
struct inmem_xml res;
res = maint_sns_xml();
xml = res.xml;
len = res.len;
} else {
xml = templates_brex_xml;
len = templates_brex_xml_len;
}
break;
default:
break;
}
} else if (strcmp(dmtype, "brdoc") == 0) {
switch (iss) {
case ISS_42:
case ISS_50:
xml = templates_brdoc_xml;
len = templates_brdoc_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "appliccrossreftable") == 0) {
switch (iss) {
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_appliccrossreftable_xml;
len = templates_appliccrossreftable_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "prdcrossreftable") == 0) {
switch (iss) {
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_prdcrossreftable_xml;
len = templates_prdcrossreftable_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "condcrossreftable") == 0) {
switch (iss) {
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_condcrossreftable_xml;
len = templates_condcrossreftable_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "comrep") == 0) {
switch (iss) {
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_comrep_xml;
len = templates_comrep_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "process") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_process_xml;
len = templates_process_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "ipd") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_ipd_xml;
len = templates_ipd_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "fault") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_fault_xml;
len = templates_fault_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "checklist") == 0) {
switch (iss) {
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_checklist_xml;
len = templates_checklist_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "learning") == 0) {
switch (iss) {
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_learning_xml;
len = templates_learning_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "container") == 0) {
switch (iss) {
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_container_xml;
len = templates_container_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "crew") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_crew_xml;
len = templates_crew_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "sb") == 0) {
switch (iss) {
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_sb_xml;
len = templates_sb_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "schedul") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_schedul_xml;
len = templates_schedul_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "wrngdata") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_wrngdata_xml;
len = templates_wrngdata_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "wrngflds") == 0) {
switch (iss) {
case ISS_20:
case ISS_21:
case ISS_22:
case ISS_23:
case ISS_30:
case ISS_40:
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_wrngflds_xml;
len = templates_wrngflds_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "scocontent") == 0) {
switch (iss) {
case ISS_41:
case ISS_42:
case ISS_50:
xml = templates_scocontent_xml;
len = templates_scocontent_xml_len;
break;
default:
break;
}
} else if (strcmp(dmtype, "techrep") == 0) {
switch (iss) {
case ISS_23:
case ISS_30:
case ISS_40:
xml = templates_techrep_xml;
len = templates_techrep_xml_len;
break;
default:
break;
}
} else {
fprintf(stderr, ERR_PREFIX "Unknown schema %s\n", dmtype);
exit(EXIT_UNKNOWN_DMTYPE);
}

if (!xml) {
fprintf(stderr, ERR_PREFIX "No schema %s for issue %s\n", dmtype, issue_name(iss));
exit(EXIT_UNKNOWN_DMTYPE);
}

return read_xml_mem((const char *) xml, len);
}

static xmlDocPtr toissue(xmlDocPtr doc, enum issue iss)
{
xsltStylesheetPtr style;
xmlDocPtr styledoc, res, orig;
xmlNodePtr old;
unsigned char *xml = NULL;
unsigned int len;

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

orig = xmlCopyDoc(doc, 1);

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

res = xsltApplyStylesheet(style, doc, NULL);

xmlFreeDoc(doc);
xsltFreeStylesheet(style);

old = xmlDocSetRootElement(orig, xmlCopyNode(xmlDocGetRootElement(res), 1));

xmlFreeNode(old);
xmlFreeDoc(res);

return orig;
}

static void add_dmtypes_brex_val(xmlNodePtr rules, const char *key, const char *val)
{
xmlNodePtr objval;
xmlChar *name;
objval = xmlNewChild(rules->children, NULL, BAD_CAST "objectValue", NULL);
xmlSetProp(objval, BAD_CAST "valueAllowed", BAD_CAST key);
name = xmlEncodeEntitiesReentrant(NULL, BAD_CAST val);
xmlNodeSetContent(objval, name);
xmlFree(name);
}

static void process_dmtypes_xml(xmlDocPtr defaults_xml, xmlNodePtr brex_rules)
{
xmlNodePtr cur;

for (cur = xmlDocGetRootElement(defaults_xml)->children; cur; cur = cur->next) {
char *def_key, *def_val, *infname;
xmlChar *infnamev;
char code[4], variant[2], itemloc[2], learn[4], levent[2];
int p;

if (cur->type != XML_ELEMENT_NODE) continue;
if (!xmlHasProp(cur, BAD_CAST "infoCode")) continue;
if (!xmlHasProp(cur, BAD_CAST "schema")) continue;

def_key = (char *) xmlGetProp(cur, BAD_CAST "infoCode");
def_val = (char *) xmlGetProp(cur, BAD_CAST "schema");
infname = (char *) xmlGetProp(cur, BAD_CAST "infoName");
infnamev = xmlGetProp(cur, BAD_CAST "infoNameVariant");

p = sscanf(def_key, "%3s%1s-%1s-%3s%1s", code, variant, itemloc, learn, levent);

/* Get schema */
if (strcmp(dmtype, "") == 0 &&
strcmp(code, infoCode) == 0 &&
(p < 2 || strcmp(variant, "*") == 0 || strcmp(variant, infoCodeVariant) == 0) &&
(p < 3 || strcmp(itemloc, "*") == 0 || strcmp(itemloc, itemLocationCode) == 0) &&
(p < 4 || strcmp(learn, "***") == 0 || strcmp(learn, learnCode) == 0) &&
(p < 5 || strcmp(levent, "*") == 0 || strcmp(levent, learnEventCode) == 0)) {
strcpy(dmtype, def_val);
}

/* Get info name */
if (infname &&
strcmp(infoName_content, "") == 0 &&
!no_info_name &&
strcmp(code, infoCode) == 0 &&
(p < 2 || strcmp(variant, "*") == 0 || strcmp(variant, infoCodeVariant) == 0) &&
(p < 3 || strcmp(itemloc, "*") == 0 || strcmp(itemloc, itemLocationCode) == 0) &&
(p < 4 || strcmp(learn, "***") == 0 || strcmp(learn, learnCode) == 0) &&
(p < 5 || strcmp(levent, "*") == 0 || strcmp(levent, learnEventCode) == 0)) {
strcpy(infoName_content, infname);

if (infnamev && !info_name_variant) {
info_name_variant = xmlStrdup(infnamev);
}
}

if (brex_rules) {
add_dmtypes_brex_val(brex_rules, def_key, infname);
}

xmlFree(def_key);
xmlFree(def_val);
xmlFree(infname);
xmlFree(infnamev);
}
}

static void set_remarks(xmlDocPtr doc, xmlChar *text)
{
xmlNodePtr remarks;

remarks = firstXPathNode(doc, NULL, "//remarks");

if (text) {
xmlNodePtr simplePara;
simplePara = xmlNewChild(remarks, NULL, BAD_CAST "simplePara", NULL);
xmlNodeSetContent(simplePara, text);
} else {
xmlUnlinkNode(remarks);
xmlFreeNode(remarks);
}
}

static void set_skill_level(xmlDocPtr doc, xmlChar *code)
{
xmlNodePtr skill_level;

skill_level = firstXPathNode(doc, NULL, "//skillLevel");

if (code) {
xmlSetProp(skill_level, BAD_CAST "skillLevelCode", code);
} else {
xmlUnlinkNode(skill_level);
xmlFreeNode(skill_level);
}
}

/* Dump the built-in dmtypes XML or text */
static void print_dmtypes(void)
{
printf("%.*s", dmtypes_xml_len, dmtypes_xml);
}
static void print_dmtypes_txt(void)
{
printf("%.*s", dmtypes_txt_len, dmtypes_txt);
}

/* Try reading the ISO language and country codes from the environment,
* otherwise default to "und" (undetermined) for language and ZZ for
* country.
*/
static void set_env_lang(void)
{
char *env, *lang, *lang_l, *lang_c;

if (!(env = getenv("LANG"))) {
if (strcmp(languageIsoCode, "") == 0) {
strcpy(languageIsoCode, DEFAULT_LANGUAGE_ISO_CODE);
}
if (strcmp(countryIsoCode, "") == 0) {
strcpy(countryIsoCode, DEFAULT_COUNTRY_ISO_CODE);
}
return;
}

lang = strdup(env);
lang_l = strtok(lang, "_");
lang_c = strtok(NULL, ".");

if (strcmp(languageIsoCode, "") == 0) {
if (lang_l) {
strncpy(languageIsoCode, lang_l, 3);
} else {
strcpy(languageIsoCode, DEFAULT_LANGUAGE_ISO_CODE);
}
}
if (strcmp(countryIsoCode, "") == 0) {
if (lang_c) {
strncpy(countryIsoCode, lang_c, 2);
} else {
strcpy(countryIsoCode, DEFAULT_COUNTRY_ISO_CODE);
}
}

free(lang);
}

static void add_brex_rule(xmlNodePtr rules, xmlDocPtr brexmap, const char *key, const char *val)
{
xmlXPathContextPtr ctx;
xmlXPathObjectPtr obj;

ctx = xmlXPathNewContext(brexmap);
xmlXPathRegisterVariable(ctx, BAD_CAST "key", xmlXPathNewString(BAD_CAST key));
obj = xmlXPathEval(BAD_CAST "//default[@ident=$key]", ctx);

if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
xmlChar *id, *path, use[256];
xmlNodePtr rule, objpath, objval;

id = xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "id");
path = xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "path");

xmlStrPrintf(use, 256, "%s must be %s", key, val);

rule = xmlNewChild(rules, NULL, BAD_CAST "structureObjectRule", NULL);
if (id) {
xmlSetProp(rule, BAD_CAST "id", id);
}
objpath = xmlNewChild(rule, NULL, BAD_CAST "objectPath", BAD_CAST path);
xmlNewChild(rule, NULL, BAD_CAST "objectUse", use);
objval = xmlNewChild(rule, NULL, BAD_CAST "objectValue", NULL);

xmlSetProp(objpath, BAD_CAST "allowedObjectFlag", BAD_CAST "2");
xmlSetProp(objval, BAD_CAST "valueAllowed", BAD_CAST val);

xmlFree(id);
xmlFree(path);
}

xmlXPathFreeObject(obj);
xmlXPathFreeContext(ctx);
}

static xmlDocPtr read_default_brexmap(void)
{
char fname[PATH_MAX];

if (find_config(fname, DEFAULT_BREXMAP_FNAME)) {
return read_xml_doc(fname);
} else {
return read_xml_mem((const char *) ___common_brexmap_xml, ___common_brexmap_xml_len);
}
}

static void dump_templ(const char *fname, const unsigned char *xml, const unsigned int len)
{
FILE *f;
f = fopen(fname, "w");
fprintf(f, "%.*s", len, xml);
fclose(f);
}

static void dump_templates(const char *path)
{
if (access(path, W_OK) == -1 || chdir(path)) {
fprintf(stderr, E_BAD_TEMPL_DIR, path);
exit(EXIT_BAD_TEMPL_DIR);
}

dump_templ("appliccrossreftable.xml",
templates_appliccrossreftable_xml,
templates_appliccrossreftable_xml_len);
dump_templ("brdoc.xml",
templates_brdoc_xml,
templates_brdoc_xml_len);
dump_templ("brex.xml",
templates_brex_xml,
templates_brex_xml_len);
dump_templ("checklist.xml",
templates_checklist_xml,
templates_checklist_xml_len);
dump_templ("comrep.xml",
templates_comrep_xml,
templates_comrep_xml_len);
dump_templ("condcrossreftable.xml",
templates_condcrossreftable_xml,
templates_condcrossreftable_xml_len);
dump_templ("container.xml",
templates_container_xml,
templates_container_xml_len);
dump_templ("crew.xml",
templates_crew_xml,
templates_crew_xml_len);
dump_templ("descript.xml",
templates_descript_xml,
templates_descript_xml_len);
dump_templ("fault.xml",
templates_fault_xml,
templates_fault_xml_len);
dump_templ("frontmatter.xml",
templates_frontmatter_xml,
templates_frontmatter_xml_len);
dump_templ("ipd.xml",
templates_ipd_xml,
templates_ipd_xml_len);
dump_templ("learning.xml",
templates_learning_xml,
templates_learning_xml_len);
dump_templ("prdcrossreftable.xml",
templates_prdcrossreftable_xml,
templates_prdcrossreftable_xml_len);
dump_templ("proced.xml",
templates_proced_xml,
templates_proced_xml_len);
dump_templ("process.xml",
templates_process_xml,
templates_process_xml_len);
dump_templ("sb.xml",
templates_sb_xml,
templates_sb_xml_len);
dump_templ("schedul.xml",
templates_schedul_xml,
templates_schedul_xml_len);
dump_templ("scocontent.xml",
templates_scocontent_xml,
templates_scocontent_xml_len);
dump_templ("techrep.xml",
templates_techrep_xml,
templates_techrep_xml_len);
dump_templ("wrngdata.xml",
templates_wrngdata_xml,
templates_wrngdata_xml_len);
dump_templ("wrngflds.xml",
templates_wrngflds_xml,
templates_wrngflds_xml_len);
}

/* Generate a random code. */
static void random_code(char *dst, size_t n, const char *modelid)
{
static const char alphanum[] = "ABCDEFGHIJKLMNOPQRSTUVXWYZ0123456789";

if (strcmp(modelid, "") != 0) {
snprintf(dst, n, "%s-%c%c%c%c-%c%c-%c%c-%c%c%c%c-%c%c%c%c%c-000A-D",
modelid,
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)]);
} else {
snprintf(dst, n, "%c%c%c%c%c%c%c%c%c%c%c%c%c%c-%c%c%c%c-%c%c-%c%c-%c%c%c%c-%c%c%c%c%c-000A-D",
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)],
alphanum[rand() % (sizeof(alphanum) - 1)]);
}
}

int main(int argc, char **argv)
{
char learn[8] = "";
char iss[16] = "";

xmlDocPtr dm;
xmlNode *dmodule;
xmlNode *identAndStatusSection;
xmlNode *dmAddress;
xmlNode *dmIdent;
xmlNode *dmCode;
xmlNode *language;
xmlNode *issueInfo;
xmlNode *dmAddressItems;
xmlNode *issueDate;
xmlNode *dmStatus;
xmlNode *security;
xmlNode *dmTitle;
xmlNode *techName;
xmlNode *infoName;
xmlNode *infoNameVariant;
xmlNode *responsiblePartnerCompany;
xmlNode *originator;

FILE *defaults;

char defaults_fname[PATH_MAX];
char dmtypes_fname[PATH_MAX];
bool custom_defaults = false;
bool custom_dmtypes = false;

int i;
int c;

bool showprompts = false;
char dmcode[256] = "";
bool skipdmc = false;
bool verbose = false;
bool overwrite = false;
char *out = NULL;
bool tech_name_flag = false;
bool no_overwrite_error = false;

xmlDocPtr defaults_xml;
xmlNodePtr brex_rules = NULL;
xmlDocPtr brexmap = NULL;

char *defaults_dir_str;
char *defaults_dir;

char *outdir = NULL;

const char *sopts = "a:pd:D:L:C:n:w:c:r:R:o:O:t:i:T:#:Ns:Bb:S:I:v$:@:fm:,.%:qM:P:!k:j:~:z:V:h?";
struct option lopts[] = {
{"version" , no_argument , 0, 0},
{"help" , no_argument , 0, 'h'},
{"act" , required_argument, 0, 'a'},
{"prompt" , no_argument , 0, 'p'},
{"defaults" , required_argument, 0, 'd'},
{"dmtypes" , required_argument, 0, 'D'},
{"language" , required_argument, 0, 'L'},
{"country" , required_argument, 0, 'C'},
{"issno" , required_argument, 0, 'n'},
{"inwork" , required_argument, 0, 'w'},
{"security" , required_argument, 0, 'c'},
{"rpcname" , required_argument, 0, 'r'},
{"rpccode" , required_argument, 0, 'R'},
{"orgname" , required_argument, 0, 'o'},
{"orgcode" , required_argument, 0, 'O'},
{"techname" , required_argument, 0, 't'},
{"infoname" , required_argument, 0, 'i'},
{"type" , required_argument, 0, 'T'},
{"code" , required_argument, 0, '#'},
{"omit-issue" , no_argument , 0, 'N'},
{"schema" , required_argument, 0, 's'},
{"generate-brex-rules" , no_argument , 0, 'B'},
{"brex" , required_argument, 0, 'b'},
{"sns" , required_argument, 0, 'S'},
{"date" , required_argument, 0, 'I'},
{"verbose" , no_argument , 0, 'v'},
{"overwrite" , no_argument , 0, 'f'},
{"issue" , required_argument, 0, '$'},
{"out" , required_argument, 0, '@'},
{"remarks" , required_argument, 0, 'm'},
{"dump-dmtypes" , no_argument , 0, '.'},
{"dump-dmtypes-xml" , no_argument , 0, ','},
{"templates" , required_argument, 0, '%'},
{"quiet" , no_argument , 0, 'q'},
{"maintained-sns" , required_argument, 0, 'M'},
{"sns-levels" , required_argument, 0, 'P'},
{"no-infoname" , no_argument , 0, '!'},
{"skill" , required_argument, 0, 'k'},
{"brexmap" , required_argument, 0, 'j'},
{"dump-templates" , required_argument, 0, '~'},
{"issue-type" , required_argument, 0, 'z'},
{"infoname-variant" , required_argument, 0, 'V'},
LIBXML2_PARSE_LONGOPT_DEFS
{0, 0, 0, 0}
};
int loptind = 0;

srand(time(NULL) + getpid());

while ((c = getopt_long(argc, argv, sopts, lopts, &loptind)) != -1) {
switch (c) {
case 0:
if (strcmp(lopts[loptind].name, "version") == 0) {
show_version();
return 0;
}
LIBXML2_PARSE_LONGOPT_HANDLE(lopts, loptind, optarg)
break;
case 'a': act_dmcode = strdup(optarg); break;
case 'p': showprompts = true; break;
case 'd': strcpy(defaults_fname, optarg); custom_defaults = true; break;
case 'D': strcpy(dmtypes_fname, optarg); custom_dmtypes = true; break;
case 'L': strcpy(languageIsoCode, optarg); break;
case 'C': strcpy(countryIsoCode, optarg); break;
case 'n': strcpy(issueNumber, optarg); break;
case 'w': strcpy(inWork, optarg); break;
case 'c': strcpy(securityClassification, optarg); break;
case 'r': strcpy(responsiblePartnerCompany_enterpriseName, optarg); break;
case 'R': strcpy(responsiblePartnerCompany_enterpriseCode, optarg); break;
case 'o': strcpy(originator_enterpriseName, optarg); break;
case 'O': strcpy(originator_enterpriseCode, optarg); break;
case 't': strcpy(techName_content, optarg); tech_name_flag = true; break;
case 'i': strcpy(infoName_content, optarg); break;
case 'T': strcpy(dmtype, optarg); break;
case '#': if (strchr(optarg, '-')) {
strncpy(dmcode, optarg, 255);
} else {
random_code(dmcode, 256, optarg);
}
skipdmc = true;
break;
case 'N': no_issue = true; no_issue_set = true; break;
case 's': strcpy(schema, optarg); break;
case 'B': if (!brex_rules) brex_rules = xmlNewNode(NULL, BAD_CAST "structureObjectRuleGroup"); break;
case 'b': strcpy(brex_dmcode, optarg); break;
case 'S': sns_fname = strdup(optarg); break;
case 'I': strcpy(issue_date, optarg); break;
case 'V': info_name_variant = xmlStrdup(BAD_CAST optarg); break;
case 'v': verbose = true; break;
case 'f': overwrite = true; break;
case '$': issue = get_issue(optarg); break;
case '@': out = strdup(optarg); break;
case 'm': remarks = xmlStrdup(BAD_CAST optarg); break;
case ',': print_dmtypes(); return 0;
case '.': print_dmtypes_txt(); return 0;
case '%': template_dir = strdup(optarg); break;
case 'q': no_overwrite_error = true; break;
case 'M': maint_sns = strdup(optarg); break;
case 'P': sns_title_levels = atoi(optarg); break;
case '!': no_info_name = true; break;
case 'k': skill_level_code = xmlStrdup(BAD_CAST optarg); break;
case 'j': if (!brexmap) brexmap = read_xml_doc(optarg); break;
case '~': dump_templates(optarg); return 0;
case 'z': issue_type = xmlStrdup(BAD_CAST optarg); break;
case 'h':
case '?': show_help(); return 0;
}
}

if (!custom_defaults) {
find_config(defaults_fname, DEFAULT_DEFAULTS_FNAME);
}
if (!custom_dmtypes) {
find_config(dmtypes_fname, DEFAULT_DMTYPES_FNAME);
}

defaults_dir_str = strdup(defaults_fname);
defaults_dir = dirname(defaults_dir_str);

if (!brexmap) {
brexmap = read_default_brexmap();
}

if (brex_rules) {
xmlNodePtr dmtypes_brex_rule, objpath, def;
xmlChar *id, *path;

def = xpath_first_node(brexmap, NULL, BAD_CAST "//dmtypes");
id = xmlGetProp(def, BAD_CAST "id");
path = xmlGetProp(def, BAD_CAST "path");

dmtypes_brex_rule = xmlNewChild(brex_rules, NULL, BAD_CAST "structureObjectRule", NULL);

if (id) {
xmlSetProp(dmtypes_brex_rule, BAD_CAST "id", id);
}

objpath = xmlNewChild(dmtypes_brex_rule, NULL, BAD_CAST "objectPath", path);
xmlSetProp(objpath, BAD_CAST "allowedObjectFlag", BAD_CAST "2");

xmlNewChild(dmtypes_brex_rule, NULL, BAD_CAST "objectUse", BREX_INFOCODE_USE);

xmlFree(id);
xmlFree(path);
}

if ((defaults_xml = read_xml_doc(defaults_fname))) {
xmlNodePtr cur;

for (cur = xmlDocGetRootElement(defaults_xml)->children; cur; cur = cur->next) {
char *def_key, *def_val;

if (cur->type != XML_ELEMENT_NODE) continue;
if (!xmlHasProp(cur, BAD_CAST "ident")) continue;
if (!xmlHasProp(cur, BAD_CAST "value")) continue;

def_key = (char *) xmlGetProp(cur, BAD_CAST "ident");
def_val = (char *) xmlGetProp(cur, BAD_CAST "value");

copy_default_value(def_key, def_val);

if (brex_rules) {
add_brex_rule(brex_rules, brexmap, def_key, def_val);
}

xmlFree(def_key);
xmlFree(def_val);
}

xmlFreeDoc(defaults_xml);
} else if ((defaults = fopen(defaults_fname, "r"))) {
char default_line[1024];

while (fgets(default_line, 1024, defaults)) {
char def_key[32], def_val[256];

if (sscanf(default_line, "%31s %255[^\n]", def_key, def_val) != 2)
continue;

copy_default_value(def_key, def_val);

if (brex_rules) {
add_brex_rule(brex_rules, brexmap, def_key, def_val);
}
}

fclose(defaults);
}

if (strcmp(dmcode, "-") == 0) {
random_code(dmcode, 256, modelIdentCode);
}

if (strcmp(dmcode, "") != 0) {
int n, offset;

offset = strncmp(dmcode, "DMC-", 4) == 0 ? 4 : 0;

n = sscanf(dmcode + offset, "%14[^-]-%4[^-]-%3[^-]-%c%c-%4[^-]-%2s%3[^-]-%3s%c-%c-%3s%1s",
modelIdentCode,
systemDiffCode,
systemCode,
subSystemCode,
subSubSystemCode,
assyCode,
disassyCode,
disassyCodeVariant,
infoCode,
infoCodeVariant,
itemLocationCode,
learnCode,
learnEventCode);

if (n != 11 && n != 13) {
fprintf(stderr, ERR_PREFIX "Bad data module code: %s\n", dmcode);
exit(EXIT_BAD_DMC);
}
}

if (strcmp(dmtype, "") == 0 || (strcmp(infoName_content, "") == 0 && !no_info_name)) {
if ((defaults_xml = read_xml_doc(dmtypes_fname))) {
process_dmtypes_xml(defaults_xml, brex_rules);
xmlFreeDoc(defaults_xml);
} else if ((defaults = fopen(dmtypes_fname, "r"))) {
char default_line[1024];

while (fgets(default_line, 1024, defaults)) {
char def_key[32], def_val[256], infname[256];
int n;
char code[4], variant[2], itemloc[2], learn[4], levent[2];
int p;

n = sscanf(default_line, "%31s %255s %255[^\n]", def_key, def_val, infname);

if (n < 2)
continue;

p = sscanf(def_key, "%3s%1s-%1s-%3s%1s", code, variant, itemloc, learn, levent);

/* Get schema */
if (strcmp(dmtype, "") == 0 &&
strcmp(code, infoCode) == 0 &&
(p < 2 || strcmp(variant, "*") == 0 || strcmp(variant, infoCodeVariant) == 0) &&
(p < 3 || strcmp(itemloc, "*") == 0 || strcmp(itemloc, itemLocationCode) == 0) &&
(p < 4 || strcmp(learn, "***") == 0 || strcmp(learn, learnCode) == 0) &&
(p < 5 || strcmp(levent, "*") == 0 || strcmp(levent, learnEventCode) == 0)) {
strcpy(dmtype, def_val);
}

/* Get info name */
if (n == 3 &&
strcmp(infoName_content, "") == 0 &&
!no_info_name &&
strcmp(code, infoCode) == 0 &&
(p < 2 || strcmp(variant, "*") == 0 || strcmp(variant, infoCodeVariant) == 0) &&
(p < 3 || strcmp(itemloc, "*") == 0 || strcmp(itemloc, itemLocationCode) == 0) &&
(p < 4 || strcmp(learn, "***") == 0 || strcmp(learn, learnCode) == 0) &&
(p < 5 || strcmp(levent, "*") == 0 || strcmp(levent, learnEventCode) == 0)) {
strcpy(infoName_content, infname);
}

if (brex_rules) {
add_dmtypes_brex_val(brex_rules, def_key, n == 3 ? infname : NULL);
}
}

fclose(defaults);
} else {
defaults_xml = read_xml_mem((const char *) dmtypes_xml, dmtypes_xml_len);
process_dmtypes_xml(defaults_xml, brex_rules);
xmlFreeDoc(defaults_xml);
}
}

if (showprompts) {
if (!skipdmc) {
prompt("Model identification code", modelIdentCode, MAX_MODEL_IDENT_CODE);
prompt("System difference code", systemDiffCode, MAX_SYSTEM_DIFF_CODE);
prompt("System code", systemCode, MAX_SYSTEM_CODE);
prompt("Sub-system code", subSystemCode, MAX_SUB_SYSTEM_CODE);
prompt("Sub-sub-system code", subSubSystemCode, MAX_SUB_SUB_SYSTEM_CODE);
prompt("Assembly code", assyCode, MAX_ASSY_CODE);
prompt("Disassembly code", disassyCode, MAX_DISASSY_CODE);
prompt("Disassembly code variant", disassyCodeVariant, MAX_DISASSY_CODE_VARIANT);
prompt("Information code", infoCode, MAX_INFO_CODE);
prompt("Information code variant", infoCodeVariant, MAX_INFO_CODE_VARIANT);
prompt("Item location code", itemLocationCode, MAX_ITEM_LOCATION_CODE);
prompt("Learn code", learnCode, MAX_LEARN_CODE);
prompt("Learn event code", learnEventCode, MAX_LEARN_EVENT_CODE);
}
prompt("Language ISO code", languageIsoCode, MAX_LANGUAGE_ISO_CODE);
prompt("Country ISO code", countryIsoCode, MAX_COUNTRY_ISO_CODE);
prompt("Issue number", issueNumber, MAX_ISSUE_NUMBER);
prompt("In-work issue", inWork, MAX_IN_WORK);
prompt("Security classification", securityClassification, MAX_SECURITY_CLASSIFICATION);
prompt("Responsible partner company", responsiblePartnerCompany_enterpriseName, MAX_ENTERPRISE_NAME);
prompt("Originator", originator_enterpriseName, MAX_ENTERPRISE_NAME);
prompt("Tech name", techName_content, MAX_TECH_NAME);
prompt("Info name", infoName_content, MAX_INFO_NAME);
prompt("DM type", dmtype, 32);
prompt("Schema", schema, 1024);
}

if (strcmp(modelIdentCode, "") == 0 ||
strcmp(systemDiffCode, "") == 0 ||
strcmp(systemCode, "") == 0 ||
strcmp(subSystemCode, "") == 0 ||
strcmp(subSubSystemCode, "") == 0 ||
strcmp(assyCode, "") == 0 ||
strcmp(disassyCode, "") == 0 ||
strcmp(disassyCodeVariant, "") == 0 ||
strcmp(infoCode, "") == 0 ||
strcmp(infoCodeVariant, "") == 0 ||
strcmp(itemLocationCode, "") == 0) {

fprintf(stderr, ERR_PREFIX "Missing required DMC components: ");
fprintf(stderr, "DMC-%s-%s-%s-%s%s-%s-%s%s-%s%s-%s\n",
strcmp(modelIdentCode, "") == 0 ? "???" : modelIdentCode,
strcmp(systemDiffCode, "") == 0 ? "???" : systemDiffCode,
strcmp(systemCode, "") == 0 ? "???" : systemCode,
strcmp(subSystemCode, "") == 0 ? "???" : subSystemCode,
strcmp(subSubSystemCode, "") == 0 ? "???" : subSubSystemCode,
strcmp(assyCode, "") == 0 ? "???" : assyCode,
strcmp(disassyCode, "") == 0 ? "???" : disassyCode,
strcmp(disassyCodeVariant, "") == 0 ? "???" : disassyCodeVariant,
strcmp(infoCode, "") == 0 ? "???" : infoCode,
strcmp(infoCodeVariant, "") == 0 ? "???" : infoCodeVariant,
strcmp(itemLocationCode, "") == 0 ? "???" : itemLocationCode);

exit(EXIT_BAD_DMC);
}

if (!tech_name_flag && (maint_sns || sns_fname || strcmp(brex_dmcode, "") != 0)) {
xmlDocPtr brex;
brex = set_tech_from_sns(defaults_dir);
xmlFreeDoc(brex);
}

if (issue == NO_ISS) issue = DEFAULT_S1000D_ISSUE;
if (strcmp(issueNumber, "") == 0) strcpy(issueNumber, "000");
if (strcmp(inWork, "") == 0) strcpy(inWork, "01");
if (strcmp(securityClassification, "") == 0) strcpy(securityClassification, "01");

set_env_lang();
for (i = 0; languageIsoCode[i]; ++i) {
languageIsoCode[i] = tolower(languageIsoCode[i]);
}
for (i = 0; countryIsoCode[i]; ++i) {
countryIsoCode[i] = toupper(countryIsoCode[i]);
}

if (sns_title_levels == 0) {
sns_title_levels = 1;
}

dm = xml_skeleton(dmtype, issue);

dmodule = xmlDocGetRootElement(dm);
identAndStatusSection = find_child(dmodule, "identAndStatusSection");
dmAddress = find_child(identAndStatusSection, "dmAddress");
dmIdent = find_child(dmAddress, "dmIdent");
dmCode = find_child(dmIdent, "dmCode");
language = find_child(dmIdent, "language");
issueInfo = find_child(dmIdent, "issueInfo");
dmAddressItems = find_child(dmAddress, "dmAddressItems");
issueDate = find_child(dmAddressItems, "issueDate");
dmStatus = find_child(identAndStatusSection, "dmStatus");
security = find_child(dmStatus, "security");
dmTitle = find_child(dmAddressItems, "dmTitle");
techName = find_child(dmTitle, "techName");
infoName = find_child(dmTitle, "infoName");
infoNameVariant = find_child(dmTitle, "infoNameVariant");

if (strcmp(schema, "") != 0) {
xmlSetProp(dmodule, BAD_CAST "xsi:noNamespaceSchemaLocation", BAD_CAST schema);
}

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

if (strcmp(learnCode, "") != 0) xmlSetProp(dmCode, BAD_CAST "learnCode", BAD_CAST learnCode);
if (strcmp(learnEventCode, "") != 0) xmlSetProp(dmCode, BAD_CAST "learnEventCode", BAD_CAST learnEventCode);

xmlSetProp(language, BAD_CAST "languageIsoCode", BAD_CAST languageIsoCode);
xmlSetProp(language, BAD_CAST "countryIsoCode", BAD_CAST countryIsoCode);

xmlSetProp(issueInfo, BAD_CAST "issueNumber", BAD_CAST issueNumber);
xmlSetProp(issueInfo, BAD_CAST "inWork", BAD_CAST inWork);

set_issue_date(issueDate);

if (issue_type) xmlSetProp(dmStatus, BAD_CAST "issueType", issue_type);

/* SB DMs also contain an "original issue date" */
if (strcmp(dmtype, "sb") == 0) {
xmlNodePtr sbissdate;
sbissdate = firstXPathNode(dm, NULL, "//sbOriginalIssueDate/issueDate");
if (sbissdate) set_issue_date(sbissdate);
}

xmlSetProp(security, BAD_CAST "securityClassification", BAD_CAST securityClassification);

xmlNodeSetContent(techName, BAD_CAST techName_content);

if (strcmp(infoName_content, "") == 0) {
xmlUnlinkNode(infoName);
xmlFreeNode(infoName);
} else {
xmlChar *s;
s = xmlEncodeEntitiesReentrant(dm, BAD_CAST infoName_content);
xmlNodeSetContent(infoName, s);
xmlFree(s);
}

if (info_name_variant) {
xmlChar *s;
s = xmlEncodeEntitiesReentrant(dm, info_name_variant);
xmlNodeSetContent(infoNameVariant, s);
xmlFree(s);
} else {
xmlUnlinkNode(infoNameVariant);
xmlFreeNode(infoNameVariant);
}

responsiblePartnerCompany = find_child(dmStatus, "responsiblePartnerCompany");
if (strcmp(responsiblePartnerCompany_enterpriseCode, "") != 0) {
xmlSetProp(responsiblePartnerCompany, BAD_CAST "enterpriseCode", BAD_CAST responsiblePartnerCompany_enterpriseCode);
}
if (strcmp(responsiblePartnerCompany_enterpriseName, "") != 0) {
xmlNodePtr node;
if ((node = firstXPathNode(dm, NULL, "//responsiblePartnerCompany/enterpriseName"))) {
xmlNodeSetContent(node, BAD_CAST responsiblePartnerCompany_enterpriseName);
} else {
xmlNewChild(responsiblePartnerCompany, NULL, BAD_CAST "enterpriseName", BAD_CAST responsiblePartnerCompany_enterpriseName);
}
}

originator = find_child(dmStatus, "originator");
if (strcmp(originator_enterpriseCode, "") != 0) {
xmlSetProp(originator, BAD_CAST "enterpriseCode", BAD_CAST originator_enterpriseCode);
}
if (strcmp(originator_enterpriseName, "") != 0) {
xmlNodePtr node;
if ((node = firstXPathNode(dm, NULL, "//originator/enterpriseName"))) {
xmlNodeSetContent(node, BAD_CAST originator_enterpriseName);
} else {
xmlNewChild(originator, NULL, BAD_CAST "enterpriseName", BAD_CAST originator_enterpriseName);
}
}

set_skill_level(dm, skill_level_code);

set_remarks(dm, remarks);

if (act_dmcode) {
set_act(dm, act_dmcode);
} else {
unset_act(dm);
}

if (strcmp(brex_dmcode, "") != 0)
set_brex(dm, brex_dmcode);

if (brex_rules) {
xmlNodePtr context_rules;
if ((context_rules = firstXPathNode(dm, NULL, "//contextRules"))) {
xmlAddChild(context_rules, brex_rules);
} else {
xmlFreeNode(brex_rules);
}
}

for (i = 0; languageIsoCode[i]; ++i) languageIsoCode[i] = toupper(languageIsoCode[i]);

if (strcmp(learnCode, "") != 0 && strcmp(learnEventCode, "") != 0) {
snprintf(learn, 8, "-%s%s", learnCode, learnEventCode);
}

if (!no_issue) {
snprintf(iss, 16, "_%s-%s", issueNumber, inWork);
}

if (issue < ISS_50) {
if (strcmp(brex_dmcode, "") == 0) {
switch (issue) {
case ISS_22:
set_brex(dm, ISS_22_DEFAULT_BREX);
break;
case ISS_23:
set_brex(dm, ISS_23_DEFAULT_BREX);
break;
case ISS_30:
set_brex(dm, ISS_30_DEFAULT_BREX);
break;
case ISS_40:
set_brex(dm, ISS_40_DEFAULT_BREX);
break;
case ISS_41:
set_brex(dm, ISS_41_DEFAULT_BREX);
break;
case ISS_42:
set_brex(dm, ISS_42_DEFAULT_BREX);
break;
default:
break;
}
}

dm = toissue(dm, issue);
}

if (out && isdir(out, false)) {
outdir = out;
out = NULL;
}

if (!out) {
char dmc[MAX_DATAMODULE_CODE];

snprintf(dmc, MAX_DATAMODULE_CODE,
"DMC-%s-%s-%s-%s%s-%s-%s%s-%s%s-%s%s%s_%s-%s.XML",
modelIdentCode,
systemDiffCode,
systemCode,
subSystemCode,
subSubSystemCode,
assyCode,
disassyCode,
disassyCodeVariant,
infoCode,
infoCodeVariant,
itemLocationCode,
learn,
iss,
languageIsoCode,
countryIsoCode);

out = strdup(dmc);
}

if (outdir) {
if (chdir(outdir) != 0) {
fprintf(stderr, ERR_PREFIX "Could not change to directory %s: %s\n", outdir, strerror(errno));
exit(EXIT_OS_ERROR);
}
}

if (!overwrite && access(out, F_OK) != -1) {
if (no_overwrite_error) return 0;
if (outdir) {
fprintf(stderr, ERR_PREFIX "%s/%s already exists. Use -f to overwrite.\n", outdir, out);
} else {
fprintf(stderr, ERR_PREFIX "%s already exists. Use -f to overwrite.\n", out);
}
exit(EXIT_DM_EXISTS);
}

save_xml_doc(dm, out);

if (verbose) {
if (outdir) {
printf("%s/%s\n", outdir, out);
} else {
puts(out);
}
}

free(out);
free(outdir);
free(template_dir);
free(act_dmcode);
free(sns_fname);
free(maint_sns);
free(skill_level_code);
free(defaults_dir_str);

xmlFree(issue_type);
xmlFree(remarks);
xmlFree(info_name_variant);

xmlFreeDoc(brexmap);
xmlFreeDoc(dm);

xmlCleanupParser();
xsltCleanupGlobals();

return 0;
}