diff -r 000000000000 -r 044383f39525 imgtools/imglib/filesystem/source/longname.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imgtools/imglib/filesystem/source/longname.cpp Tue Oct 27 16:36:35 2009 +0000 @@ -0,0 +1,458 @@ +/* +* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Receives the long file name and prepares short and long directory +* entries. +* @internalComponent +* @released +* +*/ + + +#include "longname.h" + + +/** +Constructor: Responsible to create +1. Short entry +2. Sub components of long entry name as per microsoft FAT spec. + +@internalComponent +@released + +@param aClusterPtr - Cluster instance address +@param aEntry - CDirectory class pointer +*/ + +ClongName::ClongName(CCluster* aClusterPtr, + CDirectory* aEntry): + iClusterPtr(aClusterPtr), + iTildeNumberPosition(ETildeNumberPosition), + iSubNameProperEnd(false), + iFirstNullName(false) +{ + iLongName = aEntry->GetEntryName(); + iLongEntryAttribute = aEntry->GetEntryAttribute(); + iClusterNumber = aClusterPtr->GetCurrentClusterNumber(); + iLongNameLength = iLongName.length(); + if(iLongNameLength == 0) + { + throw ErrorHandler(EMPTYFILENAME, __FILE__, __LINE__); + } + FormatLongFileName(iLongName); + iShortName = GetShortEntryName(); + GShortEntryList.push_back(iShortName); +} + + +/** +Static function to clear the strings stored in static Global Stringlist + +@internalComponent +@released +*/ +void ClongName::DestroyShortEntryList() +{ + GShortEntryList.clear(); +} + +/** +Destructor: To clear the contents from the STL containers in any exception case. +In normal case the containers are cleared once its usage is finished + +@internalComponent +@released +*/ + +ClongName::~ClongName() +{ + iSubNamesList.clear(); + while(iLongEntryStack.size() > 0) + { + delete iLongEntryStack.top(); + iLongEntryStack.pop(); + } + /* Cluster instance should be deleted only by dirregion, So just assign + * NULL value to the pointer + */ + iClusterPtr = NULL; +} + +/** +Function takes a long entry and writes all of the attributes into iLongNameEntryString. +To write the sub name's in a formatted WriteSubName() function invoked + +@internalComponent +@released + +@param aLongEntry - the long entry +*/ +void ClongName::WriteLongEntry(CLongEntry* aLongEntry,String& longEntryString) +{ + longEntryString.append(KWriteOnce, aLongEntry->GetDirOrder()); + WriteSubName(aLongEntry->GetSubName1(),(ESubName1Length*2),longEntryString); + longEntryString.append(KWriteOnce, aLongEntry->GetAttribute()); + longEntryString.append(KWriteOnce, aLongEntry->GetDirType()); + longEntryString.append(KWriteOnce, aLongEntry->GetCheckSum()); + WriteSubName(aLongEntry->GetSubName2(),(ESubName2Length*2),longEntryString); + unsigned short int lowClusterNumber = aLongEntry->GetClusterNumberLow(); + longEntryString.append(ToString(lowClusterNumber)); + WriteSubName(aLongEntry->GetSubName3(),(ESubName3Length*2),longEntryString); +} + +/** +Function responsible to +1. Write the sub name of the long entry, every character splitted by '.'(00) +2. If the name is not multiple of 13 this function applies NULL character padding and + padding with 'FF'. + +@internalComponent +@released + +@param aName - Sub name of a long entry +@param aSubNameLength - No of characters to be filled +@param alongEntryString - formatted sub name appended to this string +*/ +void ClongName::WriteSubName(String& aSubName,unsigned short aSubNameLength,String& alongEntryString) +{ + unsigned int subNameCurrLength = aSubName.length(); + if(subNameCurrLength == 0) + { + iFirstNullName = true; + } + else + { + iFirstNullName = false; + } + unsigned int beginIndex = 1; + if(subNameCurrLength > 0) + { + //Insert zero between every character, as per FAT spec requirement + while(subNameCurrLength > 0) + { + aSubName.insert(beginIndex,1,0); //Insert zero once + beginIndex += 2; //Jump 2 characters + --subNameCurrLength; + } + subNameCurrLength = aSubName.length(); + if(subNameCurrLength == aSubNameLength) + { + iSubNameProperEnd = true; + } + //Apply padding with two zero's to mention Long Name end. + if(subNameCurrLength < aSubNameLength) + { + aSubName.insert(subNameCurrLength, KPaddingCharCnt, 0); + } + } + subNameCurrLength = aSubName.length(); + if((iSubNameProperEnd == true) && (iFirstNullName == true)) + { + aSubName.insert(subNameCurrLength, KPaddingCharCnt, 0); + iSubNameProperEnd = false; + iFirstNullName = false; + } + subNameCurrLength = aSubName.length(); + //Insert FF for all unfilled characters. + if(subNameCurrLength < aSubNameLength) + { + aSubName.insert(subNameCurrLength,(aSubNameLength - subNameCurrLength), + KLongNamePaddingChar); + } + alongEntryString.append(aSubName.c_str(),aSubName.length()); +} + +/** +Function responsible to push the string into iNameList container and to erase the input +strings data + +@internalComponent +@released + +@param aFirstName - first sub name +@param aSecondName - Second sub name +@param aThirdName - third sub name +*/ +void ClongName::PushAndErase(String& aFirstName,String& aSecondName,String& aThirdName) +{ + iSubNamesList.push_back(aFirstName); + aFirstName.erase(); + iSubNamesList.push_back(aSecondName); + aSecondName.erase(); + iSubNamesList.push_back(aThirdName); + aThirdName.erase(); +} + +/** +Function responsible split single sub name from the long name + +@internalComponent +@released + +@param aLongName - The long name need to be splitted +@param aStartIndex - Sub name starting index +@param aStringLength - total string length +@param aSubNameLength - Length of the Sub Name of required length +@param aSubName - splitted Sub Name assigned using this string +*/ +void ClongName::GetSubName(String& aLongName, + int& aStartIndex, + int& aStringLength, + int aSubNameLength, + String& aSubName) +{ + if((aStartIndex + aSubNameLength) <= aStringLength) + { + aSubName = aLongName.substr(aStartIndex,aSubNameLength); + aStartIndex += aSubNameLength; + return; + } + aSubName = aLongName.substr(aStartIndex); + aStartIndex += aSubName.length(); +} + +/** +Function to split the long file name into smaller sub names,such as it should be +written into long directory entries. All splitted names are pushed into the +iNameList container. + +@internalComponent +@released +*/ +void ClongName::FormatLongFileName(String& aLongName) +{ + int stringLength = aLongName.length(); + int startIndex = 0; + String iSubName1; + String iSubName2; + String iSubName3; + + while(startIndex < stringLength) + { + GetSubName(aLongName,startIndex,stringLength,ESubName1Length,iSubName1); + GetSubName(aLongName,startIndex,stringLength,ESubName2Length,iSubName2); + GetSubName(aLongName,startIndex,stringLength,ESubName3Length,iSubName3); + PushAndErase(iSubName1,iSubName2,iSubName3); + } +} + +/** +Function responsible to create new short name if the currently generated short name +already exists. + +eg. Input:UNITTE~1TXT returns:UNITTE~2TXT + +@internalComponent +@released + +@return - returns the short name +*/ +void ClongName::CheckAndUpdateShortName(String& aShortName) +{ + char trailingChar; + StringList::iterator beginIter = GShortEntryList.begin(); + StringList::iterator endIter = GShortEntryList.end(); + String tempString; + while(beginIter != endIter) + { + tempString = (*beginIter); + if(strcmp(tempString.c_str(),aShortName.c_str()) == 0) + { + trailingChar = aShortName.at(iTildeNumberPosition); + aShortName[iTildeNumberPosition] = ++trailingChar; //Increment the character value by 1 + continue; + } + ++beginIter; + } +} + +/** +Function responsible to take the long file name as input and to prepare the short name. +e.g. Long File Name.pl to LONGFI~1PL + +@internalComponent +@released + +@return - returns the short name +*/ + +String ClongName::GetShortEntryName() +{ + String shortName; + unsigned int extensionIndex = iLongName.find_last_of(KDot); + + unsigned int dotIndex = extensionIndex; + //Erase all the dots from the string, but keep the extension index + while(dotIndex != String::npos) + { + iLongName.erase(dotIndex,1); //Erase the dot + dotIndex = iLongName.find_first_of(KDot); + if(dotIndex != String::npos) + { + //Decrement only if more than one dot exists + --extensionIndex; + } + } + + if((iLongEntryAttribute & EAttrDirectory)== 0) + { + if(extensionIndex <= EShortNameInitialLength) + { + //if the full name length is less than 6 characters, assign the whole name + shortName.assign(iLongName.c_str(),extensionIndex); + } + else + { + shortName.assign(iLongName.c_str(),EShortNameInitialLength); + } + //+1 is added to get '~' symbol position + iTildeNumberPosition = shortName.length() + 1; + } + else + { + shortName.assign(iLongName.c_str(),EShortNameInitialLength); + } + shortName += KTilde; + shortName += KTildeNumber; + shortName.assign(ToUpper(shortName)); + if(extensionIndex < iLongName.length()) //to identify whether the name has any extension. + { + if(shortName.length() < ENameLength) + { + shortName.append((ENameLength - shortName.length()),KSpace); + } + String shortNameString = iLongName.substr(extensionIndex,EExtensionLength); + shortName.append(ToUpper(shortNameString)); + CheckAndUpdateShortName(shortName); + return shortName; + } + //extension padding + shortName.append(EExtensionLength,KSpace); + CheckAndUpdateShortName(shortName); + return shortName; +} + +/** +Function takes the short entry name as input and calculates checksum as per the +Microsoft FAT spec. + +@internalComponent +@released + +@return - returns checkSum +*/ + +unsigned char ClongName::CalculateCheckSum() +{ + char* tempShortNamePtr = (char*)iShortName.c_str(); + unsigned short int nameLength = 0; + unsigned char chckSum = '\0'; + for(nameLength = ENameLengthWithExtension; nameLength != 0; nameLength--) + { + chckSum = ((chckSum & 1) ? 0x80 : NULL) + (chckSum >>1) + *tempShortNamePtr++; + } + return chckSum; +} + +/** +Function responsible to initialize short entry attributes. +Short entry is also an sub entry along with Long entries + +@internalComponent +@released + +@param aEntry - directory entry which has long file name +@return shortEntry - returns the initialized short Directory entry +*/ +CDirectory* ClongName::CreateShortEntry(CDirectory* aEntry) +{ + CDirectory* shortEntry = new CDirectory((char*)iShortName.c_str()); + shortEntry->SetEntryAttribute(aEntry->GetEntryAttribute()); + if(aEntry->IsFile()) + { + shortEntry->SetFilePath((char*)aEntry->GetFilePath().c_str()); + } + shortEntry->SetFileSize(aEntry->GetFileSize()); + /** Initialize the cluster number variables by splitting high and low words of + current cluster number + */ + shortEntry->SetClusterNumberHi((unsigned short)(iClusterNumber >> KBitShift16)); + shortEntry->SetClusterNumberLow((unsigned short)(iClusterNumber & KHighWordMask)); + return shortEntry; +} + +/** +Function responsible +1. To erase the string from the iNameList container. +2. To pop out the element + +@internalComponent +@released +*/ +void ClongName::PopAndErase() +{ + iSubNamesList.front().erase(); + iSubNamesList.pop_front(); +} + +/** +Function responsible to +1. Pop all the name's 3 by 3 from iNameList container +2. Construct long name directory entries +3. Push the long entries into iLongEntryStack +4. finally create Long name sub entries as string and append it to longEntryString. + +@internalComponent +@released + +@return - returns the formatted long name string +*/ +String ClongName::CreateLongEntries() +{ + String longEntryString; + CLongEntry* longEntryObject; + unsigned char chckSum = CalculateCheckSum(); + unsigned char dirOrderNumber = 0x00; + while(iSubNamesList.size() > 0) + { + longEntryObject = new CLongEntry(chckSum); + longEntryObject->SetSubName1(iSubNamesList.front()); + PopAndErase(); + longEntryObject->SetSubName2(iSubNamesList.front()); + PopAndErase(); + longEntryObject->SetSubName3(iSubNamesList.front()); + PopAndErase(); + longEntryObject->SetDirOrder(++dirOrderNumber); + + iLongEntryStack.push(longEntryObject); + } + + bool lastLongEntry = true; + while(iLongEntryStack.size() > 0) + { + if(lastLongEntry == true) + { + longEntryObject = iLongEntryStack.top(); + /* As per Microsoft FAT spec, Last sub entry of Long name Directory Order attribute + * should be logically OR'ed with value '0x40' + */ + longEntryObject->SetDirOrder(longEntryObject->GetDirOrder() | ELastLongEntry); + lastLongEntry = false; + } + WriteLongEntry(iLongEntryStack.top(),longEntryString); + delete iLongEntryStack.top(); + iLongEntryStack.pop(); + } + return longEntryString; +}