/* 

 * tclMacChan.c

 *

 *	Channel drivers for Macintosh channels for the

 *	console fds.

 *

 * Copyright (c) 1996-1997 Sun Microsystems, Inc.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tclMacChan.c,v 1.21.2.1 2005/01/27 22:53:34 andreas_kupries Exp $

 */

#include "tclInt.h"

#include "tclPort.h"

#include "tclMacInt.h"

#include <Aliases.h>

#include <Errors.h>

#include <Files.h>

#include <Gestalt.h>

#include <Processes.h>

#include <Strings.h>

#include <FSpCompat.h>

#include <MoreFiles.h>

#include <MoreFilesExtras.h>

#include "tclIO.h"

#ifdef __MSL__

#include <unix.mac.h>

#define TCL_FILE_CREATOR (__getcreator(0))

#else

#define TCL_FILE_CREATOR 'MPW '

#endif

/*

 * This structure describes per-instance state of a 

 * macintosh file based channel.

 */

typedef struct FileState {

    short fileRef;		/* Macintosh file reference number. */

    Tcl_Channel fileChan;	/* Pointer to the channel for this file. */

    int watchMask;		/* OR'ed set of flags indicating which events

    				 * are being watched. */

    int appendMode;		/* Flag to tell if in O_APPEND mode or not. */

    int volumeRef;		/* Flag to tell if in O_APPEND mode or not. */

    int pending;		/* 1 if message is pending on queue. */

    struct FileState *nextPtr;	/* Pointer to next registered file. */

} FileState;

typedef struct ThreadSpecificData {

    int initialized;		/* True after the thread initializes */

    FileState *firstFilePtr;	/* the head of the list of files managed

				 * that are being watched for file events. */

    Tcl_Channel stdinChannel;

    Tcl_Channel stdoutChannel;	/* Note - these seem unused */

    Tcl_Channel stderrChannel;

} ThreadSpecificData;

static Tcl_ThreadDataKey dataKey;

/*

 * The following structure is what is added to the Tcl event queue when

 * file events are generated.

 */

typedef struct FileEvent {

    Tcl_Event header;		/* Information that is standard for

				 * all events. */

    FileState *infoPtr;		/* Pointer to file info structure.  Note

				 * that we still have to verify that the

				 * file exists before dereferencing this

				 * pointer. */

} FileEvent;

/*

 * Static routines for this file:

 */

static int		CommonGetHandle _ANSI_ARGS_((ClientData instanceData,

		            int direction, ClientData *handlePtr));

static void		CommonWatch _ANSI_ARGS_((ClientData instanceData,

		            int mask));

static int		FileBlockMode _ANSI_ARGS_((ClientData instanceData,

			    int mode));

static void		FileChannelExitHandler _ANSI_ARGS_((

		            ClientData clientData));

static void		FileCheckProc _ANSI_ARGS_((ClientData clientData,

			    int flags));

static int		FileClose _ANSI_ARGS_((ClientData instanceData,

			    Tcl_Interp *interp));

static int		FileEventProc _ANSI_ARGS_((Tcl_Event *evPtr,

			    int flags));

static ThreadSpecificData *FileInit _ANSI_ARGS_((void));

static int		FileInput _ANSI_ARGS_((ClientData instanceData,

			    char *buf, int toRead, int *errorCode));

static int		FileOutput _ANSI_ARGS_((ClientData instanceData,

			    CONST char *buf, int toWrite, int *errorCode));

static int		FileSeek _ANSI_ARGS_((ClientData instanceData,

			    long offset, int mode, int *errorCode));

static void		FileSetupProc _ANSI_ARGS_((ClientData clientData,

			    int flags));

static void             FileThreadActionProc _ANSI_ARGS_ ((

			   ClientData instanceData, int action));

static Tcl_Channel	OpenFileChannel _ANSI_ARGS_((CONST char *fileName, 

			    int mode, int permissions, int *errorCodePtr));

static int		StdIOBlockMode _ANSI_ARGS_((ClientData instanceData,

			    int mode));

static int		StdIOClose _ANSI_ARGS_((ClientData instanceData,

			    Tcl_Interp *interp));

static int		StdIOInput _ANSI_ARGS_((ClientData instanceData,

			    char *buf, int toRead, int *errorCode));

static int		StdIOOutput _ANSI_ARGS_((ClientData instanceData,

			    CONST char *buf, int toWrite, int *errorCode));

static int		StdIOSeek _ANSI_ARGS_((ClientData instanceData,

			    long offset, int mode, int *errorCode));

static int		StdReady _ANSI_ARGS_((ClientData instanceData,

		            int mask));

/*

 * This structure describes the channel type structure for file based IO:

 */

static Tcl_ChannelType consoleChannelType = {

    "file",			/* Type name. */

    TCL_CHANNEL_VERSION_4,	/* v4 channel */

    StdIOClose,			/* Close proc. */

    StdIOInput,			/* Input proc. */

    StdIOOutput,		/* Output proc. */

    StdIOSeek,			/* Seek proc. */

    NULL,			/* Set option proc. */

    NULL,			/* Get option proc. */

    CommonWatch,		/* Initialize notifier. */

    CommonGetHandle		/* Get OS handles out of channel. */

    NULL,			/* close2proc. */

    StdIOBlockMode,		/* Set blocking/nonblocking mode.*/

    NULL,			/* flush proc. */

    NULL,			/* handler proc. */

    NULL,			/* wide seek proc. */

    NULL,		        /* thread actions */

};

/*

 * This variable describes the channel type structure for file based IO.

 */

static Tcl_ChannelType fileChannelType = {

    "file",			/* Type name. */

    TCL_CHANNEL_VERSION_4,	/* v4 channel */

    FileClose,			/* Close proc. */

    FileInput,			/* Input proc. */

    FileOutput,			/* Output proc. */

    FileSeek,			/* Seek proc. */

    NULL,			/* Set option proc. */

    NULL,			/* Get option proc. */

    CommonWatch,		/* Initialize notifier. */

    CommonGetHandle		/* Get OS handles out of channel. */

    NULL,			/* close2proc. */

    FileBlockMode,		/* Set blocking/nonblocking mode.*/

    NULL,			/* flush proc. */

    NULL,			/* handler proc. */

    NULL,			/* wide seek proc. */

    FileThreadActionProc,       /* thread actions */

};

/*

 * Hack to allow Mac Tk to override the TclGetStdChannels function.

 */

typedef void (*TclGetStdChannelsProc) _ANSI_ARGS_((Tcl_Channel *stdinPtr,

	Tcl_Channel *stdoutPtr, Tcl_Channel *stderrPtr));

TclGetStdChannelsProc getStdChannelsProc = NULL;

/*

 *----------------------------------------------------------------------

 *

 * FileInit --

 *

 *	This function initializes the file channel event source.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Creates a new event source.

 *

 *----------------------------------------------------------------------

 */

static ThreadSpecificData *

FileInit()

{

    ThreadSpecificData *tsdPtr =

	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);

    if (tsdPtr == NULL) {

	tsdPtr = TCL_TSD_INIT(&dataKey);

	tsdPtr->firstFilePtr = NULL;

	Tcl_CreateEventSource(FileSetupProc, FileCheckProc, NULL);

	Tcl_CreateThreadExitHandler(FileChannelExitHandler, NULL);

    }

    return tsdPtr;

}

/*

 *----------------------------------------------------------------------

 *

 * FileChannelExitHandler --

 *

 *	This function is called to cleanup the channel driver before

 *	Tcl is unloaded.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Destroys the communication window.

 *

 *----------------------------------------------------------------------

 */

static void

FileChannelExitHandler(

    ClientData clientData)	/* Old window proc */

{

    Tcl_DeleteEventSource(FileSetupProc, FileCheckProc, NULL);

}

/*

 *----------------------------------------------------------------------

 *

 * FileSetupProc --

 *

 *	This procedure is invoked before Tcl_DoOneEvent blocks waiting

 *	for an event.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Adjusts the block time if needed.

 *

 *----------------------------------------------------------------------

 */

void

FileSetupProc(

    ClientData data,		/* Not used. */

    int flags)			/* Event flags as passed to Tcl_DoOneEvent. */

{

    FileState *infoPtr;

    Tcl_Time blockTime = { 0, 0 };

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    if (!(flags & TCL_FILE_EVENTS)) {

	return;

    }

    /*

     * Check to see if there is a ready file.  If so, poll.

     */

    for (infoPtr = tsdPtr->firstFilePtr; infoPtr != NULL; 

	    infoPtr = infoPtr->nextPtr) {

	if (infoPtr->watchMask) {

	    Tcl_SetMaxBlockTime(&blockTime);

	    break;

	}

    }

}

/*

 *----------------------------------------------------------------------

 *

 * FileCheckProc --

 *

 *	This procedure is called by Tcl_DoOneEvent to check the file

 *	event source for events. 

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	May queue an event.

 *

 *----------------------------------------------------------------------

 */

static void

FileCheckProc(

    ClientData data,		/* Not used. */

    int flags)			/* Event flags as passed to Tcl_DoOneEvent. */

{

    FileEvent *evPtr;

    FileState *infoPtr;

    int sentMsg = 0;

    Tcl_Time blockTime = { 0, 0 };

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    if (!(flags & TCL_FILE_EVENTS)) {

	return;

    }

    /*

     * Queue events for any ready files that don't already have events

     * queued (caused by persistent states that won't generate WinSock

     * events).

     */

    for (infoPtr = tsdPtr->firstFilePtr; infoPtr != NULL; 

	    infoPtr = infoPtr->nextPtr) {

	if (infoPtr->watchMask && !infoPtr->pending) {

	    infoPtr->pending = 1;

	    evPtr = (FileEvent *) ckalloc(sizeof(FileEvent));

	    evPtr->header.proc = FileEventProc;

	    evPtr->infoPtr = infoPtr;

	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);

	}

    }

}

/*----------------------------------------------------------------------

 *

 * FileEventProc --

 *

 *	This function is invoked by Tcl_ServiceEvent when a file event

 *	reaches the front of the event queue.  This procedure invokes

 *	Tcl_NotifyChannel on the file.

 *

 * Results:

 *	Returns 1 if the event was handled, meaning it should be removed

 *	from the queue.  Returns 0 if the event was not handled, meaning

 *	it should stay on the queue.  The only time the event isn't

 *	handled is if the TCL_FILE_EVENTS flag bit isn't set.

 *

 * Side effects:

 *	Whatever the notifier callback does.

 *

 *----------------------------------------------------------------------

 */

static int

FileEventProc(

    Tcl_Event *evPtr,		/* Event to service. */

    int flags)			/* Flags that indicate what events to

				 * handle, such as TCL_FILE_EVENTS. */

{

    FileEvent *fileEvPtr = (FileEvent *)evPtr;

    FileState *infoPtr;

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    if (!(flags & TCL_FILE_EVENTS)) {

	return 0;

    }

    /*

     * Search through the list of watched files for the one whose handle

     * matches the event.  We do this rather than simply dereferencing

     * the handle in the event so that files can be deleted while the

     * event is in the queue.

     */

    for (infoPtr = tsdPtr->firstFilePtr; infoPtr != NULL; 

	    infoPtr = infoPtr->nextPtr) {

	if (fileEvPtr->infoPtr == infoPtr) {

	    infoPtr->pending = 0;

	    Tcl_NotifyChannel(infoPtr->fileChan, infoPtr->watchMask);

	    break;

	}

    }

    return 1;

}

/*

 *----------------------------------------------------------------------

 *

 * StdIOBlockMode --

 *

 *	Set blocking or non-blocking mode on channel.

 *

 * Results:

 *	0 if successful, errno when failed.

 *

 * Side effects:

 *	Sets the device into blocking or non-blocking mode.

 *

 *----------------------------------------------------------------------

 */

static int

StdIOBlockMode(

    ClientData instanceData,		/* Unused. */

    int mode)				/* The mode to set. */

{

    /*

     * Do not allow putting stdin, stdout or stderr into nonblocking mode.

     */

    if (mode == TCL_MODE_NONBLOCKING) {

	return EFAULT;

    }

    return 0;

}

/*

 *----------------------------------------------------------------------

 *

 * StdIOClose --

 *

 *	Closes the IO channel.

 *

 * Results:

 *	0 if successful, the value of errno if failed.

 *

 * Side effects:

 *	Closes the physical channel

 *

 *----------------------------------------------------------------------

 */

static int

StdIOClose(

    ClientData instanceData,	/* Unused. */

    Tcl_Interp *interp)		/* Unused. */

{

    int fd, errorCode = 0;

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    /*

     * Invalidate the stdio cache if necessary.  Note that we assume that

     * the stdio file and channel pointers will become invalid at the same

     * time.

     * Do not close standard channels while in thread-exit.

     */

    fd = (int) ((FileState*)instanceData)->fileRef;

    if (!TclInThreadExit()) {

	if (fd == 0) {

	    tsdPtr->stdinChannel = NULL;

	} else if (fd == 1) {

	    tsdPtr->stdoutChannel = NULL;

	} else if (fd == 2) {

	    tsdPtr->stderrChannel = NULL;

	} else {

	    panic("recieved invalid std file");

	}

	if (close(fd) < 0) {

	    errorCode = errno;

	}

    }

    return errorCode;

}

/*

 *----------------------------------------------------------------------

 *

 * CommonGetHandle --

 *

 *	Called from Tcl_GetChannelHandle to retrieve OS handles from inside

 *	a file based channel.

 *

 * Results:

 *	The appropriate handle or NULL if not present. 

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

static int

CommonGetHandle(

    ClientData instanceData,		/* The file state. */

    int direction,			/* Which handle to retrieve? */

    ClientData *handlePtr)

{

    if ((direction == TCL_READABLE) || (direction == TCL_WRITABLE)) {

	*handlePtr = (ClientData) ((FileState*)instanceData)->fileRef;

	return TCL_OK;

    }

    return TCL_ERROR;

}

/*

 *----------------------------------------------------------------------

 *

 * StdIOInput --

 *

 *	Reads input from the IO channel into the buffer given. Returns

 *	count of how many bytes were actually read, and an error indication.

 *

 * Results:

 *	A count of how many bytes were read is returned and an error

 *	indication is returned in an output argument.

 *

 * Side effects:

 *	Reads input from the actual channel.

 *

 *----------------------------------------------------------------------

 */

int

StdIOInput(

    ClientData instanceData,		/* Unused. */

    char *buf,				/* Where to store data read. */

    int bufSize,			/* How much space is available

                                         * in the buffer? */

    int *errorCode)			/* Where to store error code. */

{

    int fd;

    int bytesRead;			/* How many bytes were read? */

    *errorCode = 0;

    errno = 0;

    fd = (int) ((FileState*)instanceData)->fileRef;

    bytesRead = read(fd, buf, (size_t) bufSize);

    if (bytesRead > -1) {

        return bytesRead;

    }

    *errorCode = errno;

    return -1;

}

/*

 *----------------------------------------------------------------------

 *

 * StdIOOutput--

 *

 *	Writes the given output on the IO channel. Returns count of how

 *	many characters were actually written, and an error indication.

 *

 * Results:

 *	A count of how many characters were written is returned and an

 *	error indication is returned in an output argument.

 *

 * Side effects:

 *	Writes output on the actual channel.

 *

 *----------------------------------------------------------------------

 */

static int

StdIOOutput(

    ClientData instanceData,		/* Unused. */

    CONST char *buf,			/* The data buffer. */

    int toWrite,			/* How many bytes to write? */

    int *errorCode)			/* Where to store error code. */

{

    int written;

    int fd;

    *errorCode = 0;

    errno = 0;

    fd = (int) ((FileState*)instanceData)->fileRef;

    written = write(fd, (void*)buf, (size_t) toWrite);

    if (written > -1) {

        return written;

    }

    *errorCode = errno;

    return -1;

}

/*

 *----------------------------------------------------------------------

 *

 * StdIOSeek --

 *

 *	Seeks on an IO channel. Returns the new position.

 *

 * Results:

 *	-1 if failed, the new position if successful. If failed, it

 *	also sets *errorCodePtr to the error code.

 *

 * Side effects:

 *	Moves the location at which the channel will be accessed in

 *	future operations.

 *

 *----------------------------------------------------------------------

 */

static int

StdIOSeek(

    ClientData instanceData,	/* Unused. */

    long offset,		/* Offset to seek to. */

    int mode,			/* Relative to where should we seek? */

    int *errorCodePtr)		/* To store error code. */

{

    int newLoc;

    int fd;

    *errorCodePtr = 0;

    fd = (int) ((FileState*)instanceData)->fileRef;

    newLoc = lseek(fd, offset, mode);

    if (newLoc > -1) {

        return newLoc;

    }

    *errorCodePtr = errno;

    return -1;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_PidObjCmd --

 *

 *      This procedure is invoked to process the "pid" Tcl command.

 *      See the user documentation for details on what it does.

 *

 * Results:

 *      A standard Tcl result.

 *

 * Side effects:

 *      See the user documentation.

 *

 *----------------------------------------------------------------------

 */

        /* ARGSUSED */

int

Tcl_PidObjCmd(dummy, interp, objc, objv)

    ClientData dummy;           /* Not used. */

    Tcl_Interp *interp;         /* Current interpreter. */

    int objc;                   /* Number of arguments. */

    Tcl_Obj *CONST *objv;       /* Argument strings. */

{

    ProcessSerialNumber psn;

    char buf[20]; 

    Tcl_Channel chan;

    Tcl_Obj *resultPtr;

    if (objc > 2) {

        Tcl_WrongNumArgs(interp, 1, objv, "?channelId?");

        return TCL_ERROR;

    }

    if (objc == 1) {

        resultPtr = Tcl_GetObjResult(interp);

	GetCurrentProcess(&psn);

	sprintf(buf, "0x%08x%08x", psn.highLongOfPSN, psn.lowLongOfPSN);

        Tcl_SetStringObj(resultPtr, buf, -1);

    } else {

        chan = Tcl_GetChannel(interp, Tcl_GetString(objv[1]),

                NULL);

        if (chan == (Tcl_Channel) NULL) {

            return TCL_ERROR;

        } 

	/*

	 * We can't create pipelines on the Mac so

	 * this will always return an empty list.

	 */

    }

    return TCL_OK;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpGetDefaultStdChannel --

 *

 *	Constructs a channel for the specified standard OS handle.

 *

 * Results:

 *	Returns the specified default standard channel, or NULL.

 *

 * Side effects:

 *	May cause the creation of a standard channel and the underlying

 *	file.

 *

 *----------------------------------------------------------------------

 */

Tcl_Channel

TclpGetDefaultStdChannel(

    int type)			/* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */

{

    Tcl_Channel channel = NULL;

    int fd = 0;			/* Initializations needed to prevent */

    int mode = 0;		/* compiler warning (used before set). */

    char *bufMode = NULL;

    char channelName[16 + TCL_INTEGER_SPACE];

    int channelPermissions;

    FileState *fileState;

    /*

     * If the channels were not created yet, create them now and

     * store them in the static variables.

     */

    switch (type) {

	case TCL_STDIN:

	    fd = 0;

	    channelPermissions = TCL_READABLE;

	    bufMode = "line";

	    break;

	case TCL_STDOUT:

	    fd = 1;

	    channelPermissions = TCL_WRITABLE;

	    bufMode = "line";

	    break;

	case TCL_STDERR:

	    fd = 2;

	    channelPermissions = TCL_WRITABLE;

	    bufMode = "none";

	    break;

	default:

	    panic("TclGetDefaultStdChannel: Unexpected channel type");

	    break;

    }

    sprintf(channelName, "console%d", (int) fd);

    fileState = (FileState *) ckalloc((unsigned) sizeof(FileState));

    channel = Tcl_CreateChannel(&consoleChannelType, channelName,

	    (ClientData) fileState, channelPermissions);

    fileState->fileChan = channel;

    fileState->fileRef = fd;

    /*

     * Set up the normal channel options for stdio handles.

     */

    Tcl_SetChannelOption(NULL, channel, "-translation", "cr");

    Tcl_SetChannelOption(NULL, channel, "-buffering", bufMode);

    return channel;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpOpenFileChannel --

 *

 *	Open a File based channel on MacOS systems.

 *

 * Results:

 *	The new channel or NULL. If NULL, the output argument

 *	errorCodePtr is set to a POSIX error.

 *

 * Side effects:

 *	May open the channel and may cause creation of a file on the

 *	file system.

 *

 *----------------------------------------------------------------------

 */

Tcl_Channel

TclpOpenFileChannel(

    Tcl_Interp *interp,			/* Interpreter for error reporting;

                                         * can be NULL. */

    Tcl_Obj *pathPtr,			/* Name of file to open. */

    int mode,				/* POSIX open mode. */

    int permissions)			/* If the open involves creating a

                                         * file, with what modes to create

                                         * it? */

{

    Tcl_Channel chan;

    CONST char *native;

    int errorCode;

    native = Tcl_FSGetNativePath(pathPtr);

    if (native == NULL) {

	return NULL;

    }

    chan = OpenFileChannel(native, mode, permissions, &errorCode);

    if (chan == NULL) {

	Tcl_SetErrno(errorCode);

	if (interp != (Tcl_Interp *) NULL) {

            Tcl_AppendResult(interp, "couldn't open \"", 

			     Tcl_GetString(pathPtr), "\": ",

			     Tcl_PosixError(interp), (char *) NULL);

        }

	return NULL;

    }

    return chan;

}

/*

 *----------------------------------------------------------------------

 *

 * OpenFileChannel--

 *

 *	Opens a Macintosh file and creates a Tcl channel to control it.

 *

 * Results:

 *	A Tcl channel.

 *

 * Side effects:

 *	Will open a Macintosh file.

 *

 *----------------------------------------------------------------------

 */

static Tcl_Channel

OpenFileChannel(

    CONST char *fileName,		/* Name of file to open (native). */

    int mode,				/* Mode for opening file. */

    int permissions,			/* If the open involves creating a

                                         * file, with what modes to create

                                         * it? */

    int *errorCodePtr)			/* Where to store error code. */

{

    int channelPermissions;

    Tcl_Channel chan;

    char macPermision;

    FSSpec fileSpec;

    OSErr err;

    short fileRef;

    FileState *fileState;

    char channelName[16 + TCL_INTEGER_SPACE];

    ThreadSpecificData *tsdPtr;

    tsdPtr = FileInit();

    /*

     * Note we use fsRdWrShPerm instead of fsRdWrPerm which allows shared

     * writes on a file.  This isn't common on a mac but is common with 

     * Windows and UNIX and the feature is used by Tcl.

     */

    switch (mode & (O_RDONLY | O_WRONLY | O_RDWR)) {

	case O_RDWR:

	    channelPermissions = (TCL_READABLE | TCL_WRITABLE);

	    macPermision = fsRdWrShPerm;

	    break;

	case O_WRONLY:

	    /*

	     * Mac's fsRdPerm permission actually defaults to fsRdWrPerm because

	     * the Mac OS doesn't realy support write only access.  We explicitly

	     * set the permission fsRdWrShPerm so that we can have shared write

	     * access.

	     */

	    channelPermissions = TCL_WRITABLE;

	    macPermision = fsRdWrShPerm;

	    break;

	case O_RDONLY:

	default:

	    channelPermissions = TCL_READABLE;

	    macPermision = fsRdPerm;

	    break;

    }

    err = FSpLocationFromPath(strlen(fileName), fileName, &fileSpec);

    if ((err != noErr) && (err != fnfErr)) {

	*errorCodePtr = errno = TclMacOSErrorToPosixError(err);

	Tcl_SetErrno(errno);

	return NULL;

    }

    if ((err == fnfErr) && (mode & O_CREAT)) {

	err = HCreate(fileSpec.vRefNum, fileSpec.parID, fileSpec.name, TCL_FILE_CREATOR, 'TEXT');

	if (err != noErr) {

	    *errorCodePtr = errno = TclMacOSErrorToPosixError(err);

	    Tcl_SetErrno(errno);

	    return NULL;

	}

    } else if ((mode & O_CREAT) && (mode & O_EXCL)) {

        *errorCodePtr = errno = EEXIST;

	Tcl_SetErrno(errno);

        return NULL;

    }

    err = HOpenDF(fileSpec.vRefNum, fileSpec.parID, fileSpec.name, macPermision, &fileRef);

    if (err != noErr) {

	*errorCodePtr = errno = TclMacOSErrorToPosixError(err);

	Tcl_SetErrno(errno);

	return NULL;

    }

    if (mode & O_TRUNC) {

	SetEOF(fileRef, 0);

    }

    sprintf(channelName, "file%d", (int) fileRef);

    fileState = (FileState *) ckalloc((unsigned) sizeof(FileState));

    chan = Tcl_CreateChannel(&fileChannelType, channelName, 

	(ClientData) fileState, channelPermissions);

    if (chan == (Tcl_Channel) NULL) {

	*errorCodePtr = errno = EFAULT;

	Tcl_SetErrno(errno);

	FSClose(fileRef);

	ckfree((char *) fileState);

        return NULL;

    }

    fileState->fileChan = chan;

    fileState->nextPtr = tsdPtr->firstFilePtr;

    tsdPtr->firstFilePtr = fileState;

    fileState->volumeRef = fileSpec.vRefNum;

    fileState->fileRef = fileRef;

    fileState->pending = 0;

    fileState->watchMask = 0;

    if (mode & O_APPEND) {

	fileState->appendMode = true;

    } else {

	fileState->appendMode = false;

    }

    if ((mode & O_APPEND) || (mode & O_APPEND)) {

        if (Tcl_Seek(chan, 0, SEEK_END) < 0) {

	    *errorCodePtr = errno = EFAULT;

	    Tcl_SetErrno(errno);

            Tcl_Close(NULL, chan);

            FSClose(fileRef);

            ckfree((char *) fileState);

            return NULL;

        }

    }

    return chan;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_MakeFileChannel --

 *

 *	Makes a Tcl_Channel from an existing OS level file handle.

 *

 * Results:

 *	The Tcl_Channel created around the preexisting OS level file handle.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

Tcl_Channel

Tcl_MakeFileChannel(handle, mode)

    ClientData handle;		/* OS level handle. */

    int mode;			/* ORed combination of TCL_READABLE and

                                 * TCL_WRITABLE to indicate file mode. */

{

    /*

     * Not implemented yet.

     */

    return NULL;

}

/*

 *----------------------------------------------------------------------

 *

 * FileBlockMode --

 *

 *	Set blocking or non-blocking mode on channel.  Macintosh files

 *	can never really be set to blocking or non-blocking modes.

 *	However, we don't generate an error - we just return success.

 *

 * Results:

 *	0 if successful, errno when failed.

 *

 * Side effects:

 *	Sets the device into blocking or non-blocking mode.

 *

 *----------------------------------------------------------------------

 */

static int

FileBlockMode(

    ClientData instanceData,		/* Unused. */

    int mode)				/* The mode to set. */

{

    return 0;

}

/*

 *----------------------------------------------------------------------

 *

 * FileClose --

 *

 *	Closes the IO channel.

 *

 * Results:

 *	0 if successful, the value of errno if failed.

 *

 * Side effects:

 *	Closes the physical channel

 *

 *----------------------------------------------------------------------

 */

static int

FileClose(

    ClientData instanceData,	/* Unused. */

    Tcl_Interp *interp)		/* Unused. */

{