Exemplo n.º 1
0
// ---------------------------------------------------------------------------
//  MemParseHandlers: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------
void MemParseHandlers::error(const SAXParseException& e)
{
    XERCES_STD_QUALIFIER cerr << "\nError at (file " << StrX(e.getSystemId())
		 << ", line " << e.getLineNumber()
		 << ", char " << e.getColumnNumber()
         << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}
Exemplo n.º 2
0
void DOMTreeErrorReporter::error(const SAXParseException& toCatch)
{
    fSawErrors = true;
    XERCES_STD_QUALIFIER cerr << "Error at file \"" << StrX(toCatch.getSystemId())
                              << "\", line " << toCatch.getLineNumber()
                              << ", column " << toCatch.getColumnNumber()
                              << "\n   Message: " << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
}
Exemplo n.º 3
0
// overrides SAX fatalError Handler
void CommonReadHandler::fatalError(const SAXParseException& e)
{   cerr << "\nFatal Error parsing the XML input file:" << endl;
    cerr << "\nFatal Error in file " << StrX(e.getSystemId())
         << ", at line " << e.getLineNumber()
         << ", char " << e.getColumnNumber()
         << ": " << StrX(e.getMessage()) << endl;
    throw "\nFix the input file and retry.";
}
Exemplo n.º 4
0
// ---------------------------------------------------------------------------
//  SAX2CountHandlers: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------
void SAX2CountHandlers::error(const SAXParseException& e)
{
    fSawErrors = true;
    XERCES_STD_QUALIFIER cerr << "\nError at file " << StrX(e.getSystemId())
		 << ", line " << e.getLineNumber()
		 << ", char " << e.getColumnNumber()
         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}
Exemplo n.º 5
0
void BaseHarnessHandlers::fatalError(const SAXParseException& e)
{
    fSawErrors = true;
    XERCES_STD_QUALIFIER cout << "\nFatal Error at file " << StrX(e.getSystemId())
		 << ", line " << e.getLineNumber()
		 << ", char " << e.getColumnNumber()
         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}
Exemplo n.º 6
0
void InitTermTestErrorHandler::fatalError(const SAXParseException& e)
{
    fSawErrors = true;
    XERCES_STD_QUALIFIER cerr << "\nFatal Error at file " << StrX(e.getSystemId())
         << ", line " << e.getLineNumber()
         << ", char " << e.getColumnNumber()
         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}
Exemplo n.º 7
0
void DOMTreeErrorReporter::fatalError(const SAXParseException& toCatch)
{
    fSawErrors = true;
    cerr << "Fatal Error at file \"" << StrX(toCatch.getSystemId())
		 << "\", line " << toCatch.getLineNumber()
		 << ", column " << toCatch.getColumnNumber()
         << "\n   Message: " << StrX(toCatch.getMessage()) << endl;
}
Exemplo n.º 8
0
void printBasic(XSObject *xsObject, const char *type)
{
    XERCES_STD_QUALIFIER cout << "Name:\t\t\t";
    const XMLCh *nameSpace = xsObject->getNamespace();
    if (nameSpace && *nameSpace) {
        XERCES_STD_QUALIFIER cout << StrX(nameSpace) << ", ";
    }
    XERCES_STD_QUALIFIER cout << StrX(xsObject->getName()) << "\n";
    XERCES_STD_QUALIFIER cout << "Component Type:\t" << type << XERCES_STD_QUALIFIER endl;
}
Exemplo n.º 9
0
void LoadSchemaErrorHandler::warning(const XERCES_CPP_NAMESPACE::SAXParseException& e)
{
  XERCES_STD_QUALIFIER cerr << "\nWarning at file " << StrX(e.getSystemId())
                            << ", line " << e.getLineNumber()
                            << ", char " << e.getColumnNumber()
                            << "\n  Message: " << StrX(e.getMessage())
                            << XERCES_STD_QUALIFIER endl;
  //XQueryDiagnostics xqueryDiagnostics;
  //ZORBA_WARNING(&xqueryDiagnostics, XQST0059, StrX(e.getMessage()), _loc);
}
Exemplo n.º 10
0
bool            Module::AddDOMattribute    (const string attribute, const string value){

	if (HasDOMattribute(attribute))
	    return false;

	((DOMElement*) m_node)->setAttribute( StrX(attribute).XMLchar(), StrX(value).XMLchar() );

	return true;

}
Exemplo n.º 11
0
int deCommand(void * *mObject,const  void * paramNode){

	DOMNode * node=(DOMNode *)paramNode;
	node=node->getFirstChild();
	if(!node)
	//err log here
		return AXIS_FAIL;
	if(node->getNodeType()!=DOMNode::NodeType::ELEMENT_NODE)
	node=SoapParser::getNextSiblingNotNull(node,DOMNode::NodeType::ELEMENT_NODE);
	if(!node)
		//err log here
		return AXIS_FAIL;

	if(0!=strcmp("Statement",StrX(node->getLocalName()).localForm()))
		//err log here
		return AXIS_FAIL;

	
	//if there is next element node,err!
	DOMNode * nextnode=node->getNextSibling();
	if(nextnode){
		if(nextnode->getNodeType()==DOMNode::NodeType::ELEMENT_NODE)
			//err log here
			return AXIS_FAIL;
		else
			nextnode=SoapParser::getNextSiblingNotNull(node,DOMNode::NodeType::ELEMENT_NODE);
			if(nextnode)
				//err log here
				return AXIS_FAIL;		
	}

	node=node->getFirstChild();
	if(!node)
		//err log here
		return AXIS_FAIL;
	if(node->getNodeType()!=DOMNode::NodeType::TEXT_NODE)
	node=SoapParser::getNextSiblingNotNull(node,DOMNode::NodeType::TEXT_NODE);
	if(!node)
		//err log here
		return AXIS_FAIL;

	string value=StrX(node->getNodeValue()).localForm();
	Command *cmd=new Command(value); 

	if(!*mObject)
		*mObject=cmd;
	else{
		delete cmd;
		//err log here
		return AXIS_FAIL;
	}

	return AXIS_SUCCESS;
}
Exemplo n.º 12
0
// ---------------------------------------------------------------------------
//  Program entry point
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
    // cannot return out of catch-blocks lest exception-destruction
    // result in calls to destroyed memory handler!
    int errorCode = 0;
    // Initialize the XML4C system
    try
    {
         XMLPlatformUtils::Initialize();
    }

    catch (const XMLException& toCatch)
    {
         XERCES_STD_QUALIFIER cerr   << "Error during initialization! Message:\n"
                << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
         errorCode = 1;
    }
    if(errorCode) {
        XMLPlatformUtils::Terminate();
        return errorCode;
    } 

    // Check command line and extract arguments.
    // We only have one required parameter, which is the file to process
    if ((argC != 2) ||
        (*(argV[1]) == '-'))
    {
        usage();
        XMLPlatformUtils::Terminate();
        return 2;
    }

    try
    {
		process(argV[1]);
    }
    catch (const OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorCode = 5;
    }
    catch (const XMLException& e)
    {
        XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << argV[1] << "'\n"
             << "Exception message is:  \n"
             << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
        errorCode = 3;
    }

    XMLPlatformUtils::Terminate();

	return errorCode;
}
Exemplo n.º 13
0
//---------------------------------------------------------------------
//  Prints the Attribute's properties
//---------------------------------------------------------------------
void processAttributes( XMLAttDefList& attList, bool margin )
{
    if ( attList.isEmpty() )
    {
        return;
    }

    if ( margin )
    {
        XERCES_STD_QUALIFIER cout << "\t";
    }

    XERCES_STD_QUALIFIER cout << "Attributes:\n";
    for (unsigned int i=0; i<attList.getAttDefCount(); i++)
    {
        // Name
        SchemaAttDef& curAttDef = (SchemaAttDef&)attList.getAttDef(i);
        XERCES_STD_QUALIFIER cout << "\tName:\t\t\t" << StrX(curAttDef.getFullName()) << "\n";

        // Type
        XERCES_STD_QUALIFIER cout << "\tType:\t\t\t";
		XERCES_STD_QUALIFIER cout << StrX(XMLAttDef::getAttTypeString(curAttDef.getType()));
        XERCES_STD_QUALIFIER cout << "\n";

        // Default Type
        XERCES_STD_QUALIFIER cout << "\tDefault Type:\t";
		XERCES_STD_QUALIFIER cout << StrX(XMLAttDef::getDefAttTypeString(curAttDef.getDefaultType()));
        XERCES_STD_QUALIFIER cout << "\n";

        // Value
        if( curAttDef.getValue() )
        {
            XERCES_STD_QUALIFIER cout << "\tValue:\t\t\t";
            XERCES_STD_QUALIFIER cout << StrX(curAttDef.getValue());
            XERCES_STD_QUALIFIER cout << "\n";
        }

        // Enum. values
        if( curAttDef.getEnumeration() )
        {
            XERCES_STD_QUALIFIER cout << "\tEnumeration:\t";
            XERCES_STD_QUALIFIER cout << StrX(curAttDef.getEnumeration());
            XERCES_STD_QUALIFIER cout << "\n";
        }

         const DatatypeValidator* dv = curAttDef.getDatatypeValidator();
         processDatatypeValidator( dv, true );

        XERCES_STD_QUALIFIER cout << "\n";
    }
}
Exemplo n.º 14
0
    bool serializeDOM(std::ostream& output, bool)
    {
	XMLCh tempStr[100];
	XMLString::transcode("LS", tempStr, 99);
	DOMImplementationLS *impl = dynamic_cast<DOMImplementationLS *>(DOMImplementationRegistry::getDOMImplementation(tempStr));
	DOMLSSerializer   *theSerializer = impl->createLSSerializer();
	DOMLSOutput       *theOutputDesc = impl->createLSOutput();

	bool rc = false;

	try
	{
	    MemBufFormatTarget *myFormTarget = new MemBufFormatTarget();

	    /* do the serialization through DOMLSSerializer::write(); */

	    theOutputDesc->setByteStream(myFormTarget);
	    theSerializer->write(inputFileDOM, theOutputDesc);

	    const XMLByte * data = myFormTarget->getRawBuffer();
	    XMLSize_t len = myFormTarget->getLen();

	    output.write( reinterpret_cast<const char *>(data), len );

	    delete myFormTarget;
	    rc = true;
	}
	catch (IOException& e ) {
	    cerr << StrX(e.getMessage());
	    cerr << "  Code is " << e.getCode();

	    if ( errno != 0 ) {
		cerr << ": " << strerror( errno );
	    }
	}
	catch (XMLException& e)
	{
	    cerr << "An error occurred during creation of output transcoder. Msg is:"
		 << endl
		 << StrX(e.getMessage());
	    if ( errno != 0 ) {
		cerr << ": " << strerror( errno );
	    }
	    cerr << endl;
	    rc = false;
	}
	delete theSerializer;
	return rc;
    }
Exemplo n.º 15
0
void Coil::Initialize (DOMNode* node) {
	
	//m_sens_mag = NULL;
	//m_sens_pha = NULL;
	m_node     = node;
	
	string s = StrX(((DOMElement*) node)->getAttribute (StrX("Name").XMLchar() )).std_str() ;
	
	if (s.empty()) {
		((DOMElement*) node)->setAttribute(StrX("Name").XMLchar(),node->getNodeName());
		SetName( StrX(node->getNodeName()).std_str() );
	}
	
	
}
Exemplo n.º 16
0
/**
 * Constructor.
 * 
 * @param xmlFile the character string containing XML representation of the parameter set data.
 */
ParameterSet::ParameterSet(const char* xmlFile)
{
	// Initialize the XML4C2 system
	try
	{
		XMLPlatformUtils::Initialize();
		std::cout << "initialized XML platform\n";

		PARAMETER_TAG_NAME = XMLString::transcode("parameter");
		NAME_TAG_NAME = XMLString::transcode("name");
		VALUE_TAG_NAME = XMLString::transcode("value");
		UNITS_TAG_NAME = XMLString::transcode("units");

		INT_PARAM_TYPE = XMLString::transcode("IntParamType");
		DOUBLE_PARAM_TYPE = XMLString::transcode("DoubleParamType");
		STRING_PARAM_TYPE = XMLString::transcode("StringParamType");
		BOOL_PARAM_TYPE = XMLString::transcode("BoolParamType");
		INT_ARRAY_PARAM_TYPE = XMLString::transcode("IntArrayParamType");
		DOUBLE_ARRAY_PARAM_TYPE = XMLString::transcode("DoubleArrayParamType");
		STRING_ARRAY_PARAM_TYPE = XMLString::transcode("StringArrayParamType");

		parseInputString(xmlFile);
	}
	catch (const XMLException& toCatch)
	{
		std::cerr << "Error during initialization! Message:\n"
		<< StrX(toCatch.getMessage()) << std::endl;
	}
	catch (const std::invalid_argument argError)
	{
		std::cerr <<          "****** Error validating against the parameter set definition! ******* \n\nMessage: \n\n"
		<< argError.what() << "*********************************************************************" 
		<< std::endl << std::endl;
	}
}
void TestParser::TextDecl(  const   XMLCh* const    versionStr
                            , const XMLCh* const    encodingStr)
{
    if (fOutputType == OutputType_Debug)
    {
        XERCES_STD_QUALIFIER cout << "Got TEXTDECL:\n    ";

        if (XMLString::stringLen(versionStr))
            XERCES_STD_QUALIFIER cout << "Version: " << StrX(versionStr);

        if (XMLString::stringLen(encodingStr))
            XERCES_STD_QUALIFIER cout << "Encoding: " << StrX(encodingStr);

        XERCES_STD_QUALIFIER cout << "\n" << XERCES_STD_QUALIFIER endl;
    }
}
Exemplo n.º 18
0
XMLIO::XMLIO () {

	try {
        XMLPlatformUtils::Initialize();
    } catch (const  XMLException& e) {
        XERCES_STD_QUALIFIER cerr << "Error during Xerces-c Initialization.\n"
             << "  Exception message:"
             << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
    }

	m_parser       = new XercesDOMParser;
    m_err_reporter = new DOMTreeErrorReporter;

	XercesDOMParser::ValSchemes valScheme    = XercesDOMParser::Val_Auto;
	doNamespaces                             = false;
	doSchema                                 = false;
	schemaFullChecking                       = false;
	doCreate                                 = false;

	m_parser->setValidationScheme             (valScheme);
	m_parser->setDoNamespaces                 (doNamespaces);
	m_parser->setDoSchema                     (doSchema);
	m_parser->setValidationSchemaFullChecking (schemaFullChecking);
	m_parser->setCreateEntityReferenceNodes   (doCreate);
	m_parser->setErrorHandler                 (m_err_reporter);

}
Exemplo n.º 19
0
void processElements(XSNamedMap<XSObject> *xsElements)
{
    if (!xsElements || xsElements->getLength() == 0) {
        XERCES_STD_QUALIFIER cout << "no elements\n\n"  << XERCES_STD_QUALIFIER endl;
        return;
    }    
    for (XMLSize_t i=0; i < xsElements->getLength(); i++) {
        XSElementDeclaration *xsElement = (XSElementDeclaration *)xsElements->item(i);
        printBasic(xsElement, "Element");
        
        // Content Model
        XSTypeDefinition *xsTypeDef = xsElement->getTypeDefinition();
        XERCES_STD_QUALIFIER cout << "Content Model" << "\n";
        XERCES_STD_QUALIFIER cout << "\tType:\t";
        if (xsTypeDef->getTypeCategory() == XSTypeDefinition::SIMPLE_TYPE) {
            XERCES_STD_QUALIFIER cout << "Simple\n";
        } else {
            XERCES_STD_QUALIFIER cout << "Complex\n";
        }
        XERCES_STD_QUALIFIER cout << "\tName:\t"
            << StrX(xsTypeDef->getName()) << "\n";
        
        XERCES_STD_QUALIFIER cout << "\n--------------------------------------------" << XERCES_STD_QUALIFIER endl;
    }
}
Exemplo n.º 20
0
void            Module::Initialize (DOMNode* node) {

    //if node has no "Name" attribute, insert it and use the node name for its value
	string s     = StrX(((DOMElement*) node)->getAttribute (StrX("Name").XMLchar() )).std_str() ;
   	if (s.empty())
		((DOMElement*) node)->setAttribute(StrX("Name").XMLchar(),node->getNodeName());

    //set the module name to the node name as well
	SetName( StrX(node->getNodeName()).std_str() );

	//set the instances of this node and the sequence tree
	m_node       = node;
	m_seq_tree   = SequenceTree::instance();
	m_parameters = m_seq_tree->GetParameters();

}
Exemplo n.º 21
0
void processParticle(XSParticle *xsParticle)
{
    if (!xsParticle) {
        XERCES_STD_QUALIFIER cout << "xsParticle is NULL"; 
        return;
    }
    XSParticle::TERM_TYPE termType = xsParticle->getTermType();
    if (termType == XSParticle::TERM_ELEMENT) {
        XSElementDeclaration *xsElement = xsParticle->getElementTerm();
        XERCES_STD_QUALIFIER cout << StrX(xsElement->getName());
    } else if (termType == XSParticle::TERM_MODELGROUP) {
        XERCES_STD_QUALIFIER cout << "(";
        
        XSModelGroup *xsModelGroup = xsParticle->getModelGroupTerm();
        XSModelGroup::COMPOSITOR_TYPE compositorType = xsModelGroup->getCompositor();
        XSParticleList *xsParticleList = xsModelGroup->getParticles();
        for (unsigned i = 0; i < xsParticleList->size()-1; i++) {
            processParticle(xsParticleList->elementAt(i));
            printCompositorTypeConnector(compositorType);
        }
        processParticle(xsParticleList->elementAt(xsParticleList->size()-1));
        
        XERCES_STD_QUALIFIER cout << ")";
    } else if (termType == XSParticle::TERM_WILDCARD) {
        XERCES_STD_QUALIFIER cout << "* (wildcard)";
    }
}
void TestParser::startAttList(const DTDElementDecl& elemDecl)
{
    if (fOutputType == OutputType_Debug)
    {
        XERCES_STD_QUALIFIER cout << "Got STARTATTLIST:\n    "
                << "Name: " << StrX(elemDecl.getFullName())
                << "\n" << XERCES_STD_QUALIFIER endl;
    }
     else if (fOutputType != OutputType_None)
    {
        if (fInExtSubset)
            return;

        if (fIntDTDOutput)
            XERCES_STD_QUALIFIER cout << "<!ATTLIST " << StrX(elemDecl.getFullName());
    }
}
void
TestParser::showIds(const XMLCh* const publicId, const XMLCh* const systemId)
{
    if (XMLString::stringLen(publicId) || XMLString::stringLen(systemId))
    {
        if (!XMLString::stringLen(publicId))
        {
            XERCES_STD_QUALIFIER cout << " SYSTEM '" << StrX(systemId) << "'";
        }
         else
        {
            XERCES_STD_QUALIFIER cout << " PUBLIC '" << StrX(publicId) << "'";
            if (systemId)
                XERCES_STD_QUALIFIER cout << " '" << StrX(systemId) << "'";
        }
    }
}
void TestParser::startEntityReference(const XMLEntityDecl& entDecl)
{
    if (fOutputType == OutputType_Debug)
    {
        XERCES_STD_QUALIFIER cout << "Got STARTENTITY:\n    "
             << "Name: " << StrX(entDecl.getName()) << "\n" << XERCES_STD_QUALIFIER endl;
    }
}
Exemplo n.º 25
0
// ---------------------------------------------------------------------------
//  DOMCountHandlers: Overrides of the DOM ErrorHandler interface
// ---------------------------------------------------------------------------
bool DOMCountErrorHandler::handleError(const DOMError& domError)
{
    fSawErrors = true;
    if (domError.getSeverity() == DOMError::DOM_SEVERITY_WARNING)
        XERCES_STD_QUALIFIER cerr << "\nWarning at file ";
    else if (domError.getSeverity() == DOMError::DOM_SEVERITY_ERROR)
        XERCES_STD_QUALIFIER cerr << "\nError at file ";
    else
        XERCES_STD_QUALIFIER cerr << "\nFatal Error at file ";

    XERCES_STD_QUALIFIER cerr << StrX(domError.getLocation()->getURI())
         << ", line " << domError.getLocation()->getLineNumber()
         << ", char " << domError.getLocation()->getColumnNumber()
         << "\n  Message: " << StrX(domError.getMessage()) << XERCES_STD_QUALIFIER endl;

    return true;
}
void TestParser::XMLDecl(const  XMLCh* const    versionStr
                        , const XMLCh* const    encodingStr
                        , const XMLCh* const    standaloneStr
                        , const XMLCh* const    autoEncStr)
{
    if (fOutputType == OutputType_Debug)
    {
        XERCES_STD_QUALIFIER cout << "Got XMLDECL:\n    "
             << "Version:\"" << StrX(versionStr) << "\""
             << " Encoding:\"" << StrX(encodingStr) << "\""
             << " Standalone:\"" << StrX(standaloneStr) << "\""
             << " Auto Encoding:\"" << StrX(autoEncStr) << "\""
             << "\n"
             << "    SrcOfs: " << fScanner->getSrcOffset()
             << "\n" << XERCES_STD_QUALIFIER endl;
    }
     else if (fOutputType == OutputType_XML)
    {
        XERCES_STD_QUALIFIER cout << "<?xml";

        if (XMLString::stringLen(versionStr))
            XERCES_STD_QUALIFIER cout << " version=\"" << StrX(versionStr) << '"';

        if (XMLString::stringLen(encodingStr))
            XERCES_STD_QUALIFIER cout << " encoding=\"" << StrX(encodingStr) << '"';

        if (XMLString::stringLen(standaloneStr))
            XERCES_STD_QUALIFIER cout  << " standlone=\"" << StrX(standaloneStr) << '"';

        XERCES_STD_QUALIFIER cout << " ?>";
    }
}
Exemplo n.º 27
0
void XMLConfigErrorHandler::error(const SAXParseException &toCatch) {

	m_lstrErrors.push_back(
		QString("XML parsing error: %1, line %2, column %3").arg(StrX(toCatch.getMessage()).char_str())
															.arg(toCatch.getLineNumber())
															.arg(toCatch.getColumnNumber()));

    m_bSawErrors = true;
}
void TestParser::doctypeComment(const XMLCh* const comment)
{
    if (fOutputType == OutputType_Debug)
    {
        XERCES_STD_QUALIFIER cout << "Got DTD COMMENT:\n    "
             << "Text: \"" << StrX(comment) << "\"\n"
             << "    SrcOfs: " << fScanner->getSrcOffset()
             << "\n" << XERCES_STD_QUALIFIER endl;
    }
     else if (fOutputType != OutputType_None)
    {
        if (fInExtSubset)
            return;

        if (fIntDTDOutput)
            XERCES_STD_QUALIFIER cout << "<!--" << StrX(comment) << "-->";
    }
}
Exemplo n.º 29
0
Module* ModulePrototypeFactory::CloneModule   (DOMNode* node)        {

	string  name    = StrX(node->getNodeName()).std_str() ;
	transform(name.begin(), name.end(), name.begin(), (int(*)(int)) toupper);
	Module* toClone = GetModule(name);
	if (!toClone)
		return NULL;
	return toClone->Clone();

}
Exemplo n.º 30
0
//////////////////////////////////////////////////////////////////////////////
/// \brief 
/// \param str 
/// \return string 
//////////////////////////////////////////////////////////////////////////////
string XMLUtil::WideCharToString(const XMLCh * wstr, int wstrlen)
{
//	return StrX(wstr ).c_str();

/*	if (wstrlen == -1 )
	{
		wstrlen = (int)wcslen(wstr);
	}*/

	// test korean with WideCharToMultiByte
	//	int WideCharToMultiByte(
	//		UINT CodePage,            // code page
	//		DWORD dwFlags,            // performance and mapping flags
	//		LPCWSTR lpWideCharStr,    // wide-character string
	//		int cchWideChar,          // number of chars in string
	//		LPSTR lpMultiByteStr,     // buffer for new string
	//		int cbMultiByte,          // size of buffer
	//		LPCSTR lpDefaultChar,     // default for unmappable chars
	//		LPBOOL lpUsedDefaultChar  // set when default char used
	//	);
	//
	//lpDefaultChar 
	//	[in] Points to the character used if a wide character cannot be represented in the specified code page. 
	//  If this parameter is NULL, a system default value is used. 
	//  The function is faster when both lpDefaultChar and lpUsedDefaultChar are NULL. 
	//	For the code pages mentioned in dwFlags, lpDefaultChar must be NULL, 
	//  otherwise the function fails with ERROR_INVALID_PARAMETER. 

	//	lpUsedDefaultChar 
	//	[in] Points to a flag that indicates whether a default character was used. 
	//  The flag is set to TRUE if one or more wide characters in the source string 
	//  cannot be represented in the specified code page. Otherwise, the flag is set to FALSE. 
	//  This parameter may be NULL. The function is faster when both lpDefaultChar and lpUsedDefaultChar are NULL. 
	//	For the code pages mentioned in dwFlags, lpUsedDefaultChar must be NULL, 
	//  otherwise the function fails with ERROR_INVALID_PARAMETER. 

	// 최소한의 복사를 줄이기 위해서 스트링을 준비. 	
/*	string strBuffer;
	strBuffer.reserve(wstrlen * 2 + 1);		// capacity 를 충분하게.. 
	int nCopied = WideCharToMultiByte(
		CP_OEMCP,
		WC_COMPOSITECHECK,
		wstr,									// wide string
		wstrlen,								// length of wide string
		const_cast<LPSTR>(strBuffer.data()),	// mbcs string (unicode)
		(int)strBuffer.capacity(),					// length of mbcs string
		NULL,									// NULL 이 빠르다는데?
		NULL);
	strBuffer[nCopied] = 0;
	strBuffer._Mysize = nCopied;				// 수동으로 지정해야 한다.

	return strBuffer;*/
	return StrX(wstr).toString();
}