Logo Search packages:      
Sourcecode: tcl8.4 version File versions  Download package

tclMacChan.c

/* 
 * 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. */
{
    FileState *fileState = (FileState *) instanceData;
    int errorCode = 0;
    OSErr err;

    err = FSClose(fileState->fileRef);
    FlushVol(NULL, fileState->volumeRef);
    if (err != noErr) {
      errorCode = errno = TclMacOSErrorToPosixError(err);
      panic("error during file close");
    }

    ckfree((char *) fileState);
    Tcl_SetErrno(errorCode);
    return errorCode;
}

/*
 *----------------------------------------------------------------------
 *
 * FileInput --
 *
 *    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
FileInput(
    ClientData instanceData,  /* Unused. */
    char *buffer,                   /* Where to store data read. */
    int bufSize,                    /* How much space is available
                                 * in the buffer? */
    int *errorCodePtr)              /* Where to store error code. */
{
    FileState *fileState = (FileState *) instanceData;
    OSErr err;
    long length = bufSize;

    *errorCodePtr = 0;
    errno = 0;
    err = FSRead(fileState->fileRef, &length, buffer);
    if ((err == noErr) || (err == eofErr)) {
      return length;
    } else {
      switch (err) {
          case ioErr:
            *errorCodePtr = errno = EIO;
          case afpAccessDenied:
            *errorCodePtr = errno = EACCES;
          default:
            *errorCodePtr = errno = EINVAL;
      }
        return -1;      
    }
    *errorCodePtr = errno;
    return -1;
}

/*
 *----------------------------------------------------------------------
 *
 * FileOutput--
 *
 *    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
FileOutput(
    ClientData instanceData,        /* Unused. */
    CONST char *buffer,             /* The data buffer. */
    int toWrite,              /* How many bytes to write? */
    int *errorCodePtr)              /* Where to store error code. */
{
    FileState *fileState = (FileState *) instanceData;
    long length = toWrite;
    OSErr err;

    *errorCodePtr = 0;
    errno = 0;
    
    if (fileState->appendMode == true) {
      FileSeek(instanceData, 0, SEEK_END, errorCodePtr);
      *errorCodePtr = 0;
    }
    
    err = FSWrite(fileState->fileRef, &length, buffer);
    if (err == noErr) {
      err = FlushFile(fileState->fileRef);
    } else {
      *errorCodePtr = errno = TclMacOSErrorToPosixError(err);
      return -1;
    }
    return length;
}

/*
 *----------------------------------------------------------------------
 *
 * FileSeek --
 *
 *    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
FileSeek(
    ClientData instanceData,  /* Unused. */
    long offset,        /* Offset to seek to. */
    int mode,                 /* Relative to where should we seek? */
    int *errorCodePtr)        /* To store error code. */
{
    FileState *fileState = (FileState *) instanceData;
    IOParam pb;
    OSErr err;

    *errorCodePtr = 0;
    pb.ioCompletion = NULL;
    pb.ioRefNum = fileState->fileRef;
    if (mode == SEEK_SET) {
      pb.ioPosMode = fsFromStart;
    } else if (mode == SEEK_END) {
      pb.ioPosMode = fsFromLEOF;
    } else if (mode == SEEK_CUR) {
      err = PBGetFPosSync((ParmBlkPtr) &pb);
      if (pb.ioResult == noErr) {
          if (offset == 0) {
            return pb.ioPosOffset;
          }
          offset += pb.ioPosOffset;
      }
      pb.ioPosMode = fsFromStart;
    }
    pb.ioPosOffset = offset;
    err = PBSetFPosSync((ParmBlkPtr) &pb);
    if (pb.ioResult == noErr){
      return pb.ioPosOffset;
    } else if (pb.ioResult == eofErr) {
      long currentEOF, newEOF;
      long buffer, i, length;
      
      err = PBGetEOFSync((ParmBlkPtr) &pb);
      currentEOF = (long) pb.ioMisc;
      if (mode == SEEK_SET) {
          newEOF = offset;
      } else if (mode == SEEK_END) {
          newEOF = offset + currentEOF;
      } else if (mode == SEEK_CUR) {
          err = PBGetFPosSync((ParmBlkPtr) &pb);
          newEOF = offset + pb.ioPosOffset;
      }
      
      /*
       * Write 0's to the new EOF.
       */
      pb.ioPosOffset = 0;
      pb.ioPosMode = fsFromLEOF;
      err = PBGetFPosSync((ParmBlkPtr) &pb);
      length = 1;
      buffer = 0;
      for (i = 0; i < (newEOF - currentEOF); i++) {
          err = FSWrite(fileState->fileRef, &length, &buffer);
      }
      err = PBGetFPosSync((ParmBlkPtr) &pb);
      if (pb.ioResult == noErr){
          return pb.ioPosOffset;
      }
    }
    *errorCodePtr = errno = TclMacOSErrorToPosixError(err);
    return -1;
}

/*
 *----------------------------------------------------------------------
 *
 * CommonWatch --
 *
 *    Initialize the notifier to watch handles from this channel.
 *
 * Results:
 *    None.
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

static void
CommonWatch(
    ClientData instanceData,        /* The file state. */
    int mask)                       /* Events of interest; an OR-ed
                                         * combination of TCL_READABLE,
                                         * TCL_WRITABLE and TCL_EXCEPTION. */
{
    FileState *infoPtr = (FileState *) instanceData;
    Tcl_Time blockTime = { 0, 0 };

    infoPtr->watchMask = mask;
    if (infoPtr->watchMask) {
      Tcl_SetMaxBlockTime(&blockTime);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * FileThreadActionProc --
 *
 *    Insert or remove any thread local refs to this channel.
 *
 * Results:
 *    None.
 *
 * Side effects:
 *    Changes thread local list of valid channels.
 *
 *----------------------------------------------------------------------
 */

static void
FileThreadActionProc (instanceData, action)
     ClientData instanceData;
     int action;
{
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    FileState *infoPtr = (FileState *) instanceData;

    if (action == TCL_CHANNEL_THREAD_INSERT) {
      infoPtr->nextPtr = tsdPtr->firstFilePtr;
      tsdPtr->firstFilePtr = infoPtr;
    } else {
      FileState **nextPtrPtr;
      int removed = 0;

      for (nextPtrPtr = &(tsdPtr->firstFilePtr); (*nextPtrPtr) != NULL;
           nextPtrPtr = &((*nextPtrPtr)->nextPtr)) {
          if ((*nextPtrPtr) == infoPtr) {
              (*nextPtrPtr) = infoPtr->nextPtr;
            removed = 1;
            break;
          }
      }

      /*
       * This could happen if the channel was created in one thread
       * and then moved to another without updating the thread
       * local data in each thread.
       */

      if (!removed) {
          panic("file info ptr not on thread channel list");
      }
    }
}

Generated by  Doxygen 1.6.0   Back to index