void EntityFactory::LoadItems(const char* filename) { TiXmlDocument doc; if (!doc.LoadFile(filename)) { DIE("can't open items definition %s\n%s", filename, doc.ErrorDesc()); } TiXmlHandle handle(&doc); TiXmlElement* elem = handle.FirstChildElement().FirstChildElement().Element(); const char* name; while (elem != NULL) { QueryPtr(elem, "name", name); Item::Type item_type = Item::StringToType(name); ItemPattern item; QueryStr(elem, "label", item.label); QueryInt(elem, "x", item.x); QueryInt(elem, "y", item.y); QueryInt(elem, "w", item.w); QueryInt(elem, "h", item.h); items_[Item::StringToType(name)] = item; elem = elem->NextSiblingElement(); } }
BOOL ISAPI_STRINGW::CopyToOffset( WCHAR * szStringW, DWORD cchStringW, DWORD cchOffset ) /*++ Purpose: Copies a Unicode string into the ISAPI_STRINGW's data, starting at the specified offset, in characters. Arguments: szStringW - The Unicode string to copy cchStringW - The number of characters to copy cchOffset - The offset, in chracters, at which to copy Returns: TRUE on success, FALSE on failure --*/ { DWORD cbData; // // Ensure that we have enough storage available // cbData = ( cchStringW + 1 ) * sizeof(WCHAR); if ( ResizeBuffer( cbData + cchOffset * sizeof(WCHAR) ) == FALSE ) { return FALSE; } // // Copy the data and ensure proper termination // CopyMemory( QueryStr() + cchOffset, szStringW, cbData ); SetLen( QueryCCH() + cchStringW ); return TRUE; }
BOOL ISAPI_STRING::CopyToOffset( CHAR * szString, DWORD cchString, DWORD dwOffset ) /*++ Purpose: Copies a string into the ISAPI_STRING's data, starting at the specified offset. Arguments: szString - The string to copy cchString - The number of characters to copy dwOffset - The offset at which to copy Returns: TRUE on success, FALSE on failure --*/ { DWORD cbData; // // Ensure that we have enough storage available // cbData = cchString + sizeof(CHAR); if ( ResizeBuffer( cbData + dwOffset ) == FALSE ) { return FALSE; } // // Copy the data and ensure proper termination // CopyMemory( QueryStr() + dwOffset, szString, cbData ); SetLen( QueryCCH() + cbData - sizeof(CHAR) ); return TRUE; }
BOOL ISAPI_STRING::SetLen( DWORD cchNewLength ) /*++ Purpose: Sets the length of the data in the ISAPI_STRING object, truncating the current data if necessary. Arguments: cchNewLength - The new data length. Returns: TRUE on success, FALSE on failure. --*/ { CHAR * pCursor; // // Ensure that we don't set the length to // something longer than the current buffer // if ( cchNewLength > QueryBufferSize() - 1 ) { SetLastError( ERROR_INVALID_PARAMETER ); return FALSE; } pCursor = QueryStr(); pCursor[cchNewLength] = '\0'; _Buffer.SetDataSize( cchNewLength + sizeof(CHAR) ); return TRUE; }
VOID ISAPI_STRINGW::CalcLen( VOID ) /*++ Purpose: Calculates the size in characters of the ISAPI_STRINGW data by doing a wcslen. Arguments: None Returns: None --*/ { _Buffer.SetDataSize( wcslen( QueryStr() ) + 1 ); }
BOOL ISAPI_STRINGW::CopyAToOffset( CHAR * szString, DWORD cchString, DWORD cchOffset ) /*++ Purpose: Copies an ANSI string into the ISAPI_STRINGW's data, starting at the specified offset, in characters. Arguments: szString - The ANSI string to copy cchString - The number of characters to copy cchOffset - The offset, in chracters, at which to copy Returns: TRUE on success, FALSE on failure --*/ { WCHAR * pCursor; DWORD cbString; DWORD cchCopied; DWORD cchData; DWORD cbData; cchData = QueryCCH(); cbData = QueryCB(); // // Ensure that we have enough storage available // cbString = ( cchString + 1 ) * sizeof(WCHAR); if ( ResizeBuffer( cbString + cchOffset * sizeof(WCHAR) ) == FALSE ) { goto Failed; } // // Set the point into which the copy will occur // pCursor = QueryStr() + cchData; // // Convert the ANSI string into Unicode using // the default system code page. // cchCopied = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szString, cchString, pCursor, cbData ); if ( cchCopied == 0 ) { goto Failed; } SetLen( cchData + cchCopied ); return TRUE; Failed: // // No special cleanup to be done // return FALSE; }
BOOL ISAPI_STRINGW::vsprintf_s( WCHAR * szFormatW, va_list args ) /*++ Purpose: Sets the specified printf-style formatted Unicode string into the ISAPI_STRINGW object using a va_list of args. Arguments: szFormat - The Unicode string format ... - Zero or more additional arguments Returns: TRUE on success, FALSE on failure --*/ { INT cchWritten; DWORD cbBuffer; BOOL fResult; // // Build the formatted string // do { cbBuffer = QueryBufferSize(); cchWritten = (DWORD)_vsnwprintf_s( QueryStr(), sizeof(QueryStr()), cbBuffer, szFormatW, args ); if ( cchWritten < 0 ) { // // If we just failed, and the buffer // is already at its maximum size, // then fail. // if ( cbBuffer >= QueryMaxAlloc() ) { goto Failed; } // // Grow the buffer and try again // cbBuffer *= 2; // // Don't exceed the max buffer size // if ( cbBuffer > QueryMaxAlloc() ) { cbBuffer = QueryMaxAlloc(); } fResult = ResizeBuffer( cbBuffer ); if ( !fResult ) { goto Failed; } } } while ( cchWritten < 0 ); SetLen( cchWritten ); return TRUE; Failed: // // No special cleanup needed // return FALSE; }
CHAR * ISAPI_STRING::FindStr( CHAR * szSubString, BOOL fCaseInsensitive, DWORD dwStartingOffset ) /*++ Purpose: Finds the specified sub-string in the ISAPI_STRING's data. Arguments: szSubString - The sub-string to find fCaseInsensitive - If TRUE, does a case insensitive search dwStartingOffset - The starting offset in the ISAPI_STRING to start search Returns: Pointer to the instance of the sub-string if found, NULL if not found --*/ { CHAR * pCursor; CHAR * pEnd; CHAR * szFound; CHAR * szString; CHAR c1; CHAR c2; DWORD cchString; DWORD cchSubString; DWORD cchData; DWORD n; // // If we are trying to search beyond the length // of the string, then we aren't going to find it // cchData = QueryCCH(); if ( dwStartingOffset > cchData ) { goto NotFound; } szString = QueryStr() + dwStartingOffset; cchString = cchData - dwStartingOffset; // // If szString is smaller than szSubString, then // we aren't going to find it. // cchSubString = strlen( szSubString ); if ( cchSubString > cchString ) { goto NotFound; } // // Set boundaries for the search // pEnd = szString + cchString - cchSubString; // // Search now // szFound = NULL; for ( pCursor = szString; pCursor <= pEnd; pCursor++ ) { c1 = fCaseInsensitive ? UPCASE_ANSI_CHAR( *pCursor ) : *pCursor; c2 = fCaseInsensitive ? UPCASE_ANSI_CHAR( *szSubString ) : *szSubString; if ( c1 == c2 ) { szFound = pCursor; for ( n = 1; n < cchSubString; n++ ) { c1 = fCaseInsensitive ? UPCASE_ANSI_CHAR( *(pCursor+n) ) : *(pCursor+n); c2 = fCaseInsensitive ? UPCASE_ANSI_CHAR( *(szSubString+n) ) : *(szSubString+n); if ( c1 != c2 ) { szFound = NULL; break; } } if ( szFound ) { return szFound; } } } NotFound: SetLastError( ERROR_INVALID_INDEX ); return NULL; }
BOOL ISAPI_STRING::CopyWToOffset( WCHAR * szStringW, DWORD cchStringW, DWORD dwOffset ) /*++ Purpose: Copies a Unicode string into the ISAPI_STRING's data, starting at the specified offset. Arguments: szStringW - The Unicode string to copy cchStringW - The number of characters to copy dwOffset - The offset at which to copy Returns: TRUE on success, FALSE on failure --*/ { CHAR * pCursor; DWORD cbData; DWORD cbCopied; DWORD cchData; cchData = QueryCCH(); // // Ensure that we have enough storage available // cbData = cchStringW + sizeof(CHAR); if ( QueryBufferSize() < cbData + dwOffset && ResizeBuffer( cbData + dwOffset ) == FALSE ) { goto Failed; } // // Set the point into which the copy will occur // pCursor = QueryStr() + cchData; // // Convert the wide string into ANSI using // the default system code page. // cbCopied = WideCharToMultiByte( CP_ACP, 0, szStringW, cchStringW, pCursor, cbData, NULL, NULL ); if ( cbCopied == 0 ) { goto Failed; } SetLen( cchData + cbCopied ); return TRUE; Failed: // // No special cleanup to be done // return FALSE; }