904 lines
25 KiB
C++
904 lines
25 KiB
C++
/******************************************************************************
|
|
* Copyright (C) 2002, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
******************************************************************************/
|
|
#include "xml2txt.h"
|
|
|
|
static bool DTDFLAG = false;
|
|
static char* gTxtFile;
|
|
static char* gXmlFile;
|
|
static const char *sourceDir;
|
|
static const char *destDir;
|
|
static bool gDoNamespaces = false;
|
|
static bool gDoSchema = false;
|
|
static bool gDoCreate = false;
|
|
static XMLCh* gEncodingName = 0;
|
|
static XMLFormatter::UnRepFlags gUnRepFlags = XMLFormatter::UnRep_CharRef;
|
|
static DOMParser::ValSchemes gValScheme = DOMParser::Val_Auto;
|
|
static XMLFormatter* gFormatter = 0;
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
HELP,
|
|
SOURCEDIR,
|
|
DESTDIR,
|
|
};
|
|
//#define UOPTION_TXT UOPTION_DEF("txt", 't', UOPT_NO_ARG)
|
|
//#define UOPTION_RES UOPTION_DEF("res", 'r', UOPT_NO_ARG)
|
|
|
|
UOption options[]={
|
|
UOPTION_HELP_H,
|
|
UOPTION_SOURCEDIR,
|
|
UOPTION_DESTDIR,
|
|
};
|
|
|
|
|
|
|
|
#ifdef XP_MAC_CONSOLE
|
|
#include <console.h>
|
|
#endif
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
//
|
|
// Usage()
|
|
//
|
|
// ---------------------------------------------------------------------------
|
|
void usage()
|
|
{
|
|
cout << "\nUsage: XML2TXT [OPTIONS] [FILES]\n\n"
|
|
"This program is used to convert XML files to TXT files.\n"
|
|
"Please refer to the following options. Options are not \n"
|
|
"case sensitive.\n"
|
|
"Options:\n"
|
|
"\t-s or --sourcedir \t source directory for files followed by path, default is current directory.\n"
|
|
"\t-d or --destdir \t destination directory, followed by the path, default is current directory.\n"
|
|
"\t-h or -? or --help \t this usage text.\n"
|
|
"\nAttention: \n"
|
|
"\tThe text file's encoding is the same as the source file's.\n"
|
|
|
|
<< endl;
|
|
}
|
|
|
|
int main(int argC, char* argV[])
|
|
{
|
|
int retval = 0;
|
|
const char* arg=NULL;
|
|
|
|
try
|
|
{
|
|
XMLPlatformUtils::Initialize();
|
|
}
|
|
|
|
catch(const XMLException& toCatch)
|
|
{
|
|
cerr << "Error during Xerces-c Initialization.\n"
|
|
<< " Exception message:"
|
|
<< DOMString(toCatch.getMessage()) << endl;
|
|
return 1;
|
|
}
|
|
|
|
#ifdef XP_MAC_CONSOLE
|
|
|
|
argC = ccommand((char***)&argV);
|
|
#endif
|
|
|
|
argC = u_parseArgs(argC, argV, (int32_t)(sizeof(options)/sizeof(options[0])), options);
|
|
|
|
if(argC<0) {
|
|
cout << "error in command line argument" << argV[-argC] << endl;
|
|
}
|
|
|
|
// Watch for special case help request
|
|
if(argC<2 || options[HELP].doesOccur) {
|
|
usage();
|
|
return argC < 0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
|
|
}
|
|
|
|
if(options[SOURCEDIR].doesOccur) {
|
|
sourceDir = options[SOURCEDIR].value;
|
|
}
|
|
else {
|
|
#ifdef WIN32
|
|
destDir = _getcwd(NULL, 0);
|
|
#else
|
|
destDir = getcwd(NULL, 0);
|
|
#endif
|
|
}
|
|
|
|
if(options[DESTDIR].doesOccur) {
|
|
destDir = options[DESTDIR].value;
|
|
}
|
|
else {
|
|
#ifdef WIN32
|
|
destDir = _getcwd(NULL, 0);
|
|
#else
|
|
destDir = getcwd(NULL, 0);
|
|
#endif
|
|
}
|
|
|
|
for(int i = 1; i< argC; i++) {
|
|
arg = getLongPathname(argV[i]);
|
|
|
|
gXmlFile = CreateFile(arg, sourceDir);
|
|
|
|
gTxtFile = CreateTxtName(arg, destDir);
|
|
|
|
|
|
retval = ProcessTxtFile();
|
|
}
|
|
XMLPlatformUtils::Terminate();
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
int ProcessTxtFile()
|
|
{
|
|
int retval = 0;
|
|
|
|
DOMParser* parser;
|
|
DOMTreeErrorReporter* errReporter;
|
|
parser = new DOMParser();
|
|
errReporter = new DOMTreeErrorReporter();
|
|
parser->setValidationScheme(gValScheme);
|
|
parser->setDoNamespaces(true);
|
|
parser->setDoSchema(gDoSchema);
|
|
|
|
parser->setErrorHandler(errReporter);
|
|
parser->setCreateEntityReferenceNodes(gDoCreate);
|
|
parser->setToCreateXMLDeclTypeNode(true);
|
|
|
|
//
|
|
// Parse the XML file, catching any XML exceptions that might propogate
|
|
// out of it.
|
|
//
|
|
bool errorsOccured = false;
|
|
try
|
|
{
|
|
parser->parse(gXmlFile);
|
|
int errorCount = parser->getErrorCount();
|
|
if (errorCount > 0)
|
|
errorsOccured = true;
|
|
}
|
|
|
|
catch (const XMLException& e)
|
|
{
|
|
|
|
|
|
cerr << "An error occured during parsing\n Message: "
|
|
<< DOMString(e.getMessage()) << endl;
|
|
errorsOccured = true;
|
|
}
|
|
|
|
|
|
catch (const DOM_DOMException& e)
|
|
{
|
|
cerr << "A DOM error occured during parsing\n DOMException code: "
|
|
<< e.code << endl;
|
|
errorsOccured = true;
|
|
}
|
|
|
|
catch (...)
|
|
{
|
|
cerr << "An error occured during parsing\n " << endl;
|
|
errorsOccured = true;
|
|
}
|
|
|
|
if(!errorsOccured && !errReporter->getSawErrors())
|
|
{
|
|
DOM_Node document = parser->getDocument();
|
|
Check(document); //if check fails, exit(0); else excute the following code
|
|
if(DTDFLAG == false){
|
|
cout << "DTD no assigned!" << endl;
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
// If the parse and doubt-check was successful, output the document data from the DOM tree
|
|
if (!errorsOccured && !errReporter->getSawErrors())
|
|
{
|
|
DOM_Node doc = parser->getDocument();
|
|
DOMPrintFormatTarget *formatTarget = new DOMPrintFormatTarget(gTxtFile);
|
|
|
|
|
|
|
|
if (gEncodingName == 0)
|
|
{
|
|
DOMString encNameStr("UTF-8");
|
|
DOM_Node aNode = doc.getFirstChild();
|
|
if (aNode.getNodeType() == DOM_Node::XML_DECL_NODE)
|
|
{
|
|
DOMString aStr = ((DOM_XMLDecl &)aNode).getEncoding();
|
|
if (aStr != "")
|
|
{
|
|
encNameStr = aStr;
|
|
}
|
|
}
|
|
unsigned int lent = encNameStr.length();
|
|
gEncodingName = new XMLCh[lent + 1];
|
|
XMLString::copyNString(gEncodingName, encNameStr.rawBuffer(), lent);
|
|
gEncodingName[lent] = 0;
|
|
}
|
|
|
|
|
|
try
|
|
{
|
|
gFormatter = new XMLFormatter(gEncodingName, formatTarget,
|
|
XMLFormatter::NoEscapes, gUnRepFlags);
|
|
ofstream ofile(gTxtFile, ios::trunc);
|
|
cout << doc;
|
|
}
|
|
catch (XMLException& e)
|
|
{
|
|
cerr << "An error occurred during creation of output transcoder. Msg is:"
|
|
<< endl
|
|
<< DOMString(e.getMessage()) << endl;
|
|
retval = 3;
|
|
}
|
|
delete formatTarget;
|
|
delete gFormatter;
|
|
}
|
|
delete errReporter;
|
|
delete parser;
|
|
parser = NULL;
|
|
errReporter = NULL;
|
|
delete gEncodingName;
|
|
gEncodingName=NULL;
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// double-check before DOM Tree PrintOut
|
|
//----------------------------------------------------------------------------
|
|
void Check( DOM_Node &document)
|
|
{
|
|
// Get the name and value out for convenience
|
|
DOMString nodeName = document.getNodeName(); //<tag name>, type
|
|
DOMString nodeValue = document.getNodeValue(); //<tag content>
|
|
|
|
DOMString attributeKey, attributeVal; //(key/name)(val/filename)
|
|
unsigned long lent = nodeValue.length();
|
|
switch (document.getNodeType())
|
|
{
|
|
case DOM_Node::TEXT_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
case DOM_Node::PROCESSING_INSTRUCTION_NODE :
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::DOCUMENT_NODE :
|
|
{
|
|
|
|
DOM_Node child = document.getFirstChild();
|
|
while( child != 0)
|
|
{
|
|
Check(child);
|
|
child = child.getNextSibling();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case DOM_Node::ELEMENT_NODE :
|
|
{
|
|
DOM_NamedNodeMap attributes = document.getAttributes();
|
|
int attrCount = attributes.getLength();
|
|
int item_num=0;
|
|
for (int i = 0; i < attrCount; i++)
|
|
{
|
|
DOM_Node attribute = attributes.item(i);
|
|
|
|
if(attribute.getNodeName().equals("key")||attribute.getNodeName().equals("name")){
|
|
attributeKey = attribute.getNodeValue();
|
|
}
|
|
else if(attribute.getNodeName().equals("val")||attribute.getNodeName().equals("filename")){
|
|
attributeVal = attribute.getNodeValue();
|
|
item_num = i;
|
|
}
|
|
else{
|
|
//call error report
|
|
ErrorReport(document, 0);
|
|
}
|
|
}
|
|
|
|
if(document.getParentNode().getNodeName().equals("array") && attributeKey!=NULL){
|
|
ErrorReport(document, 1); //ErrorType =1--the element in the array has name
|
|
}
|
|
else if(document.getParentNode().getNodeName().equals("table") && attributeKey==NULL){
|
|
ErrorReport(document, 2); //element in a table has no name
|
|
}
|
|
|
|
if(document.getNodeName().equals("table"))
|
|
{
|
|
//unsigned int Child_Num;
|
|
if(document.hasChildNodes())
|
|
{
|
|
ChildName* cn = new ChildName();
|
|
cn->SetNext(NULL);
|
|
ChildName* head = CheckNameDuplicate(document, cn);
|
|
DelChildName(head);
|
|
}
|
|
}
|
|
else if(document.getNodeName().equals("array")) {}
|
|
else if(document.getNodeName().equals("resourceBundle")) {}
|
|
|
|
else if(document.getNodeName().equals("str")||document.getNodeName().equals("importBin"))
|
|
{
|
|
CheckEscape(attributes, attributeVal, item_num);
|
|
}
|
|
|
|
else if(document.getNodeName().equals("intVector"))
|
|
{
|
|
DOMString ivstring;
|
|
ivstring = CheckIntvector(attributeVal, document);
|
|
if(ivstring !=NULL)
|
|
attributes.item(item_num).setNodeValue(ivstring);
|
|
}
|
|
|
|
else if(document.getNodeName().equals("int"))
|
|
{
|
|
CheckInt(attributeVal, document);
|
|
}
|
|
|
|
else if(document.getNodeName().equals("bin"))
|
|
{
|
|
CheckBin(attributeVal, document);
|
|
}
|
|
|
|
else if(document.getNodeName().equals("import")) {}
|
|
else if(document.getNodeName().equals("alias")) {}
|
|
else {
|
|
ErrorReport(document, 6);
|
|
}
|
|
|
|
|
|
DOM_Node child = document.getFirstChild();
|
|
if (child != 0)
|
|
{
|
|
while( child != 0)
|
|
{
|
|
Check(child);
|
|
child = child.getNextSibling();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::ENTITY_REFERENCE_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::CDATA_SECTION_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::COMMENT_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::DOCUMENT_TYPE_NODE:
|
|
{
|
|
DTDFLAG = true;
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::ENTITY_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::XML_DECL_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
default:
|
|
cerr << "Unrecognized node type = "
|
|
<< (long)document.getNodeType() << endl;
|
|
}
|
|
}
|
|
|
|
void CheckEscape(DOM_NamedNodeMap attributes, DOMString attributeVal, int item_num)
|
|
{
|
|
unsigned int len;
|
|
char Escape[7] = {'\\', 'u', '0', '0', '2', '2', '\0'};
|
|
len = attributeVal.length();
|
|
DOMString fromStr;
|
|
DOMString toStr;
|
|
const XMLCh quote[] = {(unsigned short)0x22, (unsigned short) 0};
|
|
if(len>0)
|
|
{
|
|
for(unsigned int i=0; i<len; i++)
|
|
{
|
|
fromStr = attributeVal.substringData (i,1);
|
|
char* temp=fromStr.transcode();
|
|
if(fromStr.equals(quote))
|
|
{
|
|
toStr.appendData(Escape);
|
|
}
|
|
else
|
|
toStr.appendData(fromStr);
|
|
}
|
|
attributes.item(item_num).setNodeValue(toStr);
|
|
}
|
|
}
|
|
|
|
DOMString getAttributeKey(DOM_Node CNode)
|
|
{
|
|
DOM_NamedNodeMap attributes = CNode.getAttributes();
|
|
int attrCount = attributes.getLength();
|
|
DOMString attributeKey;
|
|
|
|
for (int i = 0; i < attrCount; i++)
|
|
{
|
|
DOM_Node attribute = attributes.item(i);
|
|
|
|
if(attribute.getNodeName().equals("key"))
|
|
attributeKey = attribute.getNodeValue();
|
|
}
|
|
return attributeKey;
|
|
}
|
|
|
|
void DelChildName(ChildName* cn)
|
|
{
|
|
ChildName* temp = cn->Next;
|
|
while(temp!=NULL)
|
|
{
|
|
delete cn;
|
|
cn = NULL;
|
|
cn = temp;
|
|
temp = temp->Next;
|
|
}
|
|
delete cn;
|
|
}
|
|
|
|
ChildName* CheckNameDuplicate(DOM_Node document, ChildName* cn)
|
|
{
|
|
DOM_Node CNode = document.getFirstChild();
|
|
|
|
while(CNode!=NULL)
|
|
{
|
|
if(CNode.getNodeName().equals("string")||CNode.getNodeName().equals("bin")||CNode.getNodeName().equals("int")||CNode.getNodeName().equals("intvector")||CNode.getNodeName().equals("import")||CNode.getNodeName().equals("table")||CNode.getNodeName().equals("array"))
|
|
{
|
|
DOMString cname = getAttributeKey(CNode);
|
|
char* string = cname.transcode();
|
|
ChildName* temp = cn;
|
|
while(temp->Next!=NULL)
|
|
{
|
|
if(cname.equals(temp->Name))
|
|
{
|
|
DelChildName(cn);
|
|
ErrorReport(CNode, 5); //name duplication
|
|
}
|
|
temp = temp ->Next;
|
|
}
|
|
|
|
ChildName* childname = new ChildName();
|
|
childname->SetName(cname);
|
|
childname->SetNext(cn);
|
|
cn = childname;
|
|
}
|
|
CNode = CNode.getNextSibling();
|
|
}
|
|
return cn;
|
|
}
|
|
|
|
unsigned int GetCNodeNum(DOM_Node document)
|
|
{
|
|
unsigned int num=0;
|
|
DOM_Node CNode = document.getFirstChild();
|
|
while(CNode!=NULL)
|
|
{
|
|
if(CNode.getNodeName().equals("string")||CNode.getNodeName().equals("bin")||CNode.getNodeName().equals("int")||CNode.getNodeName().equals("intvector")||CNode.getNodeName().equals("import")||CNode.getNodeName().equals("table")||CNode.getNodeName().equals("array"))
|
|
num++;
|
|
CNode = CNode.getNextSibling();
|
|
}
|
|
return num;
|
|
}
|
|
|
|
void CheckBin(DOMString attributeVal, DOM_Node document)
|
|
{
|
|
char *stopstring;
|
|
char toConv[2] = {'\0', '\0'};
|
|
char* string = attributeVal.transcode();
|
|
int count = strlen(string);
|
|
if(count > 0)
|
|
{
|
|
if((count % 2)==0)
|
|
{
|
|
for(int i=0; i<count; i++)
|
|
{
|
|
toConv[0]=string[i];
|
|
int value = strtoul(toConv, &stopstring, 16);
|
|
unsigned int len = stopstring-toConv;
|
|
if(len!= strlen(toConv))
|
|
{
|
|
ErrorReport(document, 4); //invalid bin value
|
|
}
|
|
}
|
|
}
|
|
else
|
|
ErrorReport(document, 4); //invalid bin value
|
|
}
|
|
}
|
|
|
|
|
|
void CheckInt(DOMString attributeVal, DOM_Node document)
|
|
{
|
|
char *stopstring;
|
|
char* string= attributeVal.transcode();
|
|
long value = strtoul(string, &stopstring, 0);
|
|
unsigned int len=stopstring-string;
|
|
if(len!=strlen(string))
|
|
ErrorReport(document, 3); //invalid int value
|
|
}
|
|
|
|
DOMString CheckIntvector(DOMString attributeVal, DOM_Node document)
|
|
{
|
|
DOMString ivstring;
|
|
char* string ;
|
|
if(attributeVal != NULL)
|
|
{
|
|
string = attributeVal.transcode();
|
|
char integer[32];
|
|
char *stopstring;
|
|
int i,j;
|
|
int len = strlen(string);
|
|
int begin,end;
|
|
int value;
|
|
begin = end =0;
|
|
for(i = 0; i < len; i++)
|
|
{
|
|
if(string[i]==(char)32 && i!= (len-1)){
|
|
end = i+1;
|
|
for(j = begin; j < end; j++)
|
|
integer[j-begin] = string[j];
|
|
|
|
|
|
integer[end-begin]='\0';
|
|
ivstring.appendData(integer);
|
|
ivstring.appendData(",");
|
|
|
|
value = strtoul(integer, &stopstring, 0);
|
|
int l = stopstring - integer;
|
|
if((stopstring - integer)!=(end - begin -1))
|
|
ErrorReport(document, 3); //invalid int value
|
|
begin = end;
|
|
}
|
|
}
|
|
if(string[len-1]!=(char)32)
|
|
{
|
|
for(j = begin; j < len; j++)
|
|
integer[j-begin] = string[j];
|
|
integer[len-begin] = '\0';
|
|
ivstring.appendData(integer);
|
|
|
|
value = strtoul(integer, &stopstring, 0);
|
|
int l = stopstring - integer;
|
|
if((stopstring - integer)!=(len - begin))
|
|
ErrorReport(document, 3);
|
|
}
|
|
return ivstring;
|
|
}
|
|
else
|
|
return NULL;
|
|
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ostream << DOM_Node
|
|
//
|
|
// Stream out a DOM node, and, recursively, all of its children.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
ostream& operator<<(ostream& target, DOM_Node& toWrite)
|
|
{
|
|
// Get the name and value out for convenience
|
|
DOMString nodeName = toWrite.getNodeName(); //<tag name>, type
|
|
DOMString nodeValue = toWrite.getNodeValue(); //<tag content>
|
|
|
|
DOMString attributeKey, attributeVal; //(key/name)(val/filename)
|
|
unsigned long lent = nodeValue.length();
|
|
|
|
|
|
switch (toWrite.getNodeType())
|
|
{
|
|
case DOM_Node::TEXT_NODE:
|
|
{
|
|
gFormatter->formatBuf(nodeValue.rawBuffer(),
|
|
lent, XMLFormatter::CharEscapes);
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::PROCESSING_INSTRUCTION_NODE :
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::DOCUMENT_NODE :
|
|
{
|
|
|
|
DOM_Node child = toWrite.getFirstChild();
|
|
while( child != 0)
|
|
{
|
|
target << child;
|
|
child = child.getNextSibling();
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::ELEMENT_NODE :
|
|
{
|
|
|
|
DOM_NamedNodeMap attributes = toWrite.getAttributes();
|
|
int attrCount = attributes.getLength();
|
|
for (int i = 0; i < attrCount; i++)
|
|
{
|
|
DOM_Node attribute = attributes.item(i);
|
|
|
|
if(attribute.getNodeName().equals("key")||attribute.getNodeName().equals("name")){
|
|
attributeKey = attribute.getNodeValue();
|
|
}
|
|
else if(attribute.getNodeName().equals("val")||attribute.getNodeName().equals("filename")){
|
|
attributeVal = attribute.getNodeValue();
|
|
}
|
|
}
|
|
|
|
//Print Out
|
|
if(nodeName.equals("resourceBundle"))
|
|
*gFormatter << attributeKey;
|
|
else
|
|
{
|
|
if(nodeName.equals("bin") && attributeVal==NULL)
|
|
*gFormatter <<attributeKey << ":" << nodeName << chSpace<< "{" << chDoubleQuote <<attributeVal << chDoubleQuote;
|
|
else if(nodeName.equals("str"))
|
|
*gFormatter <<attributeKey << chSpace<< "{" << chDoubleQuote <<attributeVal << chDoubleQuote;
|
|
else if(nodeName.equals("intVector"))
|
|
*gFormatter <<attributeKey << ":" << "intvector" << chSpace<< "{" <<attributeVal ;
|
|
else if(nodeName.equals("importBin"))
|
|
*gFormatter <<attributeKey << ":" << "import" << chSpace<< "{" << chDoubleQuote <<attributeVal << chDoubleQuote ;
|
|
else
|
|
*gFormatter <<attributeKey << ":" << nodeName << chSpace<< "{" << attributeVal;
|
|
}
|
|
|
|
|
|
attributeKey = attributeVal = NULL;
|
|
|
|
|
|
DOM_Node child = toWrite.getFirstChild();
|
|
if (child != 0)
|
|
{
|
|
while( child != 0)
|
|
{
|
|
target << child;
|
|
child = child.getNextSibling();
|
|
}
|
|
if(!nodeName.equals("resourceBundle"))
|
|
*gFormatter << "}";
|
|
}
|
|
else
|
|
{
|
|
if(!nodeName.equals("resourceBundle"))
|
|
*gFormatter << "}";
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::ENTITY_REFERENCE_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::CDATA_SECTION_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::COMMENT_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::DOCUMENT_TYPE_NODE:
|
|
{
|
|
DOM_DocumentType doctype = (DOM_DocumentType &)toWrite;
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::ENTITY_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
case DOM_Node::XML_DECL_NODE:
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
default:
|
|
cerr << "Unrecognized node type = " << (long)toWrite.getNodeType() << endl;
|
|
}
|
|
return target;
|
|
}
|
|
|
|
void ErrorReport(DOM_Node& toWrite, int ErrorType){
|
|
|
|
DOM_NamedNodeMap attributes;
|
|
DOM_Node attribute;
|
|
int attrCount, i;
|
|
|
|
cout << "\nerror occurs at:\n";
|
|
DOMString ErrorMsg;
|
|
while(toWrite.getParentNode()!=NULL){
|
|
//do
|
|
ErrorMsg.insertData(0, ")");
|
|
|
|
attributes = toWrite.getAttributes();
|
|
attrCount = attributes.getLength();
|
|
|
|
if(attrCount!=0)
|
|
{
|
|
for (i = attrCount-1; i>=0; i--)
|
|
{
|
|
attribute = attributes.item(i);
|
|
ErrorMsg.insertData(0, " ; ");
|
|
ErrorMsg.insertData(0, attribute.getNodeValue());
|
|
}
|
|
}
|
|
ErrorMsg.insertData(0, "(");
|
|
ErrorMsg.insertData(0, toWrite.getNodeName());
|
|
ErrorMsg.insertData(0, "==>");
|
|
toWrite = toWrite.getParentNode();
|
|
}
|
|
ErrorMsg.appendData("\n");
|
|
|
|
switch (ErrorType)
|
|
{
|
|
case 1:
|
|
ErrorMsg.appendData("The element in the array can't have a name!\n");
|
|
break;
|
|
case 2:
|
|
ErrorMsg.appendData("The element in the table should have a name!\n");
|
|
break;
|
|
case 3:
|
|
ErrorMsg.appendData("Invalid integer value!\n");
|
|
break;
|
|
case 4:
|
|
ErrorMsg.appendData("Invalid bin!\n");
|
|
break;
|
|
case 5:
|
|
ErrorMsg.appendData("Name Duplication in the table!\n");
|
|
break;
|
|
case 6:
|
|
ErrorMsg.appendData("Invalid element name! Remember to assign correct DTD file on the xml file.\n");
|
|
break;
|
|
}
|
|
cout << ErrorMsg;
|
|
exit(0);
|
|
}
|
|
|
|
char* CreateTxtName(const char* arg, const char* Dir)
|
|
{
|
|
char* temp = CreateFile(arg, Dir);
|
|
int len = strlen(temp);
|
|
temp[len-1] = 't';
|
|
temp[len-2] = 'x';
|
|
temp[len-3] = 't';
|
|
return temp;
|
|
|
|
/*char drive[_MAX_DRIVE];
|
|
char dir[_MAX_DIR];
|
|
char fname[_MAX_FNAME];
|
|
char ext[_MAX_EXT];
|
|
_splitpath(gXmlFile, drive, dir, fname, ext);
|
|
strcpy(gTxtFile, "\0");
|
|
if (drive != NULL) {
|
|
strcat(gTxtFile, drive);
|
|
}
|
|
if (dir != NULL) {
|
|
strcat(gTxtFile, dir);
|
|
}
|
|
if (fname !=NULL) {
|
|
strcat(gTxtFile, fname);
|
|
}
|
|
strcat(gTxtFile, "tempfile.txt");*/
|
|
}
|
|
|
|
char* CreateFile(const char* arg, const char* Dir)
|
|
{ char* temp = new char[256];
|
|
char a[2]={'\\', '\0'};
|
|
char* currdir;
|
|
if(sourceDir!=NULL) {
|
|
strcpy(temp, Dir);
|
|
int len = strlen(temp);
|
|
if(temp[len - 1]!='\\')
|
|
strcat(temp, a);
|
|
strcat(temp, arg);
|
|
}
|
|
else {
|
|
char drive[_MAX_DRIVE];
|
|
char dir[_MAX_DIR];
|
|
char fname[_MAX_FNAME];
|
|
char ext[_MAX_EXT];
|
|
_splitpath(arg, drive, dir, fname, ext);
|
|
|
|
if(*drive == NULL && *dir == NULL) {
|
|
#ifdef WIN32
|
|
currdir = _getcwd(NULL, 0);
|
|
#else
|
|
currdir = getcwd(NULL, 0);
|
|
#endif
|
|
strcpy(temp, currdir);
|
|
strcat(temp, a);
|
|
}
|
|
strcat(temp, arg);
|
|
}
|
|
return temp;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ostream << DOMString
|
|
//
|
|
// Stream out a DOM string. Doing this requires that we first transcode
|
|
// to char * form in the default code page for the system
|
|
// ---------------------------------------------------------------------------
|
|
|
|
ostream& operator<< (ostream& target, const DOMString& s)
|
|
{
|
|
char *p = s.transcode();
|
|
target << p;
|
|
delete [] p;
|
|
return target;
|
|
}
|
|
|
|
|
|
XMLFormatter& operator<< (XMLFormatter& strm, const DOMString& s)
|
|
{
|
|
unsigned int lent = s.length();
|
|
|
|
if (lent <= 0)
|
|
return strm;
|
|
|
|
XMLCh* buf = new XMLCh[lent + 1];
|
|
XMLString::copyNString(buf, s.rawBuffer(), lent);
|
|
buf[lent] = 0;
|
|
strm << buf;
|
|
delete [] buf;
|
|
return strm;
|
|
}
|
|
|
|
|