/* extract CSV items using undocumented 'AfxExtractSubString()' to speed up (maybe) */
bool CCsvFile::GetItem(CStringW &item, const CStringW &line, WORD &index)
{
CStringW last_item;
bool ret = false;
last_item.Empty();
if(!AfxExtractSubString(item,line,index,','))
return false;
if(item.Left(1) == _T("\""))
{
do
{
if(item.Right(1) == _T("\""))
{
if(!last_item.IsEmpty())
item = last_item + item;
item.Trim(_T("\""));
ret = true;
break;
}
last_item += item + _T(",");
}
while(AfxExtractSubString(item,line,++index,','));
}
else
ret = true;
return ret;
}
BOOL CFileBasedProjectTemplateItem::CreateMainFile(LPCTSTR lpszTargetPath, LPCTSTR lpszCrLf)
{
CStringW text;
TextDocument doc;
bool result = doc.Read(m_strPath,text);
if (result)
{
const CStringW lineendings(L"\r\n");
int index = text.FindOneOf(lineendings);
if (index != -1)
{
CStringW line = text.Left(index);
const CStringW strKey(L"%DESCRIPTION: ");
CStringW strStartOfLine = line.Left(strKey.GetLength());
strStartOfLine.MakeUpper();
if (strKey == strStartOfLine)
{
text.Delete(0,index);
text.TrimLeft(lineendings + L' ');
}
}
LPCWSTR le = GetLineEnding(static_cast<LPCWSTR>(text),text.GetLength());
USES_CONVERSION;
if (std::wcscmp(le,T2CW(lpszCrLf)) != 0) // Line endings not equal
text.Replace(le,lpszCrLf);
result = doc.Write(lpszTargetPath,text);
}
return result;
}
BOOL CDdnPayCardApp::InitInstance()
{
CWinApp::InitInstance();
WCHAR chPath[512] = {0};
GetModuleFileNameW(this->m_hInstance,chPath,512);
CStringW strFilew = chPath;
strFilew = strFilew.Left(strFilew.ReverseFind(_T('\\')));
strFilew += _T("\\CardLog\\");
_wmkdir(strFilew);
GXX_LOG_CREATE(strFilew);
GXX_LOG_HIT(_T("init instance"));
G2XStartup();
return TRUE;
}
int sproxy()
{
unsigned __int64 nFlags;
BOOL bHasInvalid;
CStringW wszUrl;
CStringW wszOut;
CStringA szNamespace;
wchar_t **argvW = NULL ;
int argc = 0 ;
argvW = CommandLineToArgvW(GetCommandLineW(),&argc);
if(argvW == NULL)
{
EmitError(IDS_SDL_CMDLINE_FAILURE, GetLastError());
return 1;
}
PreProcessCommandLine(argc, argvW, wszOut, szNamespace, &nFlags, &bHasInvalid);
g_bUseWchar_t = ((nFlags & SPROXYFLAG_NOWCHAR_T) == 0);
if ((nFlags & SPROXYFLAG_NOLOGO) == 0)
{
PrintHeader();
}
if (nFlags & SPROXYFLAG_USAGE)
{
PrintUsage(true);
GlobalFree(argvW);
return 0;
}
ParseCommandLine(argc, argvW, wszUrl, bHasInvalid);
GlobalFree(argvW);
bHasInvalid = FALSE;
if (wszUrl.IsEmpty())
{
EmitCmdLineError(IDS_SDL_MISSING_OPTION, nFlags & SPROXYFLAG_WSDLINPUT ?"<wsdl_location>":"<discomap_location>");
bHasInvalid = TRUE;
}
if (bHasInvalid != FALSE)
{
printf("\r\n");
PrintUsage();
return 1;
}
if (nFlags & SPROXYFLAG_NOWARN)
{
SetEmitWarnings(false);
}
CHeapPtr<char> spSzNamespace;
if (szNamespace && *szNamespace)
{
if (FAILED(CreateSafeCppName(&spSzNamespace, szNamespace)))
{
EmitErrorHr(E_OUTOFMEMORY);
return 1;
}
}
CoInitialize(NULL);
HRESULT hr = S_OK;
{
CAutoPtr<CDiscoMapParser> dmParser;
if(!(nFlags & SPROXYFLAG_WSDLINPUT))
{
CComPtr<ISAXXMLReader> spDMReader;
hr = CoCreateInstance(__uuidof(SAXXMLReader30), NULL, CLSCTX_ALL,
__uuidof(ISAXXMLReader), (void **)&spDMReader);
if (FAILED(hr))
{
ATLTRACE( _T("CoCreateInstance failed!\n") );
return 1;
}
dmParser.Attach(new CDiscoMapParser(spDMReader, NULL, 0));
if(dmParser == NULL)
{
ATLTRACE(_T("Failed to create Discomap Parser : out of memory!\n"));
return 1;
}
dmParser->SetDynamicAlloc(FALSE);
hr = spDMReader->putContentHandler( dmParser );
if (FAILED(hr))
{
ATLTRACE( _T("putContentHandler failed!\n") );
return 1;
}
CErrorHandler errDM;
errDM.SetLocation(wszUrl);
hr = spDMReader->putErrorHandler( &errDM);
if (FAILED(hr))
{
ATLTRACE( _T("putErrorHandler failed!\n") );
return 1;
}
g_pDMDoc = dmParser->GetDiscoMapDocument();
if (g_pDMDoc == NULL)
{
ATLTRACE( _T("failed to create document: out of memory!\n") );
return 1;
}
hr = g_pDMDoc->SetDocumentUri( wszUrl, wszUrl.GetLength());
if (FAILED(hr))
{
ATLTRACE( _T("failed to set document uri: out of memory!\n") );
return 1;
}
g_wszFile = wszUrl;
hr = spDMReader->parseURL( wszUrl );
if (FAILED(hr))
{
ATLTRACE( _T("parseURL failed!\n") );
if ((hr == E_SAX_LOADFAILED) ||
(hr == E_SAX_FILENOTFOUND) ||
(hr == E_SAX_PATHNOTFOUND) ||
(hr == E_SAX_ACCESSDENIED))
{
EmitError(IDS_SDL_FAILED_DM_OPEN, wszUrl);
}
EmitError(IDS_SDL_PROCESS_DM_FAILURE, wszUrl);
return 1;
}
}
if(nFlags & SPROXYFLAG_WSDLINPUT)
g_wszFile = wszUrl;
else
g_wszFile = g_pDMDoc->GetWSDLFile();
CComPtr<ISAXXMLReader> spReader;
hr = CoCreateInstance(__uuidof(SAXXMLReader30), NULL, CLSCTX_ALL,
__uuidof(ISAXXMLReader), (void **)&spReader);
if (FAILED(hr))
{
ATLTRACE( _T("CoCreateInstance failed!\n") );
return 1;
}
CWSDLParser parser(spReader, NULL, 0);
parser.SetDynamicAlloc(FALSE);
hr = spReader->putContentHandler( &parser );
if (FAILED(hr))
{
ATLTRACE( _T("putContentHandler failed!\n") );
return 1;
}
CErrorHandler err;
err.SetLocation(g_wszFile);
hr = spReader->putErrorHandler( &err );
if (FAILED(hr))
{
ATLTRACE( _T("putErrorHandler failed!\n") );
return 1;
}
CWSDLDocument * pDoc = parser.GetWSDLDocument();
if (pDoc == NULL)
{
ATLTRACE( _T("failed to create document: out of memory!\n") );
return 1;
}
hr = pDoc->SetDocumentUri( g_wszFile, g_wszFile.GetLength());
if (FAILED(hr))
{
ATLTRACE( _T("failed to set document uri: out of memory!\n") );
return 1;
}
wchar_t wszTmp[ATL_URL_MAX_URL_LENGTH];
if(g_wszFile.Find(L"://") != -1 && ((g_wszFile.Left(5)).MakeLower() != L"file:") )
{
// The URL needs to be escaped only if it's not a local file
if(AtlEscapeUrl(g_wszFile,wszTmp,0,ATL_URL_MAX_URL_LENGTH-1,ATL_URL_BROWSER_MODE) == FALSE)
{
ATLTRACE( _T("failed to escape uri!\n") );
return 1;
}
hr = spReader->parseURL( wszTmp );
}
else
{
hr = spReader->parseURL( g_wszFile );
}
if (FAILED(hr))
{
ATLTRACE( _T("parseURL failed!\n") );
if ((hr == E_SAX_LOADFAILED) ||
(hr == E_SAX_FILENOTFOUND) ||
(hr == E_SAX_PATHNOTFOUND) ||
(hr == E_SAX_ACCESSDENIED))
{
EmitError(IDS_SDL_FAILED_WSDL_OPEN, g_wszFile);
}
EmitError(IDS_SDL_PROCESS_FAILURE, g_wszFile);
return 1;
}
CCodeTypeBuilder builder;
CCodeProxy proxy;
hr = builder.Initialize(parser.GetWSDLDocument(), &proxy);
if (FAILED(hr))
{
ATLTRACE( _T("builder.Initialize failed!\n") );
return PrintGenerateFailure(wszOut);
}
hr = builder.Build();
if (FAILED(hr))
{
ATLTRACE( _T("builder.Build failed!\n") );
return PrintGenerateFailure(wszOut);
}
if (wszOut.IsEmpty())
{
wszOut.Preallocate(proxy.GetServiceName().GetLength()+4);
wszOut = (LPCSTR)proxy.GetServiceName();
wszOut.Append(L".h", 2);
}
Emit(IDS_SDL_SUCCESS, wszOut);
CComObjectStack<CCppCodeGenerator> gen;
hr = gen.Generate(wszOut, &proxy,
(nFlags & SPROXYFLAG_NOPRAGMA) ? false : true,
(nFlags & SPROXYFLAG_NOCLOBBER) ? true : false,
(nFlags & SPROXYFLAG_NONAMESPACE) ? false : true,
(nFlags & SPROXYFLAG_NOPROXY) ? false : true,
spSzNamespace ? spSzNamespace : (szNamespace.IsEmpty() ? 0 : LPCSTR(szNamespace)));
if (FAILED(hr))
{
ATLTRACE( _T("gen.Generate failed!\n") );
return PrintGenerateFailure(wszOut);
}
}
CoUninitialize();
return 0;
}
void Append( const CStringW& string1, int nLen )
{
this->append(string1.Left(nLen));
}
HRESULT ProfileInfo::Read() {
HRESULT hr = S_OK;
LFile profileFile(m_csFilename);
if (!profileFile.Exists())
hr = E_PM_FILE_NOTEXIST;
if (SUCCEEDED(hr)) {
LURESULT lr = profileFile.Open();
if (lr == LFILE_ERR_OPEN || lr == LFILE_ERR_ALREADY_OPEN)
hr = E_PM_FILE_OPEN;
}
if (SUCCEEDED(hr)) {
LBuffer fileBuffer(256);
DWORD dwBytesRead;
CStringW csLine;
UINT uiLinesRead = 0;
// Read BOM (first 2 bytes)
LURESULT lr = profileFile.ReadRaw(&fileBuffer, 0, 2, &dwBytesRead);
if (lr != S_OK)
hr = E_PM_FILE_READ;
bool bFirstBlock = true;
if (SUCCEEDED(hr)) {
do {
lr = profileFile.ReadRaw(&fileBuffer, 0, fileBuffer.GetSize(), &dwBytesRead);
if (lr != S_OK)
hr = E_PM_FILE_READ;
if (SUCCEEDED(hr) && bFirstBlock) {
WCHAR *pIdent = (WCHAR *)fileBuffer.GetBuffer();
if (wcsncmp(pIdent, L"lpp_", 4) != 0)
hr = E_PM_WRONG_FORMAT;
bFirstBlock = false;
}
if (SUCCEEDED(hr)) {
WCHAR *pBuffer = (WCHAR *)fileBuffer.GetBuffer();
UINT dwCharsRead = dwBytesRead / sizeof(WCHAR);
for (int i = 0; i < dwCharsRead; ++i) {
if (pBuffer[i] == L'\n') {
CString csKey;
CString csValue;
//Ignore lines which begins with % or #
if (csLine[0] != L'%' && csLine[0] != L'#') {
int iBlankPos = csLine.Find(L'=');
if (iBlankPos >= 0) {
#ifdef _UNICODE
csKey = csLine.Left(iBlankPos);
csValue = csLine.Right(csLine.GetLength() - (iBlankPos+1));
#else
CStringW csKeyW = csLine.Left(iBlankPos);
int nLen = csKeyW.GetLength();
char *szRet = new char[nLen + 1];
WideCharToMultiByte(CP_ACP, 0, csKeyW, -1,
szRet, nLen + 1, NULL, NULL);
csKey = szRet;
delete szRet;
CStringW csValueW = csLine.Right(csLine.GetLength() - (iBlankPos+1));
nLen = csValueW.GetLength();
szRet = new char[nLen + 1];
WideCharToMultiByte(CP_ACP, 0, csValueW, -1,
szRet, nLen + 1, NULL, NULL);
csValue = szRet;
delete szRet;
#endif
if (csKey == _T("lpp_id")) {
m_iProfileID = _ttoi64((LPCTSTR)csValue);
} else if (csKey == _T("lpp_version")) {
m_iProfileVersion = _ttoi((LPCTSTR)csValue);
} else if (csKey == _T("lpp_title")) {
m_csTitle = csValue;
} else if (csKey == _T("lpp_type")) {
m_iProfileType = _ttoi((LPCTSTR)csValue);
} else {
m_aKeys.Add(csKey);
m_aValues.Add(csValue);
}
}
}
csLine.Empty();
} else {
csLine += pBuffer[i];
}
}
}
} while (dwBytesRead == fileBuffer.GetSize());
}
profileFile.Close();
}
ExtractTargetFormat();
ExtractStorageDistribution();
return hr;
}
