| #if !defined(WEAVEPATH_CPP) |
| #define WEAVEPATH_CPP |
| |
| /*** |
| * |
| * Previously, each <OS>PlatformUtils.cpp has its onw copy of the |
| * method weavePaths(), and almost of them implemented the same logic, |
| * with few platform specific difference, and unfortunately that |
| * implementation was wrong. |
| * |
| * The only platform specific issue is slash character. |
| * On all platforms other than Windows, chForwardSlash and chBackSlash |
| * are considered slash, while on Windows, two additional characters, |
| * chYenSign and chWonSign are slash as well. |
| * |
| * The idea is to maintain a SINGLE copy of this method rather than |
| * each <OS>PlatformUtils.cpp has its own copy, we introduce a new |
| * method, XMLPlatformUtils::isAnySlash(), to replace the direct checking |
| * code ( if ( c == chForwardSlash || c == chBackSlash). |
| * |
| * With this approach, we might have a performance hit since isAnySlash() |
| * is so frequently used in this implementation, so we intend to make it |
| * inline. Then we face a complier issue. |
| * |
| * There are two compilation units involved, one is PlatformUtils.cpp and |
| * the other <OS>PlatformUtils.cpp. When PlatformUtils.cp get compiled, |
| * the weavePath(), remove**Slash() have dependency upon isAnySlash() which |
| * is in <OS>PlatformUtils.cpp (and what is worse, it is inlined), so we have |
| * undefined/unresolved symbol: isAnySlash() on AIX/xlc_r, Solaris/cc and |
| * Linux/gcc, while MSVC and HP/aCC are fine with this. |
| * |
| * That means we can not place these new methods in PlatformUtils.cpp with |
| * inlined XMLPlatformUtils::isAnySlash() in <OS>PlatformUtils.cpp. |
| * |
| * The solution to this is <os>PlatformUtils.cpp will include this file so that |
| * we have only one copy of these methods while get compiled in <os>PlatformUtils |
| * inlined isAnySlash(). |
| * |
| ***/ |
| XMLCh* XMLPlatformUtils::weavePaths(const XMLCh* const basePath |
| , const XMLCh* const relativePath |
| , MemoryManager* const manager) |
| |
| { |
| // Create a buffer as large as both parts and empty it |
| XMLCh* tmpBuf = (XMLCh*) manager->allocate |
| ( |
| (XMLString::stringLen(basePath) |
| + XMLString::stringLen(relativePath) + 2) * sizeof(XMLCh) |
| );//new XMLCh[XMLString::stringLen(basePath) + XMLString::stringLen(relativePath) + 2]; |
| *tmpBuf = 0; |
| |
| // |
| // If we have no base path, then just take the relative path as is. |
| // |
| if ((!basePath) || (!*basePath)) |
| { |
| XMLString::copyString(tmpBuf, relativePath); |
| return tmpBuf; |
| } |
| |
| // |
| // Remove anything after the last slash |
| // |
| const XMLCh* basePtr = basePath + (XMLString::stringLen(basePath) - 1); |
| while ((basePtr >= basePath) && ((isAnySlash(*basePtr) == false))) |
| { |
| basePtr--; |
| } |
| |
| // There is no relevant base path, so just take the relative part |
| if (basePtr < basePath) |
| { |
| XMLString::copyString(tmpBuf, relativePath); |
| return tmpBuf; |
| } |
| |
| // |
| // 1. concatenate the base and relative |
| // 2. remove all occurences of "/./" |
| // 3. remove all occurences of segment/../ where segment is not ../ |
| // |
| |
| XMLString::subString(tmpBuf, basePath, 0, (basePtr - basePath + 1), manager); |
| tmpBuf[basePtr - basePath + 1] = 0; |
| XMLString::catString(tmpBuf, relativePath); |
| |
| removeDotSlash(tmpBuf, manager); |
| |
| removeDotDotSlash(tmpBuf, manager); |
| |
| return tmpBuf; |
| |
| } |
| |
| // |
| // Remove all occurences of './' when it is part of '/./' |
| // |
| // Since it could be '.\' or other combination on windows ( eg, '.'+chYanSign) |
| // we can't make use of patterMatch(). |
| // |
| // |
| void XMLPlatformUtils::removeDotSlash(XMLCh* const path |
| , MemoryManager* const manager) |
| { |
| if ((!path) || (!*path)) |
| return; |
| |
| XMLCh* srcPtr = XMLString::replicate(path, manager); |
| int srcLen = XMLString::stringLen(srcPtr); |
| ArrayJanitor<XMLCh> janName(srcPtr, manager); |
| XMLCh* tarPtr = path; |
| |
| while (*srcPtr) |
| { |
| if ( 3 <= srcLen ) |
| { |
| if ( (isAnySlash(*srcPtr)) && |
| (chPeriod == *(srcPtr+1)) && |
| (isAnySlash(*(srcPtr+2))) ) |
| { |
| // "\.\x" seen |
| // skip the first two, and start from the 3rd, |
| // since "\x" could be another "\." |
| srcPtr+=2; |
| srcLen-=2; |
| } |
| else |
| { |
| *tarPtr++ = *srcPtr++; // eat the current char |
| srcLen--; |
| } |
| } |
| else if ( 1 == srcLen ) |
| { |
| *tarPtr++ = *srcPtr++; |
| } |
| else if ( 2 == srcLen) |
| { |
| *tarPtr++ = *srcPtr++; |
| *tarPtr++ = *srcPtr++; |
| } |
| |
| } |
| |
| *tarPtr = 0; |
| |
| return; |
| } |
| |
| // |
| // Remove all occurences of '/segment/../' when segment is not '..' |
| // |
| // Cases with extra /../ is left to the underlying file system. |
| // |
| void XMLPlatformUtils::removeDotDotSlash(XMLCh* const path |
| , MemoryManager* const manager) |
| { |
| int pathLen = XMLString::stringLen(path); |
| XMLCh* tmp1 = (XMLCh*) manager->allocate |
| ( |
| (pathLen+1) * sizeof(XMLCh) |
| );//new XMLCh [pathLen+1]; |
| ArrayJanitor<XMLCh> tmp1Name(tmp1, manager); |
| |
| XMLCh* tmp2 = (XMLCh*) manager->allocate |
| ( |
| (pathLen+1) * sizeof(XMLCh) |
| );//new XMLCh [pathLen+1]; |
| ArrayJanitor<XMLCh> tmp2Name(tmp2, manager); |
| |
| // remove all "<segment>/../" where "<segment>" is a complete |
| // path segment not equal to ".." |
| int index = -1; |
| int segIndex = -1; |
| int offset = 1; |
| |
| while ((index = searchSlashDotDotSlash(&(path[offset]))) != -1) |
| { |
| // Undo offset |
| index += offset; |
| |
| // Find start of <segment> within substring ending at found point. |
| XMLString::subString(tmp1, path, 0, index-1, manager); |
| segIndex = index - 1; |
| while ((segIndex >= 0) && (!isAnySlash(tmp1[segIndex]))) |
| { |
| segIndex--; |
| } |
| |
| // Ensure <segment> exists and != ".." |
| if (segIndex >= 0 && |
| (path[segIndex+1] != chPeriod || |
| path[segIndex+2] != chPeriod || |
| segIndex + 3 != index)) |
| { |
| |
| XMLString::subString(tmp1, path, 0, segIndex, manager); |
| XMLString::subString(tmp2, path, index+3, XMLString::stringLen(path), manager); |
| |
| path[0] = 0; |
| XMLString::catString(path, tmp1); |
| XMLString::catString(path, tmp2); |
| |
| offset = (segIndex == 0 ? 1 : segIndex); |
| } |
| else |
| { |
| offset += 4; |
| } |
| |
| }// while |
| |
| } |
| |
| int XMLPlatformUtils::searchSlashDotDotSlash(XMLCh* const srcPath) |
| { |
| if ((!srcPath) || (!*srcPath)) |
| return -1; |
| |
| XMLCh* srcPtr = srcPath; |
| int srcLen = XMLString::stringLen(srcPath); |
| int retVal = -1; |
| |
| while (*srcPtr) |
| { |
| if ( 4 <= srcLen ) |
| { |
| if ( (isAnySlash(*srcPtr)) && |
| (chPeriod == *(srcPtr+1)) && |
| (chPeriod == *(srcPtr+2)) && |
| (isAnySlash(*(srcPtr+3))) ) |
| { |
| retVal = (srcPtr - srcPath); |
| break; |
| } |
| else |
| { |
| srcPtr++; |
| srcLen--; |
| } |
| } |
| else |
| { |
| break; |
| } |
| |
| } // while |
| |
| return retVal; |
| |
| } |
| |
| #endif |