home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / opendc12.zip / od124os2.exe / od12osr1.exe / src / IPlfmFil.cpp < prev    next >
C/C++ Source or Header  |  1997-03-21  |  25KB  |  678 lines
  1. //====START_GENERATED_PROLOG======================================
  2. //
  3. //
  4. //   COMPONENT_NAME: odutils
  5. //
  6. //   CLASSES: none
  7. //
  8. //   ORIGINS: 82,27
  9. //
  10. //
  11. //   (C) COPYRIGHT International Business Machines Corp. 1995,1996
  12. //   All Rights Reserved
  13. //   Licensed Materials - Property of IBM
  14. //   US Government Users Restricted Rights - Use, duplication or
  15. //   disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  16. //       
  17. //   IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  18. //   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19. //   PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  20. //   CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  21. //   USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  22. //   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
  23. //   OR PERFORMANCE OF THIS SOFTWARE.
  24. //
  25. //====END_GENERATED_PROLOG========================================
  26. //
  27. // @(#) 1.19 com/src/utils/IPlfmFil.cpp, odutils, od96os2, odos29712d 3/4/97 15:39:31 [ 3/21/97 17:37:45 ]
  28. /*
  29.  
  30.     File:        PlfmFile.cpp
  31.  
  32.     Contains:    Implmentation for PlatformFile class
  33.  
  34.     Owned by:    Vincent Lo
  35.  
  36.     Copyright:    ⌐ 1993-95 by Apple Computer, Inc., all rights reserved.
  37.  
  38. */
  39.  
  40. #include <stdio.h>
  41. #include <string.h>
  42. #include <wcstr.h>
  43. #include <time.h>
  44.  
  45. #ifndef _ODTYPES_
  46. #include "ODTypes.h"
  47. #endif
  48.  
  49. #ifndef _PLFMFILE_
  50. #include "PlfmFile.h"
  51. #endif
  52.  
  53. #ifndef _ODMEMORY_
  54. #include "ODMemory.h"
  55. #endif
  56.  
  57. #ifndef _EXCEPT_
  58. #include "Except.h"
  59. #endif
  60.  
  61. #ifndef _PASCLSTR_
  62. #include "PasclStr.h"
  63. #endif
  64.  
  65. #ifndef _ITEXT_
  66. #include "IText.h"
  67. #endif
  68.  
  69. #ifndef __ODTYPESP__
  70. #include <ODTypesP.h>
  71. #endif
  72.  
  73. #ifndef __ODPAGTUN__
  74. #include <ODPagTun.h>
  75. #endif
  76.  
  77. #ifndef __ODDEBUG__
  78. #include <ODDebug.h>
  79. #endif
  80.  
  81. #ifndef __ERRORS__
  82. #include <Errors.h>
  83. #endif
  84.  
  85. #if defined(_PLATFORM_UNIX_)
  86. #include <errno.h>
  87. #endif // defined(_PLATFORM_UNIX_)
  88.  
  89. //==============================================================================
  90. // Constants
  91. //==============================================================================
  92.  
  93. const ODULong    kMaxCopyBufferSize            = 32 * 1024L;
  94. const unsigned long kODMaxFileNameBufferSize = kODMaxFileNameSize + 1;
  95. const unsigned long kODMaxWcsFileNameSize = kODMaxFileNameSize * sizeof(wchar_t);
  96. const unsigned long kODMaxWcsFileNameBufferSize = kODMaxWcsFileNameSize + sizeof(wchar_t);
  97.  
  98. //==============================================================================
  99. // Scalar Types
  100. //==============================================================================
  101.  
  102. //==============================================================================
  103. // Local Classes
  104. //==============================================================================
  105.  
  106. //==============================================================================
  107. // Global Variables
  108. //==============================================================================
  109.  
  110. //==============================================================================
  111. // Function Prototype
  112. //==============================================================================
  113.  
  114. //==============================================================================
  115. // PlatformFile
  116. //==============================================================================
  117.  
  118. const ODOSType kBogusOSType = 0;    // Default type/creator value until it's read
  119.  
  120. //------------------------------------------------------------------------------
  121. // PlatformFile::PlatformFile
  122. //------------------------------------------------------------------------------
  123. PlatformFile::PlatformFile()
  124. {
  125.     fCreator = kBogusOSType;
  126.     fFileType = kBogusOSType;
  127.     fScriptTag = 0;
  128.     
  129.     fFileSpec.name[0] = 0;
  130.     fPermission = kODFileRead | kODFileWrite;
  131.     fDataRefNum = kODNoFileRefNum;
  132. }
  133.  
  134. //------------------------------------------------------------------------------
  135. // PlatformFile::~PlatformFile
  136. //------------------------------------------------------------------------------
  137. PlatformFile::~PlatformFile()
  138. {
  139. }
  140.  
  141. #if defined(_PLATFORM_WIN32_) || defined(_PLATFORM_OS2_) || defined(_PLATFORM_UNIX_)
  142. //------------------------------------------------------------------------------
  143. // PlatformFile::UniquifyAndCreate
  144. //------------------------------------------------------------------------------
  145. // This routine combines the UniquifyName and Create functions into one call
  146. // because of a window resulting from a multitasking environment.  A race
  147. // condition exists between different threads making a call to UniquifyName
  148. // followed by a call to Create.  Different threads could conceivably have
  149. // the same unique name returned, as long as no thread has yet created a file
  150. // with that unique name.  The subsequent Create could fail due to a "file
  151. // already exists" error, which lessens the value of calling UniquifyName in
  152. // the first place.
  153.  
  154. // To make things easier on the caller, UniquifyName and Create have been
  155. // rolled into one function.  This function iteratively calls UniquifyName and
  156. // Create until a file with a unique name is successfully created (or until an
  157. // error other than "file already exists" is encountered).
  158. void PlatformFile::UniquifyAndCreate(ODOSType creator, ODOSType fileType,
  159.                                      ODScriptCode scriptCode, short copyCount,
  160.                                      ODBoolean forceNewName)
  161. {
  162.     int fileCreated = 0;
  163.     short count = copyCount;
  164.     ODFileSpec savedFileSpec = fFileSpec;
  165.  
  166.     do
  167.     {
  168.         // Create unique name (or use current one if not forcing new name)
  169.         UniquifyName(kODNoResourceID, kODNULL, kODNoResourceID, kODNULL, count,
  170.                      kSpecifyNewNameOnly, forceNewName);
  171.         TRY
  172.             Create(creator, fileType, scriptCode);
  173.             fileCreated = 1;
  174.         CATCH_ALL
  175.             // If a "file already exists" error occurred, keep trying.  Otherwise,
  176.             // rethrow the exception
  177. #if defined(_PLATFORM_WIN32_)
  178.             if (_exception.error != ERROR_FILE_EXISTS)
  179. #elif defined(_PLATFORM_OS2_)
  180.             if (_exception.error != ERROR_OPEN_FAILED || !Exists())
  181. #elif defined(_PLATFORM_UNIX_)
  182.             if (_exception.error != EEXIST)
  183. #else // unimplemented platform
  184.             #error Function not implemented on specified platform
  185. #endif // defined(_PLATFORM_UNIX_)
  186.                 RERAISE;
  187.             // On each iteration, the name must be reset to the original name;
  188.             // otherwise numbers (appended from UniquifyName) will keep getting
  189.             // appended on each iteration of this loop, instead of simply
  190.             // incremented.
  191.             fFileSpec = savedFileSpec;
  192.             // UniquifyName may have had to increment more than this, but
  193.             // at least one check will be avoided
  194.             count++;
  195.         ENDTRY;
  196.         forceNewName = kODTrue;
  197.     } while (!fileCreated);
  198. }
  199. #endif // defined(_PLATFORM_WIN32_) || defined(_PLATFORM_OS2_) || defined(_PLATFORM_UNIX_)
  200.  
  201.  
  202. //------------------------------------------------------------------------------
  203. // PlatformFile::Specify
  204. //------------------------------------------------------------------------------
  205. void PlatformFile::Specify(const ODFileSpec* fileSpec)
  206. {
  207.  
  208. #if defined(_PLATFORM_WIN32_)
  209.         // Store the fully qualify file name so as to avoid problem
  210.         // creating by changing working directory in a file dialog.
  211.         char *fullPathName = (char *) malloc(kODMaxFileNameSize+1);
  212.         char *fileNameInPath;
  213.         DWORD pathLength = GetFullPathName((char *)fileSpec->name, 
  214.                                            kODMaxFileNameSize+1, 
  215.                                            fullPathName, 
  216.                                            &fileNameInPath);
  217.         if (pathLength && pathLength <= kODMaxFileNameSize)
  218.            strcpy((char *)fFileSpec.name, fullPathName);
  219.         free(fullPathName);
  220. #else
  221.     // Note:  The following strncpy and null terminator assignment replaces a
  222.     //        direct structure assignment because various callers were
  223.     //        (incorrectly) casting char * to ODFileSpec *, and did not
  224.     //        necessarily have sizeof(fFileSpec.name) bytes addressable.
  225.     strncpy((char *)fFileSpec.name, (char *)fileSpec->name, sizeof(fFileSpec.name));
  226.     fFileSpec.name[sizeof(fFileSpec.name) - 1] = '\0';
  227. #endif
  228.     fCreator = kBogusOSType;
  229.     fFileType = kBogusOSType;
  230. }
  231.  
  232. void PlatformFile::SpecifyFromFile(PlatformFile* file)
  233. {
  234.     const ODFileSpec &fileSpec = file->GetFileSpec();
  235.     this->Specify(&fileSpec);
  236. }
  237.  
  238. //------------------------------------------------------------------------------
  239. // PlatformFile::SetAsciiname
  240. //------------------------------------------------------------------------------
  241. void PlatformFile::SetAsciiName(const char* asciiName)
  242. {
  243.     wchar_t *wcsFileName;
  244.     size_t nameLength, copyLength;
  245.  
  246.     /******************************************************************
  247.     Note: To copy the specified mbs (multi-byte string) string, strncpy
  248.           cannot be used, because the string may contain a mixture of
  249.           double and single byte characters, and the string must not be
  250.           truncated so that it ends with half of a double-byte
  251.           character.
  252.  
  253.           The input string must be converted to a wcs (wide character
  254.           string) string and converted back to an mbs with the
  255.           desired max length.  This way, only complete characters
  256.           are copied, up to the given length.
  257.     ******************************************************************/
  258.     wcsFileName = (wchar_t *)malloc(kODMaxWcsFileNameBufferSize);
  259.  
  260.     mbstowcs(wcsFileName, asciiName, kODMaxWcsFileNameBufferSize);
  261.     copyLength = sizeof(fFileSpec.name) - 1;
  262.     nameLength = wcstombs((char *)fFileSpec.name, wcsFileName,
  263.                          copyLength);
  264.     if (nameLength == copyLength)
  265.         fFileSpec.name[nameLength] = '\0';
  266.  
  267.     free(wcsFileName);
  268. }
  269.  
  270. //------------------------------------------------------------------------------
  271. // PlatformFile::IsLocked
  272. //------------------------------------------------------------------------------
  273. ODBoolean PlatformFile::IsLocked()
  274. {
  275.     return  kODFalse;
  276. }
  277.  
  278. //------------------------------------------------------------------------------
  279. // PlatformFile::Lock
  280. //------------------------------------------------------------------------------
  281. void PlatformFile::Lock()
  282. {
  283. }
  284.  
  285. //------------------------------------------------------------------------------
  286. // PlatformFile::Unlock
  287. //------------------------------------------------------------------------------
  288. void PlatformFile::Unlock()
  289. {
  290. }
  291.  
  292. //------------------------------------------------------------------------------
  293. // PlatformFile::GetName
  294. //------------------------------------------------------------------------------
  295. ODName* PlatformFile::GetName()
  296. {
  297.     return CreateIText(fScriptTag, 0, (char *)fFileSpec.name);
  298. }
  299.  
  300. //------------------------------------------------------------------------------
  301. // PlatformFile::GetAsciiName
  302. //------------------------------------------------------------------------------
  303. void PlatformFile::GetAsciiName(char* asciiName, ODULong maxLength)
  304. {
  305.     wchar_t *wcsFileName;
  306.     size_t nameLength;
  307.  
  308.     /******************************************************************
  309.     Note: To copy the specified mbs (multi-byte string) string, strncpy
  310.           cannot be used, because the string may contain a mixture of
  311.           double and single byte characters, and the string must not be
  312.           truncated so that it ends with half of a double-byte
  313.           character.
  314.  
  315.           The input string must be converted to a wcs (wide character
  316.           string) string and converted back to an mbs with the
  317.           desired max length.  This way, only complete characters
  318.           are copied, up to the given length.
  319.     ******************************************************************/
  320.  
  321.     wcsFileName = (wchar_t *)malloc(kODMaxWcsFileNameBufferSize);
  322.  
  323.     mbstowcs(wcsFileName, (char *)fFileSpec.name, kODMaxWcsFileNameBufferSize);
  324.     nameLength = wcstombs(asciiName, wcsFileName, maxLength);
  325.     // Note:  The original DR4 code does this (i.e., potentially nulls out
  326.     //        byte maxLength + 1).
  327.     if (nameLength == maxLength)
  328.         asciiName[maxLength] = '\0';
  329.  
  330.     free(wcsFileName);
  331. }
  332.  
  333. //------------------------------------------------------------------------------
  334. // PlatformFile::GetPlatformCreator
  335. //------------------------------------------------------------------------------
  336. ODOSType PlatformFile::GetPlatformCreator()
  337. {
  338.     return fCreator;
  339. }    
  340.  
  341. //------------------------------------------------------------------------------
  342. // PlatformFile::GetPlatformType
  343. //------------------------------------------------------------------------------
  344. ODOSType PlatformFile::GetPlatformType()
  345. {
  346.     return fFileType;
  347. }    
  348.  
  349. //------------------------------------------------------------------------------
  350. // PlatformFile::SetPlatformType
  351. //------------------------------------------------------------------------------
  352. void PlatformFile::SetPlatformType(ODOSType fileType)
  353. {
  354.     fFileType = fileType;
  355. }    
  356.  
  357.  
  358.  
  359. //------------------------------------------------------------------------------
  360. // PlatformFile::GetAllocationBlockSize
  361. //------------------------------------------------------------------------------
  362. ODULong PlatformFile::GetAllocationBlockSize()
  363. {
  364.     return 8192; // 8K
  365. }
  366.  
  367. //------------------------------------------------------------------------------
  368. // PlatformFile::CopyFrom
  369. //------------------------------------------------------------------------------
  370. void PlatformFile::CopyFrom( PlatformFile* src )
  371. {
  372.     ODBoolean srcIsOpen = (src->GetFileRefNum() != kODNoFileRefNum);
  373.     if ( !srcIsOpen )
  374.         src->Open();
  375.     this->SetPermission( fsRdWrPerm );        // currently this is the default value
  376.     if (!this->Exists())
  377.         this->Create(src->GetPlatformCreator(), src->GetPlatformType(), 0 /*$$$$$ scriptcode?*/);
  378.  
  379.     this->Open();
  380.             
  381.     src->SetFilePos( fsFromStart, 0 );
  382.     this->SetFilePos( fsFromStart, 0 );
  383.     
  384.     ODSLong bytesLeft = src->GetEndOfFile();
  385.  
  386.     void *hbuffer = kODNULL;
  387.     ODSLong bufferSize = kMaxCopyBufferSize;
  388.     if( bufferSize > bytesLeft )
  389.         bufferSize = bytesLeft;
  390.  
  391.     if (bufferSize > 0)
  392.     {
  393.         hbuffer = new char [bufferSize];
  394.         THROW_IF_NULL(hbuffer);
  395.         void *buffer = hbuffer;
  396.  
  397.         ODSLong count;
  398.  
  399.         while( bytesLeft > 0 )
  400.         {
  401.             count = bytesLeft < bufferSize? bytesLeft: bufferSize ;
  402.             src->Read( buffer, &count );
  403.             this->Write( buffer, &count );
  404.             bytesLeft -= count ;
  405.         }
  406.         delete hbuffer;
  407.     }
  408.     
  409.     if ( !srcIsOpen )
  410.         src->Close();
  411.     this->Close();
  412. }
  413.  
  414.  
  415. //------------------------------------------------------------------------------
  416. // PlatformFile::UniquifyName
  417. // This function generates a unique name based on the filespec of this
  418. // PlatformFile object.  A unique name is generated by appending the
  419. // copyCount parameter value to the fileSpec.  The copyCount value is
  420. // incremented until a unique name is generated.
  421. // 
  422. // This implementation is a simplified version of the original Apple version.
  423. // Mac-specific parameters are ignored, and code for unused options was
  424. // removed.  Only the copyCount and forceNewName parameters are used.
  425. //------------------------------------------------------------------------------
  426.  
  427. const int kODMaxBaseFileNameSize = 8;
  428.  
  429. void PlatformFile::UniquifyName( ODSShort uniquifyingStringID,
  430.             StringHandle uniquifyingString, 
  431.             ODSShort uniquifyingNumberID,
  432.             StringHandle uniquifyingNumberString, 
  433.             short copyCount,
  434.             PFUniquifyAction action, 
  435.             ODBoolean forceNewName)
  436. { 
  437.  
  438.     if ((forceNewName != kODTryCurrentName) || this->Exists())
  439.     {
  440.         PlatformFile possibleOther;
  441.         possibleOther.SpecifyFromFile(this);
  442.  
  443.         ODFileSpec originalFileSpec = this->GetFileSpec();
  444.     
  445.         char suffixString[kODMaxFileNameSize+1];
  446.         sprintf(suffixString, "%d", copyCount);
  447.             
  448.         while (1)
  449.         {
  450.             ODFilePathname newFilePathname;
  451.             strcpy ((char *)newFilePathname, (char *)originalFileSpec.name);
  452.             ConcatenateSuffix (newFilePathname, suffixString);
  453.     
  454.             possibleOther.SetAsciiName((char *)newFilePathname);
  455.             if (!possibleOther.Exists())
  456.             {
  457.                 this->SetAsciiName((char *)newFilePathname);
  458.                 break;
  459.             }
  460.  
  461.             // Increment suffix in quest to find unused name
  462.             copyCount++;
  463.             sprintf (suffixString, "%d", copyCount);
  464.         }
  465.     }
  466. }    // UniquifyName
  467.  
  468. /**************************************************************************
  469.  This routine is used to concatenate a suffix onto the end of a file name.
  470.  Both the suffix and pathname are passed in by the caller.  The pathname
  471.  is assumed to be anything from a fully-qualified pathname to just a
  472.  file name.
  473.  
  474.  This routine must work with mbs (multi-byte string) strings, which
  475.  complicates things quite a bit.  The basic approach is to convert the
  476.  pathname to a wcs (wide character string) string and parse the wcs string
  477.  into a pathname (without file name), file name (without extension), and
  478.  extension.  Once these strings are determined, the path and extension are
  479.  converted back to mbs strings, since no more manipulation on them will be
  480.  necessary, except copying or concatenating them.
  481.  
  482.  The next step is to concatenate the suffix onto the file name.  This is
  483.  done with wcs strings.  After the suffix is concatenated, the resulting
  484.  name must be checked to make sure it does not exceed the maximum
  485.  allowed file name length.  This must be done by converting the name to
  486.  an mbs string and comparing its length to the maximum allowed length.  If
  487.  truncation is necessary, the number of bytes that must be truncated is
  488.  known, but not the characters, since mbs strings can be a mixture of
  489.  single- and double-byte characters.  So that no more characters are
  490.  truncated than necessary, the number of bytes to truncate is divided
  491.  by two (rounding up), and that many characters are truncated from the
  492.  wcs copy of the file name.  Since the name may consist of mostly
  493.  single byte characters, more truncation may be necessary.  Thus
  494.  the name truncation is an interative process.  The loop ends when
  495.  no more truncation is necessary.  An exception is thrown if the name
  496.  becomes completely truncated.
  497.  
  498.  Once the name is truncated, the length entire pathname (with the suffix
  499.  added to the file name) is compared to the maximum allowd pathname
  500.  length.  More truncation from the name may be required.  If necessary,
  501.  truncation is continued in the same manner as above until the pathname
  502.  is short enough or until an exception is thrown because the original
  503.  file name has become completely truncated.
  504. **************************************************************************/
  505. void PlatformFile::ConcatenateSuffix(ODFilePathname filePathname, char *suffixString)
  506. {
  507.     wchar_t *wcsNamePtr, *wcsExtPtr;
  508.     wchar_t *wcsFilePathname, *wcsFileName;
  509.     char *pathNoName, *fileName, *fileExtension;
  510.     long truncateLength, fileNameLengthInChars, suffixLength,
  511.          lengthOfAllButName;
  512.     ODError error = 0;
  513.     wchar_t driveSeparator = L';', extSeparator = L'.';
  514. #if defined(_PLATFORM_OS2_) || defined(_PLATFORM_WIN32_)
  515.     wchar_t pathSeparator = L'\\';
  516. #elif defined(_PLATFORM_UNIX_)
  517.     wchar_t pathSeparator = L'/';
  518. #else // unknown platform
  519.     #error IPlfmFil.cpp:  This platform not supported.
  520. #endif // defined(_PLATFORM_OS2_) || defined(_PLATFORM_WIN32_)
  521.  
  522.     wcsFilePathname = (wchar_t *)malloc(kODMaxWcsFileNameBufferSize);
  523.     wcsFileName = (wchar_t *)malloc(kODMaxWcsFileNameBufferSize);
  524.     pathNoName = (char *)malloc(kODMaxFileNameBufferSize);
  525.     fileName = (char *)malloc(kODMaxFileNameBufferSize);
  526.     fileExtension = (char *)malloc(kODMaxFileNameBufferSize);
  527.  
  528.     suffixLength = strlen(suffixString);
  529.  
  530.     if (wcsFilePathname && wcsFileName && pathNoName && fileName && fileExtension)
  531.     {
  532.         // Convert the mbs pathname to wcs
  533.         mbstowcs(wcsFilePathname, (char *)filePathname, kODMaxWcsFileNameBufferSize);
  534.  
  535.         /****************************************************************
  536.         Find file name in wcs copy of pathname and copy to another
  537.         buffer.  Strip the file name from the pathname.
  538.         ****************************************************************/
  539.         wcsNamePtr = wcsrchr(wcsFilePathname, pathSeparator);
  540.         if (!wcsNamePtr)
  541.             wcsNamePtr = wcsrchr(wcsFilePathname, driveSeparator);
  542.         if (wcsNamePtr)
  543.             wcsNamePtr++;
  544.         else
  545.             wcsNamePtr = wcsFilePathname;
  546.  
  547.         // Make wcs copy of file name
  548.         wcscpy(wcsFileName, wcsNamePtr);
  549.  
  550.         // Strip the file name from the wcs copy of the the pathname
  551.         *wcsNamePtr = L'\0';
  552.     
  553.         /****************************************************************
  554.         Locate file name extension in wcs copy of file name and copy to
  555.         another buffer in mbs format.  Then strip the extension from
  556.         the file name.
  557.         ****************************************************************/
  558.         wcsExtPtr = wcschr(wcsFileName, extSeparator);
  559.         if (wcsExtPtr)
  560.         {
  561.             wcstombs(fileExtension, wcsExtPtr, kODMaxFileNameBufferSize);
  562.             *wcsExtPtr = L'\0';
  563.         }
  564.         else
  565.             fileExtension[0] = '\0';
  566.  
  567.         /****************************************************************
  568.         Copy pathname (without file name) into another buffer in mbs
  569.         format. Deallocate wcs pathname buffer.
  570.         ****************************************************************/
  571.         wcstombs(pathNoName, wcsFilePathname, kODMaxFileNameBufferSize);
  572.         free (wcsFilePathname);
  573.         wcsFilePathname = NULL;
  574.  
  575.         /****************************************************************
  576.         Truncate the file name, if necessary, so that adding the suffix
  577.         will not cause the name to exceed the maximum allowed length.
  578.         ****************************************************************/
  579.         fileNameLengthInChars = wcslen(wcsFileName);
  580.         do
  581.         {
  582.             // Create an mbs copy of the file name
  583.             wcstombs(fileName, wcsFileName, kODMaxFileNameBufferSize);
  584.             // Calculate the number of bytes that must be truncated
  585.             // from the file name
  586.             truncateLength = strlen(fileName) + suffixLength -
  587.                              kODMaxBaseFileNameSize;
  588.             // Assume characters are double-byte, so divide the truncate
  589.             // length by two, rounding up
  590.             truncateLength++;
  591.             truncateLength >>= 1;
  592.             if (truncateLength > 0)
  593.             {
  594.                 if (truncateLength > fileNameLengthInChars)
  595.                 {
  596. #if defined(_PLATFORM_WIN32_) || defined(_PLATFORM_OS2_)
  597.                     error = ERROR_CANNOT_MAKE;
  598. #else // defined(_PLATFORM_UNIX_)
  599.                     error = ENAMETOOLONG;
  600. #endif // defined(_PLATFORM_WIN32_) || defined(_PLATFORM_OS2_)
  601.                     goto errexit;
  602.                 }
  603.  
  604.                 // Truncate temporary copy of file name
  605.                 fileNameLengthInChars -= truncateLength;
  606.                 wcsFileName[fileNameLengthInChars] = L'\0';
  607.             }
  608.             else
  609.                 truncateLength = 0;
  610.         } while (truncateLength > 0);
  611.  
  612.  
  613.         /****************************************************************
  614.         Truncate the file name some more, if necessary, so that adding
  615.         the suffix will not cause the entire path name to exceed the
  616.         maximum allowed length.
  617.         ****************************************************************/
  618.         lengthOfAllButName  = strlen(pathNoName) + suffixLength +
  619.                               strlen(fileExtension);
  620.         do
  621.         {
  622.             // Create an mbs copy of the file name
  623.             wcstombs(fileName, wcsFileName, kODMaxFileNameBufferSize);
  624.             // If total path name is still too long
  625.             truncateLength =  lengthOfAllButName + strlen(fileName) - 
  626.                               kODMaxFileNameSize;
  627.             // Assume characters are double-byte, so divide the truncate
  628.             // length by two, rounding up
  629.             truncateLength++;
  630.             truncateLength >>= 1;
  631.             if (truncateLength > 0)
  632.             {
  633.                 if (truncateLength > fileNameLengthInChars)
  634.                 {
  635. #if defined(_PLATFORM_WIN32_) || defined(_PLATFORM_OS2_)
  636.                     error = ERROR_CANNOT_MAKE;
  637. #else // defined(_PLATFORM_UNIX_)
  638.                     error = ENAMETOOLONG;
  639. #endif // defined(_PLATFORM_WIN32_) || defined(_PLATFORM_OS2_)
  640.                     goto errexit;
  641.                 }
  642.  
  643.                 // Truncate temporary copy of file name some more
  644.                 fileNameLengthInChars -= truncateLength;
  645.                 wcsFileName[fileNameLengthInChars] = L'\0';
  646.             }
  647.         } while (truncateLength > 0);
  648.  
  649.  
  650.         /****************************************************************
  651.         Copy/concatenate path, filename, suffix, and file extension
  652.         to caller's pathname buffer.
  653.         ****************************************************************/
  654.         strcpy((char *)filePathname, pathNoName);
  655.         strcat((char *)filePathname, fileName);
  656.         strcat((char *)filePathname, suffixString);
  657.         strcat((char *)filePathname, fileExtension);
  658.     }
  659.     else
  660.         error = kODErrOutOfMemory;
  661.  
  662. errexit:
  663.     
  664.     if (wcsFilePathname)
  665.         free (wcsFilePathname);
  666.     if (wcsFileName)
  667.         free (wcsFileName);
  668.     if (pathNoName)
  669.         free (pathNoName);
  670.     if (fileName)
  671.         free (fileName);
  672.     if (fileExtension)
  673.         free (fileExtension);
  674.  
  675.     if (error)
  676.         THROW(error);
  677. }
  678.