#include "tclInt.h"
#include "tclPort.h"
#include "tclMacInt.h"
#include <Aliases.h>
#include <Errors.h>
#include <Processes.h>
#include <Strings.h>
#include <Types.h>
#include <MoreFiles.h>
#include <MoreFilesExtras.h>
#include <FSpCompat.h>
static int NativeMatchType(Tcl_Obj *tempName, Tcl_GlobTypeData *types,
HFileInfo fileInfo, OSType okType, OSType okCreator);
static OSErr FspLocationFromFsPath _ANSI_ARGS_((Tcl_Obj *pathPtr,
FSSpec* specPtr));
static OSErr FspLLocationFromFsPath _ANSI_ARGS_((Tcl_Obj *pathPtr,
FSSpec* specPtr));
static OSErr
FspLocationFromFsPath(pathPtr, specPtr)
Tcl_Obj *pathPtr;
FSSpec* specPtr;
{
CONST char *native = Tcl_FSGetNativePath(pathPtr);
return FSpLocationFromPath(strlen(native), native, specPtr);
}
static OSErr
FspLLocationFromFsPath(pathPtr, specPtr)
Tcl_Obj *pathPtr;
FSSpec* specPtr;
{
CONST char *native = Tcl_FSGetNativePath(pathPtr);
return FSpLLocationFromPath(strlen(native), native, specPtr);
}
char *
TclpFindExecutable(
CONST char *argv0)
{
ProcessSerialNumber psn;
ProcessInfoRec info;
Str63 appName;
FSSpec fileSpec;
int pathLength;
Handle pathName = NULL;
OSErr err;
Tcl_DString ds;
TclInitSubsystems(argv0);
GetCurrentProcess(&psn);
info.processInfoLength = sizeof(ProcessInfoRec);
info.processName = appName;
info.processAppSpec = &fileSpec;
GetProcessInformation(&psn, &info);
if (tclExecutableName != NULL) {
ckfree(tclExecutableName);
tclExecutableName = NULL;
}
err = FSpPathFromLocation(&fileSpec, &pathLength, &pathName);
HLock(pathName);
Tcl_ExternalToUtfDString(NULL, *pathName, pathLength, &ds);
HUnlock(pathName);
DisposeHandle(pathName);
tclExecutableName = (char *) ckalloc((unsigned)
(Tcl_DStringLength(&ds) + 1));
strcpy(tclExecutableName, Tcl_DStringValue(&ds));
Tcl_DStringFree(&ds);
return tclExecutableName;
}
int
TclpMatchInDirectory(interp, resultPtr, pathPtr, pattern, types)
Tcl_Interp *interp;
Tcl_Obj *resultPtr;
Tcl_Obj *pathPtr;
CONST char *pattern;
Tcl_GlobTypeData *types;
{
OSType okType = 0;
OSType okCreator = 0;
Tcl_Obj *fileNamePtr;
fileNamePtr = Tcl_FSGetTranslatedPath(interp, pathPtr);
if (fileNamePtr == NULL) {
return TCL_ERROR;
}
if (types != NULL) {
if (types->macType != NULL) {
Tcl_GetOSTypeFromObj(NULL, types->macType, &okType);
}
if (types->macCreator != NULL) {
Tcl_GetOSTypeFromObj(NULL, types->macCreator, &okCreator);
}
}
if (pattern == NULL || (*pattern == '\0')) {
Tcl_StatBuf buf;
CInfoPBRec paramBlock;
FSSpec fileSpec;
if (TclpObjLstat(fileNamePtr, &buf) != 0) {
return TCL_OK;
}
if (FspLLocationFromFsPath(fileNamePtr, &fileSpec) == noErr) {
paramBlock.hFileInfo.ioCompletion = NULL;
paramBlock.hFileInfo.ioNamePtr = fileSpec.name;
paramBlock.hFileInfo.ioVRefNum = fileSpec.vRefNum;
paramBlock.hFileInfo.ioFDirIndex = 0;
paramBlock.hFileInfo.ioDirID = fileSpec.parID;
PBGetCatInfo(¶mBlock, 0);
}
if (NativeMatchType(fileNamePtr, types, paramBlock.hFileInfo,
okType, okCreator)) {
int fnameLen;
char *fname = Tcl_GetStringFromObj(pathPtr,&fnameLen);
if ((fnameLen > 1) && (strchr(fname+1, ':') == NULL)) {
Tcl_ListObjAppendElement(interp, resultPtr,
Tcl_NewStringObj(fname+1, fnameLen-1));
} else {
Tcl_ListObjAppendElement(interp, resultPtr, pathPtr);
}
}
return TCL_OK;
} else {
char *fname;
int fnameLen, result = TCL_OK;
int baseLength;
CInfoPBRec pb;
OSErr err;
FSSpec dirSpec;
Boolean isDirectory;
long dirID;
short itemIndex;
Str255 fileName;
Tcl_DString fileString;
Tcl_DString dsOrig;
Tcl_DStringInit(&dsOrig);
Tcl_DStringAppend(&dsOrig, Tcl_GetString(fileNamePtr), -1);
baseLength = Tcl_DStringLength(&dsOrig);
Tcl_UtfToExternalDString(NULL, Tcl_DStringValue(&dsOrig),
Tcl_DStringLength(&dsOrig), &fileString);
err = FSpLocationFromPath(Tcl_DStringLength(&fileString),
Tcl_DStringValue(&fileString), &dirSpec);
Tcl_DStringFree(&fileString);
if (err == noErr) {
err = FSpGetDirectoryID(&dirSpec, &dirID, &isDirectory);
}
if ((err != noErr) || !isDirectory) {
Tcl_DStringFree(&dsOrig);
Tcl_DStringAppend(&dsOrig, ":", 1);
Tcl_DStringAppend(&dsOrig, Tcl_GetString(fileNamePtr), -1);
baseLength = Tcl_DStringLength(&dsOrig);
Tcl_UtfToExternalDString(NULL, Tcl_DStringValue(&dsOrig),
Tcl_DStringLength(&dsOrig), &fileString);
err = FSpLocationFromPath(Tcl_DStringLength(&fileString),
Tcl_DStringValue(&fileString), &dirSpec);
Tcl_DStringFree(&fileString);
if (err == noErr) {
err = FSpGetDirectoryID(&dirSpec, &dirID, &isDirectory);
}
if ((err != noErr) || !isDirectory) {
Tcl_DStringFree(&dsOrig);
return TCL_OK;
}
}
if (Tcl_DStringValue(&dsOrig)[baseLength-1] != ':') {
Tcl_DStringAppend(&dsOrig, ":", 1);
baseLength++;
}
pb.hFileInfo.ioVRefNum = dirSpec.vRefNum;
pb.hFileInfo.ioDirID = dirID;
pb.hFileInfo.ioNamePtr = (StringPtr) fileName;
pb.hFileInfo.ioFDirIndex = itemIndex = 1;
while (1) {
pb.hFileInfo.ioFDirIndex = itemIndex;
pb.hFileInfo.ioDirID = dirID;
err = PBGetCatInfoSync(&pb);
if (err != noErr) {
break;
}
Tcl_ExternalToUtfDString(NULL, (char *) fileName + 1, fileName[0],
&fileString);
if (Tcl_StringMatch(Tcl_DStringValue(&fileString), pattern)) {
Tcl_Obj *tempName;
Tcl_DStringSetLength(&dsOrig, baseLength);
Tcl_DStringAppend(&dsOrig, Tcl_DStringValue(&fileString), -1);
fname = Tcl_DStringValue(&dsOrig);
fnameLen = Tcl_DStringLength(&dsOrig);
tempName = Tcl_NewStringObj(fname, fnameLen);
Tcl_IncrRefCount(tempName);
if (NativeMatchType(tempName, types, pb.hFileInfo,
okType, okCreator)) {
if ((fnameLen > 1) && (strchr(fname+1, ':') == NULL)) {
Tcl_ListObjAppendElement(interp, resultPtr,
Tcl_NewStringObj(fname+1, fnameLen-1));
} else {
Tcl_ListObjAppendElement(interp, resultPtr, tempName);
}
}
Tcl_DecrRefCount(tempName);
}
Tcl_DStringFree(&fileString);
itemIndex++;
}
Tcl_DStringFree(&dsOrig);
return result;
}
}
static int
NativeMatchType(
Tcl_Obj *tempName,
Tcl_GlobTypeData *types,
HFileInfo fileInfo,
OSType okType,
OSType okCreator)
{
if (types == NULL) {
if (fileInfo.ioFlFndrInfo.fdFlags & kIsInvisible) {
return 0;
}
} else {
Tcl_StatBuf buf;
if (fileInfo.ioFlFndrInfo.fdFlags & kIsInvisible) {
if ((types->perm == 0) ||
!(types->perm & TCL_GLOB_PERM_HIDDEN)) {
return 0;
}
} else {
if (types->perm & TCL_GLOB_PERM_HIDDEN) {
return 0;
}
}
if (types->perm != 0) {
if (
((types->perm & TCL_GLOB_PERM_RONLY) &&
!(fileInfo.ioFlAttrib & 1)) ||
((types->perm & TCL_GLOB_PERM_R) &&
(TclpObjAccess(tempName, R_OK) != 0)) ||
((types->perm & TCL_GLOB_PERM_W) &&
(TclpObjAccess(tempName, W_OK) != 0)) ||
((types->perm & TCL_GLOB_PERM_X) &&
(TclpObjAccess(tempName, X_OK) != 0))
) {
return 0;
}
}
if (types->type != 0) {
if (TclpObjStat(tempName, &buf) != 0) {
return 0;
}
if (
((types->type & TCL_GLOB_TYPE_BLOCK) &&
S_ISBLK(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_CHAR) &&
S_ISCHR(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_DIR) &&
S_ISDIR(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_PIPE) &&
S_ISFIFO(buf.st_mode)) ||
((types->type & TCL_GLOB_TYPE_FILE) &&
S_ISREG(buf.st_mode))
#ifdef S_ISSOCK
|| ((types->type & TCL_GLOB_TYPE_SOCK) &&
S_ISSOCK(buf.st_mode))
#endif
) {
} else {
int typeOk = 0;
#ifdef S_ISLNK
if (types->type & TCL_GLOB_TYPE_LINK) {
if (TclpObjLstat(tempName, &buf) == 0) {
if (S_ISLNK(buf.st_mode)) {
typeOk = 1;
}
}
}
#endif
if (typeOk == 0) {
return 0;
}
}
}
if (((okType != 0) && (okType !=
fileInfo.ioFlFndrInfo.fdType)) ||
((okCreator != 0) && (okCreator !=
fileInfo.ioFlFndrInfo.fdCreator))) {
return 0;
}
}
return 1;
}
int
TclpObjAccess(pathPtr, mode)
Tcl_Obj *pathPtr;
int mode;
{
HFileInfo fpb;
HVolumeParam vpb;
OSErr err;
FSSpec fileSpec;
Boolean isDirectory;
long dirID;
int full_mode = 0;
err = FspLLocationFromFsPath(pathPtr, &fileSpec);
if (err != noErr) {
errno = TclMacOSErrorToPosixError(err);
return -1;
}
FSpGetDirectoryID(&fileSpec, &dirID, &isDirectory);
vpb.ioVRefNum = fpb.ioVRefNum = fileSpec.vRefNum;
vpb.ioNamePtr = fpb.ioNamePtr = fileSpec.name;
if (isDirectory) {
fpb.ioDirID = fileSpec.parID;
} else {
fpb.ioDirID = dirID;
}
fpb.ioFDirIndex = 0;
err = PBGetCatInfoSync((CInfoPBPtr)&fpb);
if (err == noErr) {
vpb.ioVolIndex = 0;
err = PBHGetVInfoSync((HParmBlkPtr)&vpb);
if (err == noErr) {
if (mode & W_OK) {
if ((vpb.ioVAtrb & 0x0080) || (vpb.ioVAtrb & 0x8000)) {
errno = EROFS;
return -1;
}
if (fpb.ioFlAttrib & 0x01) {
errno = EACCES;
return -1;
}
}
if (!(fpb.ioFlAttrib & 0x10) && (mode & X_OK)
&& (fpb.ioFlFndrInfo.fdType != 'APPL')) {
return -1;
}
}
}
if (err != noErr) {
errno = TclMacOSErrorToPosixError(err);
return -1;
}
return 0;
}
int
TclpObjChdir(pathPtr)
Tcl_Obj *pathPtr;
{
FSSpec spec;
OSErr err;
Boolean isFolder;
long dirID;
err = FspLocationFromFsPath(pathPtr, &spec);
if (err != noErr) {
errno = ENOENT;
return -1;
}
err = FSpGetDirectoryID(&spec, &dirID, &isFolder);
if (err != noErr) {
errno = ENOENT;
return -1;
}
if (isFolder != true) {
errno = ENOTDIR;
return -1;
}
err = FSpSetDefaultDir(&spec);
if (err != noErr) {
switch (err) {
case afpAccessDenied:
errno = EACCES;
break;
default:
errno = ENOENT;
}
return -1;
}
return 0;
}
Tcl_Obj*
TclpObjGetCwd(interp)
Tcl_Interp *interp;
{
Tcl_DString ds;
if (TclpGetCwd(interp, &ds) != NULL) {
Tcl_Obj *cwdPtr = Tcl_NewStringObj(Tcl_DStringValue(&ds), -1);
Tcl_IncrRefCount(cwdPtr);
Tcl_DStringFree(&ds);
return cwdPtr;
} else {
return NULL;
}
}
CONST char *
TclpGetCwd(
Tcl_Interp *interp,
Tcl_DString *bufferPtr)
{
FSSpec theSpec;
int length;
Handle pathHandle = NULL;
if (FSpGetDefaultDir(&theSpec) != noErr) {
if (interp != NULL) {
Tcl_SetResult(interp, "error getting working directory name",
TCL_STATIC);
}
return NULL;
}
if (FSpPathFromLocation(&theSpec, &length, &pathHandle) != noErr) {
if (interp != NULL) {
Tcl_SetResult(interp, "error getting working directory name",
TCL_STATIC);
}
return NULL;
}
HLock(pathHandle);
Tcl_ExternalToUtfDString(NULL, *pathHandle, length, bufferPtr);
HUnlock(pathHandle);
DisposeHandle(pathHandle);
return Tcl_DStringValue(bufferPtr);
}
char *
TclpReadlink(
CONST char *path,
Tcl_DString *linkPtr)
{
HFileInfo fpb;
OSErr err;
FSSpec fileSpec;
Boolean isDirectory;
Boolean wasAlias;
long dirID;
char fileName[257];
char *end;
Handle theString = NULL;
int pathSize;
Tcl_DString ds;
Tcl_UtfToExternalDString(NULL, path, -1, &ds);
while ((Tcl_DStringLength(&ds) != 0)
&& (Tcl_DStringValue(&ds)[Tcl_DStringLength(&ds) - 1] == ':')) {
Tcl_DStringSetLength(&ds, Tcl_DStringLength(&ds) - 1);
}
end = strrchr(Tcl_DStringValue(&ds), ':');
if (end == NULL ) {
strcpy(fileName + 1, Tcl_DStringValue(&ds));
} else {
strcpy(fileName + 1, end + 1);
Tcl_DStringSetLength(&ds, end + 1 - Tcl_DStringValue(&ds));
}
fileName[0] = (char) strlen(fileName + 1);
if (end != NULL) {
err = FSpLocationFromPath(Tcl_DStringLength(&ds),
Tcl_DStringValue(&ds), &fileSpec);
if (err != noErr) {
Tcl_DStringFree(&ds);
errno = EINVAL;
return NULL;
}
} else {
FSMakeFSSpecCompat(0, 0, NULL, &fileSpec);
}
Tcl_DStringFree(&ds);
FSpGetDirectoryID(&fileSpec, &dirID, &isDirectory);
fpb.ioVRefNum = fileSpec.vRefNum;
fpb.ioDirID = dirID;
fpb.ioNamePtr = (StringPtr) fileName;
fpb.ioFDirIndex = 0;
err = PBGetCatInfoSync((CInfoPBPtr)&fpb);
if (err != noErr) {
errno = TclMacOSErrorToPosixError(err);
return NULL;
} else {
if (fpb.ioFlAttrib & 0x10) {
errno = EINVAL;
return NULL;
} else {
if (fpb.ioFlFndrInfo.fdFlags & 0x8000) {
} else {
errno = EINVAL;
return NULL;
}
}
}
err = FSMakeFSSpecCompat(fileSpec.vRefNum, dirID, (StringPtr) fileName,
&fileSpec);
if (err == noErr) {
err = ResolveAliasFile(&fileSpec, true, &isDirectory, &wasAlias);
}
if ((err == fnfErr) || wasAlias) {
err = FSpPathFromLocation(&fileSpec, &pathSize, &theString);
if (err != noErr) {
DisposeHandle(theString);
errno = ENAMETOOLONG;
return NULL;
}
} else {
errno = EINVAL;
return NULL;
}
Tcl_ExternalToUtfDString(NULL, *theString, pathSize, linkPtr);
DisposeHandle(theString);
return Tcl_DStringValue(linkPtr);
}
static int
TclpObjStatAlias _ANSI_ARGS_((Tcl_Obj *pathPtr, Tcl_StatBuf *bufPtr,
Boolean resolveLink));
int
TclpObjLstat(pathPtr, buf)
Tcl_Obj *pathPtr;
Tcl_StatBuf *buf;
{
return TclpObjStatAlias(pathPtr, buf, FALSE);
}
int
TclpObjStat(pathPtr, bufPtr)
Tcl_Obj *pathPtr;
Tcl_StatBuf *bufPtr;
{
return TclpObjStatAlias(pathPtr, bufPtr, TRUE);
}
static int
TclpObjStatAlias (Tcl_Obj *pathPtr, Tcl_StatBuf *bufPtr, Boolean resolveLink)
{
HFileInfo fpb;
HVolumeParam vpb;
OSErr err;
FSSpec fileSpec;
Boolean isDirectory;
long dirID;
if (resolveLink)
err = FspLocationFromFsPath(pathPtr, &fileSpec);
else
err = FspLLocationFromFsPath(pathPtr, &fileSpec);
if (err != noErr) {
errno = TclMacOSErrorToPosixError(err);
return -1;
}
FSpGetDirectoryID(&fileSpec, &dirID, &isDirectory);
vpb.ioVRefNum = fpb.ioVRefNum = fileSpec.vRefNum;
vpb.ioNamePtr = fpb.ioNamePtr = fileSpec.name;
if (isDirectory) {
fpb.ioDirID = fileSpec.parID;
} else {
fpb.ioDirID = dirID;
}
fpb.ioFDirIndex = 0;
err = PBGetCatInfoSync((CInfoPBPtr)&fpb);
if (err == noErr) {
vpb.ioVolIndex = 0;
err = PBHGetVInfoSync((HParmBlkPtr)&vpb);
if (err == noErr && bufPtr != NULL) {
bufPtr->st_mode = S_IRUSR | S_IRGRP | S_IROTH;
if (fpb.ioFlAttrib & 0x10) {
bufPtr->st_mode |= S_IFDIR;
bufPtr->st_nlink = 2;
} else {
bufPtr->st_nlink = 1;
if (fpb.ioFlFndrInfo.fdFlags & 0x8000) {
bufPtr->st_mode |= S_IFLNK;
} else {
bufPtr->st_mode |= S_IFREG;
}
}
if ((fpb.ioFlAttrib & 0x10) || (fpb.ioFlFndrInfo.fdType == 'APPL')) {
bufPtr->st_mode |= S_IXUSR | S_IXGRP | S_IXOTH;
}
if ((fpb.ioFlAttrib & 0x01) == 0){
bufPtr->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
}
bufPtr->st_ino = fpb.ioDirID;
bufPtr->st_dev = fpb.ioVRefNum;
bufPtr->st_uid = -1;
bufPtr->st_gid = -1;
bufPtr->st_rdev = 0;
bufPtr->st_size = fpb.ioFlLgLen;
bufPtr->st_blksize = vpb.ioVAlBlkSiz;
bufPtr->st_blocks = (bufPtr->st_size + bufPtr->st_blksize - 1)
/ bufPtr->st_blksize;
bufPtr->st_atime = bufPtr->st_mtime = fpb.ioFlMdDat
- TclpGetGMTOffset() + tcl_mac_epoch_offset;
bufPtr->st_ctime = fpb.ioFlCrDat - TclpGetGMTOffset()
+ tcl_mac_epoch_offset;
}
}
if (err != noErr) {
errno = TclMacOSErrorToPosixError(err);
}
return (err == noErr ? 0 : -1);
}
Tcl_Pid
Tcl_WaitPid(
Tcl_Pid pid,
int *statPtr,
int options)
{
return (Tcl_Pid) -1;
}
#undef fopen
FILE *
TclMacFOpenHack(
CONST char *path,
CONST char *mode)
{
OSErr err;
FSSpec fileSpec;
Handle pathString = NULL;
int size;
FILE * f;
err = FSpLocationFromPath(strlen(path), path, &fileSpec);
if ((err != noErr) && (err != fnfErr)) {
return NULL;
}
err = FSpPathFromLocation(&fileSpec, &size, &pathString);
if ((err != noErr) && (err != fnfErr)) {
return NULL;
}
HLock(pathString);
f = fopen(*pathString, mode);
HUnlock(pathString);
DisposeHandle(pathString);
return f;
}
char *
TclpGetUserHome(name, bufferPtr)
CONST char *name;
Tcl_DString *bufferPtr;
{
return NULL;
}
int
TclMacOSErrorToPosixError(
int error)
{
switch (error) {
case noErr:
return 0;
case bdNamErr:
return ENAMETOOLONG;
case afpObjectTypeErr:
return ENOTDIR;
case fnfErr:
case dirNFErr:
return ENOENT;
case dupFNErr:
return EEXIST;
case dirFulErr:
case dskFulErr:
return ENOSPC;
case fBsyErr:
return EBUSY;
case tmfoErr:
return ENFILE;
case fLckdErr:
case permErr:
case afpAccessDenied:
return EACCES;
case wPrErr:
case vLckdErr:
return EROFS;
case badMovErr:
return EINVAL;
case diffVolErr:
return EXDEV;
default:
return EINVAL;
}
}
int
TclMacChmod(
CONST char *path,
int mode)
{
HParamBlockRec hpb;
OSErr err;
Str255 pathName;
strcpy((char *) pathName + 1, path);
pathName[0] = strlen(path);
hpb.fileParam.ioNamePtr = pathName;
hpb.fileParam.ioVRefNum = 0;
hpb.fileParam.ioDirID = 0;
if (mode & 0200) {
err = PBHRstFLockSync(&hpb);
} else {
err = PBHSetFLockSync(&hpb);
}
if (err != noErr) {
errno = TclMacOSErrorToPosixError(err);
return -1;
}
return 0;
}
Tcl_Obj*
TclpTempFileName()
{
char fileName[L_tmpnam];
if (tmpnam(fileName) == NULL) {
return NULL;
}
return TclpNativeToNormalized((ClientData) fileName);
}
#ifdef S_IFLNK
Tcl_Obj*
TclpObjLink(pathPtr, toPtr, linkAction)
Tcl_Obj *pathPtr;
Tcl_Obj *toPtr;
int linkAction;
{
Tcl_Obj* link = NULL;
if (toPtr != NULL) {
if (TclpObjAccess(pathPtr, F_OK) != -1) {
errno = EEXIST;
return NULL;
}
if (TclpObjAccess(toPtr, F_OK) == -1) {
errno = ENOENT;
return NULL;
}
if (linkAction & TCL_CREATE_SYMBOLIC_LINK) {
FSSpec spec;
FSSpec linkSpec;
OSErr err;
CONST char *path;
AliasHandle alias;
err = FspLocationFromFsPath(toPtr, &spec);
if (err != noErr) {
errno = ENOENT;
return NULL;
}
path = Tcl_FSGetNativePath(pathPtr);
err = FSpLocationFromPath(strlen(path), path, &linkSpec);
if (err == noErr) {
err = dupFNErr;
} else {
err = NewAlias(&spec, &linkSpec, &alias);
}
if (err != noErr) {
errno = TclMacOSErrorToPosixError(err);
return NULL;
}
return toPtr;
} else {
errno = ENODEV;
return NULL;
}
} else {
Tcl_DString ds;
Tcl_Obj *transPtr = Tcl_FSGetTranslatedPath(NULL, pathPtr);
if (transPtr == NULL) {
return NULL;
}
if (TclpReadlink(Tcl_GetString(transPtr), &ds) != NULL) {
link = Tcl_NewStringObj(Tcl_DStringValue(&ds), -1);
Tcl_IncrRefCount(link);
Tcl_DStringFree(&ds);
}
}
return link;
}
#endif
Tcl_Obj*
TclpFilesystemPathType(pathObjPtr)
Tcl_Obj* pathObjPtr;
{
return NULL;
}