return strcpy(FileName, FilePath); /* FilePath has no Folders */    }return strcpy(FileName, dirPtr);}/***  return fullpathname from folder/dir-id***/char *GetFullPathFromID(char *CompletePath, short vRefNum, long dirID,                        ConstStr255Param name, OSErr *err){FSSpec      spec;    *err = FSMakeFSSpecCompat(vRefNum, dirID, name, &spec);    printerr("FSMakeFSSpecCompat:", (*err != -43) && (*err != 0), *err,             __LINE__, __FILE__, "");    if ( (*err == noErr) || (*err == fnfErr) )        {        return GetFullPathFromSpec(CompletePath, &spec, err);        }return NULL;}/***  convert real-filename to archive-filename***/char *Real2RfDfFilen(char *RfDfFilen, const char *RealPath,                    short CurrentFork, short MacZipMode, Boolean DataForkOnly){AssertStr(RealPath,"Real2RfDfFilen")AssertStr(RfDfFilen,"Real2RfDfFilen")if (DataForkOnly) /* make no changes */    {    return sstrcpy(RfDfFilen, RealPath);    }switch (MacZipMode)    {    case JohnnyLee_EF:        {        sstrcpy(RfDfFilen, RealPath);        if (CurrentFork == DataFork)            /* data-fork  */            return sstrcat(RfDfFilen, "d");        if (CurrentFork == ResourceFork)        /* resource-fork */            return sstrcat(RfDfFilen, "r");        break;        }    case NewZipMode_EF:        {        switch (CurrentFork)            {            case DataFork:                {                sstrcpy(RfDfFilen, RealPath);                return RfDfFilen;  /* data-fork  */                break;                }            case ResourceFork:                {                sstrcpy(RfDfFilen, ResourceMark);                sstrcat(RfDfFilen, RealPath);  /* resource-fork */                return RfDfFilen;                break;                }            default:                {                printerr("Real2RfDfFilen:", -1, -1,                         __LINE__, __FILE__, RealPath);                return NULL;  /* function should never reach this point */                }            }        break;        }    default:        {        printerr("Real2RfDfFilen:", -1, -1, __LINE__, __FILE__, RealPath);        return NULL;  /* function should never reach this point */        }    }printerr("Real2RfDfFilen:", -1, -1, __LINE__, __FILE__, RealPath);return NULL;  /* function should never come reach this point */}/***  convert archive-filename into a real filename***/char *RfDfFilen2Real(char *RealFn, const char *RfDfFilen, short MacZipMode,                     Boolean DataForkOnly, short *CurrentFork){short   length;int     result;AssertStr(RfDfFilen,"RfDfFilen2Real")if (DataForkOnly ||    (MacZipMode == UnKnown_EF) ||    (MacZipMode < JohnnyLee_EF))    {    *CurrentFork = DataFork;    return sstrcpy(RealFn,RfDfFilen);    }result = strncmp(RfDfFilen, ResourceMark, sizeof(ResourceMark)-2);if (result == 0)    {    MacZipMode = NewZipMode_EF;    }switch (MacZipMode)    {    case JohnnyLee_EF:        {        sstrcpy(RealFn, RfDfFilen);        length = strlen(RealFn);       /* determine Fork type */        if (RealFn[length-1] == 'd') *CurrentFork = DataFork;        else *CurrentFork = ResourceFork;        RealFn[length-1] = '\0';       /* simply cut one char  */        return RealFn;        break;        }    case NewZipMode_EF:        {                                   /* determine Fork type */        result = strncmp(RfDfFilen, ResourceMark, sizeof(ResourceMark)-2);        if (result != 0)            {            *CurrentFork = DataFork;            sstrcpy(RealFn, RfDfFilen);            return RealFn;  /* data-fork  */            }        else            {            *CurrentFork = ResourceFork;            if (strlen(RfDfFilen) > (sizeof(ResourceMark) - 1))                {                sstrcpy(RealFn, &RfDfFilen[sizeof(ResourceMark)-1]);                }            else RealFn[0] = '\0';            return RealFn;  /* resource-fork */            }        break;        }    default:        {        *CurrentFork = NoFork;        printerr("RfDfFilen2Real():", -1, MacZipMode,                 __LINE__, __FILE__, RfDfFilen);        return NULL;  /* function should never reach this point */        }    }printerr("RfDfFilen2Real():", -1, MacZipMode, __LINE__, __FILE__, RfDfFilen);return NULL;  /* function should never reach this point */}/***  return the applications name (argv[0])***/char *GetAppName(void){ProcessSerialNumber psn;static Str255       AppName;ProcessInfoRec      pinfo;OSErr               err;GetCurrentProcess(&psn);pinfo.processName = AppName;pinfo.processInfoLength = sizeof(pinfo);pinfo.processAppSpec = NULL;err = GetProcessInformation(&psn,&pinfo);AppName[AppName[0]+1] = 0x00;return (char *)&AppName[1];}/***  return fullpathname from FSSpec***/char *GetFullPathFromSpec(char *FullPath, FSSpec *Spec, OSErr *err){Handle hFullPath;short len;Assert_it(Spec,"GetFullPathFromSpec","")*err = FSpGetFullPath(Spec, &len, &hFullPath);printerr("FSpGetFullPath:", (*err != -43) && (*err != 0), *err,         __LINE__, __FILE__, "");memmove(FullPath, (Handle) *hFullPath, len);FullPath[len] = '\0';  /* make c-string */DisposeHandle((Handle)hFullPath);   /* we don't need it any more */printerr("Warning path length exceeds limit: ", len >= NAME_MAX, len,         __LINE__, __FILE__, " chars ");return FullPath;}/** This function expands a given partial path to a complete path.* Path expansions are relative to the running app.* This function follows the notation:*   1. relative path:*       a: ":subfolder:filename"    -> ":current folder:subfolder:filename"*       b: "::folder2:filename"     -> folder2 is beside the current*                                      folder on the same level*       c: "filename"               -> in current folder** An absolute path will be returned.The following characteristics of Macintosh pathnames should be noted:       A full pathname never begins with a colon, but must contain at       least one colon.       A partial pathname always begins with a colon separator except in       the case where the file partial pathname is a simple file or       directory name.       Single trailing separator colons in full or partial pathnames are       ignored except in the case of full pathnames to volumes.       In full pathnames to volumes, the trailing separator colon is required.       Consecutive separator colons can be used to ascend a level from a       directory to its parent directory. Two consecutive separator colons       will ascend one level, three consecutive separator colons will ascend       two levels, and so on. Ascending can only occur from a directory;       not a file.*/char *GetCompletePath(char *CompletePath, const char *name, FSSpec *Spec,                      OSErr *err){Boolean hasDirName = false;char currentdir[NAME_MAX];char *tmpPtr;unsigned short pathlen;AssertStr(name,"GetCompletePath")Assert_it(Spec,"GetCompletePath","")Assert_it((CompletePath != name),"GetCompletePath","")for (tmpPtr = name; *tmpPtr; tmpPtr++)    if (*tmpPtr == ':') hasDirName = true;if (name[0] != ':')   /* case c: path including volume name or only filename */    {    if (hasDirName)        {   /* okey, starts with volume name, so it must be a complete path */        sstrcpy(CompletePath, name);        }    else        {   /* only filename: add cwd and return */        getcwd(currentdir, NAME_MAX);        sstrcat(currentdir, name);        sstrcpy(CompletePath, currentdir);        }    }else if (name[1] == ':')    /* it's case b: "::folder2:filename"  */    {    printerr("GetCompletePath ", -1, *err, __LINE__, __FILE__, "not implemented");            /* it's not yet implemented; do we really need this case ?*/    return NULL;    }else                        /* it's case a: ":subfolder:filename" */    {    getcwd(CompletePath, NAME_MAX);     /* we don't need a second colon */    CompletePath[strlen(CompletePath)-1] = '\0';    sstrcat(CompletePath, name);    }pathlen = strlen(CompletePath);*err = FSpLocationFromFullPath(pathlen, CompletePath, Spec);return CompletePath;}char *MakeFilenameShorter(const char *LongFilename){static char filename[35];  /* contents should be never longer than 32 chars */static unsigned char Num = 0; /* change the number for every call */                              /* this var will rollover without a problem */char tempLongFilename[1024], charnum[5];char *last_dotpos         = tempLongFilename;unsigned long full_length = strlen(LongFilename);unsigned long ext_length  = 0;unsigned long num_to_cut  = 0;long firstpart_length;char *tmpPtr;short MaxLength = 31;if (full_length <= MaxLength) /* filename is not long */    {    return strcpy(filename,LongFilename);    }Num++;strcpy(tempLongFilename,LongFilename);/* Look for the last extension pos */for (tmpPtr = tempLongFilename; *tmpPtr; tmpPtr++)    if (*tmpPtr == '.') last_dotpos = tmpPtr;ext_length = strlen(last_dotpos);firstpart_length = last_dotpos - tempLongFilename;if (ext_length > 6)  /* up to 5 chars are treated as a */    {                /* normal extension like ".html" or ".class"  */    firstpart_length = 0;    }num_to_cut = full_length - MaxLength;/* number the files to make the names unique */sprintf(charnum,"~%x", Num);num_to_cut += strlen(charnum);if (firstpart_length == 0)    {    firstpart_length = full_length;    tempLongFilename[firstpart_length - num_to_cut] = 0;    sprintf(filename,"%s%s", tempLongFilename, charnum);    }else    {    tempLongFilename[firstpart_length - num_to_cut] = 0;    sprintf(filename,"%s%s%s", tempLongFilename, charnum, last_dotpos);    }return filename;}