/*
|
/*
|
* tclIO.c --
|
* tclIO.c --
|
*
|
*
|
* This file provides the generic portions (those that are the same on
|
* This file provides the generic portions (those that are the same on
|
* all platforms and for all channel types) of Tcl's IO facilities.
|
* all platforms and for all channel types) of Tcl's IO facilities.
|
*
|
*
|
* Copyright (c) 1998 Scriptics Corporation
|
* Copyright (c) 1998 Scriptics Corporation
|
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
|
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
|
*
|
*
|
* See the file "license.terms" for information on usage and redistribution
|
* See the file "license.terms" for information on usage and redistribution
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
*
|
*
|
* RCS: @(#) $Id: tclIO.c,v 1.1.1.1 2002-01-16 10:25:27 markom Exp $
|
* RCS: @(#) $Id: tclIO.c,v 1.1.1.1 2002-01-16 10:25:27 markom Exp $
|
*/
|
*/
|
|
|
#include "tclInt.h"
|
#include "tclInt.h"
|
#include "tclPort.h"
|
#include "tclPort.h"
|
|
|
/*
|
/*
|
* Make sure that both EAGAIN and EWOULDBLOCK are defined. This does not
|
* Make sure that both EAGAIN and EWOULDBLOCK are defined. This does not
|
* compile on systems where neither is defined. We want both defined so
|
* compile on systems where neither is defined. We want both defined so
|
* that we can test safely for both. In the code we still have to test for
|
* that we can test safely for both. In the code we still have to test for
|
* both because there may be systems on which both are defined and have
|
* both because there may be systems on which both are defined and have
|
* different values.
|
* different values.
|
*/
|
*/
|
|
|
#if ((!defined(EWOULDBLOCK)) && (defined(EAGAIN)))
|
#if ((!defined(EWOULDBLOCK)) && (defined(EAGAIN)))
|
# define EWOULDBLOCK EAGAIN
|
# define EWOULDBLOCK EAGAIN
|
#endif
|
#endif
|
#if ((!defined(EAGAIN)) && (defined(EWOULDBLOCK)))
|
#if ((!defined(EAGAIN)) && (defined(EWOULDBLOCK)))
|
# define EAGAIN EWOULDBLOCK
|
# define EAGAIN EWOULDBLOCK
|
#endif
|
#endif
|
#if ((!defined(EAGAIN)) && (!defined(EWOULDBLOCK)))
|
#if ((!defined(EAGAIN)) && (!defined(EWOULDBLOCK)))
|
error one of EWOULDBLOCK or EAGAIN must be defined
|
error one of EWOULDBLOCK or EAGAIN must be defined
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* The following structure encapsulates the state for a background channel
|
* The following structure encapsulates the state for a background channel
|
* copy. Note that the data buffer for the copy will be appended to this
|
* copy. Note that the data buffer for the copy will be appended to this
|
* structure.
|
* structure.
|
*/
|
*/
|
|
|
typedef struct CopyState {
|
typedef struct CopyState {
|
struct Channel *readPtr; /* Pointer to input channel. */
|
struct Channel *readPtr; /* Pointer to input channel. */
|
struct Channel *writePtr; /* Pointer to output channel. */
|
struct Channel *writePtr; /* Pointer to output channel. */
|
int readFlags; /* Original read channel flags. */
|
int readFlags; /* Original read channel flags. */
|
int writeFlags; /* Original write channel flags. */
|
int writeFlags; /* Original write channel flags. */
|
int toRead; /* Number of bytes to copy, or -1. */
|
int toRead; /* Number of bytes to copy, or -1. */
|
int total; /* Total bytes transferred (written). */
|
int total; /* Total bytes transferred (written). */
|
Tcl_Interp *interp; /* Interp that started the copy. */
|
Tcl_Interp *interp; /* Interp that started the copy. */
|
Tcl_Obj *cmdPtr; /* Command to be invoked at completion. */
|
Tcl_Obj *cmdPtr; /* Command to be invoked at completion. */
|
int bufSize; /* Size of appended buffer. */
|
int bufSize; /* Size of appended buffer. */
|
char buffer[1]; /* Copy buffer, this must be the last
|
char buffer[1]; /* Copy buffer, this must be the last
|
* field. */
|
* field. */
|
} CopyState;
|
} CopyState;
|
|
|
/*
|
/*
|
* struct ChannelBuffer:
|
* struct ChannelBuffer:
|
*
|
*
|
* Buffers data being sent to or from a channel.
|
* Buffers data being sent to or from a channel.
|
*/
|
*/
|
|
|
typedef struct ChannelBuffer {
|
typedef struct ChannelBuffer {
|
int nextAdded; /* The next position into which a character
|
int nextAdded; /* The next position into which a character
|
* will be put in the buffer. */
|
* will be put in the buffer. */
|
int nextRemoved; /* Position of next byte to be removed
|
int nextRemoved; /* Position of next byte to be removed
|
* from the buffer. */
|
* from the buffer. */
|
int bufSize; /* How big is the buffer? */
|
int bufSize; /* How big is the buffer? */
|
struct ChannelBuffer *nextPtr;
|
struct ChannelBuffer *nextPtr;
|
/* Next buffer in chain. */
|
/* Next buffer in chain. */
|
char buf[4]; /* Placeholder for real buffer. The real
|
char buf[4]; /* Placeholder for real buffer. The real
|
* buffer occuppies this space + bufSize-4
|
* buffer occuppies this space + bufSize-4
|
* bytes. This must be the last field in
|
* bytes. This must be the last field in
|
* the structure. */
|
* the structure. */
|
} ChannelBuffer;
|
} ChannelBuffer;
|
|
|
#define CHANNELBUFFER_HEADER_SIZE (sizeof(ChannelBuffer) - 4)
|
#define CHANNELBUFFER_HEADER_SIZE (sizeof(ChannelBuffer) - 4)
|
|
|
/*
|
/*
|
* The following defines the *default* buffer size for channels.
|
* The following defines the *default* buffer size for channels.
|
*/
|
*/
|
|
|
#define CHANNELBUFFER_DEFAULT_SIZE (1024 * 4)
|
#define CHANNELBUFFER_DEFAULT_SIZE (1024 * 4)
|
|
|
/*
|
/*
|
* Structure to record a close callback. One such record exists for
|
* Structure to record a close callback. One such record exists for
|
* each close callback registered for a channel.
|
* each close callback registered for a channel.
|
*/
|
*/
|
|
|
typedef struct CloseCallback {
|
typedef struct CloseCallback {
|
Tcl_CloseProc *proc; /* The procedure to call. */
|
Tcl_CloseProc *proc; /* The procedure to call. */
|
ClientData clientData; /* Arbitrary one-word data to pass
|
ClientData clientData; /* Arbitrary one-word data to pass
|
* to the callback. */
|
* to the callback. */
|
struct CloseCallback *nextPtr; /* For chaining close callbacks. */
|
struct CloseCallback *nextPtr; /* For chaining close callbacks. */
|
} CloseCallback;
|
} CloseCallback;
|
|
|
/*
|
/*
|
* The following structure describes the information saved from a call to
|
* The following structure describes the information saved from a call to
|
* "fileevent". This is used later when the event being waited for to
|
* "fileevent". This is used later when the event being waited for to
|
* invoke the saved script in the interpreter designed in this record.
|
* invoke the saved script in the interpreter designed in this record.
|
*/
|
*/
|
|
|
typedef struct EventScriptRecord {
|
typedef struct EventScriptRecord {
|
struct Channel *chanPtr; /* The channel for which this script is
|
struct Channel *chanPtr; /* The channel for which this script is
|
* registered. This is used only when an
|
* registered. This is used only when an
|
* error occurs during evaluation of the
|
* error occurs during evaluation of the
|
* script, to delete the handler. */
|
* script, to delete the handler. */
|
char *script; /* Script to invoke. */
|
char *script; /* Script to invoke. */
|
Tcl_Interp *interp; /* In what interpreter to invoke script? */
|
Tcl_Interp *interp; /* In what interpreter to invoke script? */
|
int mask; /* Events must overlap current mask for the
|
int mask; /* Events must overlap current mask for the
|
* stored script to be invoked. */
|
* stored script to be invoked. */
|
struct EventScriptRecord *nextPtr;
|
struct EventScriptRecord *nextPtr;
|
/* Next in chain of records. */
|
/* Next in chain of records. */
|
} EventScriptRecord;
|
} EventScriptRecord;
|
|
|
/*
|
/*
|
* struct Channel:
|
* struct Channel:
|
*
|
*
|
* One of these structures is allocated for each open channel. It contains data
|
* One of these structures is allocated for each open channel. It contains data
|
* specific to the channel but which belongs to the generic part of the Tcl
|
* specific to the channel but which belongs to the generic part of the Tcl
|
* channel mechanism, and it points at an instance specific (and type
|
* channel mechanism, and it points at an instance specific (and type
|
* specific) * instance data, and at a channel type structure.
|
* specific) * instance data, and at a channel type structure.
|
*/
|
*/
|
|
|
typedef struct Channel {
|
typedef struct Channel {
|
char *channelName; /* The name of the channel instance in Tcl
|
char *channelName; /* The name of the channel instance in Tcl
|
* commands. Storage is owned by the generic IO
|
* commands. Storage is owned by the generic IO
|
* code, is dynamically allocated. */
|
* code, is dynamically allocated. */
|
int flags; /* ORed combination of the flags defined
|
int flags; /* ORed combination of the flags defined
|
* below. */
|
* below. */
|
Tcl_EolTranslation inputTranslation;
|
Tcl_EolTranslation inputTranslation;
|
/* What translation to apply for end of line
|
/* What translation to apply for end of line
|
* sequences on input? */
|
* sequences on input? */
|
Tcl_EolTranslation outputTranslation;
|
Tcl_EolTranslation outputTranslation;
|
/* What translation to use for generating
|
/* What translation to use for generating
|
* end of line sequences in output? */
|
* end of line sequences in output? */
|
int inEofChar; /* If nonzero, use this as a signal of EOF
|
int inEofChar; /* If nonzero, use this as a signal of EOF
|
* on input. */
|
* on input. */
|
int outEofChar; /* If nonzero, append this to the channel
|
int outEofChar; /* If nonzero, append this to the channel
|
* when it is closed if it is open for
|
* when it is closed if it is open for
|
* writing. */
|
* writing. */
|
int unreportedError; /* Non-zero if an error report was deferred
|
int unreportedError; /* Non-zero if an error report was deferred
|
* because it happened in the background. The
|
* because it happened in the background. The
|
* value is the POSIX error code. */
|
* value is the POSIX error code. */
|
ClientData instanceData; /* Instance specific data. */
|
ClientData instanceData; /* Instance specific data. */
|
Tcl_ChannelType *typePtr; /* Pointer to channel type structure. */
|
Tcl_ChannelType *typePtr; /* Pointer to channel type structure. */
|
int refCount; /* How many interpreters hold references to
|
int refCount; /* How many interpreters hold references to
|
* this IO channel? */
|
* this IO channel? */
|
CloseCallback *closeCbPtr; /* Callbacks registered to be called when the
|
CloseCallback *closeCbPtr; /* Callbacks registered to be called when the
|
* channel is closed. */
|
* channel is closed. */
|
ChannelBuffer *curOutPtr; /* Current output buffer being filled. */
|
ChannelBuffer *curOutPtr; /* Current output buffer being filled. */
|
ChannelBuffer *outQueueHead;/* Points at first buffer in output queue. */
|
ChannelBuffer *outQueueHead;/* Points at first buffer in output queue. */
|
ChannelBuffer *outQueueTail;/* Points at last buffer in output queue. */
|
ChannelBuffer *outQueueTail;/* Points at last buffer in output queue. */
|
|
|
ChannelBuffer *saveInBufPtr;/* Buffer saved for input queue - eliminates
|
ChannelBuffer *saveInBufPtr;/* Buffer saved for input queue - eliminates
|
* need to allocate a new buffer for "gets"
|
* need to allocate a new buffer for "gets"
|
* that crosses buffer boundaries. */
|
* that crosses buffer boundaries. */
|
ChannelBuffer *inQueueHead; /* Points at first buffer in input queue. */
|
ChannelBuffer *inQueueHead; /* Points at first buffer in input queue. */
|
ChannelBuffer *inQueueTail; /* Points at last buffer in input queue. */
|
ChannelBuffer *inQueueTail; /* Points at last buffer in input queue. */
|
|
|
struct ChannelHandler *chPtr;/* List of channel handlers registered
|
struct ChannelHandler *chPtr;/* List of channel handlers registered
|
* for this channel. */
|
* for this channel. */
|
int interestMask; /* Mask of all events this channel has
|
int interestMask; /* Mask of all events this channel has
|
* handlers for. */
|
* handlers for. */
|
struct Channel *nextChanPtr;/* Next in list of channels currently open. */
|
struct Channel *nextChanPtr;/* Next in list of channels currently open. */
|
EventScriptRecord *scriptRecordPtr;
|
EventScriptRecord *scriptRecordPtr;
|
/* Chain of all scripts registered for
|
/* Chain of all scripts registered for
|
* event handlers ("fileevent") on this
|
* event handlers ("fileevent") on this
|
* channel. */
|
* channel. */
|
int bufSize; /* What size buffers to allocate? */
|
int bufSize; /* What size buffers to allocate? */
|
Tcl_TimerToken timer; /* Handle to wakeup timer for this channel. */
|
Tcl_TimerToken timer; /* Handle to wakeup timer for this channel. */
|
CopyState *csPtr; /* State of background copy, or NULL. */
|
CopyState *csPtr; /* State of background copy, or NULL. */
|
} Channel;
|
} Channel;
|
|
|
/*
|
/*
|
* Values for the flags field in Channel. Any ORed combination of the
|
* Values for the flags field in Channel. Any ORed combination of the
|
* following flags can be stored in the field. These flags record various
|
* following flags can be stored in the field. These flags record various
|
* options and state bits about the channel. In addition to the flags below,
|
* options and state bits about the channel. In addition to the flags below,
|
* the channel can also have TCL_READABLE (1<<1) and TCL_WRITABLE (1<<2) set.
|
* the channel can also have TCL_READABLE (1<<1) and TCL_WRITABLE (1<<2) set.
|
*/
|
*/
|
|
|
#define CHANNEL_NONBLOCKING (1<<3) /* Channel is currently in
|
#define CHANNEL_NONBLOCKING (1<<3) /* Channel is currently in
|
* nonblocking mode. */
|
* nonblocking mode. */
|
#define CHANNEL_LINEBUFFERED (1<<4) /* Output to the channel must be
|
#define CHANNEL_LINEBUFFERED (1<<4) /* Output to the channel must be
|
* flushed after every newline. */
|
* flushed after every newline. */
|
#define CHANNEL_UNBUFFERED (1<<5) /* Output to the channel must always
|
#define CHANNEL_UNBUFFERED (1<<5) /* Output to the channel must always
|
* be flushed immediately. */
|
* be flushed immediately. */
|
#define BUFFER_READY (1<<6) /* Current output buffer (the
|
#define BUFFER_READY (1<<6) /* Current output buffer (the
|
* curOutPtr field in the
|
* curOutPtr field in the
|
* channel structure) should be
|
* channel structure) should be
|
* output as soon as possible even
|
* output as soon as possible even
|
* though it may not be full. */
|
* though it may not be full. */
|
#define BG_FLUSH_SCHEDULED (1<<7) /* A background flush of the
|
#define BG_FLUSH_SCHEDULED (1<<7) /* A background flush of the
|
* queued output buffers has been
|
* queued output buffers has been
|
* scheduled. */
|
* scheduled. */
|
#define CHANNEL_CLOSED (1<<8) /* Channel has been closed. No
|
#define CHANNEL_CLOSED (1<<8) /* Channel has been closed. No
|
* further Tcl-level IO on the
|
* further Tcl-level IO on the
|
* channel is allowed. */
|
* channel is allowed. */
|
#define CHANNEL_EOF (1<<9) /* EOF occurred on this channel.
|
#define CHANNEL_EOF (1<<9) /* EOF occurred on this channel.
|
* This bit is cleared before every
|
* This bit is cleared before every
|
* input operation. */
|
* input operation. */
|
#define CHANNEL_STICKY_EOF (1<<10) /* EOF occurred on this channel because
|
#define CHANNEL_STICKY_EOF (1<<10) /* EOF occurred on this channel because
|
* we saw the input eofChar. This bit
|
* we saw the input eofChar. This bit
|
* prevents clearing of the EOF bit
|
* prevents clearing of the EOF bit
|
* before every input operation. */
|
* before every input operation. */
|
#define CHANNEL_BLOCKED (1<<11) /* EWOULDBLOCK or EAGAIN occurred
|
#define CHANNEL_BLOCKED (1<<11) /* EWOULDBLOCK or EAGAIN occurred
|
* on this channel. This bit is
|
* on this channel. This bit is
|
* cleared before every input or
|
* cleared before every input or
|
* output operation. */
|
* output operation. */
|
#define INPUT_SAW_CR (1<<12) /* Channel is in CRLF eol input
|
#define INPUT_SAW_CR (1<<12) /* Channel is in CRLF eol input
|
* translation mode and the last
|
* translation mode and the last
|
* byte seen was a "\r". */
|
* byte seen was a "\r". */
|
#define CHANNEL_DEAD (1<<13) /* The channel has been closed by
|
#define CHANNEL_DEAD (1<<13) /* The channel has been closed by
|
* the exit handler (on exit) but
|
* the exit handler (on exit) but
|
* not deallocated. When any IO
|
* not deallocated. When any IO
|
* operation sees this flag on a
|
* operation sees this flag on a
|
* channel, it does not call driver
|
* channel, it does not call driver
|
* level functions to avoid referring
|
* level functions to avoid referring
|
* to deallocated data. */
|
* to deallocated data. */
|
#define CHANNEL_GETS_BLOCKED (1<<14) /* The last input operation was a gets
|
#define CHANNEL_GETS_BLOCKED (1<<14) /* The last input operation was a gets
|
* that failed to get a comlete line.
|
* that failed to get a comlete line.
|
* When set, file events will not be
|
* When set, file events will not be
|
* delivered for buffered data unless
|
* delivered for buffered data unless
|
* an EOL is present. */
|
* an EOL is present. */
|
|
|
/*
|
/*
|
* For each channel handler registered in a call to Tcl_CreateChannelHandler,
|
* For each channel handler registered in a call to Tcl_CreateChannelHandler,
|
* there is one record of the following type. All of records for a specific
|
* there is one record of the following type. All of records for a specific
|
* channel are chained together in a singly linked list which is stored in
|
* channel are chained together in a singly linked list which is stored in
|
* the channel structure.
|
* the channel structure.
|
*/
|
*/
|
|
|
typedef struct ChannelHandler {
|
typedef struct ChannelHandler {
|
Channel *chanPtr; /* The channel structure for this channel. */
|
Channel *chanPtr; /* The channel structure for this channel. */
|
int mask; /* Mask of desired events. */
|
int mask; /* Mask of desired events. */
|
Tcl_ChannelProc *proc; /* Procedure to call in the type of
|
Tcl_ChannelProc *proc; /* Procedure to call in the type of
|
* Tcl_CreateChannelHandler. */
|
* Tcl_CreateChannelHandler. */
|
ClientData clientData; /* Argument to pass to procedure. */
|
ClientData clientData; /* Argument to pass to procedure. */
|
struct ChannelHandler *nextPtr;
|
struct ChannelHandler *nextPtr;
|
/* Next one in list of registered handlers. */
|
/* Next one in list of registered handlers. */
|
} ChannelHandler;
|
} ChannelHandler;
|
|
|
/*
|
/*
|
* This structure keeps track of the current ChannelHandler being invoked in
|
* This structure keeps track of the current ChannelHandler being invoked in
|
* the current invocation of ChannelHandlerEventProc. There is a potential
|
* the current invocation of ChannelHandlerEventProc. There is a potential
|
* problem if a ChannelHandler is deleted while it is the current one, since
|
* problem if a ChannelHandler is deleted while it is the current one, since
|
* ChannelHandlerEventProc needs to look at the nextPtr field. To handle this
|
* ChannelHandlerEventProc needs to look at the nextPtr field. To handle this
|
* problem, structures of the type below indicate the next handler to be
|
* problem, structures of the type below indicate the next handler to be
|
* processed for any (recursively nested) dispatches in progress. The
|
* processed for any (recursively nested) dispatches in progress. The
|
* nextHandlerPtr field is updated if the handler being pointed to is deleted.
|
* nextHandlerPtr field is updated if the handler being pointed to is deleted.
|
* The nextPtr field is used to chain together all recursive invocations, so
|
* The nextPtr field is used to chain together all recursive invocations, so
|
* that Tcl_DeleteChannelHandler can find all the recursively nested
|
* that Tcl_DeleteChannelHandler can find all the recursively nested
|
* invocations of ChannelHandlerEventProc and compare the handler being
|
* invocations of ChannelHandlerEventProc and compare the handler being
|
* deleted against the NEXT handler to be invoked in that invocation; when it
|
* deleted against the NEXT handler to be invoked in that invocation; when it
|
* finds such a situation, Tcl_DeleteChannelHandler updates the nextHandlerPtr
|
* finds such a situation, Tcl_DeleteChannelHandler updates the nextHandlerPtr
|
* field of the structure to the next handler.
|
* field of the structure to the next handler.
|
*/
|
*/
|
|
|
typedef struct NextChannelHandler {
|
typedef struct NextChannelHandler {
|
ChannelHandler *nextHandlerPtr; /* The next handler to be invoked in
|
ChannelHandler *nextHandlerPtr; /* The next handler to be invoked in
|
* this invocation. */
|
* this invocation. */
|
struct NextChannelHandler *nestedHandlerPtr;
|
struct NextChannelHandler *nestedHandlerPtr;
|
/* Next nested invocation of
|
/* Next nested invocation of
|
* ChannelHandlerEventProc. */
|
* ChannelHandlerEventProc. */
|
} NextChannelHandler;
|
} NextChannelHandler;
|
|
|
/*
|
/*
|
* This variable holds the list of nested ChannelHandlerEventProc invocations.
|
* This variable holds the list of nested ChannelHandlerEventProc invocations.
|
*/
|
*/
|
|
|
static NextChannelHandler *nestedHandlerPtr = (NextChannelHandler *) NULL;
|
static NextChannelHandler *nestedHandlerPtr = (NextChannelHandler *) NULL;
|
|
|
/*
|
/*
|
* List of all channels currently open.
|
* List of all channels currently open.
|
*/
|
*/
|
|
|
static Channel *firstChanPtr = (Channel *) NULL;
|
static Channel *firstChanPtr = (Channel *) NULL;
|
|
|
/*
|
/*
|
* Has a channel exit handler been created yet?
|
* Has a channel exit handler been created yet?
|
*/
|
*/
|
|
|
static int channelExitHandlerCreated = 0;
|
static int channelExitHandlerCreated = 0;
|
|
|
/*
|
/*
|
* The following structure describes the event that is added to the Tcl
|
* The following structure describes the event that is added to the Tcl
|
* event queue by the channel handler check procedure.
|
* event queue by the channel handler check procedure.
|
*/
|
*/
|
|
|
typedef struct ChannelHandlerEvent {
|
typedef struct ChannelHandlerEvent {
|
Tcl_Event header; /* Standard header for all events. */
|
Tcl_Event header; /* Standard header for all events. */
|
Channel *chanPtr; /* The channel that is ready. */
|
Channel *chanPtr; /* The channel that is ready. */
|
int readyMask; /* Events that have occurred. */
|
int readyMask; /* Events that have occurred. */
|
} ChannelHandlerEvent;
|
} ChannelHandlerEvent;
|
|
|
/*
|
/*
|
* Static variables to hold channels for stdin, stdout and stderr.
|
* Static variables to hold channels for stdin, stdout and stderr.
|
*/
|
*/
|
|
|
static Tcl_Channel stdinChannel = NULL;
|
static Tcl_Channel stdinChannel = NULL;
|
static int stdinInitialized = 0;
|
static int stdinInitialized = 0;
|
static Tcl_Channel stdoutChannel = NULL;
|
static Tcl_Channel stdoutChannel = NULL;
|
static int stdoutInitialized = 0;
|
static int stdoutInitialized = 0;
|
static Tcl_Channel stderrChannel = NULL;
|
static Tcl_Channel stderrChannel = NULL;
|
static int stderrInitialized = 0;
|
static int stderrInitialized = 0;
|
|
|
/*
|
/*
|
* Static functions in this file:
|
* Static functions in this file:
|
*/
|
*/
|
|
|
static void ChannelEventScriptInvoker _ANSI_ARGS_((
|
static void ChannelEventScriptInvoker _ANSI_ARGS_((
|
ClientData clientData, int flags));
|
ClientData clientData, int flags));
|
static void ChannelTimerProc _ANSI_ARGS_((
|
static void ChannelTimerProc _ANSI_ARGS_((
|
ClientData clientData));
|
ClientData clientData));
|
static void CheckForStdChannelsBeingClosed _ANSI_ARGS_((
|
static void CheckForStdChannelsBeingClosed _ANSI_ARGS_((
|
Tcl_Channel chan));
|
Tcl_Channel chan));
|
static void CleanupChannelHandlers _ANSI_ARGS_((
|
static void CleanupChannelHandlers _ANSI_ARGS_((
|
Tcl_Interp *interp, Channel *chanPtr));
|
Tcl_Interp *interp, Channel *chanPtr));
|
static int CloseChannel _ANSI_ARGS_((Tcl_Interp *interp,
|
static int CloseChannel _ANSI_ARGS_((Tcl_Interp *interp,
|
Channel *chanPtr, int errorCode));
|
Channel *chanPtr, int errorCode));
|
static void CloseChannelsOnExit _ANSI_ARGS_((ClientData data));
|
static void CloseChannelsOnExit _ANSI_ARGS_((ClientData data));
|
static int CopyAndTranslateBuffer _ANSI_ARGS_((
|
static int CopyAndTranslateBuffer _ANSI_ARGS_((
|
Channel *chanPtr, char *result, int space));
|
Channel *chanPtr, char *result, int space));
|
static int CopyData _ANSI_ARGS_((CopyState *csPtr, int mask));
|
static int CopyData _ANSI_ARGS_((CopyState *csPtr, int mask));
|
static void CopyEventProc _ANSI_ARGS_((ClientData clientData,
|
static void CopyEventProc _ANSI_ARGS_((ClientData clientData,
|
int mask));
|
int mask));
|
static void CreateScriptRecord _ANSI_ARGS_((
|
static void CreateScriptRecord _ANSI_ARGS_((
|
Tcl_Interp *interp, Channel *chanPtr,
|
Tcl_Interp *interp, Channel *chanPtr,
|
int mask, char *script));
|
int mask, char *script));
|
static void DeleteChannelTable _ANSI_ARGS_((
|
static void DeleteChannelTable _ANSI_ARGS_((
|
ClientData clientData, Tcl_Interp *interp));
|
ClientData clientData, Tcl_Interp *interp));
|
static void DeleteScriptRecord _ANSI_ARGS_((Tcl_Interp *interp,
|
static void DeleteScriptRecord _ANSI_ARGS_((Tcl_Interp *interp,
|
Channel *chanPtr, int mask));
|
Channel *chanPtr, int mask));
|
static void DiscardInputQueued _ANSI_ARGS_((
|
static void DiscardInputQueued _ANSI_ARGS_((
|
Channel *chanPtr, int discardSavedBuffers));
|
Channel *chanPtr, int discardSavedBuffers));
|
static void DiscardOutputQueued _ANSI_ARGS_((
|
static void DiscardOutputQueued _ANSI_ARGS_((
|
Channel *chanPtr));
|
Channel *chanPtr));
|
static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
|
static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
|
int slen));
|
int slen));
|
static int DoWrite _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
|
static int DoWrite _ANSI_ARGS_((Channel *chanPtr, char *srcPtr,
|
int slen));
|
int slen));
|
static int FlushChannel _ANSI_ARGS_((Tcl_Interp *interp,
|
static int FlushChannel _ANSI_ARGS_((Tcl_Interp *interp,
|
Channel *chanPtr, int calledFromAsyncFlush));
|
Channel *chanPtr, int calledFromAsyncFlush));
|
static Tcl_HashTable *GetChannelTable _ANSI_ARGS_((Tcl_Interp *interp));
|
static Tcl_HashTable *GetChannelTable _ANSI_ARGS_((Tcl_Interp *interp));
|
static int GetEOL _ANSI_ARGS_((Channel *chanPtr));
|
static int GetEOL _ANSI_ARGS_((Channel *chanPtr));
|
static int GetInput _ANSI_ARGS_((Channel *chanPtr));
|
static int GetInput _ANSI_ARGS_((Channel *chanPtr));
|
static void RecycleBuffer _ANSI_ARGS_((Channel *chanPtr,
|
static void RecycleBuffer _ANSI_ARGS_((Channel *chanPtr,
|
ChannelBuffer *bufPtr, int mustDiscard));
|
ChannelBuffer *bufPtr, int mustDiscard));
|
static int ScanBufferForEOL _ANSI_ARGS_((Channel *chanPtr,
|
static int ScanBufferForEOL _ANSI_ARGS_((Channel *chanPtr,
|
ChannelBuffer *bufPtr,
|
ChannelBuffer *bufPtr,
|
Tcl_EolTranslation translation, int eofChar,
|
Tcl_EolTranslation translation, int eofChar,
|
int *bytesToEOLPtr, int *crSeenPtr));
|
int *bytesToEOLPtr, int *crSeenPtr));
|
static int ScanInputForEOL _ANSI_ARGS_((Channel *chanPtr,
|
static int ScanInputForEOL _ANSI_ARGS_((Channel *chanPtr,
|
int *bytesQueuedPtr));
|
int *bytesQueuedPtr));
|
static int SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp,
|
static int SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp,
|
Channel *chanPtr, int mode));
|
Channel *chanPtr, int mode));
|
static void StopCopy _ANSI_ARGS_((CopyState *csPtr));
|
static void StopCopy _ANSI_ARGS_((CopyState *csPtr));
|
static void UpdateInterest _ANSI_ARGS_((Channel *chanPtr));
|
static void UpdateInterest _ANSI_ARGS_((Channel *chanPtr));
|
static int CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp,
|
static int CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp,
|
Channel *chan));
|
Channel *chan));
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* SetBlockMode --
|
* SetBlockMode --
|
*
|
*
|
* This function sets the blocking mode for a channel and updates
|
* This function sets the blocking mode for a channel and updates
|
* the state flags.
|
* the state flags.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Modifies the blocking mode of the channel and possibly generates
|
* Modifies the blocking mode of the channel and possibly generates
|
* an error.
|
* an error.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
SetBlockMode(interp, chanPtr, mode)
|
SetBlockMode(interp, chanPtr, mode)
|
Tcl_Interp *interp; /* Interp for error reporting. */
|
Tcl_Interp *interp; /* Interp for error reporting. */
|
Channel *chanPtr; /* Channel to modify. */
|
Channel *chanPtr; /* Channel to modify. */
|
int mode; /* One of TCL_MODE_BLOCKING or
|
int mode; /* One of TCL_MODE_BLOCKING or
|
* TCL_MODE_NONBLOCKING. */
|
* TCL_MODE_NONBLOCKING. */
|
{
|
{
|
int result = 0;
|
int result = 0;
|
if (chanPtr->typePtr->blockModeProc != NULL) {
|
if (chanPtr->typePtr->blockModeProc != NULL) {
|
result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
|
result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
|
mode);
|
mode);
|
}
|
}
|
if (result != 0) {
|
if (result != 0) {
|
Tcl_SetErrno(result);
|
Tcl_SetErrno(result);
|
if (interp != (Tcl_Interp *) NULL) {
|
if (interp != (Tcl_Interp *) NULL) {
|
Tcl_AppendResult(interp, "error setting blocking mode: ",
|
Tcl_AppendResult(interp, "error setting blocking mode: ",
|
Tcl_PosixError(interp), (char *) NULL);
|
Tcl_PosixError(interp), (char *) NULL);
|
}
|
}
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (mode == TCL_MODE_BLOCKING) {
|
if (mode == TCL_MODE_BLOCKING) {
|
chanPtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
|
chanPtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
|
} else {
|
} else {
|
chanPtr->flags |= CHANNEL_NONBLOCKING;
|
chanPtr->flags |= CHANNEL_NONBLOCKING;
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_SetStdChannel --
|
* Tcl_SetStdChannel --
|
*
|
*
|
* This function is used to change the channels that are used
|
* This function is used to change the channels that are used
|
* for stdin/stdout/stderr in new interpreters.
|
* for stdin/stdout/stderr in new interpreters.
|
*
|
*
|
* Results:
|
* Results:
|
* None
|
* None
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_SetStdChannel(channel, type)
|
Tcl_SetStdChannel(channel, type)
|
Tcl_Channel channel;
|
Tcl_Channel channel;
|
int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
|
int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
|
{
|
{
|
switch (type) {
|
switch (type) {
|
case TCL_STDIN:
|
case TCL_STDIN:
|
stdinInitialized = 1;
|
stdinInitialized = 1;
|
stdinChannel = channel;
|
stdinChannel = channel;
|
break;
|
break;
|
case TCL_STDOUT:
|
case TCL_STDOUT:
|
stdoutInitialized = 1;
|
stdoutInitialized = 1;
|
stdoutChannel = channel;
|
stdoutChannel = channel;
|
break;
|
break;
|
case TCL_STDERR:
|
case TCL_STDERR:
|
stderrInitialized = 1;
|
stderrInitialized = 1;
|
stderrChannel = channel;
|
stderrChannel = channel;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetStdChannel --
|
* Tcl_GetStdChannel --
|
*
|
*
|
* Returns the specified standard channel.
|
* Returns the specified standard channel.
|
*
|
*
|
* Results:
|
* Results:
|
* Returns the specified standard channel, or NULL.
|
* Returns the specified standard channel, or NULL.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May cause the creation of a standard channel and the underlying
|
* May cause the creation of a standard channel and the underlying
|
* file.
|
* file.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
Tcl_Channel
|
Tcl_Channel
|
Tcl_GetStdChannel(type)
|
Tcl_GetStdChannel(type)
|
int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
|
int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
|
{
|
{
|
Tcl_Channel channel = NULL;
|
Tcl_Channel channel = NULL;
|
|
|
/*
|
/*
|
* If the channels were not created yet, create them now and
|
* If the channels were not created yet, create them now and
|
* store them in the static variables. Note that we need to set
|
* store them in the static variables. Note that we need to set
|
* stdinInitialized before calling TclGetDefaultStdChannel in order
|
* stdinInitialized before calling TclGetDefaultStdChannel in order
|
* to avoid recursive loops when TclGetDefaultStdChannel calls
|
* to avoid recursive loops when TclGetDefaultStdChannel calls
|
* Tcl_CreateChannel.
|
* Tcl_CreateChannel.
|
*/
|
*/
|
|
|
switch (type) {
|
switch (type) {
|
case TCL_STDIN:
|
case TCL_STDIN:
|
if (!stdinInitialized) {
|
if (!stdinInitialized) {
|
stdinChannel = TclGetDefaultStdChannel(TCL_STDIN);
|
stdinChannel = TclGetDefaultStdChannel(TCL_STDIN);
|
stdinInitialized = 1;
|
stdinInitialized = 1;
|
|
|
/*
|
/*
|
* Artificially bump the refcount to ensure that the channel
|
* Artificially bump the refcount to ensure that the channel
|
* is only closed on exit.
|
* is only closed on exit.
|
*
|
*
|
* NOTE: Must only do this if stdinChannel is not NULL. It
|
* NOTE: Must only do this if stdinChannel is not NULL. It
|
* can be NULL in situations where Tcl is unable to connect
|
* can be NULL in situations where Tcl is unable to connect
|
* to the standard input.
|
* to the standard input.
|
*/
|
*/
|
|
|
if (stdinChannel != (Tcl_Channel) NULL) {
|
if (stdinChannel != (Tcl_Channel) NULL) {
|
(void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
|
(void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
|
stdinChannel);
|
stdinChannel);
|
}
|
}
|
}
|
}
|
channel = stdinChannel;
|
channel = stdinChannel;
|
break;
|
break;
|
case TCL_STDOUT:
|
case TCL_STDOUT:
|
if (!stdoutInitialized) {
|
if (!stdoutInitialized) {
|
stdoutChannel = TclGetDefaultStdChannel(TCL_STDOUT);
|
stdoutChannel = TclGetDefaultStdChannel(TCL_STDOUT);
|
stdoutInitialized = 1;
|
stdoutInitialized = 1;
|
|
|
/*
|
/*
|
* Artificially bump the refcount to ensure that the channel
|
* Artificially bump the refcount to ensure that the channel
|
* is only closed on exit.
|
* is only closed on exit.
|
*
|
*
|
* NOTE: Must only do this if stdoutChannel is not NULL. It
|
* NOTE: Must only do this if stdoutChannel is not NULL. It
|
* can be NULL in situations where Tcl is unable to connect
|
* can be NULL in situations where Tcl is unable to connect
|
* to the standard output.
|
* to the standard output.
|
*/
|
*/
|
|
|
if (stdoutChannel != (Tcl_Channel) NULL) {
|
if (stdoutChannel != (Tcl_Channel) NULL) {
|
(void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
|
(void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
|
stdoutChannel);
|
stdoutChannel);
|
}
|
}
|
}
|
}
|
channel = stdoutChannel;
|
channel = stdoutChannel;
|
break;
|
break;
|
case TCL_STDERR:
|
case TCL_STDERR:
|
if (!stderrInitialized) {
|
if (!stderrInitialized) {
|
stderrChannel = TclGetDefaultStdChannel(TCL_STDERR);
|
stderrChannel = TclGetDefaultStdChannel(TCL_STDERR);
|
stderrInitialized = 1;
|
stderrInitialized = 1;
|
|
|
/*
|
/*
|
* Artificially bump the refcount to ensure that the channel
|
* Artificially bump the refcount to ensure that the channel
|
* is only closed on exit.
|
* is only closed on exit.
|
*
|
*
|
* NOTE: Must only do this if stderrChannel is not NULL. It
|
* NOTE: Must only do this if stderrChannel is not NULL. It
|
* can be NULL in situations where Tcl is unable to connect
|
* can be NULL in situations where Tcl is unable to connect
|
* to the standard error.
|
* to the standard error.
|
*/
|
*/
|
|
|
if (stderrChannel != (Tcl_Channel) NULL) {
|
if (stderrChannel != (Tcl_Channel) NULL) {
|
(void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
|
(void) Tcl_RegisterChannel((Tcl_Interp *) NULL,
|
stderrChannel);
|
stderrChannel);
|
}
|
}
|
}
|
}
|
channel = stderrChannel;
|
channel = stderrChannel;
|
break;
|
break;
|
}
|
}
|
return channel;
|
return channel;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_CreateCloseHandler
|
* Tcl_CreateCloseHandler
|
*
|
*
|
* Creates a close callback which will be called when the channel is
|
* Creates a close callback which will be called when the channel is
|
* closed.
|
* closed.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Causes the callback to be called in the future when the channel
|
* Causes the callback to be called in the future when the channel
|
* will be closed.
|
* will be closed.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_CreateCloseHandler(chan, proc, clientData)
|
Tcl_CreateCloseHandler(chan, proc, clientData)
|
Tcl_Channel chan; /* The channel for which to create the
|
Tcl_Channel chan; /* The channel for which to create the
|
* close callback. */
|
* close callback. */
|
Tcl_CloseProc *proc; /* The callback routine to call when the
|
Tcl_CloseProc *proc; /* The callback routine to call when the
|
* channel will be closed. */
|
* channel will be closed. */
|
ClientData clientData; /* Arbitrary data to pass to the
|
ClientData clientData; /* Arbitrary data to pass to the
|
* close callback. */
|
* close callback. */
|
{
|
{
|
Channel *chanPtr;
|
Channel *chanPtr;
|
CloseCallback *cbPtr;
|
CloseCallback *cbPtr;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback));
|
cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback));
|
cbPtr->proc = proc;
|
cbPtr->proc = proc;
|
cbPtr->clientData = clientData;
|
cbPtr->clientData = clientData;
|
|
|
cbPtr->nextPtr = chanPtr->closeCbPtr;
|
cbPtr->nextPtr = chanPtr->closeCbPtr;
|
chanPtr->closeCbPtr = cbPtr;
|
chanPtr->closeCbPtr = cbPtr;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_DeleteCloseHandler --
|
* Tcl_DeleteCloseHandler --
|
*
|
*
|
* Removes a callback that would have been called on closing
|
* Removes a callback that would have been called on closing
|
* the channel. If there is no matching callback then this
|
* the channel. If there is no matching callback then this
|
* function has no effect.
|
* function has no effect.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* The callback will not be called in the future when the channel
|
* The callback will not be called in the future when the channel
|
* is eventually closed.
|
* is eventually closed.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_DeleteCloseHandler(chan, proc, clientData)
|
Tcl_DeleteCloseHandler(chan, proc, clientData)
|
Tcl_Channel chan; /* The channel for which to cancel the
|
Tcl_Channel chan; /* The channel for which to cancel the
|
* close callback. */
|
* close callback. */
|
Tcl_CloseProc *proc; /* The procedure for the callback to
|
Tcl_CloseProc *proc; /* The procedure for the callback to
|
* remove. */
|
* remove. */
|
ClientData clientData; /* The callback data for the callback
|
ClientData clientData; /* The callback data for the callback
|
* to remove. */
|
* to remove. */
|
{
|
{
|
Channel *chanPtr;
|
Channel *chanPtr;
|
CloseCallback *cbPtr, *cbPrevPtr;
|
CloseCallback *cbPtr, *cbPrevPtr;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
for (cbPtr = chanPtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
|
for (cbPtr = chanPtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
|
cbPtr != (CloseCallback *) NULL;
|
cbPtr != (CloseCallback *) NULL;
|
cbPtr = cbPtr->nextPtr) {
|
cbPtr = cbPtr->nextPtr) {
|
if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
|
if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
|
if (cbPrevPtr == (CloseCallback *) NULL) {
|
if (cbPrevPtr == (CloseCallback *) NULL) {
|
chanPtr->closeCbPtr = cbPtr->nextPtr;
|
chanPtr->closeCbPtr = cbPtr->nextPtr;
|
}
|
}
|
ckfree((char *) cbPtr);
|
ckfree((char *) cbPtr);
|
break;
|
break;
|
} else {
|
} else {
|
cbPrevPtr = cbPtr;
|
cbPrevPtr = cbPtr;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CloseChannelsOnExit --
|
* CloseChannelsOnExit --
|
*
|
*
|
* Closes all the existing channels, on exit. This routine is called
|
* Closes all the existing channels, on exit. This routine is called
|
* during exit processing.
|
* during exit processing.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Closes all channels.
|
* Closes all channels.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
/* ARGSUSED */
|
/* ARGSUSED */
|
static void
|
static void
|
CloseChannelsOnExit(clientData)
|
CloseChannelsOnExit(clientData)
|
ClientData clientData; /* NULL - unused. */
|
ClientData clientData; /* NULL - unused. */
|
{
|
{
|
Channel *chanPtr; /* Iterates over open channels. */
|
Channel *chanPtr; /* Iterates over open channels. */
|
Channel *nextChanPtr; /* Iterates over open channels. */
|
Channel *nextChanPtr; /* Iterates over open channels. */
|
|
|
|
|
for (chanPtr = firstChanPtr; chanPtr != (Channel *) NULL;
|
for (chanPtr = firstChanPtr; chanPtr != (Channel *) NULL;
|
chanPtr = nextChanPtr) {
|
chanPtr = nextChanPtr) {
|
nextChanPtr = chanPtr->nextChanPtr;
|
nextChanPtr = chanPtr->nextChanPtr;
|
|
|
/*
|
/*
|
* Set the channel back into blocking mode to ensure that we wait
|
* Set the channel back into blocking mode to ensure that we wait
|
* for all data to flush out.
|
* for all data to flush out.
|
*/
|
*/
|
|
|
(void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr,
|
(void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr,
|
"-blocking", "on");
|
"-blocking", "on");
|
|
|
if ((chanPtr == (Channel *) stdinChannel) ||
|
if ((chanPtr == (Channel *) stdinChannel) ||
|
(chanPtr == (Channel *) stdoutChannel) ||
|
(chanPtr == (Channel *) stdoutChannel) ||
|
(chanPtr == (Channel *) stderrChannel)) {
|
(chanPtr == (Channel *) stderrChannel)) {
|
|
|
/*
|
/*
|
* Decrement the refcount which was earlier artificially bumped
|
* Decrement the refcount which was earlier artificially bumped
|
* up to keep the channel from being closed.
|
* up to keep the channel from being closed.
|
*/
|
*/
|
|
|
chanPtr->refCount--;
|
chanPtr->refCount--;
|
}
|
}
|
|
|
if (chanPtr->refCount <= 0) {
|
if (chanPtr->refCount <= 0) {
|
|
|
/*
|
/*
|
* Close it only if the refcount indicates that the channel is not
|
* Close it only if the refcount indicates that the channel is not
|
* referenced from any interpreter. If it is, that interpreter will
|
* referenced from any interpreter. If it is, that interpreter will
|
* close the channel when it gets destroyed.
|
* close the channel when it gets destroyed.
|
*/
|
*/
|
|
|
(void) Tcl_Close((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
(void) Tcl_Close((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
|
|
} else {
|
} else {
|
|
|
/*
|
/*
|
* The refcount is greater than zero, so flush the channel.
|
* The refcount is greater than zero, so flush the channel.
|
*/
|
*/
|
|
|
Tcl_Flush((Tcl_Channel) chanPtr);
|
Tcl_Flush((Tcl_Channel) chanPtr);
|
|
|
/*
|
/*
|
* Call the device driver to actually close the underlying
|
* Call the device driver to actually close the underlying
|
* device for this channel.
|
* device for this channel.
|
*/
|
*/
|
|
|
(chanPtr->typePtr->closeProc) (chanPtr->instanceData,
|
(chanPtr->typePtr->closeProc) (chanPtr->instanceData,
|
(Tcl_Interp *) NULL);
|
(Tcl_Interp *) NULL);
|
|
|
/*
|
/*
|
* Finally, we clean up the fields in the channel data structure
|
* Finally, we clean up the fields in the channel data structure
|
* since all of them have been deleted already. We mark the
|
* since all of them have been deleted already. We mark the
|
* channel with CHANNEL_DEAD to prevent any further IO operations
|
* channel with CHANNEL_DEAD to prevent any further IO operations
|
* on it.
|
* on it.
|
*/
|
*/
|
|
|
chanPtr->instanceData = (ClientData) NULL;
|
chanPtr->instanceData = (ClientData) NULL;
|
chanPtr->flags |= CHANNEL_DEAD;
|
chanPtr->flags |= CHANNEL_DEAD;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Reinitialize all the variables to the initial state:
|
* Reinitialize all the variables to the initial state:
|
*/
|
*/
|
|
|
firstChanPtr = (Channel *) NULL;
|
firstChanPtr = (Channel *) NULL;
|
nestedHandlerPtr = (NextChannelHandler *) NULL;
|
nestedHandlerPtr = (NextChannelHandler *) NULL;
|
channelExitHandlerCreated = 0;
|
channelExitHandlerCreated = 0;
|
stdinChannel = NULL;
|
stdinChannel = NULL;
|
stdinInitialized = 0;
|
stdinInitialized = 0;
|
stdoutChannel = NULL;
|
stdoutChannel = NULL;
|
stdoutInitialized = 0;
|
stdoutInitialized = 0;
|
stderrChannel = NULL;
|
stderrChannel = NULL;
|
stderrInitialized = 0;
|
stderrInitialized = 0;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* GetChannelTable --
|
* GetChannelTable --
|
*
|
*
|
* Gets and potentially initializes the channel table for an
|
* Gets and potentially initializes the channel table for an
|
* interpreter. If it is initializing the table it also inserts
|
* interpreter. If it is initializing the table it also inserts
|
* channels for stdin, stdout and stderr if the interpreter is
|
* channels for stdin, stdout and stderr if the interpreter is
|
* trusted.
|
* trusted.
|
*
|
*
|
* Results:
|
* Results:
|
* A pointer to the hash table created, for use by the caller.
|
* A pointer to the hash table created, for use by the caller.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Initializes the channel table for an interpreter. May create
|
* Initializes the channel table for an interpreter. May create
|
* channels for stdin, stdout and stderr.
|
* channels for stdin, stdout and stderr.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static Tcl_HashTable *
|
static Tcl_HashTable *
|
GetChannelTable(interp)
|
GetChannelTable(interp)
|
Tcl_Interp *interp;
|
Tcl_Interp *interp;
|
{
|
{
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_Channel stdinChan, stdoutChan, stderrChan;
|
Tcl_Channel stdinChan, stdoutChan, stderrChan;
|
|
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
hTblPtr = (Tcl_HashTable *) ckalloc((unsigned) sizeof(Tcl_HashTable));
|
hTblPtr = (Tcl_HashTable *) ckalloc((unsigned) sizeof(Tcl_HashTable));
|
Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
|
Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
|
|
|
(void) Tcl_SetAssocData(interp, "tclIO",
|
(void) Tcl_SetAssocData(interp, "tclIO",
|
(Tcl_InterpDeleteProc *) DeleteChannelTable,
|
(Tcl_InterpDeleteProc *) DeleteChannelTable,
|
(ClientData) hTblPtr);
|
(ClientData) hTblPtr);
|
|
|
/*
|
/*
|
* If the interpreter is trusted (not "safe"), insert channels
|
* If the interpreter is trusted (not "safe"), insert channels
|
* for stdin, stdout and stderr (possibly creating them in the
|
* for stdin, stdout and stderr (possibly creating them in the
|
* process).
|
* process).
|
*/
|
*/
|
|
|
if (Tcl_IsSafe(interp) == 0) {
|
if (Tcl_IsSafe(interp) == 0) {
|
stdinChan = Tcl_GetStdChannel(TCL_STDIN);
|
stdinChan = Tcl_GetStdChannel(TCL_STDIN);
|
if (stdinChan != NULL) {
|
if (stdinChan != NULL) {
|
Tcl_RegisterChannel(interp, stdinChan);
|
Tcl_RegisterChannel(interp, stdinChan);
|
}
|
}
|
stdoutChan = Tcl_GetStdChannel(TCL_STDOUT);
|
stdoutChan = Tcl_GetStdChannel(TCL_STDOUT);
|
if (stdoutChan != NULL) {
|
if (stdoutChan != NULL) {
|
Tcl_RegisterChannel(interp, stdoutChan);
|
Tcl_RegisterChannel(interp, stdoutChan);
|
}
|
}
|
stderrChan = Tcl_GetStdChannel(TCL_STDERR);
|
stderrChan = Tcl_GetStdChannel(TCL_STDERR);
|
if (stderrChan != NULL) {
|
if (stderrChan != NULL) {
|
Tcl_RegisterChannel(interp, stderrChan);
|
Tcl_RegisterChannel(interp, stderrChan);
|
}
|
}
|
}
|
}
|
|
|
}
|
}
|
return hTblPtr;
|
return hTblPtr;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* DeleteChannelTable --
|
* DeleteChannelTable --
|
*
|
*
|
* Deletes the channel table for an interpreter, closing any open
|
* Deletes the channel table for an interpreter, closing any open
|
* channels whose refcount reaches zero. This procedure is invoked
|
* channels whose refcount reaches zero. This procedure is invoked
|
* when an interpreter is deleted, via the AssocData cleanup
|
* when an interpreter is deleted, via the AssocData cleanup
|
* mechanism.
|
* mechanism.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Deletes the hash table of channels. May close channels. May flush
|
* Deletes the hash table of channels. May close channels. May flush
|
* output on closed channels. Removes any channeEvent handlers that were
|
* output on closed channels. Removes any channeEvent handlers that were
|
* registered in this interpreter.
|
* registered in this interpreter.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
DeleteChannelTable(clientData, interp)
|
DeleteChannelTable(clientData, interp)
|
ClientData clientData; /* The per-interpreter data structure. */
|
ClientData clientData; /* The per-interpreter data structure. */
|
Tcl_Interp *interp; /* The interpreter being deleted. */
|
Tcl_Interp *interp; /* The interpreter being deleted. */
|
{
|
{
|
Tcl_HashTable *hTblPtr; /* The hash table. */
|
Tcl_HashTable *hTblPtr; /* The hash table. */
|
Tcl_HashSearch hSearch; /* Search variable. */
|
Tcl_HashSearch hSearch; /* Search variable. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Channel *chanPtr; /* Channel being deleted. */
|
Channel *chanPtr; /* Channel being deleted. */
|
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
|
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
|
/* Variables to loop over all channel events
|
/* Variables to loop over all channel events
|
* registered, to delete the ones that refer
|
* registered, to delete the ones that refer
|
* to the interpreter being deleted. */
|
* to the interpreter being deleted. */
|
|
|
/*
|
/*
|
* Delete all the registered channels - this will close channels whose
|
* Delete all the registered channels - this will close channels whose
|
* refcount reaches zero.
|
* refcount reaches zero.
|
*/
|
*/
|
|
|
hTblPtr = (Tcl_HashTable *) clientData;
|
hTblPtr = (Tcl_HashTable *) clientData;
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
|
hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
|
|
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
|
|
/*
|
/*
|
* Remove any fileevents registered in this interpreter.
|
* Remove any fileevents registered in this interpreter.
|
*/
|
*/
|
|
|
for (sPtr = chanPtr->scriptRecordPtr,
|
for (sPtr = chanPtr->scriptRecordPtr,
|
prevPtr = (EventScriptRecord *) NULL;
|
prevPtr = (EventScriptRecord *) NULL;
|
sPtr != (EventScriptRecord *) NULL;
|
sPtr != (EventScriptRecord *) NULL;
|
sPtr = nextPtr) {
|
sPtr = nextPtr) {
|
nextPtr = sPtr->nextPtr;
|
nextPtr = sPtr->nextPtr;
|
if (sPtr->interp == interp) {
|
if (sPtr->interp == interp) {
|
if (prevPtr == (EventScriptRecord *) NULL) {
|
if (prevPtr == (EventScriptRecord *) NULL) {
|
chanPtr->scriptRecordPtr = nextPtr;
|
chanPtr->scriptRecordPtr = nextPtr;
|
} else {
|
} else {
|
prevPtr->nextPtr = nextPtr;
|
prevPtr->nextPtr = nextPtr;
|
}
|
}
|
|
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
ChannelEventScriptInvoker, (ClientData) sPtr);
|
ChannelEventScriptInvoker, (ClientData) sPtr);
|
|
|
ckfree(sPtr->script);
|
ckfree(sPtr->script);
|
ckfree((char *) sPtr);
|
ckfree((char *) sPtr);
|
} else {
|
} else {
|
prevPtr = sPtr;
|
prevPtr = sPtr;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Cannot call Tcl_UnregisterChannel because that procedure calls
|
* Cannot call Tcl_UnregisterChannel because that procedure calls
|
* Tcl_GetAssocData to get the channel table, which might already
|
* Tcl_GetAssocData to get the channel table, which might already
|
* be inaccessible from the interpreter structure. Instead, we
|
* be inaccessible from the interpreter structure. Instead, we
|
* emulate the behavior of Tcl_UnregisterChannel directly here.
|
* emulate the behavior of Tcl_UnregisterChannel directly here.
|
*/
|
*/
|
|
|
Tcl_DeleteHashEntry(hPtr);
|
Tcl_DeleteHashEntry(hPtr);
|
chanPtr->refCount--;
|
chanPtr->refCount--;
|
if (chanPtr->refCount <= 0) {
|
if (chanPtr->refCount <= 0) {
|
if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
(void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
|
(void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
|
}
|
}
|
}
|
}
|
}
|
}
|
Tcl_DeleteHashTable(hTblPtr);
|
Tcl_DeleteHashTable(hTblPtr);
|
ckfree((char *) hTblPtr);
|
ckfree((char *) hTblPtr);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CheckForStdChannelsBeingClosed --
|
* CheckForStdChannelsBeingClosed --
|
*
|
*
|
* Perform special handling for standard channels being closed. When
|
* Perform special handling for standard channels being closed. When
|
* given a standard channel, if the refcount is now 1, it means that
|
* given a standard channel, if the refcount is now 1, it means that
|
* the last reference to the standard channel is being explicitly
|
* the last reference to the standard channel is being explicitly
|
* closed. Now bump the refcount artificially down to 0, to ensure the
|
* closed. Now bump the refcount artificially down to 0, to ensure the
|
* normal handling of channels being closed will occur. Also reset the
|
* normal handling of channels being closed will occur. Also reset the
|
* static pointer to the channel to NULL, to avoid dangling references.
|
* static pointer to the channel to NULL, to avoid dangling references.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Manipulates the refcount on standard channels. May smash the global
|
* Manipulates the refcount on standard channels. May smash the global
|
* static pointer to a standard channel.
|
* static pointer to a standard channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
CheckForStdChannelsBeingClosed(chan)
|
CheckForStdChannelsBeingClosed(chan)
|
Tcl_Channel chan;
|
Tcl_Channel chan;
|
{
|
{
|
Channel *chanPtr = (Channel *) chan;
|
Channel *chanPtr = (Channel *) chan;
|
|
|
if ((chan == stdinChannel) && (stdinInitialized)) {
|
if ((chan == stdinChannel) && (stdinInitialized)) {
|
if (chanPtr->refCount < 2) {
|
if (chanPtr->refCount < 2) {
|
chanPtr->refCount = 0;
|
chanPtr->refCount = 0;
|
stdinChannel = NULL;
|
stdinChannel = NULL;
|
return;
|
return;
|
}
|
}
|
} else if ((chan == stdoutChannel) && (stdoutInitialized)) {
|
} else if ((chan == stdoutChannel) && (stdoutInitialized)) {
|
if (chanPtr->refCount < 2) {
|
if (chanPtr->refCount < 2) {
|
chanPtr->refCount = 0;
|
chanPtr->refCount = 0;
|
stdoutChannel = NULL;
|
stdoutChannel = NULL;
|
return;
|
return;
|
}
|
}
|
} else if ((chan == stderrChannel) && (stderrInitialized)) {
|
} else if ((chan == stderrChannel) && (stderrInitialized)) {
|
if (chanPtr->refCount < 2) {
|
if (chanPtr->refCount < 2) {
|
chanPtr->refCount = 0;
|
chanPtr->refCount = 0;
|
stderrChannel = NULL;
|
stderrChannel = NULL;
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_UnregisterChannel --
|
* Tcl_UnregisterChannel --
|
*
|
*
|
* Deletes the hash entry for a channel associated with an interpreter.
|
* Deletes the hash entry for a channel associated with an interpreter.
|
* If the interpreter given as argument is NULL, it only decrements the
|
* If the interpreter given as argument is NULL, it only decrements the
|
* reference count.
|
* reference count.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Deletes the hash entry for a channel associated with an interpreter.
|
* Deletes the hash entry for a channel associated with an interpreter.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_UnregisterChannel(interp, chan)
|
Tcl_UnregisterChannel(interp, chan)
|
Tcl_Interp *interp; /* Interpreter in which channel is defined. */
|
Tcl_Interp *interp; /* Interpreter in which channel is defined. */
|
Tcl_Channel chan; /* Channel to delete. */
|
Tcl_Channel chan; /* Channel to delete. */
|
{
|
{
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Channel *chanPtr; /* The real IO channel. */
|
Channel *chanPtr; /* The real IO channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
if (interp != (Tcl_Interp *) NULL) {
|
if (interp != (Tcl_Interp *) NULL) {
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
hPtr = Tcl_FindHashEntry(hTblPtr, chanPtr->channelName);
|
hPtr = Tcl_FindHashEntry(hTblPtr, chanPtr->channelName);
|
if (hPtr == (Tcl_HashEntry *) NULL) {
|
if (hPtr == (Tcl_HashEntry *) NULL) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
|
if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
Tcl_DeleteHashEntry(hPtr);
|
Tcl_DeleteHashEntry(hPtr);
|
|
|
/*
|
/*
|
* Remove channel handlers that refer to this interpreter, so that they
|
* Remove channel handlers that refer to this interpreter, so that they
|
* will not be present if the actual close is delayed and more events
|
* will not be present if the actual close is delayed and more events
|
* happen on the channel. This may occur if the channel is shared
|
* happen on the channel. This may occur if the channel is shared
|
* between several interpreters, or if the channel has async
|
* between several interpreters, or if the channel has async
|
* flushing active.
|
* flushing active.
|
*/
|
*/
|
|
|
CleanupChannelHandlers(interp, chanPtr);
|
CleanupChannelHandlers(interp, chanPtr);
|
}
|
}
|
|
|
chanPtr->refCount--;
|
chanPtr->refCount--;
|
|
|
/*
|
/*
|
* Perform special handling for standard channels being closed. If the
|
* Perform special handling for standard channels being closed. If the
|
* refCount is now 1 it means that the last reference to the standard
|
* refCount is now 1 it means that the last reference to the standard
|
* channel is being explicitly closed, so bump the refCount down
|
* channel is being explicitly closed, so bump the refCount down
|
* artificially to 0. This will ensure that the channel is actually
|
* artificially to 0. This will ensure that the channel is actually
|
* closed, below. Also set the static pointer to NULL for the channel.
|
* closed, below. Also set the static pointer to NULL for the channel.
|
*/
|
*/
|
|
|
CheckForStdChannelsBeingClosed(chan);
|
CheckForStdChannelsBeingClosed(chan);
|
|
|
/*
|
/*
|
* If the refCount reached zero, close the actual channel.
|
* If the refCount reached zero, close the actual channel.
|
*/
|
*/
|
|
|
if (chanPtr->refCount <= 0) {
|
if (chanPtr->refCount <= 0) {
|
|
|
/*
|
/*
|
* Ensure that if there is another buffer, it gets flushed
|
* Ensure that if there is another buffer, it gets flushed
|
* whether or not we are doing a background flush.
|
* whether or not we are doing a background flush.
|
*/
|
*/
|
|
|
if ((chanPtr->curOutPtr != NULL) &&
|
if ((chanPtr->curOutPtr != NULL) &&
|
(chanPtr->curOutPtr->nextAdded >
|
(chanPtr->curOutPtr->nextAdded >
|
chanPtr->curOutPtr->nextRemoved)) {
|
chanPtr->curOutPtr->nextRemoved)) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
}
|
}
|
chanPtr->flags |= CHANNEL_CLOSED;
|
chanPtr->flags |= CHANNEL_CLOSED;
|
if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
if (Tcl_Close(interp, chan) != TCL_OK) {
|
if (Tcl_Close(interp, chan) != TCL_OK) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
}
|
}
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_RegisterChannel --
|
* Tcl_RegisterChannel --
|
*
|
*
|
* Adds an already-open channel to the channel table of an interpreter.
|
* Adds an already-open channel to the channel table of an interpreter.
|
* If the interpreter passed as argument is NULL, it only increments
|
* If the interpreter passed as argument is NULL, it only increments
|
* the channel refCount.
|
* the channel refCount.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May increment the reference count of a channel.
|
* May increment the reference count of a channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_RegisterChannel(interp, chan)
|
Tcl_RegisterChannel(interp, chan)
|
Tcl_Interp *interp; /* Interpreter in which to add the channel. */
|
Tcl_Interp *interp; /* Interpreter in which to add the channel. */
|
Tcl_Channel chan; /* The channel to add to this interpreter
|
Tcl_Channel chan; /* The channel to add to this interpreter
|
* channel table. */
|
* channel table. */
|
{
|
{
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
int new; /* Is the hash entry new or does it exist? */
|
int new; /* Is the hash entry new or does it exist? */
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
if (chanPtr->channelName == (char *) NULL) {
|
if (chanPtr->channelName == (char *) NULL) {
|
panic("Tcl_RegisterChannel: channel without name");
|
panic("Tcl_RegisterChannel: channel without name");
|
}
|
}
|
if (interp != (Tcl_Interp *) NULL) {
|
if (interp != (Tcl_Interp *) NULL) {
|
hTblPtr = GetChannelTable(interp);
|
hTblPtr = GetChannelTable(interp);
|
hPtr = Tcl_CreateHashEntry(hTblPtr, chanPtr->channelName, &new);
|
hPtr = Tcl_CreateHashEntry(hTblPtr, chanPtr->channelName, &new);
|
if (new == 0) {
|
if (new == 0) {
|
if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) {
|
if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) {
|
return;
|
return;
|
}
|
}
|
panic("Tcl_RegisterChannel: duplicate channel names");
|
panic("Tcl_RegisterChannel: duplicate channel names");
|
}
|
}
|
Tcl_SetHashValue(hPtr, (ClientData) chanPtr);
|
Tcl_SetHashValue(hPtr, (ClientData) chanPtr);
|
}
|
}
|
chanPtr->refCount++;
|
chanPtr->refCount++;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannel --
|
* Tcl_GetChannel --
|
*
|
*
|
* Finds an existing Tcl_Channel structure by name in a given
|
* Finds an existing Tcl_Channel structure by name in a given
|
* interpreter. This function is public because it is used by
|
* interpreter. This function is public because it is used by
|
* channel-type-specific functions.
|
* channel-type-specific functions.
|
*
|
*
|
* Results:
|
* Results:
|
* A Tcl_Channel or NULL on failure. If failed, interp->result
|
* A Tcl_Channel or NULL on failure. If failed, interp->result
|
* contains an error message. It also returns, in modePtr, the
|
* contains an error message. It also returns, in modePtr, the
|
* modes in which the channel is opened.
|
* modes in which the channel is opened.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
Tcl_Channel
|
Tcl_Channel
|
Tcl_GetChannel(interp, chanName, modePtr)
|
Tcl_GetChannel(interp, chanName, modePtr)
|
Tcl_Interp *interp; /* Interpreter in which to find or create
|
Tcl_Interp *interp; /* Interpreter in which to find or create
|
* the channel. */
|
* the channel. */
|
char *chanName; /* The name of the channel. */
|
char *chanName; /* The name of the channel. */
|
int *modePtr; /* Where to store the mode in which the
|
int *modePtr; /* Where to store the mode in which the
|
* channel was opened? Will contain an ORed
|
* channel was opened? Will contain an ORed
|
* combination of TCL_READABLE and
|
* combination of TCL_READABLE and
|
* TCL_WRITABLE, if non-NULL. */
|
* TCL_WRITABLE, if non-NULL. */
|
{
|
{
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
char *name; /* Translated name. */
|
char *name; /* Translated name. */
|
|
|
/*
|
/*
|
* Substitute "stdin", etc. Note that even though we immediately
|
* Substitute "stdin", etc. Note that even though we immediately
|
* find the channel using Tcl_GetStdChannel, we still need to look
|
* find the channel using Tcl_GetStdChannel, we still need to look
|
* it up in the specified interpreter to ensure that it is present
|
* it up in the specified interpreter to ensure that it is present
|
* in the channel table. Otherwise, safe interpreters would always
|
* in the channel table. Otherwise, safe interpreters would always
|
* have access to the standard channels.
|
* have access to the standard channels.
|
*/
|
*/
|
|
|
name = chanName;
|
name = chanName;
|
if ((chanName[0] == 's') && (chanName[1] == 't')) {
|
if ((chanName[0] == 's') && (chanName[1] == 't')) {
|
chanPtr = NULL;
|
chanPtr = NULL;
|
if (strcmp(chanName, "stdin") == 0) {
|
if (strcmp(chanName, "stdin") == 0) {
|
chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDIN);
|
chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDIN);
|
} else if (strcmp(chanName, "stdout") == 0) {
|
} else if (strcmp(chanName, "stdout") == 0) {
|
chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDOUT);
|
chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDOUT);
|
} else if (strcmp(chanName, "stderr") == 0) {
|
} else if (strcmp(chanName, "stderr") == 0) {
|
chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDERR);
|
chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDERR);
|
}
|
}
|
if (chanPtr != NULL) {
|
if (chanPtr != NULL) {
|
name = chanPtr->channelName;
|
name = chanPtr->channelName;
|
}
|
}
|
}
|
}
|
|
|
hTblPtr = GetChannelTable(interp);
|
hTblPtr = GetChannelTable(interp);
|
hPtr = Tcl_FindHashEntry(hTblPtr, name);
|
hPtr = Tcl_FindHashEntry(hTblPtr, name);
|
if (hPtr == (Tcl_HashEntry *) NULL) {
|
if (hPtr == (Tcl_HashEntry *) NULL) {
|
Tcl_AppendResult(interp, "can not find channel named \"",
|
Tcl_AppendResult(interp, "can not find channel named \"",
|
chanName, "\"", (char *) NULL);
|
chanName, "\"", (char *) NULL);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
if (modePtr != NULL) {
|
if (modePtr != NULL) {
|
*modePtr = (chanPtr->flags & (TCL_READABLE|TCL_WRITABLE));
|
*modePtr = (chanPtr->flags & (TCL_READABLE|TCL_WRITABLE));
|
}
|
}
|
|
|
return (Tcl_Channel) chanPtr;
|
return (Tcl_Channel) chanPtr;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_CreateChannel --
|
* Tcl_CreateChannel --
|
*
|
*
|
* Creates a new entry in the hash table for a Tcl_Channel
|
* Creates a new entry in the hash table for a Tcl_Channel
|
* record.
|
* record.
|
*
|
*
|
* Results:
|
* Results:
|
* Returns the new Tcl_Channel.
|
* Returns the new Tcl_Channel.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Creates a new Tcl_Channel instance and inserts it into the
|
* Creates a new Tcl_Channel instance and inserts it into the
|
* hash table.
|
* hash table.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
Tcl_Channel
|
Tcl_Channel
|
Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
|
Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
|
Tcl_ChannelType *typePtr; /* The channel type record. */
|
Tcl_ChannelType *typePtr; /* The channel type record. */
|
char *chanName; /* Name of channel to record. */
|
char *chanName; /* Name of channel to record. */
|
ClientData instanceData; /* Instance specific data. */
|
ClientData instanceData; /* Instance specific data. */
|
int mask; /* TCL_READABLE & TCL_WRITABLE to indicate
|
int mask; /* TCL_READABLE & TCL_WRITABLE to indicate
|
* if the channel is readable, writable. */
|
* if the channel is readable, writable. */
|
{
|
{
|
Channel *chanPtr; /* The channel structure newly created. */
|
Channel *chanPtr; /* The channel structure newly created. */
|
|
|
chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
|
chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel));
|
|
|
if (chanName != (char *) NULL) {
|
if (chanName != (char *) NULL) {
|
chanPtr->channelName = ckalloc((unsigned) (strlen(chanName) + 1));
|
chanPtr->channelName = ckalloc((unsigned) (strlen(chanName) + 1));
|
strcpy(chanPtr->channelName, chanName);
|
strcpy(chanPtr->channelName, chanName);
|
} else {
|
} else {
|
panic("Tcl_CreateChannel: NULL channel name");
|
panic("Tcl_CreateChannel: NULL channel name");
|
}
|
}
|
|
|
chanPtr->flags = mask;
|
chanPtr->flags = mask;
|
|
|
/*
|
/*
|
* Set the channel up initially in AUTO input translation mode to
|
* Set the channel up initially in AUTO input translation mode to
|
* accept "\n", "\r" and "\r\n". Output translation mode is set to
|
* accept "\n", "\r" and "\r\n". Output translation mode is set to
|
* a platform specific default value. The eofChar is set to 0 for both
|
* a platform specific default value. The eofChar is set to 0 for both
|
* input and output, so that Tcl does not look for an in-file EOF
|
* input and output, so that Tcl does not look for an in-file EOF
|
* indicator (e.g. ^Z) and does not append an EOF indicator to files.
|
* indicator (e.g. ^Z) and does not append an EOF indicator to files.
|
*/
|
*/
|
|
|
chanPtr->inputTranslation = TCL_TRANSLATE_AUTO;
|
chanPtr->inputTranslation = TCL_TRANSLATE_AUTO;
|
chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
|
chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
|
chanPtr->inEofChar = 0;
|
chanPtr->inEofChar = 0;
|
chanPtr->outEofChar = 0;
|
chanPtr->outEofChar = 0;
|
|
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
chanPtr->instanceData = instanceData;
|
chanPtr->instanceData = instanceData;
|
chanPtr->typePtr = typePtr;
|
chanPtr->typePtr = typePtr;
|
chanPtr->refCount = 0;
|
chanPtr->refCount = 0;
|
chanPtr->closeCbPtr = (CloseCallback *) NULL;
|
chanPtr->closeCbPtr = (CloseCallback *) NULL;
|
chanPtr->curOutPtr = (ChannelBuffer *) NULL;
|
chanPtr->curOutPtr = (ChannelBuffer *) NULL;
|
chanPtr->outQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->outQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->outQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->outQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
|
chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
|
chanPtr->inQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->inQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->inQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->inQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->chPtr = (ChannelHandler *) NULL;
|
chanPtr->chPtr = (ChannelHandler *) NULL;
|
chanPtr->interestMask = 0;
|
chanPtr->interestMask = 0;
|
chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
|
chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
|
chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
|
chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
|
chanPtr->timer = NULL;
|
chanPtr->timer = NULL;
|
chanPtr->csPtr = NULL;
|
chanPtr->csPtr = NULL;
|
|
|
/*
|
/*
|
* Link the channel into the list of all channels; create an on-exit
|
* Link the channel into the list of all channels; create an on-exit
|
* handler if there is not one already, to close off all the channels
|
* handler if there is not one already, to close off all the channels
|
* in the list on exit.
|
* in the list on exit.
|
*/
|
*/
|
|
|
chanPtr->nextChanPtr = firstChanPtr;
|
chanPtr->nextChanPtr = firstChanPtr;
|
firstChanPtr = chanPtr;
|
firstChanPtr = chanPtr;
|
|
|
if (!channelExitHandlerCreated) {
|
if (!channelExitHandlerCreated) {
|
channelExitHandlerCreated = 1;
|
channelExitHandlerCreated = 1;
|
Tcl_CreateExitHandler(CloseChannelsOnExit, (ClientData) NULL);
|
Tcl_CreateExitHandler(CloseChannelsOnExit, (ClientData) NULL);
|
}
|
}
|
|
|
/*
|
/*
|
* Install this channel in the first empty standard channel slot, if
|
* Install this channel in the first empty standard channel slot, if
|
* the channel was previously closed explicitly.
|
* the channel was previously closed explicitly.
|
*/
|
*/
|
|
|
if ((stdinChannel == NULL) && (stdinInitialized == 1)) {
|
if ((stdinChannel == NULL) && (stdinInitialized == 1)) {
|
Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDIN);
|
Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDIN);
|
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
} else if ((stdoutChannel == NULL) && (stdoutInitialized == 1)) {
|
} else if ((stdoutChannel == NULL) && (stdoutInitialized == 1)) {
|
Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDOUT);
|
Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDOUT);
|
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
} else if ((stderrChannel == NULL) && (stderrInitialized == 1)) {
|
} else if ((stderrChannel == NULL) && (stderrInitialized == 1)) {
|
Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDERR);
|
Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDERR);
|
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr);
|
}
|
}
|
return (Tcl_Channel) chanPtr;
|
return (Tcl_Channel) chanPtr;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannelMode --
|
* Tcl_GetChannelMode --
|
*
|
*
|
* Computes a mask indicating whether the channel is open for
|
* Computes a mask indicating whether the channel is open for
|
* reading and writing.
|
* reading and writing.
|
*
|
*
|
* Results:
|
* Results:
|
* An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
|
* An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_GetChannelMode(chan)
|
Tcl_GetChannelMode(chan)
|
Tcl_Channel chan; /* The channel for which the mode is
|
Tcl_Channel chan; /* The channel for which the mode is
|
* being computed. */
|
* being computed. */
|
{
|
{
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
return (chanPtr->flags & (TCL_READABLE | TCL_WRITABLE));
|
return (chanPtr->flags & (TCL_READABLE | TCL_WRITABLE));
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannelName --
|
* Tcl_GetChannelName --
|
*
|
*
|
* Returns the string identifying the channel name.
|
* Returns the string identifying the channel name.
|
*
|
*
|
* Results:
|
* Results:
|
* The string containing the channel name. This memory is
|
* The string containing the channel name. This memory is
|
* owned by the generic layer and should not be modified by
|
* owned by the generic layer and should not be modified by
|
* the caller.
|
* the caller.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
char *
|
char *
|
Tcl_GetChannelName(chan)
|
Tcl_GetChannelName(chan)
|
Tcl_Channel chan; /* The channel for which to return the name. */
|
Tcl_Channel chan; /* The channel for which to return the name. */
|
{
|
{
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
return chanPtr->channelName;
|
return chanPtr->channelName;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannelType --
|
* Tcl_GetChannelType --
|
*
|
*
|
* Given a channel structure, returns the channel type structure.
|
* Given a channel structure, returns the channel type structure.
|
*
|
*
|
* Results:
|
* Results:
|
* Returns a pointer to the channel type structure.
|
* Returns a pointer to the channel type structure.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
Tcl_ChannelType *
|
Tcl_ChannelType *
|
Tcl_GetChannelType(chan)
|
Tcl_GetChannelType(chan)
|
Tcl_Channel chan; /* The channel to return type for. */
|
Tcl_Channel chan; /* The channel to return type for. */
|
{
|
{
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
return chanPtr->typePtr;
|
return chanPtr->typePtr;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannelHandle --
|
* Tcl_GetChannelHandle --
|
*
|
*
|
* Returns an OS handle associated with a channel.
|
* Returns an OS handle associated with a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* Returns TCL_OK and places the handle in handlePtr, or returns
|
* Returns TCL_OK and places the handle in handlePtr, or returns
|
* TCL_ERROR on failure.
|
* TCL_ERROR on failure.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_GetChannelHandle(chan, direction, handlePtr)
|
Tcl_GetChannelHandle(chan, direction, handlePtr)
|
Tcl_Channel chan; /* The channel to get file from. */
|
Tcl_Channel chan; /* The channel to get file from. */
|
int direction; /* TCL_WRITABLE or TCL_READABLE. */
|
int direction; /* TCL_WRITABLE or TCL_READABLE. */
|
ClientData *handlePtr; /* Where to store handle */
|
ClientData *handlePtr; /* Where to store handle */
|
{
|
{
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
ClientData handle;
|
ClientData handle;
|
int result;
|
int result;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
|
result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
|
direction, &handle);
|
direction, &handle);
|
if (handlePtr) {
|
if (handlePtr) {
|
*handlePtr = handle;
|
*handlePtr = handle;
|
}
|
}
|
return result;
|
return result;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannelInstanceData --
|
* Tcl_GetChannelInstanceData --
|
*
|
*
|
* Returns the client data associated with a channel.
|
* Returns the client data associated with a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* The client data.
|
* The client data.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
ClientData
|
ClientData
|
Tcl_GetChannelInstanceData(chan)
|
Tcl_GetChannelInstanceData(chan)
|
Tcl_Channel chan; /* Channel for which to return client data. */
|
Tcl_Channel chan; /* Channel for which to return client data. */
|
{
|
{
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
return chanPtr->instanceData;
|
return chanPtr->instanceData;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* RecycleBuffer --
|
* RecycleBuffer --
|
*
|
*
|
* Helper function to recycle input and output buffers. Ensures
|
* Helper function to recycle input and output buffers. Ensures
|
* that two input buffers are saved (one in the input queue and
|
* that two input buffers are saved (one in the input queue and
|
* another in the saveInBufPtr field) and that curOutPtr is set
|
* another in the saveInBufPtr field) and that curOutPtr is set
|
* to a buffer. Only if these conditions are met is the buffer
|
* to a buffer. Only if these conditions are met is the buffer
|
* freed to the OS.
|
* freed to the OS.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May free a buffer to the OS.
|
* May free a buffer to the OS.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
RecycleBuffer(chanPtr, bufPtr, mustDiscard)
|
RecycleBuffer(chanPtr, bufPtr, mustDiscard)
|
Channel *chanPtr; /* Channel for which to recycle buffers. */
|
Channel *chanPtr; /* Channel for which to recycle buffers. */
|
ChannelBuffer *bufPtr; /* The buffer to recycle. */
|
ChannelBuffer *bufPtr; /* The buffer to recycle. */
|
int mustDiscard; /* If nonzero, free the buffer to the
|
int mustDiscard; /* If nonzero, free the buffer to the
|
* OS, always. */
|
* OS, always. */
|
{
|
{
|
/*
|
/*
|
* Do we have to free the buffer to the OS?
|
* Do we have to free the buffer to the OS?
|
*/
|
*/
|
|
|
if (mustDiscard) {
|
if (mustDiscard) {
|
ckfree((char *) bufPtr);
|
ckfree((char *) bufPtr);
|
return;
|
return;
|
}
|
}
|
|
|
/*
|
/*
|
* Only save buffers for the input queue if the channel is readable.
|
* Only save buffers for the input queue if the channel is readable.
|
*/
|
*/
|
|
|
if (chanPtr->flags & TCL_READABLE) {
|
if (chanPtr->flags & TCL_READABLE) {
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
chanPtr->inQueueHead = bufPtr;
|
chanPtr->inQueueHead = bufPtr;
|
chanPtr->inQueueTail = bufPtr;
|
chanPtr->inQueueTail = bufPtr;
|
goto keepit;
|
goto keepit;
|
}
|
}
|
if (chanPtr->saveInBufPtr == (ChannelBuffer *) NULL) {
|
if (chanPtr->saveInBufPtr == (ChannelBuffer *) NULL) {
|
chanPtr->saveInBufPtr = bufPtr;
|
chanPtr->saveInBufPtr = bufPtr;
|
goto keepit;
|
goto keepit;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Only save buffers for the output queue if the channel is writable.
|
* Only save buffers for the output queue if the channel is writable.
|
*/
|
*/
|
|
|
if (chanPtr->flags & TCL_WRITABLE) {
|
if (chanPtr->flags & TCL_WRITABLE) {
|
if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
|
if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
|
chanPtr->curOutPtr = bufPtr;
|
chanPtr->curOutPtr = bufPtr;
|
goto keepit;
|
goto keepit;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* If we reached this code we return the buffer to the OS.
|
* If we reached this code we return the buffer to the OS.
|
*/
|
*/
|
|
|
ckfree((char *) bufPtr);
|
ckfree((char *) bufPtr);
|
return;
|
return;
|
|
|
keepit:
|
keepit:
|
bufPtr->nextRemoved = 0;
|
bufPtr->nextRemoved = 0;
|
bufPtr->nextAdded = 0;
|
bufPtr->nextAdded = 0;
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* DiscardOutputQueued --
|
* DiscardOutputQueued --
|
*
|
*
|
* Discards all output queued in the output queue of a channel.
|
* Discards all output queued in the output queue of a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Recycles buffers.
|
* Recycles buffers.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
DiscardOutputQueued(chanPtr)
|
DiscardOutputQueued(chanPtr)
|
Channel *chanPtr; /* The channel for which to discard output. */
|
Channel *chanPtr; /* The channel for which to discard output. */
|
{
|
{
|
ChannelBuffer *bufPtr;
|
ChannelBuffer *bufPtr;
|
|
|
while (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
|
while (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
|
bufPtr = chanPtr->outQueueHead;
|
bufPtr = chanPtr->outQueueHead;
|
chanPtr->outQueueHead = bufPtr->nextPtr;
|
chanPtr->outQueueHead = bufPtr->nextPtr;
|
RecycleBuffer(chanPtr, bufPtr, 0);
|
RecycleBuffer(chanPtr, bufPtr, 0);
|
}
|
}
|
chanPtr->outQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->outQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->outQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->outQueueTail = (ChannelBuffer *) NULL;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CheckForDeadChannel --
|
* CheckForDeadChannel --
|
*
|
*
|
* This function checks is a given channel is Dead.
|
* This function checks is a given channel is Dead.
|
* (A channel that has been closed but not yet deallocated.)
|
* (A channel that has been closed but not yet deallocated.)
|
*
|
*
|
* Results:
|
* Results:
|
* True (1) if channel is Dead, False (0) if channel is Ok
|
* True (1) if channel is Dead, False (0) if channel is Ok
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None
|
* None
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
CheckForDeadChannel(interp, chanPtr)
|
CheckForDeadChannel(interp, chanPtr)
|
Tcl_Interp *interp; /* For error reporting (can be NULL) */
|
Tcl_Interp *interp; /* For error reporting (can be NULL) */
|
Channel *chanPtr; /* The channel to check. */
|
Channel *chanPtr; /* The channel to check. */
|
{
|
{
|
if (chanPtr->flags & CHANNEL_DEAD) {
|
if (chanPtr->flags & CHANNEL_DEAD) {
|
Tcl_SetErrno(EINVAL);
|
Tcl_SetErrno(EINVAL);
|
if (interp) {
|
if (interp) {
|
Tcl_AppendResult(interp,
|
Tcl_AppendResult(interp,
|
"unable to access channel: invalid channel",
|
"unable to access channel: invalid channel",
|
(char *) NULL);
|
(char *) NULL);
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* FlushChannel --
|
* FlushChannel --
|
*
|
*
|
* This function flushes as much of the queued output as is possible
|
* This function flushes as much of the queued output as is possible
|
* now. If calledFromAsyncFlush is nonzero, it is being called in an
|
* now. If calledFromAsyncFlush is nonzero, it is being called in an
|
* event handler to flush channel output asynchronously.
|
* event handler to flush channel output asynchronously.
|
*
|
*
|
* Results:
|
* Results:
|
* 0 if successful, else the error code that was returned by the
|
* 0 if successful, else the error code that was returned by the
|
* channel type operation.
|
* channel type operation.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May produce output on a channel. May block indefinitely if the
|
* May produce output on a channel. May block indefinitely if the
|
* channel is synchronous. May schedule an async flush on the channel.
|
* channel is synchronous. May schedule an async flush on the channel.
|
* May recycle memory for buffers in the output queue.
|
* May recycle memory for buffers in the output queue.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
FlushChannel(interp, chanPtr, calledFromAsyncFlush)
|
FlushChannel(interp, chanPtr, calledFromAsyncFlush)
|
Tcl_Interp *interp; /* For error reporting during close. */
|
Tcl_Interp *interp; /* For error reporting during close. */
|
Channel *chanPtr; /* The channel to flush on. */
|
Channel *chanPtr; /* The channel to flush on. */
|
int calledFromAsyncFlush; /* If nonzero then we are being
|
int calledFromAsyncFlush; /* If nonzero then we are being
|
* called from an asynchronous
|
* called from an asynchronous
|
* flush callback. */
|
* flush callback. */
|
{
|
{
|
ChannelBuffer *bufPtr; /* Iterates over buffered output
|
ChannelBuffer *bufPtr; /* Iterates over buffered output
|
* queue. */
|
* queue. */
|
int toWrite; /* Amount of output data in current
|
int toWrite; /* Amount of output data in current
|
* buffer available to be written. */
|
* buffer available to be written. */
|
int written; /* Amount of output data actually
|
int written; /* Amount of output data actually
|
* written in current round. */
|
* written in current round. */
|
int errorCode; /* Stores POSIX error codes from
|
int errorCode; /* Stores POSIX error codes from
|
* channel driver operations. */
|
* channel driver operations. */
|
errorCode = 0;
|
errorCode = 0;
|
|
|
/*
|
/*
|
* Prevent writing on a dead channel -- a channel that has been closed
|
* Prevent writing on a dead channel -- a channel that has been closed
|
* but not yet deallocated. This can occur if the exit handler for the
|
* but not yet deallocated. This can occur if the exit handler for the
|
* channel deallocation runs before all channels are deregistered in
|
* channel deallocation runs before all channels are deregistered in
|
* all interpreters.
|
* all interpreters.
|
*/
|
*/
|
|
|
if (CheckForDeadChannel(interp,chanPtr)) return -1;
|
if (CheckForDeadChannel(interp,chanPtr)) return -1;
|
|
|
/*
|
/*
|
* Loop over the queued buffers and attempt to flush as
|
* Loop over the queued buffers and attempt to flush as
|
* much as possible of the queued output to the channel.
|
* much as possible of the queued output to the channel.
|
*/
|
*/
|
|
|
while (1) {
|
while (1) {
|
|
|
/*
|
/*
|
* If the queue is empty and there is a ready current buffer, OR if
|
* If the queue is empty and there is a ready current buffer, OR if
|
* the current buffer is full, then move the current buffer to the
|
* the current buffer is full, then move the current buffer to the
|
* queue.
|
* queue.
|
*/
|
*/
|
|
|
if (((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
if (((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
(chanPtr->curOutPtr->nextAdded == chanPtr->curOutPtr->bufSize))
|
(chanPtr->curOutPtr->nextAdded == chanPtr->curOutPtr->bufSize))
|
|| ((chanPtr->flags & BUFFER_READY) &&
|
|| ((chanPtr->flags & BUFFER_READY) &&
|
(chanPtr->outQueueHead == (ChannelBuffer *) NULL))) {
|
(chanPtr->outQueueHead == (ChannelBuffer *) NULL))) {
|
chanPtr->flags &= (~(BUFFER_READY));
|
chanPtr->flags &= (~(BUFFER_READY));
|
chanPtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
|
chanPtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
|
if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
|
if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
|
chanPtr->outQueueHead = chanPtr->curOutPtr;
|
chanPtr->outQueueHead = chanPtr->curOutPtr;
|
} else {
|
} else {
|
chanPtr->outQueueTail->nextPtr = chanPtr->curOutPtr;
|
chanPtr->outQueueTail->nextPtr = chanPtr->curOutPtr;
|
}
|
}
|
chanPtr->outQueueTail = chanPtr->curOutPtr;
|
chanPtr->outQueueTail = chanPtr->curOutPtr;
|
chanPtr->curOutPtr = (ChannelBuffer *) NULL;
|
chanPtr->curOutPtr = (ChannelBuffer *) NULL;
|
}
|
}
|
bufPtr = chanPtr->outQueueHead;
|
bufPtr = chanPtr->outQueueHead;
|
|
|
/*
|
/*
|
* If we are not being called from an async flush and an async
|
* If we are not being called from an async flush and an async
|
* flush is active, we just return without producing any output.
|
* flush is active, we just return without producing any output.
|
*/
|
*/
|
|
|
if ((!calledFromAsyncFlush) &&
|
if ((!calledFromAsyncFlush) &&
|
(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* If the output queue is still empty, break out of the while loop.
|
* If the output queue is still empty, break out of the while loop.
|
*/
|
*/
|
|
|
if (bufPtr == (ChannelBuffer *) NULL) {
|
if (bufPtr == (ChannelBuffer *) NULL) {
|
break; /* Out of the "while (1)". */
|
break; /* Out of the "while (1)". */
|
}
|
}
|
|
|
/*
|
/*
|
* Produce the output on the channel.
|
* Produce the output on the channel.
|
*/
|
*/
|
|
|
toWrite = bufPtr->nextAdded - bufPtr->nextRemoved;
|
toWrite = bufPtr->nextAdded - bufPtr->nextRemoved;
|
written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
|
written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
|
bufPtr->buf + bufPtr->nextRemoved, toWrite, &errorCode);
|
bufPtr->buf + bufPtr->nextRemoved, toWrite, &errorCode);
|
|
|
/*
|
/*
|
* If the write failed completely attempt to start the asynchronous
|
* If the write failed completely attempt to start the asynchronous
|
* flush mechanism and break out of this loop - do not attempt to
|
* flush mechanism and break out of this loop - do not attempt to
|
* write any more output at this time.
|
* write any more output at this time.
|
*/
|
*/
|
|
|
if (written < 0) {
|
if (written < 0) {
|
|
|
/*
|
/*
|
* If the last attempt to write was interrupted, simply retry.
|
* If the last attempt to write was interrupted, simply retry.
|
*/
|
*/
|
|
|
if (errorCode == EINTR) {
|
if (errorCode == EINTR) {
|
errorCode = 0;
|
errorCode = 0;
|
continue;
|
continue;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is non-blocking and we would have blocked,
|
* If the channel is non-blocking and we would have blocked,
|
* start a background flushing handler and break out of the loop.
|
* start a background flushing handler and break out of the loop.
|
*/
|
*/
|
|
|
if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) {
|
if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
chanPtr->flags |= BG_FLUSH_SCHEDULED;
|
chanPtr->flags |= BG_FLUSH_SCHEDULED;
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
}
|
}
|
errorCode = 0;
|
errorCode = 0;
|
break;
|
break;
|
} else {
|
} else {
|
panic("Blocking channel driver did not block on output");
|
panic("Blocking channel driver did not block on output");
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Decide whether to report the error upwards or defer it.
|
* Decide whether to report the error upwards or defer it.
|
*/
|
*/
|
|
|
if (calledFromAsyncFlush) {
|
if (calledFromAsyncFlush) {
|
if (chanPtr->unreportedError == 0) {
|
if (chanPtr->unreportedError == 0) {
|
chanPtr->unreportedError = errorCode;
|
chanPtr->unreportedError = errorCode;
|
}
|
}
|
} else {
|
} else {
|
Tcl_SetErrno(errorCode);
|
Tcl_SetErrno(errorCode);
|
if (interp != NULL) {
|
if (interp != NULL) {
|
Tcl_SetResult(interp,
|
Tcl_SetResult(interp,
|
Tcl_PosixError(interp), TCL_VOLATILE);
|
Tcl_PosixError(interp), TCL_VOLATILE);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* When we get an error we throw away all the output
|
* When we get an error we throw away all the output
|
* currently queued.
|
* currently queued.
|
*/
|
*/
|
|
|
DiscardOutputQueued(chanPtr);
|
DiscardOutputQueued(chanPtr);
|
continue;
|
continue;
|
}
|
}
|
|
|
bufPtr->nextRemoved += written;
|
bufPtr->nextRemoved += written;
|
|
|
/*
|
/*
|
* If this buffer is now empty, recycle it.
|
* If this buffer is now empty, recycle it.
|
*/
|
*/
|
|
|
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
|
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
|
chanPtr->outQueueHead = bufPtr->nextPtr;
|
chanPtr->outQueueHead = bufPtr->nextPtr;
|
if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
|
if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) {
|
chanPtr->outQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->outQueueTail = (ChannelBuffer *) NULL;
|
}
|
}
|
RecycleBuffer(chanPtr, bufPtr, 0);
|
RecycleBuffer(chanPtr, bufPtr, 0);
|
}
|
}
|
} /* Closes "while (1)". */
|
} /* Closes "while (1)". */
|
|
|
/*
|
/*
|
* If the queue became empty and we have the asynchronous flushing
|
* If the queue became empty and we have the asynchronous flushing
|
* mechanism active, cancel the asynchronous flushing.
|
* mechanism active, cancel the asynchronous flushing.
|
*/
|
*/
|
|
|
if ((chanPtr->outQueueHead == (ChannelBuffer *) NULL) &&
|
if ((chanPtr->outQueueHead == (ChannelBuffer *) NULL) &&
|
(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
(chanPtr->flags & BG_FLUSH_SCHEDULED)) {
|
chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
|
chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
|
(chanPtr->typePtr->watchProc)(chanPtr->instanceData,
|
(chanPtr->typePtr->watchProc)(chanPtr->instanceData,
|
chanPtr->interestMask);
|
chanPtr->interestMask);
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is flagged as closed, delete it when the refCount
|
* If the channel is flagged as closed, delete it when the refCount
|
* drops to zero, the output queue is empty and there is no output
|
* drops to zero, the output queue is empty and there is no output
|
* in the current output buffer.
|
* in the current output buffer.
|
*/
|
*/
|
|
|
if ((chanPtr->flags & CHANNEL_CLOSED) && (chanPtr->refCount <= 0) &&
|
if ((chanPtr->flags & CHANNEL_CLOSED) && (chanPtr->refCount <= 0) &&
|
(chanPtr->outQueueHead == (ChannelBuffer *) NULL) &&
|
(chanPtr->outQueueHead == (ChannelBuffer *) NULL) &&
|
((chanPtr->curOutPtr == (ChannelBuffer *) NULL) ||
|
((chanPtr->curOutPtr == (ChannelBuffer *) NULL) ||
|
(chanPtr->curOutPtr->nextAdded ==
|
(chanPtr->curOutPtr->nextAdded ==
|
chanPtr->curOutPtr->nextRemoved))) {
|
chanPtr->curOutPtr->nextRemoved))) {
|
return CloseChannel(interp, chanPtr, errorCode);
|
return CloseChannel(interp, chanPtr, errorCode);
|
}
|
}
|
return errorCode;
|
return errorCode;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CloseChannel --
|
* CloseChannel --
|
*
|
*
|
* Utility procedure to close a channel and free its associated
|
* Utility procedure to close a channel and free its associated
|
* resources.
|
* resources.
|
*
|
*
|
* Results:
|
* Results:
|
* 0 on success or a POSIX error code if the operation failed.
|
* 0 on success or a POSIX error code if the operation failed.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May close the actual channel; may free memory.
|
* May close the actual channel; may free memory.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
CloseChannel(interp, chanPtr, errorCode)
|
CloseChannel(interp, chanPtr, errorCode)
|
Tcl_Interp *interp; /* For error reporting. */
|
Tcl_Interp *interp; /* For error reporting. */
|
Channel *chanPtr; /* The channel to close. */
|
Channel *chanPtr; /* The channel to close. */
|
int errorCode; /* Status of operation so far. */
|
int errorCode; /* Status of operation so far. */
|
{
|
{
|
int result = 0; /* Of calling driver close
|
int result = 0; /* Of calling driver close
|
* operation. */
|
* operation. */
|
Channel *prevChanPtr; /* Preceding channel in list of
|
Channel *prevChanPtr; /* Preceding channel in list of
|
* all channels - used to splice a
|
* all channels - used to splice a
|
* channel out of the list on close. */
|
* channel out of the list on close. */
|
|
|
if (chanPtr == NULL) {
|
if (chanPtr == NULL) {
|
return result;
|
return result;
|
}
|
}
|
|
|
/*
|
/*
|
* No more input can be consumed so discard any leftover input.
|
* No more input can be consumed so discard any leftover input.
|
*/
|
*/
|
|
|
DiscardInputQueued(chanPtr, 1);
|
DiscardInputQueued(chanPtr, 1);
|
|
|
/*
|
/*
|
* Discard a leftover buffer in the current output buffer field.
|
* Discard a leftover buffer in the current output buffer field.
|
*/
|
*/
|
|
|
if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
|
if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
|
ckfree((char *) chanPtr->curOutPtr);
|
ckfree((char *) chanPtr->curOutPtr);
|
chanPtr->curOutPtr = (ChannelBuffer *) NULL;
|
chanPtr->curOutPtr = (ChannelBuffer *) NULL;
|
}
|
}
|
|
|
/*
|
/*
|
* The caller guarantees that there are no more buffers
|
* The caller guarantees that there are no more buffers
|
* queued for output.
|
* queued for output.
|
*/
|
*/
|
|
|
if (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
|
if (chanPtr->outQueueHead != (ChannelBuffer *) NULL) {
|
panic("TclFlush, closed channel: queued output left");
|
panic("TclFlush, closed channel: queued output left");
|
}
|
}
|
|
|
/*
|
/*
|
* If the EOF character is set in the channel, append that to the
|
* If the EOF character is set in the channel, append that to the
|
* output device.
|
* output device.
|
*/
|
*/
|
|
|
if ((chanPtr->outEofChar != 0) && (chanPtr->flags & TCL_WRITABLE)) {
|
if ((chanPtr->outEofChar != 0) && (chanPtr->flags & TCL_WRITABLE)) {
|
int dummy;
|
int dummy;
|
char c;
|
char c;
|
|
|
c = (char) chanPtr->outEofChar;
|
c = (char) chanPtr->outEofChar;
|
(chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy);
|
(chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy);
|
}
|
}
|
|
|
/*
|
/*
|
* Remove TCL_READABLE and TCL_WRITABLE from chanPtr->flags, so
|
* Remove TCL_READABLE and TCL_WRITABLE from chanPtr->flags, so
|
* that close callbacks can not do input or output (assuming they
|
* that close callbacks can not do input or output (assuming they
|
* squirreled the channel away in their clientData). This also
|
* squirreled the channel away in their clientData). This also
|
* prevents infinite loops if the callback calls any C API that
|
* prevents infinite loops if the callback calls any C API that
|
* could call FlushChannel.
|
* could call FlushChannel.
|
*/
|
*/
|
|
|
chanPtr->flags &= (~(TCL_READABLE|TCL_WRITABLE));
|
chanPtr->flags &= (~(TCL_READABLE|TCL_WRITABLE));
|
|
|
/*
|
/*
|
* Splice this channel out of the list of all channels.
|
* Splice this channel out of the list of all channels.
|
*/
|
*/
|
|
|
if (chanPtr == firstChanPtr) {
|
if (chanPtr == firstChanPtr) {
|
firstChanPtr = chanPtr->nextChanPtr;
|
firstChanPtr = chanPtr->nextChanPtr;
|
} else {
|
} else {
|
for (prevChanPtr = firstChanPtr;
|
for (prevChanPtr = firstChanPtr;
|
(prevChanPtr != (Channel *) NULL) &&
|
(prevChanPtr != (Channel *) NULL) &&
|
(prevChanPtr->nextChanPtr != chanPtr);
|
(prevChanPtr->nextChanPtr != chanPtr);
|
prevChanPtr = prevChanPtr->nextChanPtr) {
|
prevChanPtr = prevChanPtr->nextChanPtr) {
|
/* Empty loop body. */
|
/* Empty loop body. */
|
}
|
}
|
if (prevChanPtr == (Channel *) NULL) {
|
if (prevChanPtr == (Channel *) NULL) {
|
panic("FlushChannel: damaged channel list");
|
panic("FlushChannel: damaged channel list");
|
}
|
}
|
prevChanPtr->nextChanPtr = chanPtr->nextChanPtr;
|
prevChanPtr->nextChanPtr = chanPtr->nextChanPtr;
|
}
|
}
|
|
|
/*
|
/*
|
* OK, close the channel itself.
|
* OK, close the channel itself.
|
*/
|
*/
|
|
|
result = (chanPtr->typePtr->closeProc) (chanPtr->instanceData, interp);
|
result = (chanPtr->typePtr->closeProc) (chanPtr->instanceData, interp);
|
|
|
if (chanPtr->channelName != (char *) NULL) {
|
if (chanPtr->channelName != (char *) NULL) {
|
ckfree(chanPtr->channelName);
|
ckfree(chanPtr->channelName);
|
}
|
}
|
|
|
/*
|
/*
|
* If we are being called synchronously, report either
|
* If we are being called synchronously, report either
|
* any latent error on the channel or the current error.
|
* any latent error on the channel or the current error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
errorCode = chanPtr->unreportedError;
|
errorCode = chanPtr->unreportedError;
|
}
|
}
|
if (errorCode == 0) {
|
if (errorCode == 0) {
|
errorCode = result;
|
errorCode = result;
|
if (errorCode != 0) {
|
if (errorCode != 0) {
|
Tcl_SetErrno(errorCode);
|
Tcl_SetErrno(errorCode);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Cancel any outstanding timer.
|
* Cancel any outstanding timer.
|
*/
|
*/
|
|
|
Tcl_DeleteTimerHandler(chanPtr->timer);
|
Tcl_DeleteTimerHandler(chanPtr->timer);
|
|
|
/*
|
/*
|
* Mark the channel as deleted by clearing the type structure.
|
* Mark the channel as deleted by clearing the type structure.
|
*/
|
*/
|
|
|
chanPtr->typePtr = NULL;
|
chanPtr->typePtr = NULL;
|
|
|
Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
|
Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
|
|
|
return errorCode;
|
return errorCode;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Close --
|
* Tcl_Close --
|
*
|
*
|
* Closes a channel.
|
* Closes a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Closes the channel if this is the last reference.
|
* Closes the channel if this is the last reference.
|
*
|
*
|
* NOTE:
|
* NOTE:
|
* Tcl_Close removes the channel as far as the user is concerned.
|
* Tcl_Close removes the channel as far as the user is concerned.
|
* However, it may continue to exist for a while longer if it has
|
* However, it may continue to exist for a while longer if it has
|
* a background flush scheduled. The device itself is eventually
|
* a background flush scheduled. The device itself is eventually
|
* closed and the channel record removed, in CloseChannel, above.
|
* closed and the channel record removed, in CloseChannel, above.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
/* ARGSUSED */
|
/* ARGSUSED */
|
int
|
int
|
Tcl_Close(interp, chan)
|
Tcl_Close(interp, chan)
|
Tcl_Interp *interp; /* Interpreter for errors. */
|
Tcl_Interp *interp; /* Interpreter for errors. */
|
Tcl_Channel chan; /* The channel being closed. Must
|
Tcl_Channel chan; /* The channel being closed. Must
|
* not be referenced in any
|
* not be referenced in any
|
* interpreter. */
|
* interpreter. */
|
{
|
{
|
ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */
|
ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */
|
CloseCallback *cbPtr; /* Iterate over close callbacks
|
CloseCallback *cbPtr; /* Iterate over close callbacks
|
* for this channel. */
|
* for this channel. */
|
EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */
|
EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */
|
Channel *chanPtr; /* The real IO channel. */
|
Channel *chanPtr; /* The real IO channel. */
|
int result; /* Of calling FlushChannel. */
|
int result; /* Of calling FlushChannel. */
|
NextChannelHandler *nhPtr;
|
NextChannelHandler *nhPtr;
|
|
|
if (chan == (Tcl_Channel) NULL) {
|
if (chan == (Tcl_Channel) NULL) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
* Perform special handling for standard channels being closed. If the
|
* Perform special handling for standard channels being closed. If the
|
* refCount is now 1 it means that the last reference to the standard
|
* refCount is now 1 it means that the last reference to the standard
|
* channel is being explicitly closed, so bump the refCount down
|
* channel is being explicitly closed, so bump the refCount down
|
* artificially to 0. This will ensure that the channel is actually
|
* artificially to 0. This will ensure that the channel is actually
|
* closed, below. Also set the static pointer to NULL for the channel.
|
* closed, below. Also set the static pointer to NULL for the channel.
|
*/
|
*/
|
|
|
CheckForStdChannelsBeingClosed(chan);
|
CheckForStdChannelsBeingClosed(chan);
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
if (chanPtr->refCount > 0) {
|
if (chanPtr->refCount > 0) {
|
panic("called Tcl_Close on channel with refCount > 0");
|
panic("called Tcl_Close on channel with refCount > 0");
|
}
|
}
|
|
|
/*
|
/*
|
* Remove any references to channel handlers for this channel that
|
* Remove any references to channel handlers for this channel that
|
* may be about to be invoked.
|
* may be about to be invoked.
|
*/
|
*/
|
|
|
for (nhPtr = nestedHandlerPtr;
|
for (nhPtr = nestedHandlerPtr;
|
nhPtr != (NextChannelHandler *) NULL;
|
nhPtr != (NextChannelHandler *) NULL;
|
nhPtr = nhPtr->nestedHandlerPtr) {
|
nhPtr = nhPtr->nestedHandlerPtr) {
|
if (nhPtr->nextHandlerPtr &&
|
if (nhPtr->nextHandlerPtr &&
|
(nhPtr->nextHandlerPtr->chanPtr == chanPtr)) {
|
(nhPtr->nextHandlerPtr->chanPtr == chanPtr)) {
|
nhPtr->nextHandlerPtr = NULL;
|
nhPtr->nextHandlerPtr = NULL;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Remove all the channel handler records attached to the channel
|
* Remove all the channel handler records attached to the channel
|
* itself.
|
* itself.
|
*/
|
*/
|
|
|
for (chPtr = chanPtr->chPtr;
|
for (chPtr = chanPtr->chPtr;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr = chNext) {
|
chPtr = chNext) {
|
chNext = chPtr->nextPtr;
|
chNext = chPtr->nextPtr;
|
ckfree((char *) chPtr);
|
ckfree((char *) chPtr);
|
}
|
}
|
chanPtr->chPtr = (ChannelHandler *) NULL;
|
chanPtr->chPtr = (ChannelHandler *) NULL;
|
|
|
|
|
/*
|
/*
|
* Cancel any pending copy operation.
|
* Cancel any pending copy operation.
|
*/
|
*/
|
|
|
StopCopy(chanPtr->csPtr);
|
StopCopy(chanPtr->csPtr);
|
|
|
/*
|
/*
|
* Must set the interest mask now to 0, otherwise infinite loops
|
* Must set the interest mask now to 0, otherwise infinite loops
|
* will occur if Tcl_DoOneEvent is called before the channel is
|
* will occur if Tcl_DoOneEvent is called before the channel is
|
* finally deleted in FlushChannel. This can happen if the channel
|
* finally deleted in FlushChannel. This can happen if the channel
|
* has a background flush active.
|
* has a background flush active.
|
*/
|
*/
|
|
|
chanPtr->interestMask = 0;
|
chanPtr->interestMask = 0;
|
|
|
/*
|
/*
|
* Remove any EventScript records for this channel.
|
* Remove any EventScript records for this channel.
|
*/
|
*/
|
|
|
for (ePtr = chanPtr->scriptRecordPtr;
|
for (ePtr = chanPtr->scriptRecordPtr;
|
ePtr != (EventScriptRecord *) NULL;
|
ePtr != (EventScriptRecord *) NULL;
|
ePtr = eNextPtr) {
|
ePtr = eNextPtr) {
|
eNextPtr = ePtr->nextPtr;
|
eNextPtr = ePtr->nextPtr;
|
ckfree(ePtr->script);
|
ckfree(ePtr->script);
|
ckfree((char *) ePtr);
|
ckfree((char *) ePtr);
|
}
|
}
|
chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
|
chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
|
|
|
/*
|
/*
|
* Invoke the registered close callbacks and delete their records.
|
* Invoke the registered close callbacks and delete their records.
|
*/
|
*/
|
|
|
while (chanPtr->closeCbPtr != (CloseCallback *) NULL) {
|
while (chanPtr->closeCbPtr != (CloseCallback *) NULL) {
|
cbPtr = chanPtr->closeCbPtr;
|
cbPtr = chanPtr->closeCbPtr;
|
chanPtr->closeCbPtr = cbPtr->nextPtr;
|
chanPtr->closeCbPtr = cbPtr->nextPtr;
|
(cbPtr->proc) (cbPtr->clientData);
|
(cbPtr->proc) (cbPtr->clientData);
|
ckfree((char *) cbPtr);
|
ckfree((char *) cbPtr);
|
}
|
}
|
|
|
/*
|
/*
|
* Ensure that the last output buffer will be flushed.
|
* Ensure that the last output buffer will be flushed.
|
*/
|
*/
|
|
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
(chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
|
(chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
}
|
}
|
|
|
/*
|
/*
|
* The call to FlushChannel will flush any queued output and invoke
|
* The call to FlushChannel will flush any queued output and invoke
|
* the close function of the channel driver, or it will set up the
|
* the close function of the channel driver, or it will set up the
|
* channel to be flushed and closed asynchronously.
|
* channel to be flushed and closed asynchronously.
|
*/
|
*/
|
|
|
chanPtr->flags |= CHANNEL_CLOSED;
|
chanPtr->flags |= CHANNEL_CLOSED;
|
result = FlushChannel(interp, chanPtr, 0);
|
result = FlushChannel(interp, chanPtr, 0);
|
if (result != 0) {
|
if (result != 0) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Write --
|
* Tcl_Write --
|
*
|
*
|
* Puts a sequence of characters into an output buffer, may queue the
|
* Puts a sequence of characters into an output buffer, may queue the
|
* buffer for output if it gets full, and also remembers whether the
|
* buffer for output if it gets full, and also remembers whether the
|
* current buffer is ready e.g. if it contains a newline and we are in
|
* current buffer is ready e.g. if it contains a newline and we are in
|
* line buffering mode.
|
* line buffering mode.
|
*
|
*
|
* Results:
|
* Results:
|
* The number of bytes written or -1 in case of error. If -1,
|
* The number of bytes written or -1 in case of error. If -1,
|
* Tcl_GetErrno will return the error code.
|
* Tcl_GetErrno will return the error code.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May buffer up output and may cause output to be produced on the
|
* May buffer up output and may cause output to be produced on the
|
* channel.
|
* channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Write(chan, srcPtr, slen)
|
Tcl_Write(chan, srcPtr, slen)
|
Tcl_Channel chan; /* The channel to buffer output for. */
|
Tcl_Channel chan; /* The channel to buffer output for. */
|
char *srcPtr; /* Output to buffer. */
|
char *srcPtr; /* Output to buffer. */
|
int slen; /* Its length. Negative means
|
int slen; /* Its length. Negative means
|
* the output is null terminated
|
* the output is null terminated
|
* and we must compute its length. */
|
* and we must compute its length. */
|
{
|
{
|
Channel *chanPtr = (Channel *) chan;
|
Channel *chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Check for unreported error.
|
* Check for unreported error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
Tcl_SetErrno(chanPtr->unreportedError);
|
Tcl_SetErrno(chanPtr->unreportedError);
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is not open for writing punt.
|
* If the channel is not open for writing punt.
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & TCL_WRITABLE)) {
|
if (!(chanPtr->flags & TCL_WRITABLE)) {
|
Tcl_SetErrno(EACCES);
|
Tcl_SetErrno(EACCES);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
Tcl_SetErrno(EBUSY);
|
Tcl_SetErrno(EBUSY);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If length passed is negative, assume that the output is null terminated
|
* If length passed is negative, assume that the output is null terminated
|
* and compute its length.
|
* and compute its length.
|
*/
|
*/
|
|
|
if (slen < 0) {
|
if (slen < 0) {
|
slen = strlen(srcPtr);
|
slen = strlen(srcPtr);
|
}
|
}
|
|
|
return DoWrite(chanPtr, srcPtr, slen);
|
return DoWrite(chanPtr, srcPtr, slen);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* DoWrite --
|
* DoWrite --
|
*
|
*
|
* Puts a sequence of characters into an output buffer, may queue the
|
* Puts a sequence of characters into an output buffer, may queue the
|
* buffer for output if it gets full, and also remembers whether the
|
* buffer for output if it gets full, and also remembers whether the
|
* current buffer is ready e.g. if it contains a newline and we are in
|
* current buffer is ready e.g. if it contains a newline and we are in
|
* line buffering mode.
|
* line buffering mode.
|
*
|
*
|
* Results:
|
* Results:
|
* The number of bytes written or -1 in case of error. If -1,
|
* The number of bytes written or -1 in case of error. If -1,
|
* Tcl_GetErrno will return the error code.
|
* Tcl_GetErrno will return the error code.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May buffer up output and may cause output to be produced on the
|
* May buffer up output and may cause output to be produced on the
|
* channel.
|
* channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
DoWrite(chanPtr, srcPtr, slen)
|
DoWrite(chanPtr, srcPtr, slen)
|
Channel *chanPtr; /* The channel to buffer output for. */
|
Channel *chanPtr; /* The channel to buffer output for. */
|
char *srcPtr; /* Data to write. */
|
char *srcPtr; /* Data to write. */
|
int slen; /* Number of bytes to write. */
|
int slen; /* Number of bytes to write. */
|
{
|
{
|
ChannelBuffer *outBufPtr; /* Current output buffer. */
|
ChannelBuffer *outBufPtr; /* Current output buffer. */
|
int foundNewline; /* Did we find a newline in output? */
|
int foundNewline; /* Did we find a newline in output? */
|
char *dPtr, *sPtr; /* Search variables for newline. */
|
char *dPtr, *sPtr; /* Search variables for newline. */
|
int crsent; /* In CRLF eol translation mode,
|
int crsent; /* In CRLF eol translation mode,
|
* remember the fact that a CR was
|
* remember the fact that a CR was
|
* output to the channel without
|
* output to the channel without
|
* its following NL. */
|
* its following NL. */
|
int i; /* Loop index for newline search. */
|
int i; /* Loop index for newline search. */
|
int destCopied; /* How many bytes were used in this
|
int destCopied; /* How many bytes were used in this
|
* destination buffer to hold the
|
* destination buffer to hold the
|
* output? */
|
* output? */
|
int totalDestCopied; /* How many bytes total were
|
int totalDestCopied; /* How many bytes total were
|
* copied to the channel buffer? */
|
* copied to the channel buffer? */
|
int srcCopied; /* How many bytes were copied from
|
int srcCopied; /* How many bytes were copied from
|
* the source string? */
|
* the source string? */
|
char *destPtr; /* Where in line to copy to? */
|
char *destPtr; /* Where in line to copy to? */
|
|
|
/*
|
/*
|
* If we are in network (or windows) translation mode, record the fact
|
* If we are in network (or windows) translation mode, record the fact
|
* that we have not yet sent a CR to the channel.
|
* that we have not yet sent a CR to the channel.
|
*/
|
*/
|
|
|
crsent = 0;
|
crsent = 0;
|
|
|
/*
|
/*
|
* Loop filling buffers and flushing them until all output has been
|
* Loop filling buffers and flushing them until all output has been
|
* consumed.
|
* consumed.
|
*/
|
*/
|
|
|
srcCopied = 0;
|
srcCopied = 0;
|
totalDestCopied = 0;
|
totalDestCopied = 0;
|
|
|
while (slen > 0) {
|
while (slen > 0) {
|
|
|
/*
|
/*
|
* Make sure there is a current output buffer to accept output.
|
* Make sure there is a current output buffer to accept output.
|
*/
|
*/
|
|
|
if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
|
if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) {
|
chanPtr->curOutPtr = (ChannelBuffer *) ckalloc((unsigned)
|
chanPtr->curOutPtr = (ChannelBuffer *) ckalloc((unsigned)
|
(CHANNELBUFFER_HEADER_SIZE + chanPtr->bufSize));
|
(CHANNELBUFFER_HEADER_SIZE + chanPtr->bufSize));
|
chanPtr->curOutPtr->nextAdded = 0;
|
chanPtr->curOutPtr->nextAdded = 0;
|
chanPtr->curOutPtr->nextRemoved = 0;
|
chanPtr->curOutPtr->nextRemoved = 0;
|
chanPtr->curOutPtr->bufSize = chanPtr->bufSize;
|
chanPtr->curOutPtr->bufSize = chanPtr->bufSize;
|
chanPtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
|
chanPtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
|
}
|
}
|
|
|
outBufPtr = chanPtr->curOutPtr;
|
outBufPtr = chanPtr->curOutPtr;
|
|
|
destCopied = outBufPtr->bufSize - outBufPtr->nextAdded;
|
destCopied = outBufPtr->bufSize - outBufPtr->nextAdded;
|
if (destCopied > slen) {
|
if (destCopied > slen) {
|
destCopied = slen;
|
destCopied = slen;
|
}
|
}
|
|
|
destPtr = outBufPtr->buf + outBufPtr->nextAdded;
|
destPtr = outBufPtr->buf + outBufPtr->nextAdded;
|
switch (chanPtr->outputTranslation) {
|
switch (chanPtr->outputTranslation) {
|
case TCL_TRANSLATE_LF:
|
case TCL_TRANSLATE_LF:
|
srcCopied = destCopied;
|
srcCopied = destCopied;
|
memcpy((VOID *) destPtr, (VOID *) srcPtr, (size_t) destCopied);
|
memcpy((VOID *) destPtr, (VOID *) srcPtr, (size_t) destCopied);
|
break;
|
break;
|
case TCL_TRANSLATE_CR:
|
case TCL_TRANSLATE_CR:
|
srcCopied = destCopied;
|
srcCopied = destCopied;
|
memcpy((VOID *) destPtr, (VOID *) srcPtr, (size_t) destCopied);
|
memcpy((VOID *) destPtr, (VOID *) srcPtr, (size_t) destCopied);
|
for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
|
for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
|
if (*dPtr == '\n') {
|
if (*dPtr == '\n') {
|
*dPtr = '\r';
|
*dPtr = '\r';
|
}
|
}
|
}
|
}
|
break;
|
break;
|
case TCL_TRANSLATE_CRLF:
|
case TCL_TRANSLATE_CRLF:
|
for (srcCopied = 0, dPtr = destPtr, sPtr = srcPtr;
|
for (srcCopied = 0, dPtr = destPtr, sPtr = srcPtr;
|
dPtr < destPtr + destCopied;
|
dPtr < destPtr + destCopied;
|
dPtr++, sPtr++, srcCopied++) {
|
dPtr++, sPtr++, srcCopied++) {
|
if (*sPtr == '\n') {
|
if (*sPtr == '\n') {
|
if (crsent) {
|
if (crsent) {
|
*dPtr = '\n';
|
*dPtr = '\n';
|
crsent = 0;
|
crsent = 0;
|
} else {
|
} else {
|
*dPtr = '\r';
|
*dPtr = '\r';
|
crsent = 1;
|
crsent = 1;
|
sPtr--, srcCopied--;
|
sPtr--, srcCopied--;
|
}
|
}
|
} else {
|
} else {
|
*dPtr = *sPtr;
|
*dPtr = *sPtr;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
case TCL_TRANSLATE_AUTO:
|
case TCL_TRANSLATE_AUTO:
|
panic("Tcl_Write: AUTO output translation mode not supported");
|
panic("Tcl_Write: AUTO output translation mode not supported");
|
default:
|
default:
|
panic("Tcl_Write: unknown output translation mode");
|
panic("Tcl_Write: unknown output translation mode");
|
}
|
}
|
|
|
/*
|
/*
|
* The current buffer is ready for output if it is full, or if it
|
* The current buffer is ready for output if it is full, or if it
|
* contains a newline and this channel is line-buffered, or if it
|
* contains a newline and this channel is line-buffered, or if it
|
* contains any output and this channel is unbuffered.
|
* contains any output and this channel is unbuffered.
|
*/
|
*/
|
|
|
outBufPtr->nextAdded += destCopied;
|
outBufPtr->nextAdded += destCopied;
|
if (!(chanPtr->flags & BUFFER_READY)) {
|
if (!(chanPtr->flags & BUFFER_READY)) {
|
if (outBufPtr->nextAdded == outBufPtr->bufSize) {
|
if (outBufPtr->nextAdded == outBufPtr->bufSize) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
} else if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
|
} else if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
|
for (sPtr = srcPtr, i = 0, foundNewline = 0;
|
for (sPtr = srcPtr, i = 0, foundNewline = 0;
|
(i < srcCopied) && (!foundNewline);
|
(i < srcCopied) && (!foundNewline);
|
i++, sPtr++) {
|
i++, sPtr++) {
|
if (*sPtr == '\n') {
|
if (*sPtr == '\n') {
|
foundNewline = 1;
|
foundNewline = 1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (foundNewline) {
|
if (foundNewline) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
}
|
}
|
} else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
|
} else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
}
|
}
|
}
|
}
|
|
|
totalDestCopied += srcCopied;
|
totalDestCopied += srcCopied;
|
srcPtr += srcCopied;
|
srcPtr += srcCopied;
|
slen -= srcCopied;
|
slen -= srcCopied;
|
|
|
if (chanPtr->flags & BUFFER_READY) {
|
if (chanPtr->flags & BUFFER_READY) {
|
if (FlushChannel(NULL, chanPtr, 0) != 0) {
|
if (FlushChannel(NULL, chanPtr, 0) != 0) {
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
} /* Closes "while" */
|
} /* Closes "while" */
|
|
|
return totalDestCopied;
|
return totalDestCopied;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Flush --
|
* Tcl_Flush --
|
*
|
*
|
* Flushes output data on a channel.
|
* Flushes output data on a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May flush output queued on this channel.
|
* May flush output queued on this channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Flush(chan)
|
Tcl_Flush(chan)
|
Tcl_Channel chan; /* The Channel to flush. */
|
Tcl_Channel chan; /* The Channel to flush. */
|
{
|
{
|
int result; /* Of calling FlushChannel. */
|
int result; /* Of calling FlushChannel. */
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Check for unreported error.
|
* Check for unreported error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
Tcl_SetErrno(chanPtr->unreportedError);
|
Tcl_SetErrno(chanPtr->unreportedError);
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is not open for writing punt.
|
* If the channel is not open for writing punt.
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & TCL_WRITABLE)) {
|
if (!(chanPtr->flags & TCL_WRITABLE)) {
|
Tcl_SetErrno(EACCES);
|
Tcl_SetErrno(EACCES);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
Tcl_SetErrno(EBUSY);
|
Tcl_SetErrno(EBUSY);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Force current output buffer to be output also.
|
* Force current output buffer to be output also.
|
*/
|
*/
|
|
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
(chanPtr->curOutPtr->nextAdded > 0)) {
|
(chanPtr->curOutPtr->nextAdded > 0)) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
}
|
}
|
|
|
result = FlushChannel(NULL, chanPtr, 0);
|
result = FlushChannel(NULL, chanPtr, 0);
|
if (result != 0) {
|
if (result != 0) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* DiscardInputQueued --
|
* DiscardInputQueued --
|
*
|
*
|
* Discards any input read from the channel but not yet consumed
|
* Discards any input read from the channel but not yet consumed
|
* by Tcl reading commands.
|
* by Tcl reading commands.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May discard input from the channel. If discardLastBuffer is zero,
|
* May discard input from the channel. If discardLastBuffer is zero,
|
* leaves one buffer in place for back-filling.
|
* leaves one buffer in place for back-filling.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
DiscardInputQueued(chanPtr, discardSavedBuffers)
|
DiscardInputQueued(chanPtr, discardSavedBuffers)
|
Channel *chanPtr; /* Channel on which to discard
|
Channel *chanPtr; /* Channel on which to discard
|
* the queued input. */
|
* the queued input. */
|
int discardSavedBuffers; /* If non-zero, discard all buffers including
|
int discardSavedBuffers; /* If non-zero, discard all buffers including
|
* last one. */
|
* last one. */
|
{
|
{
|
ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */
|
ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */
|
|
|
bufPtr = chanPtr->inQueueHead;
|
bufPtr = chanPtr->inQueueHead;
|
chanPtr->inQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->inQueueHead = (ChannelBuffer *) NULL;
|
chanPtr->inQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->inQueueTail = (ChannelBuffer *) NULL;
|
for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) {
|
for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) {
|
nxtPtr = bufPtr->nextPtr;
|
nxtPtr = bufPtr->nextPtr;
|
RecycleBuffer(chanPtr, bufPtr, discardSavedBuffers);
|
RecycleBuffer(chanPtr, bufPtr, discardSavedBuffers);
|
}
|
}
|
|
|
/*
|
/*
|
* If discardSavedBuffers is nonzero, must also discard any previously
|
* If discardSavedBuffers is nonzero, must also discard any previously
|
* saved buffer in the saveInBufPtr field.
|
* saved buffer in the saveInBufPtr field.
|
*/
|
*/
|
|
|
if (discardSavedBuffers) {
|
if (discardSavedBuffers) {
|
if (chanPtr->saveInBufPtr != (ChannelBuffer *) NULL) {
|
if (chanPtr->saveInBufPtr != (ChannelBuffer *) NULL) {
|
ckfree((char *) chanPtr->saveInBufPtr);
|
ckfree((char *) chanPtr->saveInBufPtr);
|
chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
|
chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* GetInput --
|
* GetInput --
|
*
|
*
|
* Reads input data from a device or file into an input buffer.
|
* Reads input data from a device or file into an input buffer.
|
*
|
*
|
* Results:
|
* Results:
|
* A Posix error code or 0.
|
* A Posix error code or 0.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Reads from the underlying device.
|
* Reads from the underlying device.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
GetInput(chanPtr)
|
GetInput(chanPtr)
|
Channel *chanPtr; /* Channel to read input from. */
|
Channel *chanPtr; /* Channel to read input from. */
|
{
|
{
|
int toRead; /* How much to read? */
|
int toRead; /* How much to read? */
|
int result; /* Of calling driver. */
|
int result; /* Of calling driver. */
|
int nread; /* How much was read from channel? */
|
int nread; /* How much was read from channel? */
|
ChannelBuffer *bufPtr; /* New buffer to add to input queue. */
|
ChannelBuffer *bufPtr; /* New buffer to add to input queue. */
|
|
|
/*
|
/*
|
* Prevent reading from a dead channel -- a channel that has been closed
|
* Prevent reading from a dead channel -- a channel that has been closed
|
* but not yet deallocated, which can happen if the exit handler for
|
* but not yet deallocated, which can happen if the exit handler for
|
* channel cleanup has run but the channel is still registered in some
|
* channel cleanup has run but the channel is still registered in some
|
* interpreter.
|
* interpreter.
|
*/
|
*/
|
|
|
if (CheckForDeadChannel(NULL,chanPtr)) return EINVAL;
|
if (CheckForDeadChannel(NULL,chanPtr)) return EINVAL;
|
|
|
/*
|
/*
|
* See if we can fill an existing buffer. If we can, read only
|
* See if we can fill an existing buffer. If we can, read only
|
* as much as will fit in it. Otherwise allocate a new buffer,
|
* as much as will fit in it. Otherwise allocate a new buffer,
|
* add it to the input queue and attempt to fill it to the max.
|
* add it to the input queue and attempt to fill it to the max.
|
*/
|
*/
|
|
|
if ((chanPtr->inQueueTail != (ChannelBuffer *) NULL) &&
|
if ((chanPtr->inQueueTail != (ChannelBuffer *) NULL) &&
|
(chanPtr->inQueueTail->nextAdded < chanPtr->inQueueTail->bufSize)) {
|
(chanPtr->inQueueTail->nextAdded < chanPtr->inQueueTail->bufSize)) {
|
bufPtr = chanPtr->inQueueTail;
|
bufPtr = chanPtr->inQueueTail;
|
toRead = bufPtr->bufSize - bufPtr->nextAdded;
|
toRead = bufPtr->bufSize - bufPtr->nextAdded;
|
} else {
|
} else {
|
if (chanPtr->saveInBufPtr != (ChannelBuffer *) NULL) {
|
if (chanPtr->saveInBufPtr != (ChannelBuffer *) NULL) {
|
bufPtr = chanPtr->saveInBufPtr;
|
bufPtr = chanPtr->saveInBufPtr;
|
chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
|
chanPtr->saveInBufPtr = (ChannelBuffer *) NULL;
|
} else {
|
} else {
|
bufPtr = (ChannelBuffer *) ckalloc(
|
bufPtr = (ChannelBuffer *) ckalloc(
|
((unsigned) CHANNELBUFFER_HEADER_SIZE + chanPtr->bufSize));
|
((unsigned) CHANNELBUFFER_HEADER_SIZE + chanPtr->bufSize));
|
bufPtr->bufSize = chanPtr->bufSize;
|
bufPtr->bufSize = chanPtr->bufSize;
|
}
|
}
|
bufPtr->nextRemoved = 0;
|
bufPtr->nextRemoved = 0;
|
bufPtr->nextAdded = 0;
|
bufPtr->nextAdded = 0;
|
toRead = bufPtr->bufSize;
|
toRead = bufPtr->bufSize;
|
if (chanPtr->inQueueTail == (ChannelBuffer *) NULL) {
|
if (chanPtr->inQueueTail == (ChannelBuffer *) NULL) {
|
chanPtr->inQueueHead = bufPtr;
|
chanPtr->inQueueHead = bufPtr;
|
} else {
|
} else {
|
chanPtr->inQueueTail->nextPtr = bufPtr;
|
chanPtr->inQueueTail->nextPtr = bufPtr;
|
}
|
}
|
chanPtr->inQueueTail = bufPtr;
|
chanPtr->inQueueTail = bufPtr;
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
}
|
}
|
|
|
/*
|
/*
|
* If EOF is set, we should avoid calling the driver because on some
|
* If EOF is set, we should avoid calling the driver because on some
|
* platforms it is impossible to read from a device after EOF.
|
* platforms it is impossible to read from a device after EOF.
|
*/
|
*/
|
|
|
if (chanPtr->flags & CHANNEL_EOF) {
|
if (chanPtr->flags & CHANNEL_EOF) {
|
return 0;
|
return 0;
|
}
|
}
|
|
|
nread = (chanPtr->typePtr->inputProc) (chanPtr->instanceData,
|
nread = (chanPtr->typePtr->inputProc) (chanPtr->instanceData,
|
bufPtr->buf + bufPtr->nextAdded, toRead, &result);
|
bufPtr->buf + bufPtr->nextAdded, toRead, &result);
|
|
|
if (nread == 0) {
|
if (nread == 0) {
|
chanPtr->flags |= CHANNEL_EOF;
|
chanPtr->flags |= CHANNEL_EOF;
|
} else if (nread < 0) {
|
} else if (nread < 0) {
|
if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
|
if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
|
chanPtr->flags |= CHANNEL_BLOCKED;
|
chanPtr->flags |= CHANNEL_BLOCKED;
|
result = EAGAIN;
|
result = EAGAIN;
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
Tcl_SetErrno(result);
|
Tcl_SetErrno(result);
|
} else {
|
} else {
|
panic("Blocking channel driver did not block on input");
|
panic("Blocking channel driver did not block on input");
|
}
|
}
|
} else {
|
} else {
|
Tcl_SetErrno(result);
|
Tcl_SetErrno(result);
|
}
|
}
|
return result;
|
return result;
|
} else {
|
} else {
|
bufPtr->nextAdded += nread;
|
bufPtr->nextAdded += nread;
|
|
|
/*
|
/*
|
* If we get a short read, signal up that we may be BLOCKED. We
|
* If we get a short read, signal up that we may be BLOCKED. We
|
* should avoid calling the driver because on some platforms we
|
* should avoid calling the driver because on some platforms we
|
* will block in the low level reading code even though the
|
* will block in the low level reading code even though the
|
* channel is set into nonblocking mode.
|
* channel is set into nonblocking mode.
|
*/
|
*/
|
|
|
if (nread < toRead) {
|
if (nread < toRead) {
|
chanPtr->flags |= CHANNEL_BLOCKED;
|
chanPtr->flags |= CHANNEL_BLOCKED;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CopyAndTranslateBuffer --
|
* CopyAndTranslateBuffer --
|
*
|
*
|
* Copy at most one buffer of input to the result space, doing
|
* Copy at most one buffer of input to the result space, doing
|
* eol translations according to mode in effect currently.
|
* eol translations according to mode in effect currently.
|
*
|
*
|
* Results:
|
* Results:
|
* Number of characters (as opposed to bytes) copied. May return
|
* Number of characters (as opposed to bytes) copied. May return
|
* zero if no input is available to be translated.
|
* zero if no input is available to be translated.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Consumes buffered input. May deallocate one buffer.
|
* Consumes buffered input. May deallocate one buffer.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
CopyAndTranslateBuffer(chanPtr, result, space)
|
CopyAndTranslateBuffer(chanPtr, result, space)
|
Channel *chanPtr; /* The channel from which to read input. */
|
Channel *chanPtr; /* The channel from which to read input. */
|
char *result; /* Where to store the copied input. */
|
char *result; /* Where to store the copied input. */
|
int space; /* How many bytes are available in result
|
int space; /* How many bytes are available in result
|
* to store the copied input? */
|
* to store the copied input? */
|
{
|
{
|
int bytesInBuffer; /* How many bytes are available to be
|
int bytesInBuffer; /* How many bytes are available to be
|
* copied in the current input buffer? */
|
* copied in the current input buffer? */
|
int copied; /* How many characters were already copied
|
int copied; /* How many characters were already copied
|
* into the destination space? */
|
* into the destination space? */
|
ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
|
ChannelBuffer *bufPtr; /* The buffer from which to copy bytes. */
|
char curByte; /* The byte we are currently translating. */
|
char curByte; /* The byte we are currently translating. */
|
int i; /* Iterates over the copied input looking
|
int i; /* Iterates over the copied input looking
|
* for the input eofChar. */
|
* for the input eofChar. */
|
|
|
/*
|
/*
|
* If there is no input at all, return zero. The invariant is that either
|
* If there is no input at all, return zero. The invariant is that either
|
* there is no buffer in the queue, or if the first buffer is empty, it
|
* there is no buffer in the queue, or if the first buffer is empty, it
|
* is also the last buffer (and thus there is no input in the queue).
|
* is also the last buffer (and thus there is no input in the queue).
|
* Note also that if the buffer is empty, we leave it in the queue.
|
* Note also that if the buffer is empty, we leave it in the queue.
|
*/
|
*/
|
|
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
return 0;
|
return 0;
|
}
|
}
|
bufPtr = chanPtr->inQueueHead;
|
bufPtr = chanPtr->inQueueHead;
|
bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
|
bytesInBuffer = bufPtr->nextAdded - bufPtr->nextRemoved;
|
if (bytesInBuffer < space) {
|
if (bytesInBuffer < space) {
|
space = bytesInBuffer;
|
space = bytesInBuffer;
|
}
|
}
|
copied = 0;
|
copied = 0;
|
switch (chanPtr->inputTranslation) {
|
switch (chanPtr->inputTranslation) {
|
case TCL_TRANSLATE_LF:
|
case TCL_TRANSLATE_LF:
|
|
|
if (space == 0) {
|
if (space == 0) {
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Copy the current chunk into the result buffer.
|
* Copy the current chunk into the result buffer.
|
*/
|
*/
|
|
|
memcpy((VOID *) result,
|
memcpy((VOID *) result,
|
(VOID *)(bufPtr->buf + bufPtr->nextRemoved),
|
(VOID *)(bufPtr->buf + bufPtr->nextRemoved),
|
(size_t) space);
|
(size_t) space);
|
bufPtr->nextRemoved += space;
|
bufPtr->nextRemoved += space;
|
copied = space;
|
copied = space;
|
break;
|
break;
|
|
|
case TCL_TRANSLATE_CR:
|
case TCL_TRANSLATE_CR:
|
|
|
if (space == 0) {
|
if (space == 0) {
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Copy the current chunk into the result buffer, then
|
* Copy the current chunk into the result buffer, then
|
* replace all \r with \n.
|
* replace all \r with \n.
|
*/
|
*/
|
|
|
memcpy((VOID *) result,
|
memcpy((VOID *) result,
|
(VOID *)(bufPtr->buf + bufPtr->nextRemoved),
|
(VOID *)(bufPtr->buf + bufPtr->nextRemoved),
|
(size_t) space);
|
(size_t) space);
|
bufPtr->nextRemoved += space;
|
bufPtr->nextRemoved += space;
|
for (copied = 0; copied < space; copied++) {
|
for (copied = 0; copied < space; copied++) {
|
if (result[copied] == '\r') {
|
if (result[copied] == '\r') {
|
result[copied] = '\n';
|
result[copied] = '\n';
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case TCL_TRANSLATE_CRLF:
|
case TCL_TRANSLATE_CRLF:
|
|
|
/*
|
/*
|
* If there is a held-back "\r" at EOF, produce it now.
|
* If there is a held-back "\r" at EOF, produce it now.
|
*/
|
*/
|
|
|
if (space == 0) {
|
if (space == 0) {
|
if ((chanPtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
|
if ((chanPtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
|
(INPUT_SAW_CR | CHANNEL_EOF)) {
|
(INPUT_SAW_CR | CHANNEL_EOF)) {
|
result[0] = '\r';
|
result[0] = '\r';
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Copy the current chunk and replace "\r\n" with "\n"
|
* Copy the current chunk and replace "\r\n" with "\n"
|
* (but not standalone "\r"!).
|
* (but not standalone "\r"!).
|
*/
|
*/
|
|
|
for (copied = 0;
|
for (copied = 0;
|
(copied < space) &&
|
(copied < space) &&
|
(bufPtr->nextRemoved < bufPtr->nextAdded);
|
(bufPtr->nextRemoved < bufPtr->nextAdded);
|
copied++) {
|
copied++) {
|
curByte = bufPtr->buf[bufPtr->nextRemoved];
|
curByte = bufPtr->buf[bufPtr->nextRemoved];
|
bufPtr->nextRemoved++;
|
bufPtr->nextRemoved++;
|
if (curByte == '\r') {
|
if (curByte == '\r') {
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
result[copied] = '\r';
|
result[copied] = '\r';
|
} else {
|
} else {
|
chanPtr->flags |= INPUT_SAW_CR;
|
chanPtr->flags |= INPUT_SAW_CR;
|
copied--;
|
copied--;
|
}
|
}
|
} else if (curByte == '\n') {
|
} else if (curByte == '\n') {
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
result[copied] = '\n';
|
result[copied] = '\n';
|
} else {
|
} else {
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
result[copied] = '\r';
|
result[copied] = '\r';
|
bufPtr->nextRemoved--;
|
bufPtr->nextRemoved--;
|
} else {
|
} else {
|
result[copied] = curByte;
|
result[copied] = curByte;
|
}
|
}
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case TCL_TRANSLATE_AUTO:
|
case TCL_TRANSLATE_AUTO:
|
|
|
if (space == 0) {
|
if (space == 0) {
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Loop over the current buffer, converting "\r" and "\r\n"
|
* Loop over the current buffer, converting "\r" and "\r\n"
|
* to "\n".
|
* to "\n".
|
*/
|
*/
|
|
|
for (copied = 0;
|
for (copied = 0;
|
(copied < space) &&
|
(copied < space) &&
|
(bufPtr->nextRemoved < bufPtr->nextAdded); ) {
|
(bufPtr->nextRemoved < bufPtr->nextAdded); ) {
|
curByte = bufPtr->buf[bufPtr->nextRemoved];
|
curByte = bufPtr->buf[bufPtr->nextRemoved];
|
bufPtr->nextRemoved++;
|
bufPtr->nextRemoved++;
|
if (curByte == '\r') {
|
if (curByte == '\r') {
|
result[copied] = '\n';
|
result[copied] = '\n';
|
copied++;
|
copied++;
|
if (bufPtr->nextRemoved < bufPtr->nextAdded) {
|
if (bufPtr->nextRemoved < bufPtr->nextAdded) {
|
if (bufPtr->buf[bufPtr->nextRemoved] == '\n') {
|
if (bufPtr->buf[bufPtr->nextRemoved] == '\n') {
|
bufPtr->nextRemoved++;
|
bufPtr->nextRemoved++;
|
}
|
}
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
} else {
|
} else {
|
chanPtr->flags |= INPUT_SAW_CR;
|
chanPtr->flags |= INPUT_SAW_CR;
|
}
|
}
|
} else {
|
} else {
|
if (curByte == '\n') {
|
if (curByte == '\n') {
|
if (!(chanPtr->flags & INPUT_SAW_CR)) {
|
if (!(chanPtr->flags & INPUT_SAW_CR)) {
|
result[copied] = '\n';
|
result[copied] = '\n';
|
copied++;
|
copied++;
|
}
|
}
|
} else {
|
} else {
|
result[copied] = curByte;
|
result[copied] = curByte;
|
copied++;
|
copied++;
|
}
|
}
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
panic("unknown eol translation mode");
|
panic("unknown eol translation mode");
|
}
|
}
|
|
|
/*
|
/*
|
* If an in-stream EOF character is set for this channel,, check that
|
* If an in-stream EOF character is set for this channel,, check that
|
* the input we copied so far does not contain the EOF char. If it does,
|
* the input we copied so far does not contain the EOF char. If it does,
|
* copy only up to and excluding that character.
|
* copy only up to and excluding that character.
|
*/
|
*/
|
|
|
if (chanPtr->inEofChar != 0) {
|
if (chanPtr->inEofChar != 0) {
|
for (i = 0; i < copied; i++) {
|
for (i = 0; i < copied; i++) {
|
if (result[i] == (char) chanPtr->inEofChar) {
|
if (result[i] == (char) chanPtr->inEofChar) {
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (i < copied) {
|
if (i < copied) {
|
|
|
/*
|
/*
|
* Set sticky EOF so that no further input is presented
|
* Set sticky EOF so that no further input is presented
|
* to the caller.
|
* to the caller.
|
*/
|
*/
|
|
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
|
|
/*
|
/*
|
* Reset the start of valid data in the input buffer to the
|
* Reset the start of valid data in the input buffer to the
|
* position of the eofChar, so that subsequent reads will
|
* position of the eofChar, so that subsequent reads will
|
* encounter it immediately. First we set it to the position
|
* encounter it immediately. First we set it to the position
|
* of the last byte consumed if all result bytes were the
|
* of the last byte consumed if all result bytes were the
|
* product of one input byte; since it is possible that "\r\n"
|
* product of one input byte; since it is possible that "\r\n"
|
* contracted to "\n" in the result, we have to search back
|
* contracted to "\n" in the result, we have to search back
|
* from that position until we find the eofChar, because it
|
* from that position until we find the eofChar, because it
|
* is possible that its actual position in the buffer is n
|
* is possible that its actual position in the buffer is n
|
* bytes further back (n is the number of "\r\n" sequences
|
* bytes further back (n is the number of "\r\n" sequences
|
* that were contracted to "\n" in the result).
|
* that were contracted to "\n" in the result).
|
*/
|
*/
|
|
|
bufPtr->nextRemoved -= (copied - i);
|
bufPtr->nextRemoved -= (copied - i);
|
while ((bufPtr->nextRemoved > 0) &&
|
while ((bufPtr->nextRemoved > 0) &&
|
(bufPtr->buf[bufPtr->nextRemoved] !=
|
(bufPtr->buf[bufPtr->nextRemoved] !=
|
(char) chanPtr->inEofChar)) {
|
(char) chanPtr->inEofChar)) {
|
bufPtr->nextRemoved--;
|
bufPtr->nextRemoved--;
|
}
|
}
|
copied = i;
|
copied = i;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* If the current buffer is empty recycle it.
|
* If the current buffer is empty recycle it.
|
*/
|
*/
|
|
|
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
|
if (bufPtr->nextRemoved == bufPtr->nextAdded) {
|
chanPtr->inQueueHead = bufPtr->nextPtr;
|
chanPtr->inQueueHead = bufPtr->nextPtr;
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
chanPtr->inQueueTail = (ChannelBuffer *) NULL;
|
chanPtr->inQueueTail = (ChannelBuffer *) NULL;
|
}
|
}
|
RecycleBuffer(chanPtr, bufPtr, 0);
|
RecycleBuffer(chanPtr, bufPtr, 0);
|
}
|
}
|
|
|
/*
|
/*
|
* Return the number of characters copied into the result buffer.
|
* Return the number of characters copied into the result buffer.
|
* This may be different from the number of bytes consumed, because
|
* This may be different from the number of bytes consumed, because
|
* of EOL translations.
|
* of EOL translations.
|
*/
|
*/
|
|
|
return copied;
|
return copied;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* ScanBufferForEOL --
|
* ScanBufferForEOL --
|
*
|
*
|
* Scans one buffer for EOL according to the specified EOL
|
* Scans one buffer for EOL according to the specified EOL
|
* translation mode. If it sees the input eofChar for the channel
|
* translation mode. If it sees the input eofChar for the channel
|
* it stops also.
|
* it stops also.
|
*
|
*
|
* Results:
|
* Results:
|
* TRUE if EOL is found, FALSE otherwise. Also sets output parameter
|
* TRUE if EOL is found, FALSE otherwise. Also sets output parameter
|
* bytesToEOLPtr to the number of bytes so far to EOL, and crSeenPtr
|
* bytesToEOLPtr to the number of bytes so far to EOL, and crSeenPtr
|
* to whether a "\r" was seen.
|
* to whether a "\r" was seen.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
ScanBufferForEOL(chanPtr, bufPtr, translation, eofChar, bytesToEOLPtr,
|
ScanBufferForEOL(chanPtr, bufPtr, translation, eofChar, bytesToEOLPtr,
|
crSeenPtr)
|
crSeenPtr)
|
Channel *chanPtr;
|
Channel *chanPtr;
|
ChannelBuffer *bufPtr; /* Buffer to scan for EOL. */
|
ChannelBuffer *bufPtr; /* Buffer to scan for EOL. */
|
Tcl_EolTranslation translation; /* Translation mode to use. */
|
Tcl_EolTranslation translation; /* Translation mode to use. */
|
int eofChar; /* EOF char to look for. */
|
int eofChar; /* EOF char to look for. */
|
int *bytesToEOLPtr; /* Running counter. */
|
int *bytesToEOLPtr; /* Running counter. */
|
int *crSeenPtr; /* Has "\r" been seen? */
|
int *crSeenPtr; /* Has "\r" been seen? */
|
{
|
{
|
char *rPtr; /* Iterates over input string. */
|
char *rPtr; /* Iterates over input string. */
|
char *sPtr; /* Where to stop search? */
|
char *sPtr; /* Where to stop search? */
|
int EOLFound;
|
int EOLFound;
|
int bytesToEOL;
|
int bytesToEOL;
|
|
|
for (EOLFound = 0, rPtr = bufPtr->buf + bufPtr->nextRemoved,
|
for (EOLFound = 0, rPtr = bufPtr->buf + bufPtr->nextRemoved,
|
sPtr = bufPtr->buf + bufPtr->nextAdded,
|
sPtr = bufPtr->buf + bufPtr->nextAdded,
|
bytesToEOL = *bytesToEOLPtr;
|
bytesToEOL = *bytesToEOLPtr;
|
(!EOLFound) && (rPtr < sPtr);
|
(!EOLFound) && (rPtr < sPtr);
|
rPtr++) {
|
rPtr++) {
|
switch (translation) {
|
switch (translation) {
|
case TCL_TRANSLATE_AUTO:
|
case TCL_TRANSLATE_AUTO:
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
EOLFound = 1;
|
EOLFound = 1;
|
} else if (*rPtr == '\n') {
|
} else if (*rPtr == '\n') {
|
|
|
/*
|
/*
|
* CopyAndTranslateBuffer wants to know the length
|
* CopyAndTranslateBuffer wants to know the length
|
* of the result, not the input. The input is one
|
* of the result, not the input. The input is one
|
* larger because "\r\n" shrinks to "\n".
|
* larger because "\r\n" shrinks to "\n".
|
*/
|
*/
|
|
|
if (!(*crSeenPtr)) {
|
if (!(*crSeenPtr)) {
|
bytesToEOL++;
|
bytesToEOL++;
|
EOLFound = 1;
|
EOLFound = 1;
|
} else {
|
} else {
|
|
|
/*
|
/*
|
* This is a lf at the begining of a buffer
|
* This is a lf at the begining of a buffer
|
* where the previous buffer ended in a cr.
|
* where the previous buffer ended in a cr.
|
* Consume this lf because we've already emitted
|
* Consume this lf because we've already emitted
|
* the newline for this crlf sequence. ALSO, if
|
* the newline for this crlf sequence. ALSO, if
|
* bytesToEOL is 0 (which means that we are at the
|
* bytesToEOL is 0 (which means that we are at the
|
* first character of the scan), unset the
|
* first character of the scan), unset the
|
* INPUT_SAW_CR flag in the channel, because we
|
* INPUT_SAW_CR flag in the channel, because we
|
* already handled it; leaving it set would cause
|
* already handled it; leaving it set would cause
|
* CopyAndTranslateBuffer to potentially consume
|
* CopyAndTranslateBuffer to potentially consume
|
* another lf if one follows the current byte.
|
* another lf if one follows the current byte.
|
*/
|
*/
|
|
|
bufPtr->nextRemoved++;
|
bufPtr->nextRemoved++;
|
*crSeenPtr = 0;
|
*crSeenPtr = 0;
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
chanPtr->flags &= (~(INPUT_SAW_CR));
|
}
|
}
|
} else if (*rPtr == '\r') {
|
} else if (*rPtr == '\r') {
|
bytesToEOL++;
|
bytesToEOL++;
|
EOLFound = 1;
|
EOLFound = 1;
|
} else {
|
} else {
|
*crSeenPtr = 0;
|
*crSeenPtr = 0;
|
bytesToEOL++;
|
bytesToEOL++;
|
}
|
}
|
break;
|
break;
|
case TCL_TRANSLATE_LF:
|
case TCL_TRANSLATE_LF:
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
EOLFound = 1;
|
EOLFound = 1;
|
} else {
|
} else {
|
if (*rPtr == '\n') {
|
if (*rPtr == '\n') {
|
EOLFound = 1;
|
EOLFound = 1;
|
}
|
}
|
bytesToEOL++;
|
bytesToEOL++;
|
}
|
}
|
break;
|
break;
|
case TCL_TRANSLATE_CR:
|
case TCL_TRANSLATE_CR:
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
EOLFound = 1;
|
EOLFound = 1;
|
} else {
|
} else {
|
if (*rPtr == '\r') {
|
if (*rPtr == '\r') {
|
EOLFound = 1;
|
EOLFound = 1;
|
}
|
}
|
bytesToEOL++;
|
bytesToEOL++;
|
}
|
}
|
break;
|
break;
|
case TCL_TRANSLATE_CRLF:
|
case TCL_TRANSLATE_CRLF:
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
if ((*rPtr == (char) eofChar) && (eofChar != 0)) {
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
|
EOLFound = 1;
|
EOLFound = 1;
|
} else if (*rPtr == '\n') {
|
} else if (*rPtr == '\n') {
|
|
|
/*
|
/*
|
* CopyAndTranslateBuffer wants to know the length
|
* CopyAndTranslateBuffer wants to know the length
|
* of the result, not the input. The input is one
|
* of the result, not the input. The input is one
|
* larger because crlf shrinks to lf.
|
* larger because crlf shrinks to lf.
|
*/
|
*/
|
|
|
if (*crSeenPtr) {
|
if (*crSeenPtr) {
|
EOLFound = 1;
|
EOLFound = 1;
|
} else {
|
} else {
|
bytesToEOL++;
|
bytesToEOL++;
|
}
|
}
|
} else {
|
} else {
|
if (*rPtr == '\r') {
|
if (*rPtr == '\r') {
|
*crSeenPtr = 1;
|
*crSeenPtr = 1;
|
} else {
|
} else {
|
*crSeenPtr = 0;
|
*crSeenPtr = 0;
|
}
|
}
|
bytesToEOL++;
|
bytesToEOL++;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
panic("unknown eol translation mode");
|
panic("unknown eol translation mode");
|
}
|
}
|
}
|
}
|
|
|
*bytesToEOLPtr = bytesToEOL;
|
*bytesToEOLPtr = bytesToEOL;
|
return EOLFound;
|
return EOLFound;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* ScanInputForEOL --
|
* ScanInputForEOL --
|
*
|
*
|
* Scans queued input for chanPtr for an end of line (according to the
|
* Scans queued input for chanPtr for an end of line (according to the
|
* current EOL translation mode) and returns the number of bytes
|
* current EOL translation mode) and returns the number of bytes
|
* upto and including the end of line, or -1 if none was found.
|
* upto and including the end of line, or -1 if none was found.
|
*
|
*
|
* Results:
|
* Results:
|
* Count of bytes upto and including the end of line if one is present
|
* Count of bytes upto and including the end of line if one is present
|
* or -1 if none was found. Also returns in an output parameter the
|
* or -1 if none was found. Also returns in an output parameter the
|
* number of bytes queued if no end of line was found.
|
* number of bytes queued if no end of line was found.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
ScanInputForEOL(chanPtr, bytesQueuedPtr)
|
ScanInputForEOL(chanPtr, bytesQueuedPtr)
|
Channel *chanPtr; /* Channel for which to scan queued
|
Channel *chanPtr; /* Channel for which to scan queued
|
* input for end of line. */
|
* input for end of line. */
|
int *bytesQueuedPtr; /* Where to store the number of bytes
|
int *bytesQueuedPtr; /* Where to store the number of bytes
|
* currently queued if no end of line
|
* currently queued if no end of line
|
* was found. */
|
* was found. */
|
{
|
{
|
ChannelBuffer *bufPtr; /* Iterates over queued buffers. */
|
ChannelBuffer *bufPtr; /* Iterates over queued buffers. */
|
int bytesToEOL; /* How many bytes to end of line? */
|
int bytesToEOL; /* How many bytes to end of line? */
|
int EOLFound; /* Did we find an end of line? */
|
int EOLFound; /* Did we find an end of line? */
|
int crSeen; /* Did we see a "\r" in CRLF mode? */
|
int crSeen; /* Did we see a "\r" in CRLF mode? */
|
|
|
*bytesQueuedPtr = 0;
|
*bytesQueuedPtr = 0;
|
bytesToEOL = 0;
|
bytesToEOL = 0;
|
EOLFound = 0;
|
EOLFound = 0;
|
for (bufPtr = chanPtr->inQueueHead,
|
for (bufPtr = chanPtr->inQueueHead,
|
crSeen = (chanPtr->flags & INPUT_SAW_CR) ? 1 : 0;
|
crSeen = (chanPtr->flags & INPUT_SAW_CR) ? 1 : 0;
|
(!EOLFound) && (bufPtr != (ChannelBuffer *) NULL);
|
(!EOLFound) && (bufPtr != (ChannelBuffer *) NULL);
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
EOLFound = ScanBufferForEOL(chanPtr, bufPtr, chanPtr->inputTranslation,
|
EOLFound = ScanBufferForEOL(chanPtr, bufPtr, chanPtr->inputTranslation,
|
chanPtr->inEofChar, &bytesToEOL, &crSeen);
|
chanPtr->inEofChar, &bytesToEOL, &crSeen);
|
}
|
}
|
|
|
if (EOLFound == 0) {
|
if (EOLFound == 0) {
|
*bytesQueuedPtr = bytesToEOL;
|
*bytesQueuedPtr = bytesToEOL;
|
return -1;
|
return -1;
|
}
|
}
|
return bytesToEOL;
|
return bytesToEOL;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* GetEOL --
|
* GetEOL --
|
*
|
*
|
* Accumulate input into the channel input buffer queue until an
|
* Accumulate input into the channel input buffer queue until an
|
* end of line has been seen.
|
* end of line has been seen.
|
*
|
*
|
* Results:
|
* Results:
|
* Number of bytes buffered (at least 1) or -1 on failure.
|
* Number of bytes buffered (at least 1) or -1 on failure.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Consumes input from the channel.
|
* Consumes input from the channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
GetEOL(chanPtr)
|
GetEOL(chanPtr)
|
Channel *chanPtr; /* Channel to queue input on. */
|
Channel *chanPtr; /* Channel to queue input on. */
|
{
|
{
|
int bytesToEOL; /* How many bytes in buffer up to and
|
int bytesToEOL; /* How many bytes in buffer up to and
|
* including the end of line? */
|
* including the end of line? */
|
int bytesQueued; /* How many bytes are queued currently
|
int bytesQueued; /* How many bytes are queued currently
|
* in the input chain of the channel? */
|
* in the input chain of the channel? */
|
|
|
/*
|
/*
|
* Check for unreported error.
|
* Check for unreported error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
Tcl_SetErrno(chanPtr->unreportedError);
|
Tcl_SetErrno(chanPtr->unreportedError);
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Punt if the channel is not opened for reading.
|
* Punt if the channel is not opened for reading.
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & TCL_READABLE)) {
|
if (!(chanPtr->flags & TCL_READABLE)) {
|
Tcl_SetErrno(EACCES);
|
Tcl_SetErrno(EACCES);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
Tcl_SetErrno(EBUSY);
|
Tcl_SetErrno(EBUSY);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If we have not encountered a sticky EOF, clear the EOF bit
|
* If we have not encountered a sticky EOF, clear the EOF bit
|
* (sticky EOF is set if we have seen the input eofChar, to prevent
|
* (sticky EOF is set if we have seen the input eofChar, to prevent
|
* reading beyond the eofChar). Also, always clear the BLOCKED bit.
|
* reading beyond the eofChar). Also, always clear the BLOCKED bit.
|
* We want to discover these conditions anew in each operation.
|
* We want to discover these conditions anew in each operation.
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & CHANNEL_STICKY_EOF)) {
|
if (!(chanPtr->flags & CHANNEL_STICKY_EOF)) {
|
chanPtr->flags &= (~(CHANNEL_EOF));
|
chanPtr->flags &= (~(CHANNEL_EOF));
|
}
|
}
|
chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_GETS_BLOCKED));
|
chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_GETS_BLOCKED));
|
|
|
while (1) {
|
while (1) {
|
bytesToEOL = ScanInputForEOL(chanPtr, &bytesQueued);
|
bytesToEOL = ScanInputForEOL(chanPtr, &bytesQueued);
|
if (bytesToEOL > 0) {
|
if (bytesToEOL > 0) {
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
return bytesToEOL;
|
return bytesToEOL;
|
}
|
}
|
if (chanPtr->flags & CHANNEL_EOF) {
|
if (chanPtr->flags & CHANNEL_EOF) {
|
/*
|
/*
|
* Boundary case where cr was at the end of the previous buffer
|
* Boundary case where cr was at the end of the previous buffer
|
* and this buffer just has a newline. At EOF our caller wants
|
* and this buffer just has a newline. At EOF our caller wants
|
* to see -1 for the line length.
|
* to see -1 for the line length.
|
*/
|
*/
|
return (bytesQueued == 0) ? -1 : bytesQueued ;
|
return (bytesQueued == 0) ? -1 : bytesQueued ;
|
}
|
}
|
if (chanPtr->flags & CHANNEL_BLOCKED) {
|
if (chanPtr->flags & CHANNEL_BLOCKED) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
goto blocked;
|
goto blocked;
|
}
|
}
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
}
|
}
|
if (GetInput(chanPtr) != 0) {
|
if (GetInput(chanPtr) != 0) {
|
goto blocked;
|
goto blocked;
|
}
|
}
|
}
|
}
|
|
|
blocked:
|
blocked:
|
|
|
/*
|
/*
|
* We didn't get a complete line so we need to indicate to UpdateInterest
|
* We didn't get a complete line so we need to indicate to UpdateInterest
|
* that the gets blocked. It will wait for more data instead of firing
|
* that the gets blocked. It will wait for more data instead of firing
|
* a timer, avoiding a busy wait. This is where we are assuming that the
|
* a timer, avoiding a busy wait. This is where we are assuming that the
|
* next operation is a gets. No more file events will be delivered on
|
* next operation is a gets. No more file events will be delivered on
|
* this channel until new data arrives or some operation is performed
|
* this channel until new data arrives or some operation is performed
|
* on the channel (e.g. gets, read, fconfigure) that changes the blocking
|
* on the channel (e.g. gets, read, fconfigure) that changes the blocking
|
* state. Note that this means a file event will not be delivered even
|
* state. Note that this means a file event will not be delivered even
|
* though a read would be able to consume the buffered data.
|
* though a read would be able to consume the buffered data.
|
*/
|
*/
|
|
|
chanPtr->flags |= CHANNEL_GETS_BLOCKED;
|
chanPtr->flags |= CHANNEL_GETS_BLOCKED;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Read --
|
* Tcl_Read --
|
*
|
*
|
* Reads a given number of characters from a channel.
|
* Reads a given number of characters from a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* The number of characters read, or -1 on error. Use Tcl_GetErrno()
|
* The number of characters read, or -1 on error. Use Tcl_GetErrno()
|
* to retrieve the error code for the error that occurred.
|
* to retrieve the error code for the error that occurred.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May cause input to be buffered.
|
* May cause input to be buffered.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Read(chan, bufPtr, toRead)
|
Tcl_Read(chan, bufPtr, toRead)
|
Tcl_Channel chan; /* The channel from which to read. */
|
Tcl_Channel chan; /* The channel from which to read. */
|
char *bufPtr; /* Where to store input read. */
|
char *bufPtr; /* Where to store input read. */
|
int toRead; /* Maximum number of characters to read. */
|
int toRead; /* Maximum number of characters to read. */
|
{
|
{
|
Channel *chanPtr; /* The real IO channel. */
|
Channel *chanPtr; /* The real IO channel. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Check for unreported error.
|
* Check for unreported error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
Tcl_SetErrno(chanPtr->unreportedError);
|
Tcl_SetErrno(chanPtr->unreportedError);
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Punt if the channel is not opened for reading.
|
* Punt if the channel is not opened for reading.
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & TCL_READABLE)) {
|
if (!(chanPtr->flags & TCL_READABLE)) {
|
Tcl_SetErrno(EACCES);
|
Tcl_SetErrno(EACCES);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
Tcl_SetErrno(EBUSY);
|
Tcl_SetErrno(EBUSY);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
return DoRead(chanPtr, bufPtr, toRead);
|
return DoRead(chanPtr, bufPtr, toRead);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* DoRead --
|
* DoRead --
|
*
|
*
|
* Reads a given number of characters from a channel.
|
* Reads a given number of characters from a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* The number of characters read, or -1 on error. Use Tcl_GetErrno()
|
* The number of characters read, or -1 on error. Use Tcl_GetErrno()
|
* to retrieve the error code for the error that occurred.
|
* to retrieve the error code for the error that occurred.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May cause input to be buffered.
|
* May cause input to be buffered.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
DoRead(chanPtr, bufPtr, toRead)
|
DoRead(chanPtr, bufPtr, toRead)
|
Channel *chanPtr; /* The channel from which to read. */
|
Channel *chanPtr; /* The channel from which to read. */
|
char *bufPtr; /* Where to store input read. */
|
char *bufPtr; /* Where to store input read. */
|
int toRead; /* Maximum number of characters to read. */
|
int toRead; /* Maximum number of characters to read. */
|
{
|
{
|
int copied; /* How many characters were copied into
|
int copied; /* How many characters were copied into
|
* the result string? */
|
* the result string? */
|
int copiedNow; /* How many characters were copied from
|
int copiedNow; /* How many characters were copied from
|
* the current input buffer? */
|
* the current input buffer? */
|
int result; /* Of calling GetInput. */
|
int result; /* Of calling GetInput. */
|
|
|
/*
|
/*
|
* If we have not encountered a sticky EOF, clear the EOF bit. Either
|
* If we have not encountered a sticky EOF, clear the EOF bit. Either
|
* way clear the BLOCKED bit. We want to discover these anew during
|
* way clear the BLOCKED bit. We want to discover these anew during
|
* each operation.
|
* each operation.
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & CHANNEL_STICKY_EOF)) {
|
if (!(chanPtr->flags & CHANNEL_STICKY_EOF)) {
|
chanPtr->flags &= (~(CHANNEL_EOF));
|
chanPtr->flags &= (~(CHANNEL_EOF));
|
}
|
}
|
chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_GETS_BLOCKED));
|
chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_GETS_BLOCKED));
|
|
|
for (copied = 0; copied < toRead; copied += copiedNow) {
|
for (copied = 0; copied < toRead; copied += copiedNow) {
|
copiedNow = CopyAndTranslateBuffer(chanPtr, bufPtr + copied,
|
copiedNow = CopyAndTranslateBuffer(chanPtr, bufPtr + copied,
|
toRead - copied);
|
toRead - copied);
|
if (copiedNow == 0) {
|
if (copiedNow == 0) {
|
if (chanPtr->flags & CHANNEL_EOF) {
|
if (chanPtr->flags & CHANNEL_EOF) {
|
goto done;
|
goto done;
|
}
|
}
|
if (chanPtr->flags & CHANNEL_BLOCKED) {
|
if (chanPtr->flags & CHANNEL_BLOCKED) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
goto done;
|
goto done;
|
}
|
}
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
}
|
}
|
result = GetInput(chanPtr);
|
result = GetInput(chanPtr);
|
if (result != 0) {
|
if (result != 0) {
|
if (result != EAGAIN) {
|
if (result != EAGAIN) {
|
copied = -1;
|
copied = -1;
|
}
|
}
|
goto done;
|
goto done;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
chanPtr->flags &= (~(CHANNEL_BLOCKED));
|
|
|
done:
|
done:
|
/*
|
/*
|
* Update the notifier state so we don't block while there is still
|
* Update the notifier state so we don't block while there is still
|
* data in the buffers.
|
* data in the buffers.
|
*/
|
*/
|
|
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
return copied;
|
return copied;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Gets --
|
* Tcl_Gets --
|
*
|
*
|
* Reads a complete line of input from the channel into a
|
* Reads a complete line of input from the channel into a
|
* Tcl_DString.
|
* Tcl_DString.
|
*
|
*
|
* Results:
|
* Results:
|
* Length of line read or -1 if error, EOF or blocked. If -1, use
|
* Length of line read or -1 if error, EOF or blocked. If -1, use
|
* Tcl_GetErrno() to retrieve the POSIX error code for the
|
* Tcl_GetErrno() to retrieve the POSIX error code for the
|
* error or condition that occurred.
|
* error or condition that occurred.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May flush output on the channel. May cause input to be
|
* May flush output on the channel. May cause input to be
|
* consumed from the channel.
|
* consumed from the channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Gets(chan, lineRead)
|
Tcl_Gets(chan, lineRead)
|
Tcl_Channel chan; /* Channel from which to read. */
|
Tcl_Channel chan; /* Channel from which to read. */
|
Tcl_DString *lineRead; /* The characters of the line read
|
Tcl_DString *lineRead; /* The characters of the line read
|
* (excluding the terminating newline if
|
* (excluding the terminating newline if
|
* present) will be appended to this
|
* present) will be appended to this
|
* DString. The caller must have initialized
|
* DString. The caller must have initialized
|
* it and is responsible for managing the
|
* it and is responsible for managing the
|
* storage. */
|
* storage. */
|
{
|
{
|
Channel *chanPtr; /* The channel to read from. */
|
Channel *chanPtr; /* The channel to read from. */
|
char *buf; /* Points into DString where data
|
char *buf; /* Points into DString where data
|
* will be stored. */
|
* will be stored. */
|
int offset; /* Offset from start of DString at
|
int offset; /* Offset from start of DString at
|
* which to append the line just read. */
|
* which to append the line just read. */
|
int copiedTotal; /* Accumulates total length of input copied. */
|
int copiedTotal; /* Accumulates total length of input copied. */
|
int copiedNow; /* How many bytes were copied from the
|
int copiedNow; /* How many bytes were copied from the
|
* current input buffer? */
|
* current input buffer? */
|
int lineLen; /* Length of line read, including the
|
int lineLen; /* Length of line read, including the
|
* translated newline. If this is zero
|
* translated newline. If this is zero
|
* and neither EOF nor BLOCKED is set,
|
* and neither EOF nor BLOCKED is set,
|
* the current line is empty. */
|
* the current line is empty. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
lineLen = GetEOL(chanPtr);
|
lineLen = GetEOL(chanPtr);
|
if (lineLen < 0) {
|
if (lineLen < 0) {
|
copiedTotal = -1;
|
copiedTotal = -1;
|
goto done;
|
goto done;
|
}
|
}
|
offset = Tcl_DStringLength(lineRead);
|
offset = Tcl_DStringLength(lineRead);
|
Tcl_DStringSetLength(lineRead, lineLen + offset);
|
Tcl_DStringSetLength(lineRead, lineLen + offset);
|
buf = Tcl_DStringValue(lineRead) + offset;
|
buf = Tcl_DStringValue(lineRead) + offset;
|
|
|
for (copiedTotal = 0; copiedTotal < lineLen; copiedTotal += copiedNow) {
|
for (copiedTotal = 0; copiedTotal < lineLen; copiedTotal += copiedNow) {
|
copiedNow = CopyAndTranslateBuffer(chanPtr, buf + copiedTotal,
|
copiedNow = CopyAndTranslateBuffer(chanPtr, buf + copiedTotal,
|
lineLen - copiedTotal);
|
lineLen - copiedTotal);
|
}
|
}
|
if ((copiedTotal > 0) && (buf[copiedTotal - 1] == '\n')) {
|
if ((copiedTotal > 0) && (buf[copiedTotal - 1] == '\n')) {
|
copiedTotal--;
|
copiedTotal--;
|
}
|
}
|
Tcl_DStringSetLength(lineRead, copiedTotal + offset);
|
Tcl_DStringSetLength(lineRead, copiedTotal + offset);
|
|
|
done:
|
done:
|
/*
|
/*
|
* Update the notifier state so we don't block while there is still
|
* Update the notifier state so we don't block while there is still
|
* data in the buffers.
|
* data in the buffers.
|
*/
|
*/
|
|
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
return copiedTotal;
|
return copiedTotal;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetsObj --
|
* Tcl_GetsObj --
|
*
|
*
|
* Reads a complete line of input from the channel into a
|
* Reads a complete line of input from the channel into a
|
* string object.
|
* string object.
|
*
|
*
|
* Results:
|
* Results:
|
* Length of line read or -1 if error, EOF or blocked. If -1, use
|
* Length of line read or -1 if error, EOF or blocked. If -1, use
|
* Tcl_GetErrno() to retrieve the POSIX error code for the
|
* Tcl_GetErrno() to retrieve the POSIX error code for the
|
* error or condition that occurred.
|
* error or condition that occurred.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May flush output on the channel. May cause input to be
|
* May flush output on the channel. May cause input to be
|
* consumed from the channel.
|
* consumed from the channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_GetsObj(chan, objPtr)
|
Tcl_GetsObj(chan, objPtr)
|
Tcl_Channel chan; /* Channel from which to read. */
|
Tcl_Channel chan; /* Channel from which to read. */
|
Tcl_Obj *objPtr; /* The characters of the line read
|
Tcl_Obj *objPtr; /* The characters of the line read
|
* (excluding the terminating newline if
|
* (excluding the terminating newline if
|
* present) will be appended to this
|
* present) will be appended to this
|
* object. The caller must have initialized
|
* object. The caller must have initialized
|
* it and is responsible for managing the
|
* it and is responsible for managing the
|
* storage. */
|
* storage. */
|
{
|
{
|
Channel *chanPtr; /* The channel to read from. */
|
Channel *chanPtr; /* The channel to read from. */
|
char *buf; /* Points into DString where data
|
char *buf; /* Points into DString where data
|
* will be stored. */
|
* will be stored. */
|
int offset; /* Offset from start of DString at
|
int offset; /* Offset from start of DString at
|
* which to append the line just read. */
|
* which to append the line just read. */
|
int copiedTotal; /* Accumulates total length of input copied. */
|
int copiedTotal; /* Accumulates total length of input copied. */
|
int copiedNow; /* How many bytes were copied from the
|
int copiedNow; /* How many bytes were copied from the
|
* current input buffer? */
|
* current input buffer? */
|
int lineLen; /* Length of line read, including the
|
int lineLen; /* Length of line read, including the
|
* translated newline. If this is zero
|
* translated newline. If this is zero
|
* and neither EOF nor BLOCKED is set,
|
* and neither EOF nor BLOCKED is set,
|
* the current line is empty. */
|
* the current line is empty. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
lineLen = GetEOL(chanPtr);
|
lineLen = GetEOL(chanPtr);
|
if (lineLen < 0) {
|
if (lineLen < 0) {
|
copiedTotal = -1;
|
copiedTotal = -1;
|
goto done;
|
goto done;
|
}
|
}
|
|
|
(void) Tcl_GetStringFromObj(objPtr, &offset);
|
(void) Tcl_GetStringFromObj(objPtr, &offset);
|
Tcl_SetObjLength(objPtr, lineLen + offset);
|
Tcl_SetObjLength(objPtr, lineLen + offset);
|
buf = Tcl_GetStringFromObj(objPtr, NULL) + offset;
|
buf = Tcl_GetStringFromObj(objPtr, NULL) + offset;
|
|
|
for (copiedTotal = 0; copiedTotal < lineLen; copiedTotal += copiedNow) {
|
for (copiedTotal = 0; copiedTotal < lineLen; copiedTotal += copiedNow) {
|
copiedNow = CopyAndTranslateBuffer(chanPtr, buf + copiedTotal,
|
copiedNow = CopyAndTranslateBuffer(chanPtr, buf + copiedTotal,
|
lineLen - copiedTotal);
|
lineLen - copiedTotal);
|
}
|
}
|
if ((copiedTotal > 0) && (buf[copiedTotal - 1] == '\n')) {
|
if ((copiedTotal > 0) && (buf[copiedTotal - 1] == '\n')) {
|
copiedTotal--;
|
copiedTotal--;
|
}
|
}
|
Tcl_SetObjLength(objPtr, copiedTotal + offset);
|
Tcl_SetObjLength(objPtr, copiedTotal + offset);
|
|
|
done:
|
done:
|
/*
|
/*
|
* Update the notifier state so we don't block while there is still
|
* Update the notifier state so we don't block while there is still
|
* data in the buffers.
|
* data in the buffers.
|
*/
|
*/
|
|
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
return copiedTotal;
|
return copiedTotal;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Ungets --
|
* Tcl_Ungets --
|
*
|
*
|
* Causes the supplied string to be added to the input queue of
|
* Causes the supplied string to be added to the input queue of
|
* the channel, at either the head or tail of the queue.
|
* the channel, at either the head or tail of the queue.
|
*
|
*
|
* Results:
|
* Results:
|
* The number of bytes stored in the channel, or -1 on error.
|
* The number of bytes stored in the channel, or -1 on error.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Adds input to the input queue of a channel.
|
* Adds input to the input queue of a channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Ungets(chan, str, len, atEnd)
|
Tcl_Ungets(chan, str, len, atEnd)
|
Tcl_Channel chan; /* The channel for which to add the input. */
|
Tcl_Channel chan; /* The channel for which to add the input. */
|
char *str; /* The input itself. */
|
char *str; /* The input itself. */
|
int len; /* The length of the input. */
|
int len; /* The length of the input. */
|
int atEnd; /* If non-zero, add at end of queue; otherwise
|
int atEnd; /* If non-zero, add at end of queue; otherwise
|
* add at head of queue. */
|
* add at head of queue. */
|
{
|
{
|
Channel *chanPtr; /* The real IO channel. */
|
Channel *chanPtr; /* The real IO channel. */
|
ChannelBuffer *bufPtr; /* Buffer to contain the data. */
|
ChannelBuffer *bufPtr; /* Buffer to contain the data. */
|
int i;
|
int i;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Check for unreported error.
|
* Check for unreported error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
Tcl_SetErrno(chanPtr->unreportedError);
|
Tcl_SetErrno(chanPtr->unreportedError);
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Punt if the channel is not opened for reading.
|
* Punt if the channel is not opened for reading.
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & TCL_READABLE)) {
|
if (!(chanPtr->flags & TCL_READABLE)) {
|
Tcl_SetErrno(EACCES);
|
Tcl_SetErrno(EACCES);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
Tcl_SetErrno(EBUSY);
|
Tcl_SetErrno(EBUSY);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If we have encountered a sticky EOF, just punt without storing.
|
* If we have encountered a sticky EOF, just punt without storing.
|
* (sticky EOF is set if we have seen the input eofChar, to prevent
|
* (sticky EOF is set if we have seen the input eofChar, to prevent
|
* reading beyond the eofChar). Otherwise, clear the EOF flags, and
|
* reading beyond the eofChar). Otherwise, clear the EOF flags, and
|
* clear the BLOCKED bit. We want to discover these conditions anew
|
* clear the BLOCKED bit. We want to discover these conditions anew
|
* in each operation.
|
* in each operation.
|
*/
|
*/
|
|
|
if (chanPtr->flags & CHANNEL_STICKY_EOF) {
|
if (chanPtr->flags & CHANNEL_STICKY_EOF) {
|
return len;
|
return len;
|
}
|
}
|
chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
|
chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
|
|
|
bufPtr = (ChannelBuffer *) ckalloc((unsigned)
|
bufPtr = (ChannelBuffer *) ckalloc((unsigned)
|
(CHANNELBUFFER_HEADER_SIZE + len));
|
(CHANNELBUFFER_HEADER_SIZE + len));
|
for (i = 0; i < len; i++) {
|
for (i = 0; i < len; i++) {
|
bufPtr->buf[i] = str[i];
|
bufPtr->buf[i] = str[i];
|
}
|
}
|
bufPtr->bufSize = len;
|
bufPtr->bufSize = len;
|
bufPtr->nextAdded = len;
|
bufPtr->nextAdded = len;
|
bufPtr->nextRemoved = 0;
|
bufPtr->nextRemoved = 0;
|
|
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) {
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
chanPtr->inQueueHead = bufPtr;
|
chanPtr->inQueueHead = bufPtr;
|
chanPtr->inQueueTail = bufPtr;
|
chanPtr->inQueueTail = bufPtr;
|
} else if (atEnd) {
|
} else if (atEnd) {
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
bufPtr->nextPtr = (ChannelBuffer *) NULL;
|
chanPtr->inQueueTail->nextPtr = bufPtr;
|
chanPtr->inQueueTail->nextPtr = bufPtr;
|
chanPtr->inQueueTail = bufPtr;
|
chanPtr->inQueueTail = bufPtr;
|
} else {
|
} else {
|
bufPtr->nextPtr = chanPtr->inQueueHead;
|
bufPtr->nextPtr = chanPtr->inQueueHead;
|
chanPtr->inQueueHead = bufPtr;
|
chanPtr->inQueueHead = bufPtr;
|
}
|
}
|
|
|
/*
|
/*
|
* Update the notifier state so we don't block while there is still
|
* Update the notifier state so we don't block while there is still
|
* data in the buffers.
|
* data in the buffers.
|
*/
|
*/
|
|
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
return len;
|
return len;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Seek --
|
* Tcl_Seek --
|
*
|
*
|
* Implements seeking on Tcl Channels. This is a public function
|
* Implements seeking on Tcl Channels. This is a public function
|
* so that other C facilities may be implemented on top of it.
|
* so that other C facilities may be implemented on top of it.
|
*
|
*
|
* Results:
|
* Results:
|
* The new access point or -1 on error. If error, use Tcl_GetErrno()
|
* The new access point or -1 on error. If error, use Tcl_GetErrno()
|
* to retrieve the POSIX error code for the error that occurred.
|
* to retrieve the POSIX error code for the error that occurred.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May flush output on the channel. May discard queued input.
|
* May flush output on the channel. May discard queued input.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Seek(chan, offset, mode)
|
Tcl_Seek(chan, offset, mode)
|
Tcl_Channel chan; /* The channel on which to seek. */
|
Tcl_Channel chan; /* The channel on which to seek. */
|
int offset; /* Offset to seek to. */
|
int offset; /* Offset to seek to. */
|
int mode; /* Relative to which location to seek? */
|
int mode; /* Relative to which location to seek? */
|
{
|
{
|
Channel *chanPtr; /* The real IO channel. */
|
Channel *chanPtr; /* The real IO channel. */
|
ChannelBuffer *bufPtr;
|
ChannelBuffer *bufPtr;
|
int inputBuffered, outputBuffered;
|
int inputBuffered, outputBuffered;
|
int result; /* Of device driver operations. */
|
int result; /* Of device driver operations. */
|
int curPos; /* Position on the device. */
|
int curPos; /* Position on the device. */
|
int wasAsync; /* Was the channel nonblocking before the
|
int wasAsync; /* Was the channel nonblocking before the
|
* seek operation? If so, must restore to
|
* seek operation? If so, must restore to
|
* nonblocking mode after the seek. */
|
* nonblocking mode after the seek. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Check for unreported error.
|
* Check for unreported error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
Tcl_SetErrno(chanPtr->unreportedError);
|
Tcl_SetErrno(chanPtr->unreportedError);
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Disallow seek on channels that are open for neither writing nor
|
* Disallow seek on channels that are open for neither writing nor
|
* reading (e.g. socket server channels).
|
* reading (e.g. socket server channels).
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & (TCL_WRITABLE|TCL_READABLE))) {
|
if (!(chanPtr->flags & (TCL_WRITABLE|TCL_READABLE))) {
|
Tcl_SetErrno(EACCES);
|
Tcl_SetErrno(EACCES);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
Tcl_SetErrno(EBUSY);
|
Tcl_SetErrno(EBUSY);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Disallow seek on dead channels -- channels that have been closed but
|
* Disallow seek on dead channels -- channels that have been closed but
|
* not yet been deallocated. Such channels can be found if the exit
|
* not yet been deallocated. Such channels can be found if the exit
|
* handler for channel cleanup has run but the channel is still
|
* handler for channel cleanup has run but the channel is still
|
* registered in an interpreter.
|
* registered in an interpreter.
|
*/
|
*/
|
|
|
if (CheckForDeadChannel(NULL,chanPtr)) return -1;
|
if (CheckForDeadChannel(NULL,chanPtr)) return -1;
|
|
|
/*
|
/*
|
* Disallow seek on channels whose type does not have a seek procedure
|
* Disallow seek on channels whose type does not have a seek procedure
|
* defined. This means that the channel does not support seeking.
|
* defined. This means that the channel does not support seeking.
|
*/
|
*/
|
|
|
if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
|
if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
|
Tcl_SetErrno(EINVAL);
|
Tcl_SetErrno(EINVAL);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Compute how much input and output is buffered. If both input and
|
* Compute how much input and output is buffered. If both input and
|
* output is buffered, cannot compute the current position.
|
* output is buffered, cannot compute the current position.
|
*/
|
*/
|
|
|
for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
|
for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
}
|
}
|
for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
|
for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
}
|
}
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
(chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
|
(chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
outputBuffered +=
|
outputBuffered +=
|
(chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
|
(chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
|
}
|
}
|
|
|
if ((inputBuffered != 0) && (outputBuffered != 0)) {
|
if ((inputBuffered != 0) && (outputBuffered != 0)) {
|
Tcl_SetErrno(EFAULT);
|
Tcl_SetErrno(EFAULT);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If we are seeking relative to the current position, compute the
|
* If we are seeking relative to the current position, compute the
|
* corrected offset taking into account the amount of unread input.
|
* corrected offset taking into account the amount of unread input.
|
*/
|
*/
|
|
|
if (mode == SEEK_CUR) {
|
if (mode == SEEK_CUR) {
|
offset -= inputBuffered;
|
offset -= inputBuffered;
|
}
|
}
|
|
|
/*
|
/*
|
* Discard any queued input - this input should not be read after
|
* Discard any queued input - this input should not be read after
|
* the seek.
|
* the seek.
|
*/
|
*/
|
|
|
DiscardInputQueued(chanPtr, 0);
|
DiscardInputQueued(chanPtr, 0);
|
|
|
/*
|
/*
|
* Reset EOF and BLOCKED flags. We invalidate them by moving the
|
* Reset EOF and BLOCKED flags. We invalidate them by moving the
|
* access point. Also clear CR related flags.
|
* access point. Also clear CR related flags.
|
*/
|
*/
|
|
|
chanPtr->flags &=
|
chanPtr->flags &=
|
(~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR));
|
(~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR));
|
|
|
/*
|
/*
|
* If the channel is in asynchronous output mode, switch it back
|
* If the channel is in asynchronous output mode, switch it back
|
* to synchronous mode and cancel any async flush that may be
|
* to synchronous mode and cancel any async flush that may be
|
* scheduled. After the flush, the channel will be put back into
|
* scheduled. After the flush, the channel will be put back into
|
* asynchronous output mode.
|
* asynchronous output mode.
|
*/
|
*/
|
|
|
wasAsync = 0;
|
wasAsync = 0;
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
wasAsync = 1;
|
wasAsync = 1;
|
result = 0;
|
result = 0;
|
if (chanPtr->typePtr->blockModeProc != NULL) {
|
if (chanPtr->typePtr->blockModeProc != NULL) {
|
result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
|
result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
|
TCL_MODE_BLOCKING);
|
TCL_MODE_BLOCKING);
|
}
|
}
|
if (result != 0) {
|
if (result != 0) {
|
Tcl_SetErrno(result);
|
Tcl_SetErrno(result);
|
return -1;
|
return -1;
|
}
|
}
|
chanPtr->flags &= (~(CHANNEL_NONBLOCKING));
|
chanPtr->flags &= (~(CHANNEL_NONBLOCKING));
|
if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
|
if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
|
chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
|
chanPtr->flags &= (~(BG_FLUSH_SCHEDULED));
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* If the flush fails we cannot recover the original position. In
|
* If the flush fails we cannot recover the original position. In
|
* that case the seek is not attempted because we do not know where
|
* that case the seek is not attempted because we do not know where
|
* the access position is - instead we return the error. FlushChannel
|
* the access position is - instead we return the error. FlushChannel
|
* has already called Tcl_SetErrno() to report the error upwards.
|
* has already called Tcl_SetErrno() to report the error upwards.
|
* If the flush succeeds we do the seek also.
|
* If the flush succeeds we do the seek also.
|
*/
|
*/
|
|
|
if (FlushChannel(NULL, chanPtr, 0) != 0) {
|
if (FlushChannel(NULL, chanPtr, 0) != 0) {
|
curPos = -1;
|
curPos = -1;
|
} else {
|
} else {
|
|
|
/*
|
/*
|
* Now seek to the new position in the channel as requested by the
|
* Now seek to the new position in the channel as requested by the
|
* caller.
|
* caller.
|
*/
|
*/
|
|
|
curPos = (chanPtr->typePtr->seekProc) (chanPtr->instanceData,
|
curPos = (chanPtr->typePtr->seekProc) (chanPtr->instanceData,
|
(long) offset, mode, &result);
|
(long) offset, mode, &result);
|
if (curPos == -1) {
|
if (curPos == -1) {
|
Tcl_SetErrno(result);
|
Tcl_SetErrno(result);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Restore to nonblocking mode if that was the previous behavior.
|
* Restore to nonblocking mode if that was the previous behavior.
|
*
|
*
|
* NOTE: Even if there was an async flush active we do not restore
|
* NOTE: Even if there was an async flush active we do not restore
|
* it now because we already flushed all the queued output, above.
|
* it now because we already flushed all the queued output, above.
|
*/
|
*/
|
|
|
if (wasAsync) {
|
if (wasAsync) {
|
chanPtr->flags |= CHANNEL_NONBLOCKING;
|
chanPtr->flags |= CHANNEL_NONBLOCKING;
|
result = 0;
|
result = 0;
|
if (chanPtr->typePtr->blockModeProc != NULL) {
|
if (chanPtr->typePtr->blockModeProc != NULL) {
|
result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
|
result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData,
|
TCL_MODE_NONBLOCKING);
|
TCL_MODE_NONBLOCKING);
|
}
|
}
|
if (result != 0) {
|
if (result != 0) {
|
Tcl_SetErrno(result);
|
Tcl_SetErrno(result);
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
|
|
return curPos;
|
return curPos;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Tell --
|
* Tcl_Tell --
|
*
|
*
|
* Returns the position of the next character to be read/written on
|
* Returns the position of the next character to be read/written on
|
* this channel.
|
* this channel.
|
*
|
*
|
* Results:
|
* Results:
|
* A nonnegative integer on success, -1 on failure. If failed,
|
* A nonnegative integer on success, -1 on failure. If failed,
|
* use Tcl_GetErrno() to retrieve the POSIX error code for the
|
* use Tcl_GetErrno() to retrieve the POSIX error code for the
|
* error that occurred.
|
* error that occurred.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Tell(chan)
|
Tcl_Tell(chan)
|
Tcl_Channel chan; /* The channel to return pos for. */
|
Tcl_Channel chan; /* The channel to return pos for. */
|
{
|
{
|
Channel *chanPtr; /* The actual channel to tell on. */
|
Channel *chanPtr; /* The actual channel to tell on. */
|
ChannelBuffer *bufPtr;
|
ChannelBuffer *bufPtr;
|
int inputBuffered, outputBuffered;
|
int inputBuffered, outputBuffered;
|
int result; /* Of calling device driver. */
|
int result; /* Of calling device driver. */
|
int curPos; /* Position on device. */
|
int curPos; /* Position on device. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Check for unreported error.
|
* Check for unreported error.
|
*/
|
*/
|
|
|
if (chanPtr->unreportedError != 0) {
|
if (chanPtr->unreportedError != 0) {
|
Tcl_SetErrno(chanPtr->unreportedError);
|
Tcl_SetErrno(chanPtr->unreportedError);
|
chanPtr->unreportedError = 0;
|
chanPtr->unreportedError = 0;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Disallow tell on dead channels -- channels that have been closed but
|
* Disallow tell on dead channels -- channels that have been closed but
|
* not yet been deallocated. Such channels can be found if the exit
|
* not yet been deallocated. Such channels can be found if the exit
|
* handler for channel cleanup has run but the channel is still
|
* handler for channel cleanup has run but the channel is still
|
* registered in an interpreter.
|
* registered in an interpreter.
|
*/
|
*/
|
|
|
if (CheckForDeadChannel(NULL,chanPtr)) return -1;
|
if (CheckForDeadChannel(NULL,chanPtr)) return -1;
|
|
|
/*
|
/*
|
* Disallow tell on channels that are open for neither
|
* Disallow tell on channels that are open for neither
|
* writing nor reading (e.g. socket server channels).
|
* writing nor reading (e.g. socket server channels).
|
*/
|
*/
|
|
|
if (!(chanPtr->flags & (TCL_WRITABLE|TCL_READABLE))) {
|
if (!(chanPtr->flags & (TCL_WRITABLE|TCL_READABLE))) {
|
Tcl_SetErrno(EACCES);
|
Tcl_SetErrno(EACCES);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
Tcl_SetErrno(EBUSY);
|
Tcl_SetErrno(EBUSY);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Disallow tell on channels whose type does not have a seek procedure
|
* Disallow tell on channels whose type does not have a seek procedure
|
* defined. This means that the channel does not support seeking.
|
* defined. This means that the channel does not support seeking.
|
*/
|
*/
|
|
|
if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
|
if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) {
|
Tcl_SetErrno(EINVAL);
|
Tcl_SetErrno(EINVAL);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Compute how much input and output is buffered. If both input and
|
* Compute how much input and output is buffered. If both input and
|
* output is buffered, cannot compute the current position.
|
* output is buffered, cannot compute the current position.
|
*/
|
*/
|
|
|
for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
|
for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
}
|
}
|
for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
|
for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
}
|
}
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) &&
|
(chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
|
(chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) {
|
chanPtr->flags |= BUFFER_READY;
|
chanPtr->flags |= BUFFER_READY;
|
outputBuffered +=
|
outputBuffered +=
|
(chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
|
(chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved);
|
}
|
}
|
|
|
if ((inputBuffered != 0) && (outputBuffered != 0)) {
|
if ((inputBuffered != 0) && (outputBuffered != 0)) {
|
Tcl_SetErrno(EFAULT);
|
Tcl_SetErrno(EFAULT);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* Get the current position in the device and compute the position
|
* Get the current position in the device and compute the position
|
* where the next character will be read or written.
|
* where the next character will be read or written.
|
*/
|
*/
|
|
|
curPos = (chanPtr->typePtr->seekProc) (chanPtr->instanceData,
|
curPos = (chanPtr->typePtr->seekProc) (chanPtr->instanceData,
|
(long) 0, SEEK_CUR, &result);
|
(long) 0, SEEK_CUR, &result);
|
if (curPos == -1) {
|
if (curPos == -1) {
|
Tcl_SetErrno(result);
|
Tcl_SetErrno(result);
|
return -1;
|
return -1;
|
}
|
}
|
if (inputBuffered != 0) {
|
if (inputBuffered != 0) {
|
return (curPos - inputBuffered);
|
return (curPos - inputBuffered);
|
}
|
}
|
return (curPos + outputBuffered);
|
return (curPos + outputBuffered);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_Eof --
|
* Tcl_Eof --
|
*
|
*
|
* Returns 1 if the channel is at EOF, 0 otherwise.
|
* Returns 1 if the channel is at EOF, 0 otherwise.
|
*
|
*
|
* Results:
|
* Results:
|
* 1 or 0, always.
|
* 1 or 0, always.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_Eof(chan)
|
Tcl_Eof(chan)
|
Tcl_Channel chan; /* Does this channel have EOF? */
|
Tcl_Channel chan; /* Does this channel have EOF? */
|
{
|
{
|
Channel *chanPtr; /* The real channel structure. */
|
Channel *chanPtr; /* The real channel structure. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
return ((chanPtr->flags & CHANNEL_STICKY_EOF) ||
|
return ((chanPtr->flags & CHANNEL_STICKY_EOF) ||
|
((chanPtr->flags & CHANNEL_EOF) && (Tcl_InputBuffered(chan) == 0)))
|
((chanPtr->flags & CHANNEL_EOF) && (Tcl_InputBuffered(chan) == 0)))
|
? 1 : 0;
|
? 1 : 0;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_InputBlocked --
|
* Tcl_InputBlocked --
|
*
|
*
|
* Returns 1 if input is blocked on this channel, 0 otherwise.
|
* Returns 1 if input is blocked on this channel, 0 otherwise.
|
*
|
*
|
* Results:
|
* Results:
|
* 0 or 1, always.
|
* 0 or 1, always.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_InputBlocked(chan)
|
Tcl_InputBlocked(chan)
|
Tcl_Channel chan; /* Is this channel blocked? */
|
Tcl_Channel chan; /* Is this channel blocked? */
|
{
|
{
|
Channel *chanPtr; /* The real channel structure. */
|
Channel *chanPtr; /* The real channel structure. */
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
return (chanPtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
|
return (chanPtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_InputBuffered --
|
* Tcl_InputBuffered --
|
*
|
*
|
* Returns the number of bytes of input currently buffered in the
|
* Returns the number of bytes of input currently buffered in the
|
* internal buffer of a channel.
|
* internal buffer of a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* The number of input bytes buffered, or zero if the channel is not
|
* The number of input bytes buffered, or zero if the channel is not
|
* open for reading.
|
* open for reading.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_InputBuffered(chan)
|
Tcl_InputBuffered(chan)
|
Tcl_Channel chan; /* The channel to query. */
|
Tcl_Channel chan; /* The channel to query. */
|
{
|
{
|
Channel *chanPtr;
|
Channel *chanPtr;
|
int bytesBuffered;
|
int bytesBuffered;
|
ChannelBuffer *bufPtr;
|
ChannelBuffer *bufPtr;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead;
|
for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
}
|
}
|
return bytesBuffered;
|
return bytesBuffered;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_SetChannelBufferSize --
|
* Tcl_SetChannelBufferSize --
|
*
|
*
|
* Sets the size of buffers to allocate to store input or output
|
* Sets the size of buffers to allocate to store input or output
|
* in the channel. The size must be between 10 bytes and 1 MByte.
|
* in the channel. The size must be between 10 bytes and 1 MByte.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Sets the size of buffers subsequently allocated for this channel.
|
* Sets the size of buffers subsequently allocated for this channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_SetChannelBufferSize(chan, sz)
|
Tcl_SetChannelBufferSize(chan, sz)
|
Tcl_Channel chan; /* The channel whose buffer size
|
Tcl_Channel chan; /* The channel whose buffer size
|
* to set. */
|
* to set. */
|
int sz; /* The size to set. */
|
int sz; /* The size to set. */
|
{
|
{
|
Channel *chanPtr;
|
Channel *chanPtr;
|
|
|
/*
|
/*
|
* If the buffer size is smaller than 10 bytes or larger than one MByte,
|
* If the buffer size is smaller than 10 bytes or larger than one MByte,
|
* do not accept the requested size and leave the current buffer size.
|
* do not accept the requested size and leave the current buffer size.
|
*/
|
*/
|
|
|
if (sz < 10) {
|
if (sz < 10) {
|
return;
|
return;
|
}
|
}
|
if (sz > (1024 * 1024)) {
|
if (sz > (1024 * 1024)) {
|
return;
|
return;
|
}
|
}
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
chanPtr->bufSize = sz;
|
chanPtr->bufSize = sz;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannelBufferSize --
|
* Tcl_GetChannelBufferSize --
|
*
|
*
|
* Retrieves the size of buffers to allocate for this channel.
|
* Retrieves the size of buffers to allocate for this channel.
|
*
|
*
|
* Results:
|
* Results:
|
* The size.
|
* The size.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_GetChannelBufferSize(chan)
|
Tcl_GetChannelBufferSize(chan)
|
Tcl_Channel chan; /* The channel for which to find the
|
Tcl_Channel chan; /* The channel for which to find the
|
* buffer size. */
|
* buffer size. */
|
{
|
{
|
Channel *chanPtr;
|
Channel *chanPtr;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
return chanPtr->bufSize;
|
return chanPtr->bufSize;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_BadChannelOption --
|
* Tcl_BadChannelOption --
|
*
|
*
|
* This procedure generates a "bad option" error message in an
|
* This procedure generates a "bad option" error message in an
|
* (optional) interpreter. It is used by channel drivers when
|
* (optional) interpreter. It is used by channel drivers when
|
* a invalid Set/Get option is requested. Its purpose is to concatenate
|
* a invalid Set/Get option is requested. Its purpose is to concatenate
|
* the generic options list to the specific ones and factorize
|
* the generic options list to the specific ones and factorize
|
* the generic options error message string.
|
* the generic options error message string.
|
*
|
*
|
* Results:
|
* Results:
|
* TCL_ERROR.
|
* TCL_ERROR.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* An error message is generated in interp's result object to
|
* An error message is generated in interp's result object to
|
* indicate that a command was invoked with the a bad option
|
* indicate that a command was invoked with the a bad option
|
* The message has the form
|
* The message has the form
|
* bad option "blah": should be one of
|
* bad option "blah": should be one of
|
* <...generic options...>+<...specific options...>
|
* <...generic options...>+<...specific options...>
|
* "blah" is the optionName argument and "<specific options>"
|
* "blah" is the optionName argument and "<specific options>"
|
* is a space separated list of specific option words.
|
* is a space separated list of specific option words.
|
* The function takes good care of inserting minus signs before
|
* The function takes good care of inserting minus signs before
|
* each option, commas after, and an "or" before the last option.
|
* each option, commas after, and an "or" before the last option.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_BadChannelOption(interp, optionName, optionList)
|
Tcl_BadChannelOption(interp, optionName, optionList)
|
Tcl_Interp *interp; /* Current interpreter. (can be NULL)*/
|
Tcl_Interp *interp; /* Current interpreter. (can be NULL)*/
|
char *optionName; /* 'bad option' name */
|
char *optionName; /* 'bad option' name */
|
char *optionList; /* Specific options list to append
|
char *optionList; /* Specific options list to append
|
* to the standard generic options.
|
* to the standard generic options.
|
* can be NULL for generic options
|
* can be NULL for generic options
|
* only.
|
* only.
|
*/
|
*/
|
{
|
{
|
if (interp) {
|
if (interp) {
|
CONST char *genericopt =
|
CONST char *genericopt =
|
"blocking buffering buffersize eofchar translation";
|
"blocking buffering buffersize eofchar translation";
|
char **argv;
|
char **argv;
|
int argc, i;
|
int argc, i;
|
Tcl_DString ds;
|
Tcl_DString ds;
|
|
|
Tcl_DStringInit(&ds);
|
Tcl_DStringInit(&ds);
|
Tcl_DStringAppend(&ds, (char *) genericopt, -1);
|
Tcl_DStringAppend(&ds, (char *) genericopt, -1);
|
if (optionList && (*optionList)) {
|
if (optionList && (*optionList)) {
|
Tcl_DStringAppend(&ds, " ", 1);
|
Tcl_DStringAppend(&ds, " ", 1);
|
Tcl_DStringAppend(&ds, optionList, -1);
|
Tcl_DStringAppend(&ds, optionList, -1);
|
}
|
}
|
if (Tcl_SplitList(interp, Tcl_DStringValue(&ds),
|
if (Tcl_SplitList(interp, Tcl_DStringValue(&ds),
|
&argc, &argv) != TCL_OK) {
|
&argc, &argv) != TCL_OK) {
|
panic("malformed option list in channel driver");
|
panic("malformed option list in channel driver");
|
}
|
}
|
Tcl_ResetResult(interp);
|
Tcl_ResetResult(interp);
|
Tcl_AppendResult(interp, "bad option \"", optionName,
|
Tcl_AppendResult(interp, "bad option \"", optionName,
|
"\": should be one of ", (char *) NULL);
|
"\": should be one of ", (char *) NULL);
|
argc--;
|
argc--;
|
for (i = 0; i < argc; i++) {
|
for (i = 0; i < argc; i++) {
|
Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL);
|
Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL);
|
}
|
}
|
Tcl_AppendResult(interp, "or -", argv[i], (char *) NULL);
|
Tcl_AppendResult(interp, "or -", argv[i], (char *) NULL);
|
Tcl_DStringFree(&ds);
|
Tcl_DStringFree(&ds);
|
ckfree((char *) argv);
|
ckfree((char *) argv);
|
}
|
}
|
Tcl_SetErrno(EINVAL);
|
Tcl_SetErrno(EINVAL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_GetChannelOption --
|
* Tcl_GetChannelOption --
|
*
|
*
|
* Gets a mode associated with an IO channel. If the optionName arg
|
* Gets a mode associated with an IO channel. If the optionName arg
|
* is non NULL, retrieves the value of that option. If the optionName
|
* is non NULL, retrieves the value of that option. If the optionName
|
* arg is NULL, retrieves a list of alternating option names and
|
* arg is NULL, retrieves a list of alternating option names and
|
* values for the given channel.
|
* values for the given channel.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result. Also sets the supplied DString to the
|
* A standard Tcl result. Also sets the supplied DString to the
|
* string value of the option(s) returned.
|
* string value of the option(s) returned.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
|
Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
|
Tcl_Interp *interp; /* For error reporting - can be NULL. */
|
Tcl_Interp *interp; /* For error reporting - can be NULL. */
|
Tcl_Channel chan; /* Channel on which to get option. */
|
Tcl_Channel chan; /* Channel on which to get option. */
|
char *optionName; /* Option to get. */
|
char *optionName; /* Option to get. */
|
Tcl_DString *dsPtr; /* Where to store value(s). */
|
Tcl_DString *dsPtr; /* Where to store value(s). */
|
{
|
{
|
size_t len; /* Length of optionName string. */
|
size_t len; /* Length of optionName string. */
|
char optionVal[128]; /* Buffer for sprintf. */
|
char optionVal[128]; /* Buffer for sprintf. */
|
Channel *chanPtr = (Channel *) chan;
|
Channel *chanPtr = (Channel *) chan;
|
int flags;
|
int flags;
|
|
|
/*
|
/*
|
* If we are in the middle of a background copy, use the saved flags.
|
* If we are in the middle of a background copy, use the saved flags.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
if (chanPtr == chanPtr->csPtr->readPtr) {
|
if (chanPtr == chanPtr->csPtr->readPtr) {
|
flags = chanPtr->csPtr->readFlags;
|
flags = chanPtr->csPtr->readFlags;
|
} else {
|
} else {
|
flags = chanPtr->csPtr->writeFlags;
|
flags = chanPtr->csPtr->writeFlags;
|
}
|
}
|
} else {
|
} else {
|
flags = chanPtr->flags;
|
flags = chanPtr->flags;
|
}
|
}
|
|
|
/*
|
/*
|
* Disallow options on dead channels -- channels that have been closed but
|
* Disallow options on dead channels -- channels that have been closed but
|
* not yet been deallocated. Such channels can be found if the exit
|
* not yet been deallocated. Such channels can be found if the exit
|
* handler for channel cleanup has run but the channel is still
|
* handler for channel cleanup has run but the channel is still
|
* registered in an interpreter.
|
* registered in an interpreter.
|
*/
|
*/
|
|
|
if (CheckForDeadChannel(interp,chanPtr)) return TCL_ERROR;
|
if (CheckForDeadChannel(interp,chanPtr)) return TCL_ERROR;
|
|
|
/*
|
/*
|
* If the optionName is NULL it means that we want a list of all
|
* If the optionName is NULL it means that we want a list of all
|
* options and values.
|
* options and values.
|
*/
|
*/
|
|
|
if (optionName == (char *) NULL) {
|
if (optionName == (char *) NULL) {
|
len = 0;
|
len = 0;
|
} else {
|
} else {
|
len = strlen(optionName);
|
len = strlen(optionName);
|
}
|
}
|
|
|
if ((len == 0) || ((len > 2) && (optionName[1] == 'b') &&
|
if ((len == 0) || ((len > 2) && (optionName[1] == 'b') &&
|
(strncmp(optionName, "-blocking", len) == 0))) {
|
(strncmp(optionName, "-blocking", len) == 0))) {
|
if (len == 0) {
|
if (len == 0) {
|
Tcl_DStringAppendElement(dsPtr, "-blocking");
|
Tcl_DStringAppendElement(dsPtr, "-blocking");
|
}
|
}
|
Tcl_DStringAppendElement(dsPtr,
|
Tcl_DStringAppendElement(dsPtr,
|
(flags & CHANNEL_NONBLOCKING) ? "0" : "1");
|
(flags & CHANNEL_NONBLOCKING) ? "0" : "1");
|
if (len > 0) {
|
if (len > 0) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
}
|
}
|
if ((len == 0) || ((len > 7) && (optionName[1] == 'b') &&
|
if ((len == 0) || ((len > 7) && (optionName[1] == 'b') &&
|
(strncmp(optionName, "-buffering", len) == 0))) {
|
(strncmp(optionName, "-buffering", len) == 0))) {
|
if (len == 0) {
|
if (len == 0) {
|
Tcl_DStringAppendElement(dsPtr, "-buffering");
|
Tcl_DStringAppendElement(dsPtr, "-buffering");
|
}
|
}
|
if (flags & CHANNEL_LINEBUFFERED) {
|
if (flags & CHANNEL_LINEBUFFERED) {
|
Tcl_DStringAppendElement(dsPtr, "line");
|
Tcl_DStringAppendElement(dsPtr, "line");
|
} else if (flags & CHANNEL_UNBUFFERED) {
|
} else if (flags & CHANNEL_UNBUFFERED) {
|
Tcl_DStringAppendElement(dsPtr, "none");
|
Tcl_DStringAppendElement(dsPtr, "none");
|
} else {
|
} else {
|
Tcl_DStringAppendElement(dsPtr, "full");
|
Tcl_DStringAppendElement(dsPtr, "full");
|
}
|
}
|
if (len > 0) {
|
if (len > 0) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
}
|
}
|
if ((len == 0) || ((len > 7) && (optionName[1] == 'b') &&
|
if ((len == 0) || ((len > 7) && (optionName[1] == 'b') &&
|
(strncmp(optionName, "-buffersize", len) == 0))) {
|
(strncmp(optionName, "-buffersize", len) == 0))) {
|
if (len == 0) {
|
if (len == 0) {
|
Tcl_DStringAppendElement(dsPtr, "-buffersize");
|
Tcl_DStringAppendElement(dsPtr, "-buffersize");
|
}
|
}
|
TclFormatInt(optionVal, chanPtr->bufSize);
|
TclFormatInt(optionVal, chanPtr->bufSize);
|
Tcl_DStringAppendElement(dsPtr, optionVal);
|
Tcl_DStringAppendElement(dsPtr, optionVal);
|
if (len > 0) {
|
if (len > 0) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
}
|
}
|
if ((len == 0) ||
|
if ((len == 0) ||
|
((len > 1) && (optionName[1] == 'e') &&
|
((len > 1) && (optionName[1] == 'e') &&
|
(strncmp(optionName, "-eofchar", len) == 0))) {
|
(strncmp(optionName, "-eofchar", len) == 0))) {
|
if (len == 0) {
|
if (len == 0) {
|
Tcl_DStringAppendElement(dsPtr, "-eofchar");
|
Tcl_DStringAppendElement(dsPtr, "-eofchar");
|
}
|
}
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
Tcl_DStringStartSublist(dsPtr);
|
Tcl_DStringStartSublist(dsPtr);
|
}
|
}
|
if (flags & TCL_READABLE) {
|
if (flags & TCL_READABLE) {
|
if (chanPtr->inEofChar == 0) {
|
if (chanPtr->inEofChar == 0) {
|
Tcl_DStringAppendElement(dsPtr, "");
|
Tcl_DStringAppendElement(dsPtr, "");
|
} else {
|
} else {
|
char buf[4];
|
char buf[4];
|
|
|
sprintf(buf, "%c", chanPtr->inEofChar);
|
sprintf(buf, "%c", chanPtr->inEofChar);
|
Tcl_DStringAppendElement(dsPtr, buf);
|
Tcl_DStringAppendElement(dsPtr, buf);
|
}
|
}
|
}
|
}
|
if (flags & TCL_WRITABLE) {
|
if (flags & TCL_WRITABLE) {
|
if (chanPtr->outEofChar == 0) {
|
if (chanPtr->outEofChar == 0) {
|
Tcl_DStringAppendElement(dsPtr, "");
|
Tcl_DStringAppendElement(dsPtr, "");
|
} else {
|
} else {
|
char buf[4];
|
char buf[4];
|
|
|
sprintf(buf, "%c", chanPtr->outEofChar);
|
sprintf(buf, "%c", chanPtr->outEofChar);
|
Tcl_DStringAppendElement(dsPtr, buf);
|
Tcl_DStringAppendElement(dsPtr, buf);
|
}
|
}
|
}
|
}
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
Tcl_DStringEndSublist(dsPtr);
|
Tcl_DStringEndSublist(dsPtr);
|
}
|
}
|
if (len > 0) {
|
if (len > 0) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
}
|
}
|
if ((len == 0) ||
|
if ((len == 0) ||
|
((len > 1) && (optionName[1] == 't') &&
|
((len > 1) && (optionName[1] == 't') &&
|
(strncmp(optionName, "-translation", len) == 0))) {
|
(strncmp(optionName, "-translation", len) == 0))) {
|
if (len == 0) {
|
if (len == 0) {
|
Tcl_DStringAppendElement(dsPtr, "-translation");
|
Tcl_DStringAppendElement(dsPtr, "-translation");
|
}
|
}
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
Tcl_DStringStartSublist(dsPtr);
|
Tcl_DStringStartSublist(dsPtr);
|
}
|
}
|
if (flags & TCL_READABLE) {
|
if (flags & TCL_READABLE) {
|
if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) {
|
if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) {
|
Tcl_DStringAppendElement(dsPtr, "auto");
|
Tcl_DStringAppendElement(dsPtr, "auto");
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) {
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) {
|
Tcl_DStringAppendElement(dsPtr, "cr");
|
Tcl_DStringAppendElement(dsPtr, "cr");
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) {
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) {
|
Tcl_DStringAppendElement(dsPtr, "crlf");
|
Tcl_DStringAppendElement(dsPtr, "crlf");
|
} else {
|
} else {
|
Tcl_DStringAppendElement(dsPtr, "lf");
|
Tcl_DStringAppendElement(dsPtr, "lf");
|
}
|
}
|
}
|
}
|
if (flags & TCL_WRITABLE) {
|
if (flags & TCL_WRITABLE) {
|
if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) {
|
if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) {
|
Tcl_DStringAppendElement(dsPtr, "auto");
|
Tcl_DStringAppendElement(dsPtr, "auto");
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) {
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) {
|
Tcl_DStringAppendElement(dsPtr, "cr");
|
Tcl_DStringAppendElement(dsPtr, "cr");
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) {
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) {
|
Tcl_DStringAppendElement(dsPtr, "crlf");
|
Tcl_DStringAppendElement(dsPtr, "crlf");
|
} else {
|
} else {
|
Tcl_DStringAppendElement(dsPtr, "lf");
|
Tcl_DStringAppendElement(dsPtr, "lf");
|
}
|
}
|
}
|
}
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
|
Tcl_DStringEndSublist(dsPtr);
|
Tcl_DStringEndSublist(dsPtr);
|
}
|
}
|
if (len > 0) {
|
if (len > 0) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
}
|
}
|
if (chanPtr->typePtr->getOptionProc != (Tcl_DriverGetOptionProc *) NULL) {
|
if (chanPtr->typePtr->getOptionProc != (Tcl_DriverGetOptionProc *) NULL) {
|
/*
|
/*
|
* let the driver specific handle additional options
|
* let the driver specific handle additional options
|
* and result code and message.
|
* and result code and message.
|
*/
|
*/
|
|
|
return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData,
|
return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData,
|
interp, optionName, dsPtr);
|
interp, optionName, dsPtr);
|
} else {
|
} else {
|
/*
|
/*
|
* no driver specific options case.
|
* no driver specific options case.
|
*/
|
*/
|
|
|
if (len == 0) {
|
if (len == 0) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
return Tcl_BadChannelOption(interp, optionName, NULL);
|
return Tcl_BadChannelOption(interp, optionName, NULL);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_SetChannelOption --
|
* Tcl_SetChannelOption --
|
*
|
*
|
* Sets an option on a channel.
|
* Sets an option on a channel.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result. Also sets interp->result on error if
|
* A standard Tcl result. Also sets interp->result on error if
|
* interp is not NULL.
|
* interp is not NULL.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May modify an option on a device.
|
* May modify an option on a device.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
Tcl_SetChannelOption(interp, chan, optionName, newValue)
|
Tcl_SetChannelOption(interp, chan, optionName, newValue)
|
Tcl_Interp *interp; /* For error reporting - can be NULL. */
|
Tcl_Interp *interp; /* For error reporting - can be NULL. */
|
Tcl_Channel chan; /* Channel on which to set mode. */
|
Tcl_Channel chan; /* Channel on which to set mode. */
|
char *optionName; /* Which option to set? */
|
char *optionName; /* Which option to set? */
|
char *newValue; /* New value for option. */
|
char *newValue; /* New value for option. */
|
{
|
{
|
int newMode; /* New (numeric) mode to sert. */
|
int newMode; /* New (numeric) mode to sert. */
|
Channel *chanPtr; /* The real IO channel. */
|
Channel *chanPtr; /* The real IO channel. */
|
size_t len; /* Length of optionName string. */
|
size_t len; /* Length of optionName string. */
|
int argc;
|
int argc;
|
char **argv;
|
char **argv;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* If the channel is in the middle of a background copy, fail.
|
* If the channel is in the middle of a background copy, fail.
|
*/
|
*/
|
|
|
if (chanPtr->csPtr) {
|
if (chanPtr->csPtr) {
|
if (interp) {
|
if (interp) {
|
Tcl_AppendResult(interp,
|
Tcl_AppendResult(interp,
|
"unable to set channel options: background copy in progress",
|
"unable to set channel options: background copy in progress",
|
(char *) NULL);
|
(char *) NULL);
|
}
|
}
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Disallow options on dead channels -- channels that have been closed but
|
* Disallow options on dead channels -- channels that have been closed but
|
* not yet been deallocated. Such channels can be found if the exit
|
* not yet been deallocated. Such channels can be found if the exit
|
* handler for channel cleanup has run but the channel is still
|
* handler for channel cleanup has run but the channel is still
|
* registered in an interpreter.
|
* registered in an interpreter.
|
*/
|
*/
|
|
|
if (CheckForDeadChannel(NULL,chanPtr)) return TCL_ERROR;
|
if (CheckForDeadChannel(NULL,chanPtr)) return TCL_ERROR;
|
|
|
len = strlen(optionName);
|
len = strlen(optionName);
|
|
|
if ((len > 2) && (optionName[1] == 'b') &&
|
if ((len > 2) && (optionName[1] == 'b') &&
|
(strncmp(optionName, "-blocking", len) == 0)) {
|
(strncmp(optionName, "-blocking", len) == 0)) {
|
if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) {
|
if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (newMode) {
|
if (newMode) {
|
newMode = TCL_MODE_BLOCKING;
|
newMode = TCL_MODE_BLOCKING;
|
} else {
|
} else {
|
newMode = TCL_MODE_NONBLOCKING;
|
newMode = TCL_MODE_NONBLOCKING;
|
}
|
}
|
return SetBlockMode(interp, chanPtr, newMode);
|
return SetBlockMode(interp, chanPtr, newMode);
|
}
|
}
|
|
|
if ((len > 7) && (optionName[1] == 'b') &&
|
if ((len > 7) && (optionName[1] == 'b') &&
|
(strncmp(optionName, "-buffering", len) == 0)) {
|
(strncmp(optionName, "-buffering", len) == 0)) {
|
len = strlen(newValue);
|
len = strlen(newValue);
|
if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
|
if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
|
chanPtr->flags &=
|
chanPtr->flags &=
|
(~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED));
|
(~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED));
|
} else if ((newValue[0] == 'l') &&
|
} else if ((newValue[0] == 'l') &&
|
(strncmp(newValue, "line", len) == 0)) {
|
(strncmp(newValue, "line", len) == 0)) {
|
chanPtr->flags &= (~(CHANNEL_UNBUFFERED));
|
chanPtr->flags &= (~(CHANNEL_UNBUFFERED));
|
chanPtr->flags |= CHANNEL_LINEBUFFERED;
|
chanPtr->flags |= CHANNEL_LINEBUFFERED;
|
} else if ((newValue[0] == 'n') &&
|
} else if ((newValue[0] == 'n') &&
|
(strncmp(newValue, "none", len) == 0)) {
|
(strncmp(newValue, "none", len) == 0)) {
|
chanPtr->flags &= (~(CHANNEL_LINEBUFFERED));
|
chanPtr->flags &= (~(CHANNEL_LINEBUFFERED));
|
chanPtr->flags |= CHANNEL_UNBUFFERED;
|
chanPtr->flags |= CHANNEL_UNBUFFERED;
|
} else {
|
} else {
|
if (interp) {
|
if (interp) {
|
Tcl_AppendResult(interp, "bad value for -buffering: ",
|
Tcl_AppendResult(interp, "bad value for -buffering: ",
|
"must be one of full, line, or none",
|
"must be one of full, line, or none",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((len > 7) && (optionName[1] == 'b') &&
|
if ((len > 7) && (optionName[1] == 'b') &&
|
(strncmp(optionName, "-buffersize", len) == 0)) {
|
(strncmp(optionName, "-buffersize", len) == 0)) {
|
chanPtr->bufSize = atoi(newValue);
|
chanPtr->bufSize = atoi(newValue);
|
if ((chanPtr->bufSize < 10) || (chanPtr->bufSize > (1024 * 1024))) {
|
if ((chanPtr->bufSize < 10) || (chanPtr->bufSize > (1024 * 1024))) {
|
chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
|
chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((len > 1) && (optionName[1] == 'e') &&
|
if ((len > 1) && (optionName[1] == 'e') &&
|
(strncmp(optionName, "-eofchar", len) == 0)) {
|
(strncmp(optionName, "-eofchar", len) == 0)) {
|
if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
|
if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (argc == 0) {
|
if (argc == 0) {
|
chanPtr->inEofChar = 0;
|
chanPtr->inEofChar = 0;
|
chanPtr->outEofChar = 0;
|
chanPtr->outEofChar = 0;
|
} else if (argc == 1) {
|
} else if (argc == 1) {
|
if (chanPtr->flags & TCL_WRITABLE) {
|
if (chanPtr->flags & TCL_WRITABLE) {
|
chanPtr->outEofChar = (int) argv[0][0];
|
chanPtr->outEofChar = (int) argv[0][0];
|
}
|
}
|
if (chanPtr->flags & TCL_READABLE) {
|
if (chanPtr->flags & TCL_READABLE) {
|
chanPtr->inEofChar = (int) argv[0][0];
|
chanPtr->inEofChar = (int) argv[0][0];
|
}
|
}
|
} else if (argc != 2) {
|
} else if (argc != 2) {
|
if (interp) {
|
if (interp) {
|
Tcl_AppendResult(interp,
|
Tcl_AppendResult(interp,
|
"bad value for -eofchar: should be a list of one or",
|
"bad value for -eofchar: should be a list of one or",
|
" two elements", (char *) NULL);
|
" two elements", (char *) NULL);
|
}
|
}
|
ckfree((char *) argv);
|
ckfree((char *) argv);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
} else {
|
} else {
|
if (chanPtr->flags & TCL_READABLE) {
|
if (chanPtr->flags & TCL_READABLE) {
|
chanPtr->inEofChar = (int) argv[0][0];
|
chanPtr->inEofChar = (int) argv[0][0];
|
}
|
}
|
if (chanPtr->flags & TCL_WRITABLE) {
|
if (chanPtr->flags & TCL_WRITABLE) {
|
chanPtr->outEofChar = (int) argv[1][0];
|
chanPtr->outEofChar = (int) argv[1][0];
|
}
|
}
|
}
|
}
|
if (argv != (char **) NULL) {
|
if (argv != (char **) NULL) {
|
ckfree((char *) argv);
|
ckfree((char *) argv);
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((len > 1) && (optionName[1] == 't') &&
|
if ((len > 1) && (optionName[1] == 't') &&
|
(strncmp(optionName, "-translation", len) == 0)) {
|
(strncmp(optionName, "-translation", len) == 0)) {
|
char *readMode, *writeMode;
|
char *readMode, *writeMode;
|
|
|
if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
|
if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
if (argc == 1) {
|
if (argc == 1) {
|
readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
|
readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
|
writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
|
writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
|
} else if (argc == 2) {
|
} else if (argc == 2) {
|
readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
|
readMode = (chanPtr->flags & TCL_READABLE) ? argv[0] : NULL;
|
writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
|
writeMode = (chanPtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
|
} else {
|
} else {
|
if (interp) {
|
if (interp) {
|
Tcl_AppendResult(interp,
|
Tcl_AppendResult(interp,
|
"bad value for -translation: must be a one or two",
|
"bad value for -translation: must be a one or two",
|
" element list", (char *) NULL);
|
" element list", (char *) NULL);
|
}
|
}
|
ckfree((char *) argv);
|
ckfree((char *) argv);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
if (readMode) {
|
if (readMode) {
|
if (*readMode == '\0') {
|
if (*readMode == '\0') {
|
newMode = chanPtr->inputTranslation;
|
newMode = chanPtr->inputTranslation;
|
} else if (strcmp(readMode, "auto") == 0) {
|
} else if (strcmp(readMode, "auto") == 0) {
|
newMode = TCL_TRANSLATE_AUTO;
|
newMode = TCL_TRANSLATE_AUTO;
|
} else if (strcmp(readMode, "binary") == 0) {
|
} else if (strcmp(readMode, "binary") == 0) {
|
chanPtr->inEofChar = 0;
|
chanPtr->inEofChar = 0;
|
newMode = TCL_TRANSLATE_LF;
|
newMode = TCL_TRANSLATE_LF;
|
} else if (strcmp(readMode, "lf") == 0) {
|
} else if (strcmp(readMode, "lf") == 0) {
|
newMode = TCL_TRANSLATE_LF;
|
newMode = TCL_TRANSLATE_LF;
|
} else if (strcmp(readMode, "cr") == 0) {
|
} else if (strcmp(readMode, "cr") == 0) {
|
newMode = TCL_TRANSLATE_CR;
|
newMode = TCL_TRANSLATE_CR;
|
} else if (strcmp(readMode, "crlf") == 0) {
|
} else if (strcmp(readMode, "crlf") == 0) {
|
newMode = TCL_TRANSLATE_CRLF;
|
newMode = TCL_TRANSLATE_CRLF;
|
} else if (strcmp(readMode, "platform") == 0) {
|
} else if (strcmp(readMode, "platform") == 0) {
|
newMode = TCL_PLATFORM_TRANSLATION;
|
newMode = TCL_PLATFORM_TRANSLATION;
|
} else {
|
} else {
|
if (interp) {
|
if (interp) {
|
Tcl_AppendResult(interp,
|
Tcl_AppendResult(interp,
|
"bad value for -translation: ",
|
"bad value for -translation: ",
|
"must be one of auto, binary, cr, lf, crlf,",
|
"must be one of auto, binary, cr, lf, crlf,",
|
" or platform", (char *) NULL);
|
" or platform", (char *) NULL);
|
}
|
}
|
ckfree((char *) argv);
|
ckfree((char *) argv);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
/*
|
/*
|
* Reset the EOL flags since we need to look at any buffered
|
* Reset the EOL flags since we need to look at any buffered
|
* data to see if the new translation mode allows us to
|
* data to see if the new translation mode allows us to
|
* complete the line.
|
* complete the line.
|
*/
|
*/
|
|
|
if (newMode != chanPtr->inputTranslation) {
|
if (newMode != chanPtr->inputTranslation) {
|
chanPtr->inputTranslation = (Tcl_EolTranslation) newMode;
|
chanPtr->inputTranslation = (Tcl_EolTranslation) newMode;
|
chanPtr->flags &= ~(INPUT_SAW_CR);
|
chanPtr->flags &= ~(INPUT_SAW_CR);
|
chanPtr->flags &= ~(CHANNEL_GETS_BLOCKED);
|
chanPtr->flags &= ~(CHANNEL_GETS_BLOCKED);
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
}
|
}
|
}
|
}
|
if (writeMode) {
|
if (writeMode) {
|
if (*writeMode == '\0') {
|
if (*writeMode == '\0') {
|
/* Do nothing. */
|
/* Do nothing. */
|
} else if (strcmp(writeMode, "auto") == 0) {
|
} else if (strcmp(writeMode, "auto") == 0) {
|
/*
|
/*
|
* This is a hack to get TCP sockets to produce output
|
* This is a hack to get TCP sockets to produce output
|
* in CRLF mode if they are being set into AUTO mode.
|
* in CRLF mode if they are being set into AUTO mode.
|
* A better solution for achieving this effect will be
|
* A better solution for achieving this effect will be
|
* coded later.
|
* coded later.
|
*/
|
*/
|
|
|
if (strcmp(chanPtr->typePtr->typeName, "tcp") == 0) {
|
if (strcmp(chanPtr->typePtr->typeName, "tcp") == 0) {
|
chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
|
chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
|
} else {
|
} else {
|
chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
|
chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
|
}
|
}
|
} else if (strcmp(writeMode, "binary") == 0) {
|
} else if (strcmp(writeMode, "binary") == 0) {
|
chanPtr->outEofChar = 0;
|
chanPtr->outEofChar = 0;
|
chanPtr->outputTranslation = TCL_TRANSLATE_LF;
|
chanPtr->outputTranslation = TCL_TRANSLATE_LF;
|
} else if (strcmp(writeMode, "lf") == 0) {
|
} else if (strcmp(writeMode, "lf") == 0) {
|
chanPtr->outputTranslation = TCL_TRANSLATE_LF;
|
chanPtr->outputTranslation = TCL_TRANSLATE_LF;
|
} else if (strcmp(writeMode, "cr") == 0) {
|
} else if (strcmp(writeMode, "cr") == 0) {
|
chanPtr->outputTranslation = TCL_TRANSLATE_CR;
|
chanPtr->outputTranslation = TCL_TRANSLATE_CR;
|
} else if (strcmp(writeMode, "crlf") == 0) {
|
} else if (strcmp(writeMode, "crlf") == 0) {
|
chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
|
chanPtr->outputTranslation = TCL_TRANSLATE_CRLF;
|
} else if (strcmp(writeMode, "platform") == 0) {
|
} else if (strcmp(writeMode, "platform") == 0) {
|
chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
|
chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
|
} else {
|
} else {
|
if (interp) {
|
if (interp) {
|
Tcl_AppendResult(interp,
|
Tcl_AppendResult(interp,
|
"bad value for -translation: ",
|
"bad value for -translation: ",
|
"must be one of auto, binary, cr, lf, crlf,",
|
"must be one of auto, binary, cr, lf, crlf,",
|
" or platform", (char *) NULL);
|
" or platform", (char *) NULL);
|
}
|
}
|
ckfree((char *) argv);
|
ckfree((char *) argv);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
}
|
}
|
ckfree((char *) argv);
|
ckfree((char *) argv);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if (chanPtr->typePtr->setOptionProc != (Tcl_DriverSetOptionProc *) NULL) {
|
if (chanPtr->typePtr->setOptionProc != (Tcl_DriverSetOptionProc *) NULL) {
|
return (chanPtr->typePtr->setOptionProc) (chanPtr->instanceData,
|
return (chanPtr->typePtr->setOptionProc) (chanPtr->instanceData,
|
interp, optionName, newValue);
|
interp, optionName, newValue);
|
}
|
}
|
|
|
return Tcl_BadChannelOption(interp, optionName, (char *) NULL);
|
return Tcl_BadChannelOption(interp, optionName, (char *) NULL);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CleanupChannelHandlers --
|
* CleanupChannelHandlers --
|
*
|
*
|
* Removes channel handlers that refer to the supplied interpreter,
|
* Removes channel handlers that refer to the supplied interpreter,
|
* so that if the actual channel is not closed now, these handlers
|
* so that if the actual channel is not closed now, these handlers
|
* will not run on subsequent events on the channel. This would be
|
* will not run on subsequent events on the channel. This would be
|
* erroneous, because the interpreter no longer has a reference to
|
* erroneous, because the interpreter no longer has a reference to
|
* this channel.
|
* this channel.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Removes channel handlers.
|
* Removes channel handlers.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
CleanupChannelHandlers(interp, chanPtr)
|
CleanupChannelHandlers(interp, chanPtr)
|
Tcl_Interp *interp;
|
Tcl_Interp *interp;
|
Channel *chanPtr;
|
Channel *chanPtr;
|
{
|
{
|
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
|
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
|
|
|
/*
|
/*
|
* Remove fileevent records on this channel that refer to the
|
* Remove fileevent records on this channel that refer to the
|
* given interpreter.
|
* given interpreter.
|
*/
|
*/
|
|
|
for (sPtr = chanPtr->scriptRecordPtr,
|
for (sPtr = chanPtr->scriptRecordPtr,
|
prevPtr = (EventScriptRecord *) NULL;
|
prevPtr = (EventScriptRecord *) NULL;
|
sPtr != (EventScriptRecord *) NULL;
|
sPtr != (EventScriptRecord *) NULL;
|
sPtr = nextPtr) {
|
sPtr = nextPtr) {
|
nextPtr = sPtr->nextPtr;
|
nextPtr = sPtr->nextPtr;
|
if (sPtr->interp == interp) {
|
if (sPtr->interp == interp) {
|
if (prevPtr == (EventScriptRecord *) NULL) {
|
if (prevPtr == (EventScriptRecord *) NULL) {
|
chanPtr->scriptRecordPtr = nextPtr;
|
chanPtr->scriptRecordPtr = nextPtr;
|
} else {
|
} else {
|
prevPtr->nextPtr = nextPtr;
|
prevPtr->nextPtr = nextPtr;
|
}
|
}
|
|
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
ChannelEventScriptInvoker, (ClientData) sPtr);
|
ChannelEventScriptInvoker, (ClientData) sPtr);
|
|
|
ckfree(sPtr->script);
|
ckfree(sPtr->script);
|
ckfree((char *) sPtr);
|
ckfree((char *) sPtr);
|
} else {
|
} else {
|
prevPtr = sPtr;
|
prevPtr = sPtr;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_NotifyChannel --
|
* Tcl_NotifyChannel --
|
*
|
*
|
* This procedure is called by a channel driver when a driver
|
* This procedure is called by a channel driver when a driver
|
* detects an event on a channel. This procedure is responsible
|
* detects an event on a channel. This procedure is responsible
|
* for actually handling the event by invoking any channel
|
* for actually handling the event by invoking any channel
|
* handler callbacks.
|
* handler callbacks.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Whatever the channel handler callback procedure does.
|
* Whatever the channel handler callback procedure does.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_NotifyChannel(channel, mask)
|
Tcl_NotifyChannel(channel, mask)
|
Tcl_Channel channel; /* Channel that detected an event. */
|
Tcl_Channel channel; /* Channel that detected an event. */
|
int mask; /* OR'ed combination of TCL_READABLE,
|
int mask; /* OR'ed combination of TCL_READABLE,
|
* TCL_WRITABLE, or TCL_EXCEPTION: indicates
|
* TCL_WRITABLE, or TCL_EXCEPTION: indicates
|
* which events were detected. */
|
* which events were detected. */
|
{
|
{
|
Channel *chanPtr = (Channel *) channel;
|
Channel *chanPtr = (Channel *) channel;
|
ChannelHandler *chPtr;
|
ChannelHandler *chPtr;
|
NextChannelHandler nh;
|
NextChannelHandler nh;
|
|
|
/*
|
/*
|
* Preserve the channel struct in case the script closes it.
|
* Preserve the channel struct in case the script closes it.
|
*/
|
*/
|
|
|
Tcl_Preserve((ClientData) channel);
|
Tcl_Preserve((ClientData) channel);
|
|
|
/*
|
/*
|
* If we are flushing in the background, be sure to call FlushChannel
|
* If we are flushing in the background, be sure to call FlushChannel
|
* for writable events. Note that we have to discard the writable
|
* for writable events. Note that we have to discard the writable
|
* event so we don't call any write handlers before the flush is
|
* event so we don't call any write handlers before the flush is
|
* complete.
|
* complete.
|
*/
|
*/
|
|
|
if ((chanPtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
|
if ((chanPtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
|
FlushChannel(NULL, chanPtr, 1);
|
FlushChannel(NULL, chanPtr, 1);
|
mask &= ~TCL_WRITABLE;
|
mask &= ~TCL_WRITABLE;
|
}
|
}
|
|
|
/*
|
/*
|
* Add this invocation to the list of recursive invocations of
|
* Add this invocation to the list of recursive invocations of
|
* ChannelHandlerEventProc.
|
* ChannelHandlerEventProc.
|
*/
|
*/
|
|
|
nh.nextHandlerPtr = (ChannelHandler *) NULL;
|
nh.nextHandlerPtr = (ChannelHandler *) NULL;
|
nh.nestedHandlerPtr = nestedHandlerPtr;
|
nh.nestedHandlerPtr = nestedHandlerPtr;
|
nestedHandlerPtr = &nh;
|
nestedHandlerPtr = &nh;
|
|
|
for (chPtr = chanPtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
|
for (chPtr = chanPtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
|
|
|
/*
|
/*
|
* If this channel handler is interested in any of the events that
|
* If this channel handler is interested in any of the events that
|
* have occurred on the channel, invoke its procedure.
|
* have occurred on the channel, invoke its procedure.
|
*/
|
*/
|
|
|
if ((chPtr->mask & mask) != 0) {
|
if ((chPtr->mask & mask) != 0) {
|
nh.nextHandlerPtr = chPtr->nextPtr;
|
nh.nextHandlerPtr = chPtr->nextPtr;
|
(*(chPtr->proc))(chPtr->clientData, mask);
|
(*(chPtr->proc))(chPtr->clientData, mask);
|
chPtr = nh.nextHandlerPtr;
|
chPtr = nh.nextHandlerPtr;
|
} else {
|
} else {
|
chPtr = chPtr->nextPtr;
|
chPtr = chPtr->nextPtr;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Update the notifier interest, since it may have changed after
|
* Update the notifier interest, since it may have changed after
|
* invoking event handlers.
|
* invoking event handlers.
|
*/
|
*/
|
|
|
if (chanPtr->typePtr != NULL) {
|
if (chanPtr->typePtr != NULL) {
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
}
|
}
|
|
|
Tcl_Release((ClientData) channel);
|
Tcl_Release((ClientData) channel);
|
|
|
nestedHandlerPtr = nh.nestedHandlerPtr;
|
nestedHandlerPtr = nh.nestedHandlerPtr;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* UpdateInterest --
|
* UpdateInterest --
|
*
|
*
|
* Arrange for the notifier to call us back at appropriate times
|
* Arrange for the notifier to call us back at appropriate times
|
* based on the current state of the channel.
|
* based on the current state of the channel.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May schedule a timer or driver handler.
|
* May schedule a timer or driver handler.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
UpdateInterest(chanPtr)
|
UpdateInterest(chanPtr)
|
Channel *chanPtr; /* Channel to update. */
|
Channel *chanPtr; /* Channel to update. */
|
{
|
{
|
int mask = chanPtr->interestMask;
|
int mask = chanPtr->interestMask;
|
|
|
/*
|
/*
|
* If there are flushed buffers waiting to be written, then
|
* If there are flushed buffers waiting to be written, then
|
* we need to watch for the channel to become writable.
|
* we need to watch for the channel to become writable.
|
*/
|
*/
|
|
|
if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
|
if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
|
mask |= TCL_WRITABLE;
|
mask |= TCL_WRITABLE;
|
}
|
}
|
|
|
/*
|
/*
|
* If there is data in the input queue, and we aren't blocked waiting for
|
* If there is data in the input queue, and we aren't blocked waiting for
|
* an EOL, then we need to schedule a timer so we don't block in the
|
* an EOL, then we need to schedule a timer so we don't block in the
|
* notifier. Also, cancel the read interest so we don't get duplicate
|
* notifier. Also, cancel the read interest so we don't get duplicate
|
* events.
|
* events.
|
*/
|
*/
|
|
|
if (mask & TCL_READABLE) {
|
if (mask & TCL_READABLE) {
|
if (!(chanPtr->flags & CHANNEL_GETS_BLOCKED)
|
if (!(chanPtr->flags & CHANNEL_GETS_BLOCKED)
|
&& (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
|
&& (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
|
&& (chanPtr->inQueueHead->nextRemoved <
|
&& (chanPtr->inQueueHead->nextRemoved <
|
chanPtr->inQueueHead->nextAdded)) {
|
chanPtr->inQueueHead->nextAdded)) {
|
mask &= ~TCL_READABLE;
|
mask &= ~TCL_READABLE;
|
if (!chanPtr->timer) {
|
if (!chanPtr->timer) {
|
chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
|
chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
|
(ClientData) chanPtr);
|
(ClientData) chanPtr);
|
}
|
}
|
}
|
}
|
}
|
}
|
(chanPtr->typePtr->watchProc)(chanPtr->instanceData, mask);
|
(chanPtr->typePtr->watchProc)(chanPtr->instanceData, mask);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* ChannelTimerProc --
|
* ChannelTimerProc --
|
*
|
*
|
* Timer handler scheduled by UpdateInterest to monitor the
|
* Timer handler scheduled by UpdateInterest to monitor the
|
* channel buffers until they are empty.
|
* channel buffers until they are empty.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May invoke channel handlers.
|
* May invoke channel handlers.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
ChannelTimerProc(clientData)
|
ChannelTimerProc(clientData)
|
ClientData clientData;
|
ClientData clientData;
|
{
|
{
|
Channel *chanPtr = (Channel *) clientData;
|
Channel *chanPtr = (Channel *) clientData;
|
|
|
if (!(chanPtr->flags & CHANNEL_GETS_BLOCKED)
|
if (!(chanPtr->flags & CHANNEL_GETS_BLOCKED)
|
&& (chanPtr->interestMask & TCL_READABLE)
|
&& (chanPtr->interestMask & TCL_READABLE)
|
&& (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
|
&& (chanPtr->inQueueHead != (ChannelBuffer *) NULL)
|
&& (chanPtr->inQueueHead->nextRemoved <
|
&& (chanPtr->inQueueHead->nextRemoved <
|
chanPtr->inQueueHead->nextAdded)) {
|
chanPtr->inQueueHead->nextAdded)) {
|
/*
|
/*
|
* Restart the timer in case a channel handler reenters the
|
* Restart the timer in case a channel handler reenters the
|
* event loop before UpdateInterest gets called by Tcl_NotifyChannel.
|
* event loop before UpdateInterest gets called by Tcl_NotifyChannel.
|
*/
|
*/
|
|
|
chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
|
chanPtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
|
(ClientData) chanPtr);
|
(ClientData) chanPtr);
|
Tcl_NotifyChannel((Tcl_Channel)chanPtr, TCL_READABLE);
|
Tcl_NotifyChannel((Tcl_Channel)chanPtr, TCL_READABLE);
|
|
|
} else {
|
} else {
|
chanPtr->timer = NULL;
|
chanPtr->timer = NULL;
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_CreateChannelHandler --
|
* Tcl_CreateChannelHandler --
|
*
|
*
|
* Arrange for a given procedure to be invoked whenever the
|
* Arrange for a given procedure to be invoked whenever the
|
* channel indicated by the chanPtr arg becomes readable or
|
* channel indicated by the chanPtr arg becomes readable or
|
* writable.
|
* writable.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* From now on, whenever the I/O channel given by chanPtr becomes
|
* From now on, whenever the I/O channel given by chanPtr becomes
|
* ready in the way indicated by mask, proc will be invoked.
|
* ready in the way indicated by mask, proc will be invoked.
|
* See the manual entry for details on the calling sequence
|
* See the manual entry for details on the calling sequence
|
* to proc. If there is already an event handler for chan, proc
|
* to proc. If there is already an event handler for chan, proc
|
* and clientData, then the mask will be updated.
|
* and clientData, then the mask will be updated.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_CreateChannelHandler(chan, mask, proc, clientData)
|
Tcl_CreateChannelHandler(chan, mask, proc, clientData)
|
Tcl_Channel chan; /* The channel to create the handler for. */
|
Tcl_Channel chan; /* The channel to create the handler for. */
|
int mask; /* OR'ed combination of TCL_READABLE,
|
int mask; /* OR'ed combination of TCL_READABLE,
|
* TCL_WRITABLE, and TCL_EXCEPTION:
|
* TCL_WRITABLE, and TCL_EXCEPTION:
|
* indicates conditions under which
|
* indicates conditions under which
|
* proc should be called. Use 0 to
|
* proc should be called. Use 0 to
|
* disable a registered handler. */
|
* disable a registered handler. */
|
Tcl_ChannelProc *proc; /* Procedure to call for each
|
Tcl_ChannelProc *proc; /* Procedure to call for each
|
* selected event. */
|
* selected event. */
|
ClientData clientData; /* Arbitrary data to pass to proc. */
|
ClientData clientData; /* Arbitrary data to pass to proc. */
|
{
|
{
|
ChannelHandler *chPtr;
|
ChannelHandler *chPtr;
|
Channel *chanPtr;
|
Channel *chanPtr;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Check whether this channel handler is not already registered. If
|
* Check whether this channel handler is not already registered. If
|
* it is not, create a new record, else reuse existing record (smash
|
* it is not, create a new record, else reuse existing record (smash
|
* current values).
|
* current values).
|
*/
|
*/
|
|
|
for (chPtr = chanPtr->chPtr;
|
for (chPtr = chanPtr->chPtr;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr = chPtr->nextPtr) {
|
chPtr = chPtr->nextPtr) {
|
if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
|
if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
|
(chPtr->clientData == clientData)) {
|
(chPtr->clientData == clientData)) {
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (chPtr == (ChannelHandler *) NULL) {
|
if (chPtr == (ChannelHandler *) NULL) {
|
chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
|
chPtr = (ChannelHandler *) ckalloc((unsigned) sizeof(ChannelHandler));
|
chPtr->mask = 0;
|
chPtr->mask = 0;
|
chPtr->proc = proc;
|
chPtr->proc = proc;
|
chPtr->clientData = clientData;
|
chPtr->clientData = clientData;
|
chPtr->chanPtr = chanPtr;
|
chPtr->chanPtr = chanPtr;
|
chPtr->nextPtr = chanPtr->chPtr;
|
chPtr->nextPtr = chanPtr->chPtr;
|
chanPtr->chPtr = chPtr;
|
chanPtr->chPtr = chPtr;
|
}
|
}
|
|
|
/*
|
/*
|
* The remainder of the initialization below is done regardless of
|
* The remainder of the initialization below is done regardless of
|
* whether or not this is a new record or a modification of an old
|
* whether or not this is a new record or a modification of an old
|
* one.
|
* one.
|
*/
|
*/
|
|
|
chPtr->mask = mask;
|
chPtr->mask = mask;
|
|
|
/*
|
/*
|
* Recompute the interest mask for the channel - this call may actually
|
* Recompute the interest mask for the channel - this call may actually
|
* be disabling an existing handler.
|
* be disabling an existing handler.
|
*/
|
*/
|
|
|
chanPtr->interestMask = 0;
|
chanPtr->interestMask = 0;
|
for (chPtr = chanPtr->chPtr;
|
for (chPtr = chanPtr->chPtr;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr = chPtr->nextPtr) {
|
chPtr = chPtr->nextPtr) {
|
chanPtr->interestMask |= chPtr->mask;
|
chanPtr->interestMask |= chPtr->mask;
|
}
|
}
|
|
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_DeleteChannelHandler --
|
* Tcl_DeleteChannelHandler --
|
*
|
*
|
* Cancel a previously arranged callback arrangement for an IO
|
* Cancel a previously arranged callback arrangement for an IO
|
* channel.
|
* channel.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* If a callback was previously registered for this chan, proc and
|
* If a callback was previously registered for this chan, proc and
|
* clientData , it is removed and the callback will no longer be called
|
* clientData , it is removed and the callback will no longer be called
|
* when the channel becomes ready for IO.
|
* when the channel becomes ready for IO.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tcl_DeleteChannelHandler(chan, proc, clientData)
|
Tcl_DeleteChannelHandler(chan, proc, clientData)
|
Tcl_Channel chan; /* The channel for which to remove the
|
Tcl_Channel chan; /* The channel for which to remove the
|
* callback. */
|
* callback. */
|
Tcl_ChannelProc *proc; /* The procedure in the callback to delete. */
|
Tcl_ChannelProc *proc; /* The procedure in the callback to delete. */
|
ClientData clientData; /* The client data in the callback
|
ClientData clientData; /* The client data in the callback
|
* to delete. */
|
* to delete. */
|
|
|
{
|
{
|
ChannelHandler *chPtr, *prevChPtr;
|
ChannelHandler *chPtr, *prevChPtr;
|
Channel *chanPtr;
|
Channel *chanPtr;
|
NextChannelHandler *nhPtr;
|
NextChannelHandler *nhPtr;
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
|
|
/*
|
/*
|
* Find the entry and the previous one in the list.
|
* Find the entry and the previous one in the list.
|
*/
|
*/
|
|
|
for (prevChPtr = (ChannelHandler *) NULL, chPtr = chanPtr->chPtr;
|
for (prevChPtr = (ChannelHandler *) NULL, chPtr = chanPtr->chPtr;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr = chPtr->nextPtr) {
|
chPtr = chPtr->nextPtr) {
|
if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
|
if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
|
&& (chPtr->proc == proc)) {
|
&& (chPtr->proc == proc)) {
|
break;
|
break;
|
}
|
}
|
prevChPtr = chPtr;
|
prevChPtr = chPtr;
|
}
|
}
|
|
|
/*
|
/*
|
* If not found, return without doing anything.
|
* If not found, return without doing anything.
|
*/
|
*/
|
|
|
if (chPtr == (ChannelHandler *) NULL) {
|
if (chPtr == (ChannelHandler *) NULL) {
|
return;
|
return;
|
}
|
}
|
|
|
/*
|
/*
|
* If ChannelHandlerEventProc is about to process this handler, tell it to
|
* If ChannelHandlerEventProc is about to process this handler, tell it to
|
* process the next one instead - we are going to delete *this* one.
|
* process the next one instead - we are going to delete *this* one.
|
*/
|
*/
|
|
|
for (nhPtr = nestedHandlerPtr;
|
for (nhPtr = nestedHandlerPtr;
|
nhPtr != (NextChannelHandler *) NULL;
|
nhPtr != (NextChannelHandler *) NULL;
|
nhPtr = nhPtr->nestedHandlerPtr) {
|
nhPtr = nhPtr->nestedHandlerPtr) {
|
if (nhPtr->nextHandlerPtr == chPtr) {
|
if (nhPtr->nextHandlerPtr == chPtr) {
|
nhPtr->nextHandlerPtr = chPtr->nextPtr;
|
nhPtr->nextHandlerPtr = chPtr->nextPtr;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Splice it out of the list of channel handlers.
|
* Splice it out of the list of channel handlers.
|
*/
|
*/
|
|
|
if (prevChPtr == (ChannelHandler *) NULL) {
|
if (prevChPtr == (ChannelHandler *) NULL) {
|
chanPtr->chPtr = chPtr->nextPtr;
|
chanPtr->chPtr = chPtr->nextPtr;
|
} else {
|
} else {
|
prevChPtr->nextPtr = chPtr->nextPtr;
|
prevChPtr->nextPtr = chPtr->nextPtr;
|
}
|
}
|
ckfree((char *) chPtr);
|
ckfree((char *) chPtr);
|
|
|
/*
|
/*
|
* Recompute the interest list for the channel, so that infinite loops
|
* Recompute the interest list for the channel, so that infinite loops
|
* will not result if Tcl_DeleteChanelHandler is called inside an event.
|
* will not result if Tcl_DeleteChanelHandler is called inside an event.
|
*/
|
*/
|
|
|
chanPtr->interestMask = 0;
|
chanPtr->interestMask = 0;
|
for (chPtr = chanPtr->chPtr;
|
for (chPtr = chanPtr->chPtr;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr != (ChannelHandler *) NULL;
|
chPtr = chPtr->nextPtr) {
|
chPtr = chPtr->nextPtr) {
|
chanPtr->interestMask |= chPtr->mask;
|
chanPtr->interestMask |= chPtr->mask;
|
}
|
}
|
|
|
UpdateInterest(chanPtr);
|
UpdateInterest(chanPtr);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* DeleteScriptRecord --
|
* DeleteScriptRecord --
|
*
|
*
|
* Delete a script record for this combination of channel, interp
|
* Delete a script record for this combination of channel, interp
|
* and mask.
|
* and mask.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Deletes a script record and cancels a channel event handler.
|
* Deletes a script record and cancels a channel event handler.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
DeleteScriptRecord(interp, chanPtr, mask)
|
DeleteScriptRecord(interp, chanPtr, mask)
|
Tcl_Interp *interp; /* Interpreter in which script was to be
|
Tcl_Interp *interp; /* Interpreter in which script was to be
|
* executed. */
|
* executed. */
|
Channel *chanPtr; /* The channel for which to delete the
|
Channel *chanPtr; /* The channel for which to delete the
|
* script record (if any). */
|
* script record (if any). */
|
int mask; /* Events in mask must exactly match mask
|
int mask; /* Events in mask must exactly match mask
|
* of script to delete. */
|
* of script to delete. */
|
{
|
{
|
EventScriptRecord *esPtr, *prevEsPtr;
|
EventScriptRecord *esPtr, *prevEsPtr;
|
|
|
for (esPtr = chanPtr->scriptRecordPtr,
|
for (esPtr = chanPtr->scriptRecordPtr,
|
prevEsPtr = (EventScriptRecord *) NULL;
|
prevEsPtr = (EventScriptRecord *) NULL;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr != (EventScriptRecord *) NULL;
|
prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
|
prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
|
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
|
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
|
if (esPtr == chanPtr->scriptRecordPtr) {
|
if (esPtr == chanPtr->scriptRecordPtr) {
|
chanPtr->scriptRecordPtr = esPtr->nextPtr;
|
chanPtr->scriptRecordPtr = esPtr->nextPtr;
|
} else {
|
} else {
|
prevEsPtr->nextPtr = esPtr->nextPtr;
|
prevEsPtr->nextPtr = esPtr->nextPtr;
|
}
|
}
|
|
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
|
|
ckfree(esPtr->script);
|
ckfree(esPtr->script);
|
ckfree((char *) esPtr);
|
ckfree((char *) esPtr);
|
|
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CreateScriptRecord --
|
* CreateScriptRecord --
|
*
|
*
|
* Creates a record to store a script to be executed when a specific
|
* Creates a record to store a script to be executed when a specific
|
* event fires on a specific channel.
|
* event fires on a specific channel.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Causes the script to be stored for later execution.
|
* Causes the script to be stored for later execution.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
CreateScriptRecord(interp, chanPtr, mask, script)
|
CreateScriptRecord(interp, chanPtr, mask, script)
|
Tcl_Interp *interp; /* Interpreter in which to execute
|
Tcl_Interp *interp; /* Interpreter in which to execute
|
* the stored script. */
|
* the stored script. */
|
Channel *chanPtr; /* Channel for which script is to
|
Channel *chanPtr; /* Channel for which script is to
|
* be stored. */
|
* be stored. */
|
int mask; /* Set of events for which script
|
int mask; /* Set of events for which script
|
* will be invoked. */
|
* will be invoked. */
|
char *script; /* A copy of this script is stored
|
char *script; /* A copy of this script is stored
|
* in the newly created record. */
|
* in the newly created record. */
|
{
|
{
|
EventScriptRecord *esPtr;
|
EventScriptRecord *esPtr;
|
|
|
for (esPtr = chanPtr->scriptRecordPtr;
|
for (esPtr = chanPtr->scriptRecordPtr;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr = esPtr->nextPtr) {
|
esPtr = esPtr->nextPtr) {
|
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
|
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
|
ckfree(esPtr->script);
|
ckfree(esPtr->script);
|
esPtr->script = (char *) NULL;
|
esPtr->script = (char *) NULL;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (esPtr == (EventScriptRecord *) NULL) {
|
if (esPtr == (EventScriptRecord *) NULL) {
|
esPtr = (EventScriptRecord *) ckalloc((unsigned)
|
esPtr = (EventScriptRecord *) ckalloc((unsigned)
|
sizeof(EventScriptRecord));
|
sizeof(EventScriptRecord));
|
Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
|
Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
esPtr->nextPtr = chanPtr->scriptRecordPtr;
|
esPtr->nextPtr = chanPtr->scriptRecordPtr;
|
chanPtr->scriptRecordPtr = esPtr;
|
chanPtr->scriptRecordPtr = esPtr;
|
}
|
}
|
esPtr->chanPtr = chanPtr;
|
esPtr->chanPtr = chanPtr;
|
esPtr->interp = interp;
|
esPtr->interp = interp;
|
esPtr->mask = mask;
|
esPtr->mask = mask;
|
esPtr->script = ckalloc((unsigned) (strlen(script) + 1));
|
esPtr->script = ckalloc((unsigned) (strlen(script) + 1));
|
strcpy(esPtr->script, script);
|
strcpy(esPtr->script, script);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* ChannelEventScriptInvoker --
|
* ChannelEventScriptInvoker --
|
*
|
*
|
* Invokes a script scheduled by "fileevent" for when the channel
|
* Invokes a script scheduled by "fileevent" for when the channel
|
* becomes ready for IO. This function is invoked by the channel
|
* becomes ready for IO. This function is invoked by the channel
|
* handler which was created by the Tcl "fileevent" command.
|
* handler which was created by the Tcl "fileevent" command.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Whatever the script does.
|
* Whatever the script does.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
ChannelEventScriptInvoker(clientData, mask)
|
ChannelEventScriptInvoker(clientData, mask)
|
ClientData clientData; /* The script+interp record. */
|
ClientData clientData; /* The script+interp record. */
|
int mask; /* Not used. */
|
int mask; /* Not used. */
|
{
|
{
|
Tcl_Interp *interp; /* Interpreter in which to eval the script. */
|
Tcl_Interp *interp; /* Interpreter in which to eval the script. */
|
Channel *chanPtr; /* The channel for which this handler is
|
Channel *chanPtr; /* The channel for which this handler is
|
* registered. */
|
* registered. */
|
char *script; /* Script to eval. */
|
char *script; /* Script to eval. */
|
EventScriptRecord *esPtr; /* The event script + interpreter to eval it
|
EventScriptRecord *esPtr; /* The event script + interpreter to eval it
|
* in. */
|
* in. */
|
int result; /* Result of call to eval script. */
|
int result; /* Result of call to eval script. */
|
|
|
esPtr = (EventScriptRecord *) clientData;
|
esPtr = (EventScriptRecord *) clientData;
|
|
|
chanPtr = esPtr->chanPtr;
|
chanPtr = esPtr->chanPtr;
|
mask = esPtr->mask;
|
mask = esPtr->mask;
|
interp = esPtr->interp;
|
interp = esPtr->interp;
|
script = esPtr->script;
|
script = esPtr->script;
|
|
|
/*
|
/*
|
* We must preserve the interpreter so we can report errors on it
|
* We must preserve the interpreter so we can report errors on it
|
* later. Note that we do not need to preserve the channel because
|
* later. Note that we do not need to preserve the channel because
|
* that is done by Tcl_NotifyChannel before calling channel handlers.
|
* that is done by Tcl_NotifyChannel before calling channel handlers.
|
*/
|
*/
|
|
|
Tcl_Preserve((ClientData) interp);
|
Tcl_Preserve((ClientData) interp);
|
result = Tcl_GlobalEval(interp, script);
|
result = Tcl_GlobalEval(interp, script);
|
|
|
/*
|
/*
|
* On error, cause a background error and remove the channel handler
|
* On error, cause a background error and remove the channel handler
|
* and the script record.
|
* and the script record.
|
*
|
*
|
* NOTE: Must delete channel handler before causing the background error
|
* NOTE: Must delete channel handler before causing the background error
|
* because the background error may want to reinstall the handler.
|
* because the background error may want to reinstall the handler.
|
*/
|
*/
|
|
|
if (result != TCL_OK) {
|
if (result != TCL_OK) {
|
if (chanPtr->typePtr != NULL) {
|
if (chanPtr->typePtr != NULL) {
|
DeleteScriptRecord(interp, chanPtr, mask);
|
DeleteScriptRecord(interp, chanPtr, mask);
|
}
|
}
|
Tcl_BackgroundError(interp);
|
Tcl_BackgroundError(interp);
|
}
|
}
|
Tcl_Release((ClientData) interp);
|
Tcl_Release((ClientData) interp);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tcl_FileEventCmd --
|
* Tcl_FileEventCmd --
|
*
|
*
|
* This procedure implements the "fileevent" Tcl command. See the
|
* This procedure implements the "fileevent" Tcl command. See the
|
* user documentation for details on what it does. This command is
|
* user documentation for details on what it does. This command is
|
* based on the Tk command "fileevent" which in turn is based on work
|
* based on the Tk command "fileevent" which in turn is based on work
|
* contributed by Mark Diekhans.
|
* contributed by Mark Diekhans.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May create a channel handler for the specified channel.
|
* May create a channel handler for the specified channel.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
/* ARGSUSED */
|
/* ARGSUSED */
|
int
|
int
|
Tcl_FileEventCmd(clientData, interp, argc, argv)
|
Tcl_FileEventCmd(clientData, interp, argc, argv)
|
ClientData clientData; /* Not used. */
|
ClientData clientData; /* Not used. */
|
Tcl_Interp *interp; /* Interpreter in which the channel
|
Tcl_Interp *interp; /* Interpreter in which the channel
|
* for which to create the handler
|
* for which to create the handler
|
* is found. */
|
* is found. */
|
int argc; /* Number of arguments. */
|
int argc; /* Number of arguments. */
|
char **argv; /* Argument strings. */
|
char **argv; /* Argument strings. */
|
{
|
{
|
Channel *chanPtr; /* The channel to create
|
Channel *chanPtr; /* The channel to create
|
* the handler for. */
|
* the handler for. */
|
Tcl_Channel chan; /* The opaque type for the channel. */
|
Tcl_Channel chan; /* The opaque type for the channel. */
|
int c; /* First char of mode argument. */
|
int c; /* First char of mode argument. */
|
int mask; /* Mask for events of interest. */
|
int mask; /* Mask for events of interest. */
|
size_t length; /* Length of mode argument. */
|
size_t length; /* Length of mode argument. */
|
|
|
/*
|
/*
|
* Parse arguments.
|
* Parse arguments.
|
*/
|
*/
|
|
|
if ((argc != 3) && (argc != 4)) {
|
if ((argc != 3) && (argc != 4)) {
|
Tcl_AppendResult(interp, "wrong # args: must be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: must be \"", argv[0],
|
" channelId event ?script?", (char *) NULL);
|
" channelId event ?script?", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
c = argv[2][0];
|
c = argv[2][0];
|
length = strlen(argv[2]);
|
length = strlen(argv[2]);
|
if ((c == 'r') && (strncmp(argv[2], "readable", length) == 0)) {
|
if ((c == 'r') && (strncmp(argv[2], "readable", length) == 0)) {
|
mask = TCL_READABLE;
|
mask = TCL_READABLE;
|
} else if ((c == 'w') && (strncmp(argv[2], "writable", length) == 0)) {
|
} else if ((c == 'w') && (strncmp(argv[2], "writable", length) == 0)) {
|
mask = TCL_WRITABLE;
|
mask = TCL_WRITABLE;
|
} else {
|
} else {
|
Tcl_AppendResult(interp, "bad event name \"", argv[2],
|
Tcl_AppendResult(interp, "bad event name \"", argv[2],
|
"\": must be readable or writable", (char *) NULL);
|
"\": must be readable or writable", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
chan = Tcl_GetChannel(interp, argv[1], NULL);
|
chan = Tcl_GetChannel(interp, argv[1], NULL);
|
if (chan == (Tcl_Channel) NULL) {
|
if (chan == (Tcl_Channel) NULL) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
if ((chanPtr->flags & mask) == 0) {
|
if ((chanPtr->flags & mask) == 0) {
|
Tcl_AppendResult(interp, "channel is not ",
|
Tcl_AppendResult(interp, "channel is not ",
|
(mask == TCL_READABLE) ? "readable" : "writable",
|
(mask == TCL_READABLE) ? "readable" : "writable",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
/*
|
/*
|
* If we are supposed to return the script, do so.
|
* If we are supposed to return the script, do so.
|
*/
|
*/
|
|
|
if (argc == 3) {
|
if (argc == 3) {
|
EventScriptRecord *esPtr;
|
EventScriptRecord *esPtr;
|
for (esPtr = chanPtr->scriptRecordPtr;
|
for (esPtr = chanPtr->scriptRecordPtr;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr = esPtr->nextPtr) {
|
esPtr = esPtr->nextPtr) {
|
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
|
if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
|
Tcl_SetResult(interp, esPtr->script, TCL_STATIC);
|
Tcl_SetResult(interp, esPtr->script, TCL_STATIC);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
* If we are supposed to delete a stored script, do so.
|
* If we are supposed to delete a stored script, do so.
|
*/
|
*/
|
|
|
if (argv[3][0] == 0) {
|
if (argv[3][0] == 0) {
|
DeleteScriptRecord(interp, chanPtr, mask);
|
DeleteScriptRecord(interp, chanPtr, mask);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
* Make the script record that will link between the event and the
|
* Make the script record that will link between the event and the
|
* script to invoke. This also creates a channel event handler which
|
* script to invoke. This also creates a channel event handler which
|
* will evaluate the script in the supplied interpreter.
|
* will evaluate the script in the supplied interpreter.
|
*/
|
*/
|
|
|
CreateScriptRecord(interp, chanPtr, mask, argv[3]);
|
CreateScriptRecord(interp, chanPtr, mask, argv[3]);
|
|
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TclTestChannelCmd --
|
* TclTestChannelCmd --
|
*
|
*
|
* Implements the Tcl "testchannel" debugging command and its
|
* Implements the Tcl "testchannel" debugging command and its
|
* subcommands. This is part of the testing environment but must be
|
* subcommands. This is part of the testing environment but must be
|
* in this file instead of tclTest.c because it needs access to the
|
* in this file instead of tclTest.c because it needs access to the
|
* fields of struct Channel.
|
* fields of struct Channel.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
/* ARGSUSED */
|
/* ARGSUSED */
|
int
|
int
|
TclTestChannelCmd(clientData, interp, argc, argv)
|
TclTestChannelCmd(clientData, interp, argc, argv)
|
ClientData clientData; /* Not used. */
|
ClientData clientData; /* Not used. */
|
Tcl_Interp *interp; /* Interpreter for result. */
|
Tcl_Interp *interp; /* Interpreter for result. */
|
int argc; /* Count of additional args. */
|
int argc; /* Count of additional args. */
|
char **argv; /* Additional arg strings. */
|
char **argv; /* Additional arg strings. */
|
{
|
{
|
char *cmdName; /* Sub command. */
|
char *cmdName; /* Sub command. */
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
|
Tcl_HashSearch hSearch; /* Search variable. */
|
Tcl_HashSearch hSearch; /* Search variable. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Tcl_HashEntry *hPtr; /* Search variable. */
|
Channel *chanPtr; /* The actual channel. */
|
Channel *chanPtr; /* The actual channel. */
|
Tcl_Channel chan; /* The opaque type. */
|
Tcl_Channel chan; /* The opaque type. */
|
size_t len; /* Length of subcommand string. */
|
size_t len; /* Length of subcommand string. */
|
int IOQueued; /* How much IO is queued inside channel? */
|
int IOQueued; /* How much IO is queued inside channel? */
|
ChannelBuffer *bufPtr; /* For iterating over queued IO. */
|
ChannelBuffer *bufPtr; /* For iterating over queued IO. */
|
char buf[128]; /* For sprintf. */
|
char buf[128]; /* For sprintf. */
|
|
|
if (argc < 2) {
|
if (argc < 2) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" subcommand ?additional args..?\"", (char *) NULL);
|
" subcommand ?additional args..?\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
cmdName = argv[1];
|
cmdName = argv[1];
|
len = strlen(cmdName);
|
len = strlen(cmdName);
|
|
|
chanPtr = (Channel *) NULL;
|
chanPtr = (Channel *) NULL;
|
if (argc > 2) {
|
if (argc > 2) {
|
chan = Tcl_GetChannel(interp, argv[2], NULL);
|
chan = Tcl_GetChannel(interp, argv[2], NULL);
|
if (chan == (Tcl_Channel) NULL) {
|
if (chan == (Tcl_Channel) NULL) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
chanPtr = (Channel *) chan;
|
chanPtr = (Channel *) chan;
|
}
|
}
|
|
|
if ((cmdName[0] == 'i') && (strncmp(cmdName, "info", len) == 0)) {
|
if ((cmdName[0] == 'i') && (strncmp(cmdName, "info", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" info channelName\"", (char *) NULL);
|
" info channelName\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
Tcl_AppendElement(interp, argv[2]);
|
Tcl_AppendElement(interp, argv[2]);
|
Tcl_AppendElement(interp, chanPtr->typePtr->typeName);
|
Tcl_AppendElement(interp, chanPtr->typePtr->typeName);
|
if (chanPtr->flags & TCL_READABLE) {
|
if (chanPtr->flags & TCL_READABLE) {
|
Tcl_AppendElement(interp, "read");
|
Tcl_AppendElement(interp, "read");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
if (chanPtr->flags & TCL_WRITABLE) {
|
if (chanPtr->flags & TCL_WRITABLE) {
|
Tcl_AppendElement(interp, "write");
|
Tcl_AppendElement(interp, "write");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
if (chanPtr->flags & CHANNEL_NONBLOCKING) {
|
Tcl_AppendElement(interp, "nonblocking");
|
Tcl_AppendElement(interp, "nonblocking");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "blocking");
|
Tcl_AppendElement(interp, "blocking");
|
}
|
}
|
if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
|
if (chanPtr->flags & CHANNEL_LINEBUFFERED) {
|
Tcl_AppendElement(interp, "line");
|
Tcl_AppendElement(interp, "line");
|
} else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
|
} else if (chanPtr->flags & CHANNEL_UNBUFFERED) {
|
Tcl_AppendElement(interp, "none");
|
Tcl_AppendElement(interp, "none");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "full");
|
Tcl_AppendElement(interp, "full");
|
}
|
}
|
if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
|
if (chanPtr->flags & BG_FLUSH_SCHEDULED) {
|
Tcl_AppendElement(interp, "async_flush");
|
Tcl_AppendElement(interp, "async_flush");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
if (chanPtr->flags & CHANNEL_EOF) {
|
if (chanPtr->flags & CHANNEL_EOF) {
|
Tcl_AppendElement(interp, "eof");
|
Tcl_AppendElement(interp, "eof");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
if (chanPtr->flags & CHANNEL_BLOCKED) {
|
if (chanPtr->flags & CHANNEL_BLOCKED) {
|
Tcl_AppendElement(interp, "blocked");
|
Tcl_AppendElement(interp, "blocked");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "unblocked");
|
Tcl_AppendElement(interp, "unblocked");
|
}
|
}
|
if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) {
|
if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) {
|
Tcl_AppendElement(interp, "auto");
|
Tcl_AppendElement(interp, "auto");
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
Tcl_AppendElement(interp, "saw_cr");
|
Tcl_AppendElement(interp, "saw_cr");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_LF) {
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_LF) {
|
Tcl_AppendElement(interp, "lf");
|
Tcl_AppendElement(interp, "lf");
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) {
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) {
|
Tcl_AppendElement(interp, "cr");
|
Tcl_AppendElement(interp, "cr");
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) {
|
} else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) {
|
Tcl_AppendElement(interp, "crlf");
|
Tcl_AppendElement(interp, "crlf");
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
if (chanPtr->flags & INPUT_SAW_CR) {
|
Tcl_AppendElement(interp, "queued_cr");
|
Tcl_AppendElement(interp, "queued_cr");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
}
|
}
|
if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) {
|
if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) {
|
Tcl_AppendElement(interp, "auto");
|
Tcl_AppendElement(interp, "auto");
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_LF) {
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_LF) {
|
Tcl_AppendElement(interp, "lf");
|
Tcl_AppendElement(interp, "lf");
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) {
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) {
|
Tcl_AppendElement(interp, "cr");
|
Tcl_AppendElement(interp, "cr");
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) {
|
} else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) {
|
Tcl_AppendElement(interp, "crlf");
|
Tcl_AppendElement(interp, "crlf");
|
}
|
}
|
for (IOQueued = 0, bufPtr = chanPtr->inQueueHead;
|
for (IOQueued = 0, bufPtr = chanPtr->inQueueHead;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
IOQueued += bufPtr->nextAdded - bufPtr->nextRemoved;
|
IOQueued += bufPtr->nextAdded - bufPtr->nextRemoved;
|
}
|
}
|
TclFormatInt(buf, IOQueued);
|
TclFormatInt(buf, IOQueued);
|
Tcl_AppendElement(interp, buf);
|
Tcl_AppendElement(interp, buf);
|
|
|
IOQueued = 0;
|
IOQueued = 0;
|
if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
|
if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
|
IOQueued = chanPtr->curOutPtr->nextAdded -
|
IOQueued = chanPtr->curOutPtr->nextAdded -
|
chanPtr->curOutPtr->nextRemoved;
|
chanPtr->curOutPtr->nextRemoved;
|
}
|
}
|
for (bufPtr = chanPtr->outQueueHead;
|
for (bufPtr = chanPtr->outQueueHead;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
IOQueued += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
IOQueued += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
}
|
}
|
TclFormatInt(buf, IOQueued);
|
TclFormatInt(buf, IOQueued);
|
Tcl_AppendElement(interp, buf);
|
Tcl_AppendElement(interp, buf);
|
|
|
TclFormatInt(buf, Tcl_Tell((Tcl_Channel) chanPtr));
|
TclFormatInt(buf, Tcl_Tell((Tcl_Channel) chanPtr));
|
Tcl_AppendElement(interp, buf);
|
Tcl_AppendElement(interp, buf);
|
|
|
TclFormatInt(buf, chanPtr->refCount);
|
TclFormatInt(buf, chanPtr->refCount);
|
Tcl_AppendElement(interp, buf);
|
Tcl_AppendElement(interp, buf);
|
|
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'i') &&
|
if ((cmdName[0] == 'i') &&
|
(strncmp(cmdName, "inputbuffered", len) == 0)) {
|
(strncmp(cmdName, "inputbuffered", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "channel name required",
|
Tcl_AppendResult(interp, "channel name required",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
for (IOQueued = 0, bufPtr = chanPtr->inQueueHead;
|
for (IOQueued = 0, bufPtr = chanPtr->inQueueHead;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
IOQueued += bufPtr->nextAdded - bufPtr->nextRemoved;
|
IOQueued += bufPtr->nextAdded - bufPtr->nextRemoved;
|
}
|
}
|
sprintf(buf, "%d", IOQueued);
|
sprintf(buf, "%d", IOQueued);
|
Tcl_AppendResult(interp, buf, (char *) NULL);
|
Tcl_AppendResult(interp, buf, (char *) NULL);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'm') && (strncmp(cmdName, "mode", len) == 0)) {
|
if ((cmdName[0] == 'm') && (strncmp(cmdName, "mode", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "channel name required",
|
Tcl_AppendResult(interp, "channel name required",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
if (chanPtr->flags & TCL_READABLE) {
|
if (chanPtr->flags & TCL_READABLE) {
|
Tcl_AppendElement(interp, "read");
|
Tcl_AppendElement(interp, "read");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
if (chanPtr->flags & TCL_WRITABLE) {
|
if (chanPtr->flags & TCL_WRITABLE) {
|
Tcl_AppendElement(interp, "write");
|
Tcl_AppendElement(interp, "write");
|
} else {
|
} else {
|
Tcl_AppendElement(interp, "");
|
Tcl_AppendElement(interp, "");
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'n') && (strncmp(cmdName, "name", len) == 0)) {
|
if ((cmdName[0] == 'n') && (strncmp(cmdName, "name", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "channel name required",
|
Tcl_AppendResult(interp, "channel name required",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
Tcl_AppendResult(interp, chanPtr->channelName, (char *) NULL);
|
Tcl_AppendResult(interp, chanPtr->channelName, (char *) NULL);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'o') && (strncmp(cmdName, "open", len) == 0)) {
|
if ((cmdName[0] == 'o') && (strncmp(cmdName, "open", len) == 0)) {
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr = Tcl_NextHashEntry(&hSearch)) {
|
hPtr = Tcl_NextHashEntry(&hSearch)) {
|
Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
|
Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'o') &&
|
if ((cmdName[0] == 'o') &&
|
(strncmp(cmdName, "outputbuffered", len) == 0)) {
|
(strncmp(cmdName, "outputbuffered", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "channel name required",
|
Tcl_AppendResult(interp, "channel name required",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
IOQueued = 0;
|
IOQueued = 0;
|
if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
|
if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) {
|
IOQueued = chanPtr->curOutPtr->nextAdded -
|
IOQueued = chanPtr->curOutPtr->nextAdded -
|
chanPtr->curOutPtr->nextRemoved;
|
chanPtr->curOutPtr->nextRemoved;
|
}
|
}
|
for (bufPtr = chanPtr->outQueueHead;
|
for (bufPtr = chanPtr->outQueueHead;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr != (ChannelBuffer *) NULL;
|
bufPtr = bufPtr->nextPtr) {
|
bufPtr = bufPtr->nextPtr) {
|
IOQueued += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
IOQueued += (bufPtr->nextAdded - bufPtr->nextRemoved);
|
}
|
}
|
sprintf(buf, "%d", IOQueued);
|
sprintf(buf, "%d", IOQueued);
|
Tcl_AppendResult(interp, buf, (char *) NULL);
|
Tcl_AppendResult(interp, buf, (char *) NULL);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'q') &&
|
if ((cmdName[0] == 'q') &&
|
(strncmp(cmdName, "queuedcr", len) == 0)) {
|
(strncmp(cmdName, "queuedcr", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "channel name required",
|
Tcl_AppendResult(interp, "channel name required",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
Tcl_AppendResult(interp,
|
Tcl_AppendResult(interp,
|
(chanPtr->flags & INPUT_SAW_CR) ? "1" : "0",
|
(chanPtr->flags & INPUT_SAW_CR) ? "1" : "0",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'r') && (strncmp(cmdName, "readable", len) == 0)) {
|
if ((cmdName[0] == 'r') && (strncmp(cmdName, "readable", len) == 0)) {
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr = Tcl_NextHashEntry(&hSearch)) {
|
hPtr = Tcl_NextHashEntry(&hSearch)) {
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
if (chanPtr->flags & TCL_READABLE) {
|
if (chanPtr->flags & TCL_READABLE) {
|
Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
|
Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
|
}
|
}
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'r') && (strncmp(cmdName, "refcount", len) == 0)) {
|
if ((cmdName[0] == 'r') && (strncmp(cmdName, "refcount", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "channel name required",
|
Tcl_AppendResult(interp, "channel name required",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
sprintf(buf, "%d", chanPtr->refCount);
|
sprintf(buf, "%d", chanPtr->refCount);
|
Tcl_AppendResult(interp, buf, (char *) NULL);
|
Tcl_AppendResult(interp, buf, (char *) NULL);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 't') && (strncmp(cmdName, "type", len) == 0)) {
|
if ((cmdName[0] == 't') && (strncmp(cmdName, "type", len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "channel name required",
|
Tcl_AppendResult(interp, "channel name required",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
Tcl_AppendResult(interp, chanPtr->typePtr->typeName, (char *) NULL);
|
Tcl_AppendResult(interp, chanPtr->typePtr->typeName, (char *) NULL);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmdName[0] == 'w') && (strncmp(cmdName, "writable", len) == 0)) {
|
if ((cmdName[0] == 'w') && (strncmp(cmdName, "writable", len) == 0)) {
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
if (hTblPtr == (Tcl_HashTable *) NULL) {
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch);
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr != (Tcl_HashEntry *) NULL;
|
hPtr = Tcl_NextHashEntry(&hSearch)) {
|
hPtr = Tcl_NextHashEntry(&hSearch)) {
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
chanPtr = (Channel *) Tcl_GetHashValue(hPtr);
|
if (chanPtr->flags & TCL_WRITABLE) {
|
if (chanPtr->flags & TCL_WRITABLE) {
|
Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
|
Tcl_AppendElement(interp, Tcl_GetHashKey(hTblPtr, hPtr));
|
}
|
}
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
Tcl_AppendResult(interp, "bad option \"", cmdName, "\": should be ",
|
Tcl_AppendResult(interp, "bad option \"", cmdName, "\": should be ",
|
"info, open, readable, or writable",
|
"info, open, readable, or writable",
|
(char *) NULL);
|
(char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TclTestChannelEventCmd --
|
* TclTestChannelEventCmd --
|
*
|
*
|
* This procedure implements the "testchannelevent" command. It is
|
* This procedure implements the "testchannelevent" command. It is
|
* used to test the Tcl channel event mechanism. It is present in
|
* used to test the Tcl channel event mechanism. It is present in
|
* this file instead of tclTest.c because it needs access to the
|
* this file instead of tclTest.c because it needs access to the
|
* internal structure of the channel.
|
* internal structure of the channel.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Creates, deletes and returns channel event handlers.
|
* Creates, deletes and returns channel event handlers.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
/* ARGSUSED */
|
/* ARGSUSED */
|
int
|
int
|
TclTestChannelEventCmd(dummy, interp, argc, argv)
|
TclTestChannelEventCmd(dummy, interp, argc, argv)
|
ClientData dummy; /* Not used. */
|
ClientData dummy; /* Not used. */
|
Tcl_Interp *interp; /* Current interpreter. */
|
Tcl_Interp *interp; /* Current interpreter. */
|
int argc; /* Number of arguments. */
|
int argc; /* Number of arguments. */
|
char **argv; /* Argument strings. */
|
char **argv; /* Argument strings. */
|
{
|
{
|
Channel *chanPtr;
|
Channel *chanPtr;
|
EventScriptRecord *esPtr, *prevEsPtr, *nextEsPtr;
|
EventScriptRecord *esPtr, *prevEsPtr, *nextEsPtr;
|
char *cmd;
|
char *cmd;
|
int index, i, mask, len;
|
int index, i, mask, len;
|
|
|
if ((argc < 3) || (argc > 5)) {
|
if ((argc < 3) || (argc > 5)) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" channelName cmd ?arg1? ?arg2?\"", (char *) NULL);
|
" channelName cmd ?arg1? ?arg2?\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
chanPtr = (Channel *) Tcl_GetChannel(interp, argv[1], NULL);
|
chanPtr = (Channel *) Tcl_GetChannel(interp, argv[1], NULL);
|
if (chanPtr == (Channel *) NULL) {
|
if (chanPtr == (Channel *) NULL) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
cmd = argv[2];
|
cmd = argv[2];
|
len = strlen(cmd);
|
len = strlen(cmd);
|
if ((cmd[0] == 'a') && (strncmp(cmd, "add", (unsigned) len) == 0)) {
|
if ((cmd[0] == 'a') && (strncmp(cmd, "add", (unsigned) len) == 0)) {
|
if (argc != 5) {
|
if (argc != 5) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" channelName add eventSpec script\"", (char *) NULL);
|
" channelName add eventSpec script\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (strcmp(argv[3], "readable") == 0) {
|
if (strcmp(argv[3], "readable") == 0) {
|
mask = TCL_READABLE;
|
mask = TCL_READABLE;
|
} else if (strcmp(argv[3], "writable") == 0) {
|
} else if (strcmp(argv[3], "writable") == 0) {
|
mask = TCL_WRITABLE;
|
mask = TCL_WRITABLE;
|
} else if (strcmp(argv[3], "none") == 0) {
|
} else if (strcmp(argv[3], "none") == 0) {
|
mask = 0;
|
mask = 0;
|
} else {
|
} else {
|
Tcl_AppendResult(interp, "bad event name \"", argv[3],
|
Tcl_AppendResult(interp, "bad event name \"", argv[3],
|
"\": must be readable, writable, or none", (char *) NULL);
|
"\": must be readable, writable, or none", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
esPtr = (EventScriptRecord *) ckalloc((unsigned)
|
esPtr = (EventScriptRecord *) ckalloc((unsigned)
|
sizeof(EventScriptRecord));
|
sizeof(EventScriptRecord));
|
esPtr->nextPtr = chanPtr->scriptRecordPtr;
|
esPtr->nextPtr = chanPtr->scriptRecordPtr;
|
chanPtr->scriptRecordPtr = esPtr;
|
chanPtr->scriptRecordPtr = esPtr;
|
|
|
esPtr->chanPtr = chanPtr;
|
esPtr->chanPtr = chanPtr;
|
esPtr->interp = interp;
|
esPtr->interp = interp;
|
esPtr->mask = mask;
|
esPtr->mask = mask;
|
esPtr->script = ckalloc((unsigned) (strlen(argv[4]) + 1));
|
esPtr->script = ckalloc((unsigned) (strlen(argv[4]) + 1));
|
strcpy(esPtr->script, argv[4]);
|
strcpy(esPtr->script, argv[4]);
|
|
|
Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
|
Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
|
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmd[0] == 'd') && (strncmp(cmd, "delete", (unsigned) len) == 0)) {
|
if ((cmd[0] == 'd') && (strncmp(cmd, "delete", (unsigned) len) == 0)) {
|
if (argc != 4) {
|
if (argc != 4) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" channelName delete index\"", (char *) NULL);
|
" channelName delete index\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (Tcl_GetInt(interp, argv[3], &index) == TCL_ERROR) {
|
if (Tcl_GetInt(interp, argv[3], &index) == TCL_ERROR) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (index < 0) {
|
if (index < 0) {
|
Tcl_AppendResult(interp, "bad event index: ", argv[3],
|
Tcl_AppendResult(interp, "bad event index: ", argv[3],
|
": must be nonnegative", (char *) NULL);
|
": must be nonnegative", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
for (i = 0, esPtr = chanPtr->scriptRecordPtr;
|
for (i = 0, esPtr = chanPtr->scriptRecordPtr;
|
(i < index) && (esPtr != (EventScriptRecord *) NULL);
|
(i < index) && (esPtr != (EventScriptRecord *) NULL);
|
i++, esPtr = esPtr->nextPtr) {
|
i++, esPtr = esPtr->nextPtr) {
|
/* Empty loop body. */
|
/* Empty loop body. */
|
}
|
}
|
if (esPtr == (EventScriptRecord *) NULL) {
|
if (esPtr == (EventScriptRecord *) NULL) {
|
Tcl_AppendResult(interp, "bad event index ", argv[3],
|
Tcl_AppendResult(interp, "bad event index ", argv[3],
|
": out of range", (char *) NULL);
|
": out of range", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (esPtr == chanPtr->scriptRecordPtr) {
|
if (esPtr == chanPtr->scriptRecordPtr) {
|
chanPtr->scriptRecordPtr = esPtr->nextPtr;
|
chanPtr->scriptRecordPtr = esPtr->nextPtr;
|
} else {
|
} else {
|
for (prevEsPtr = chanPtr->scriptRecordPtr;
|
for (prevEsPtr = chanPtr->scriptRecordPtr;
|
(prevEsPtr != (EventScriptRecord *) NULL) &&
|
(prevEsPtr != (EventScriptRecord *) NULL) &&
|
(prevEsPtr->nextPtr != esPtr);
|
(prevEsPtr->nextPtr != esPtr);
|
prevEsPtr = prevEsPtr->nextPtr) {
|
prevEsPtr = prevEsPtr->nextPtr) {
|
/* Empty loop body. */
|
/* Empty loop body. */
|
}
|
}
|
if (prevEsPtr == (EventScriptRecord *) NULL) {
|
if (prevEsPtr == (EventScriptRecord *) NULL) {
|
panic("TclTestChannelEventCmd: damaged event script list");
|
panic("TclTestChannelEventCmd: damaged event script list");
|
}
|
}
|
prevEsPtr->nextPtr = esPtr->nextPtr;
|
prevEsPtr->nextPtr = esPtr->nextPtr;
|
}
|
}
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ckfree(esPtr->script);
|
ckfree(esPtr->script);
|
ckfree((char *) esPtr);
|
ckfree((char *) esPtr);
|
|
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmd[0] == 'l') && (strncmp(cmd, "list", (unsigned) len) == 0)) {
|
if ((cmd[0] == 'l') && (strncmp(cmd, "list", (unsigned) len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" channelName list\"", (char *) NULL);
|
" channelName list\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
for (esPtr = chanPtr->scriptRecordPtr;
|
for (esPtr = chanPtr->scriptRecordPtr;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr = esPtr->nextPtr) {
|
esPtr = esPtr->nextPtr) {
|
char *event;
|
char *event;
|
if (esPtr->mask) {
|
if (esPtr->mask) {
|
event = ((esPtr->mask == TCL_READABLE)
|
event = ((esPtr->mask == TCL_READABLE)
|
? "readable" : "writable");
|
? "readable" : "writable");
|
} else {
|
} else {
|
event = "none";
|
event = "none";
|
}
|
}
|
Tcl_AppendElement(interp, event);
|
Tcl_AppendElement(interp, event);
|
Tcl_AppendElement(interp, esPtr->script);
|
Tcl_AppendElement(interp, esPtr->script);
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmd[0] == 'r') && (strncmp(cmd, "removeall", (unsigned) len) == 0)) {
|
if ((cmd[0] == 'r') && (strncmp(cmd, "removeall", (unsigned) len) == 0)) {
|
if (argc != 3) {
|
if (argc != 3) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" channelName removeall\"", (char *) NULL);
|
" channelName removeall\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
for (esPtr = chanPtr->scriptRecordPtr;
|
for (esPtr = chanPtr->scriptRecordPtr;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr != (EventScriptRecord *) NULL;
|
esPtr = nextEsPtr) {
|
esPtr = nextEsPtr) {
|
nextEsPtr = esPtr->nextPtr;
|
nextEsPtr = esPtr->nextPtr;
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ckfree(esPtr->script);
|
ckfree(esPtr->script);
|
ckfree((char *) esPtr);
|
ckfree((char *) esPtr);
|
}
|
}
|
chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
|
chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL;
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
if ((cmd[0] == 's') && (strncmp(cmd, "set", (unsigned) len) == 0)) {
|
if ((cmd[0] == 's') && (strncmp(cmd, "set", (unsigned) len) == 0)) {
|
if (argc != 5) {
|
if (argc != 5) {
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
|
" channelName delete index event\"", (char *) NULL);
|
" channelName delete index event\"", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (Tcl_GetInt(interp, argv[3], &index) == TCL_ERROR) {
|
if (Tcl_GetInt(interp, argv[3], &index) == TCL_ERROR) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (index < 0) {
|
if (index < 0) {
|
Tcl_AppendResult(interp, "bad event index: ", argv[3],
|
Tcl_AppendResult(interp, "bad event index: ", argv[3],
|
": must be nonnegative", (char *) NULL);
|
": must be nonnegative", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
for (i = 0, esPtr = chanPtr->scriptRecordPtr;
|
for (i = 0, esPtr = chanPtr->scriptRecordPtr;
|
(i < index) && (esPtr != (EventScriptRecord *) NULL);
|
(i < index) && (esPtr != (EventScriptRecord *) NULL);
|
i++, esPtr = esPtr->nextPtr) {
|
i++, esPtr = esPtr->nextPtr) {
|
/* Empty loop body. */
|
/* Empty loop body. */
|
}
|
}
|
if (esPtr == (EventScriptRecord *) NULL) {
|
if (esPtr == (EventScriptRecord *) NULL) {
|
Tcl_AppendResult(interp, "bad event index ", argv[3],
|
Tcl_AppendResult(interp, "bad event index ", argv[3],
|
": out of range", (char *) NULL);
|
": out of range", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
if (strcmp(argv[4], "readable") == 0) {
|
if (strcmp(argv[4], "readable") == 0) {
|
mask = TCL_READABLE;
|
mask = TCL_READABLE;
|
} else if (strcmp(argv[4], "writable") == 0) {
|
} else if (strcmp(argv[4], "writable") == 0) {
|
mask = TCL_WRITABLE;
|
mask = TCL_WRITABLE;
|
} else if (strcmp(argv[4], "none") == 0) {
|
} else if (strcmp(argv[4], "none") == 0) {
|
mask = 0;
|
mask = 0;
|
} else {
|
} else {
|
Tcl_AppendResult(interp, "bad event name \"", argv[4],
|
Tcl_AppendResult(interp, "bad event name \"", argv[4],
|
"\": must be readable, writable, or none", (char *) NULL);
|
"\": must be readable, writable, or none", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
esPtr->mask = mask;
|
esPtr->mask = mask;
|
Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
|
Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
ChannelEventScriptInvoker, (ClientData) esPtr);
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
Tcl_AppendResult(interp, "bad command ", cmd, ", must be one of ",
|
Tcl_AppendResult(interp, "bad command ", cmd, ", must be one of ",
|
"add, delete, list, set, or removeall", (char *) NULL);
|
"add, delete, list, set, or removeall", (char *) NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
|
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TclCopyChannel --
|
* TclCopyChannel --
|
*
|
*
|
* This routine copies data from one channel to another, either
|
* This routine copies data from one channel to another, either
|
* synchronously or asynchronously. If a command script is
|
* synchronously or asynchronously. If a command script is
|
* supplied, the operation runs in the background. The script
|
* supplied, the operation runs in the background. The script
|
* is invoked when the copy completes. Otherwise the function
|
* is invoked when the copy completes. Otherwise the function
|
* waits until the copy is completed before returning.
|
* waits until the copy is completed before returning.
|
*
|
*
|
* Results:
|
* Results:
|
* A standard Tcl result.
|
* A standard Tcl result.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* May schedule a background copy operation that causes both
|
* May schedule a background copy operation that causes both
|
* channels to be marked busy.
|
* channels to be marked busy.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
int
|
int
|
TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
|
TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
|
Tcl_Interp *interp; /* Current interpreter. */
|
Tcl_Interp *interp; /* Current interpreter. */
|
Tcl_Channel inChan; /* Channel to read from. */
|
Tcl_Channel inChan; /* Channel to read from. */
|
Tcl_Channel outChan; /* Channel to write to. */
|
Tcl_Channel outChan; /* Channel to write to. */
|
int toRead; /* Amount of data to copy, or -1 for all. */
|
int toRead; /* Amount of data to copy, or -1 for all. */
|
Tcl_Obj *cmdPtr; /* Pointer to script to execute or NULL. */
|
Tcl_Obj *cmdPtr; /* Pointer to script to execute or NULL. */
|
{
|
{
|
Channel *inPtr = (Channel *) inChan;
|
Channel *inPtr = (Channel *) inChan;
|
Channel *outPtr = (Channel *) outChan;
|
Channel *outPtr = (Channel *) outChan;
|
int readFlags, writeFlags;
|
int readFlags, writeFlags;
|
CopyState *csPtr;
|
CopyState *csPtr;
|
int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0;
|
int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0;
|
|
|
if (inPtr->csPtr) {
|
if (inPtr->csPtr) {
|
Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
|
Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
|
Tcl_GetChannelName(inChan), "\" is busy", NULL);
|
Tcl_GetChannelName(inChan), "\" is busy", NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
if (outPtr->csPtr) {
|
if (outPtr->csPtr) {
|
Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
|
Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "channel \"",
|
Tcl_GetChannelName(outChan), "\" is busy", NULL);
|
Tcl_GetChannelName(outChan), "\" is busy", NULL);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
|
|
readFlags = inPtr->flags;
|
readFlags = inPtr->flags;
|
writeFlags = outPtr->flags;
|
writeFlags = outPtr->flags;
|
|
|
/*
|
/*
|
* Set up the blocking mode appropriately. Background copies need
|
* Set up the blocking mode appropriately. Background copies need
|
* non-blocking channels. Foreground copies need blocking channels.
|
* non-blocking channels. Foreground copies need blocking channels.
|
* If there is an error, restore the old blocking mode.
|
* If there is an error, restore the old blocking mode.
|
*/
|
*/
|
|
|
if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
|
if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
|
if (SetBlockMode(interp, inPtr,
|
if (SetBlockMode(interp, inPtr,
|
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING)
|
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING)
|
!= TCL_OK) {
|
!= TCL_OK) {
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
}
|
}
|
if (inPtr != outPtr) {
|
if (inPtr != outPtr) {
|
if (nonBlocking != (writeFlags & CHANNEL_NONBLOCKING)) {
|
if (nonBlocking != (writeFlags & CHANNEL_NONBLOCKING)) {
|
if (SetBlockMode(NULL, outPtr,
|
if (SetBlockMode(NULL, outPtr,
|
nonBlocking ? TCL_MODE_BLOCKING : TCL_MODE_NONBLOCKING)
|
nonBlocking ? TCL_MODE_BLOCKING : TCL_MODE_NONBLOCKING)
|
!= TCL_OK) {
|
!= TCL_OK) {
|
if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
|
if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
|
SetBlockMode(NULL, inPtr,
|
SetBlockMode(NULL, inPtr,
|
(readFlags & CHANNEL_NONBLOCKING)
|
(readFlags & CHANNEL_NONBLOCKING)
|
? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
|
? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
|
return TCL_ERROR;
|
return TCL_ERROR;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Make sure the output side is unbuffered.
|
* Make sure the output side is unbuffered.
|
*/
|
*/
|
|
|
outPtr->flags = (outPtr->flags & ~(CHANNEL_LINEBUFFERED))
|
outPtr->flags = (outPtr->flags & ~(CHANNEL_LINEBUFFERED))
|
| CHANNEL_UNBUFFERED;
|
| CHANNEL_UNBUFFERED;
|
|
|
/*
|
/*
|
* Allocate a new CopyState to maintain info about the current copy in
|
* Allocate a new CopyState to maintain info about the current copy in
|
* progress. This structure will be deallocated when the copy is
|
* progress. This structure will be deallocated when the copy is
|
* completed.
|
* completed.
|
*/
|
*/
|
|
|
csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inPtr->bufSize);
|
csPtr = (CopyState*) ckalloc(sizeof(CopyState) + inPtr->bufSize);
|
csPtr->bufSize = inPtr->bufSize;
|
csPtr->bufSize = inPtr->bufSize;
|
csPtr->readPtr = inPtr;
|
csPtr->readPtr = inPtr;
|
csPtr->writePtr = outPtr;
|
csPtr->writePtr = outPtr;
|
csPtr->readFlags = readFlags;
|
csPtr->readFlags = readFlags;
|
csPtr->writeFlags = writeFlags;
|
csPtr->writeFlags = writeFlags;
|
csPtr->toRead = toRead;
|
csPtr->toRead = toRead;
|
csPtr->total = 0;
|
csPtr->total = 0;
|
csPtr->interp = interp;
|
csPtr->interp = interp;
|
if (cmdPtr) {
|
if (cmdPtr) {
|
Tcl_IncrRefCount(cmdPtr);
|
Tcl_IncrRefCount(cmdPtr);
|
}
|
}
|
csPtr->cmdPtr = cmdPtr;
|
csPtr->cmdPtr = cmdPtr;
|
inPtr->csPtr = csPtr;
|
inPtr->csPtr = csPtr;
|
outPtr->csPtr = csPtr;
|
outPtr->csPtr = csPtr;
|
|
|
/*
|
/*
|
* Start copying data between the channels.
|
* Start copying data between the channels.
|
*/
|
*/
|
|
|
return CopyData(csPtr, 0);
|
return CopyData(csPtr, 0);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CopyData --
|
* CopyData --
|
*
|
*
|
* This function implements the lowest level of the copying
|
* This function implements the lowest level of the copying
|
* mechanism for TclCopyChannel.
|
* mechanism for TclCopyChannel.
|
*
|
*
|
* Results:
|
* Results:
|
* Returns TCL_OK on success, else TCL_ERROR.
|
* Returns TCL_OK on success, else TCL_ERROR.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Moves data between channels, may create channel handlers.
|
* Moves data between channels, may create channel handlers.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static int
|
static int
|
CopyData(csPtr, mask)
|
CopyData(csPtr, mask)
|
CopyState *csPtr; /* State of copy operation. */
|
CopyState *csPtr; /* State of copy operation. */
|
int mask; /* Current channel event flags. */
|
int mask; /* Current channel event flags. */
|
{
|
{
|
Tcl_Interp *interp;
|
Tcl_Interp *interp;
|
Tcl_Obj *cmdPtr, *errObj = NULL;
|
Tcl_Obj *cmdPtr, *errObj = NULL;
|
Tcl_Channel inChan, outChan;
|
Tcl_Channel inChan, outChan;
|
int result = TCL_OK;
|
int result = TCL_OK;
|
int size;
|
int size;
|
int total;
|
int total;
|
|
|
inChan = (Tcl_Channel)csPtr->readPtr;
|
inChan = (Tcl_Channel)csPtr->readPtr;
|
outChan = (Tcl_Channel)csPtr->writePtr;
|
outChan = (Tcl_Channel)csPtr->writePtr;
|
interp = csPtr->interp;
|
interp = csPtr->interp;
|
cmdPtr = csPtr->cmdPtr;
|
cmdPtr = csPtr->cmdPtr;
|
|
|
/*
|
/*
|
* Copy the data the slow way, using the translation mechanism.
|
* Copy the data the slow way, using the translation mechanism.
|
*/
|
*/
|
|
|
while (csPtr->toRead != 0) {
|
while (csPtr->toRead != 0) {
|
|
|
/*
|
/*
|
* Check for unreported background errors.
|
* Check for unreported background errors.
|
*/
|
*/
|
|
|
if (csPtr->readPtr->unreportedError != 0) {
|
if (csPtr->readPtr->unreportedError != 0) {
|
Tcl_SetErrno(csPtr->readPtr->unreportedError);
|
Tcl_SetErrno(csPtr->readPtr->unreportedError);
|
csPtr->readPtr->unreportedError = 0;
|
csPtr->readPtr->unreportedError = 0;
|
goto readError;
|
goto readError;
|
}
|
}
|
if (csPtr->writePtr->unreportedError != 0) {
|
if (csPtr->writePtr->unreportedError != 0) {
|
Tcl_SetErrno(csPtr->writePtr->unreportedError);
|
Tcl_SetErrno(csPtr->writePtr->unreportedError);
|
csPtr->writePtr->unreportedError = 0;
|
csPtr->writePtr->unreportedError = 0;
|
goto writeError;
|
goto writeError;
|
}
|
}
|
|
|
/*
|
/*
|
* Read up to bufSize bytes.
|
* Read up to bufSize bytes.
|
*/
|
*/
|
|
|
if ((csPtr->toRead == -1)
|
if ((csPtr->toRead == -1)
|
|| (csPtr->toRead > csPtr->bufSize)) {
|
|| (csPtr->toRead > csPtr->bufSize)) {
|
size = csPtr->bufSize;
|
size = csPtr->bufSize;
|
} else {
|
} else {
|
size = csPtr->toRead;
|
size = csPtr->toRead;
|
}
|
}
|
size = DoRead(csPtr->readPtr, csPtr->buffer, size);
|
size = DoRead(csPtr->readPtr, csPtr->buffer, size);
|
|
|
if (size < 0) {
|
if (size < 0) {
|
readError:
|
readError:
|
errObj = Tcl_NewObj();
|
errObj = Tcl_NewObj();
|
Tcl_AppendStringsToObj(errObj, "error reading \"",
|
Tcl_AppendStringsToObj(errObj, "error reading \"",
|
Tcl_GetChannelName(inChan), "\": ",
|
Tcl_GetChannelName(inChan), "\": ",
|
Tcl_PosixError(interp), (char *) NULL);
|
Tcl_PosixError(interp), (char *) NULL);
|
break;
|
break;
|
} else if (size == 0) {
|
} else if (size == 0) {
|
/*
|
/*
|
* We had an underflow on the read side. If we are at EOF,
|
* We had an underflow on the read side. If we are at EOF,
|
* then the copying is done, otherwise set up a channel
|
* then the copying is done, otherwise set up a channel
|
* handler to detect when the channel becomes readable again.
|
* handler to detect when the channel becomes readable again.
|
*/
|
*/
|
|
|
if (Tcl_Eof(inChan)) {
|
if (Tcl_Eof(inChan)) {
|
break;
|
break;
|
} else if (!(mask & TCL_READABLE)) {
|
} else if (!(mask & TCL_READABLE)) {
|
if (mask & TCL_WRITABLE) {
|
if (mask & TCL_WRITABLE) {
|
Tcl_DeleteChannelHandler(outChan, CopyEventProc,
|
Tcl_DeleteChannelHandler(outChan, CopyEventProc,
|
(ClientData) csPtr);
|
(ClientData) csPtr);
|
}
|
}
|
Tcl_CreateChannelHandler(inChan, TCL_READABLE,
|
Tcl_CreateChannelHandler(inChan, TCL_READABLE,
|
CopyEventProc, (ClientData) csPtr);
|
CopyEventProc, (ClientData) csPtr);
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
* Now write the buffer out.
|
* Now write the buffer out.
|
*/
|
*/
|
|
|
size = DoWrite(csPtr->writePtr, csPtr->buffer, size);
|
size = DoWrite(csPtr->writePtr, csPtr->buffer, size);
|
if (size < 0) {
|
if (size < 0) {
|
writeError:
|
writeError:
|
errObj = Tcl_NewObj();
|
errObj = Tcl_NewObj();
|
Tcl_AppendStringsToObj(errObj, "error writing \"",
|
Tcl_AppendStringsToObj(errObj, "error writing \"",
|
Tcl_GetChannelName(outChan), "\": ",
|
Tcl_GetChannelName(outChan), "\": ",
|
Tcl_PosixError(interp), (char *) NULL);
|
Tcl_PosixError(interp), (char *) NULL);
|
break;
|
break;
|
}
|
}
|
|
|
/*
|
/*
|
* Check to see if the write is happening in the background. If so,
|
* Check to see if the write is happening in the background. If so,
|
* stop copying and wait for the channel to become writable again.
|
* stop copying and wait for the channel to become writable again.
|
*/
|
*/
|
|
|
if (csPtr->writePtr->flags & BG_FLUSH_SCHEDULED) {
|
if (csPtr->writePtr->flags & BG_FLUSH_SCHEDULED) {
|
if (!(mask & TCL_WRITABLE)) {
|
if (!(mask & TCL_WRITABLE)) {
|
if (mask & TCL_READABLE) {
|
if (mask & TCL_READABLE) {
|
Tcl_DeleteChannelHandler(outChan, CopyEventProc,
|
Tcl_DeleteChannelHandler(outChan, CopyEventProc,
|
(ClientData) csPtr);
|
(ClientData) csPtr);
|
}
|
}
|
Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
|
Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
|
CopyEventProc, (ClientData) csPtr);
|
CopyEventProc, (ClientData) csPtr);
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
|
|
/*
|
/*
|
* Update the current byte count if we care.
|
* Update the current byte count if we care.
|
*/
|
*/
|
|
|
if (csPtr->toRead != -1) {
|
if (csPtr->toRead != -1) {
|
csPtr->toRead -= size;
|
csPtr->toRead -= size;
|
}
|
}
|
csPtr->total += size;
|
csPtr->total += size;
|
|
|
/*
|
/*
|
* For background copies, we only do one buffer per invocation so
|
* For background copies, we only do one buffer per invocation so
|
* we don't starve the rest of the system.
|
* we don't starve the rest of the system.
|
*/
|
*/
|
|
|
if (cmdPtr) {
|
if (cmdPtr) {
|
/*
|
/*
|
* The first time we enter this code, there won't be a
|
* The first time we enter this code, there won't be a
|
* channel handler established yet, so do it here.
|
* channel handler established yet, so do it here.
|
*/
|
*/
|
|
|
if (mask == 0) {
|
if (mask == 0) {
|
Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
|
Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
|
CopyEventProc, (ClientData) csPtr);
|
CopyEventProc, (ClientData) csPtr);
|
}
|
}
|
return TCL_OK;
|
return TCL_OK;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Make the callback or return the number of bytes transferred.
|
* Make the callback or return the number of bytes transferred.
|
* The local total is used because StopCopy frees csPtr.
|
* The local total is used because StopCopy frees csPtr.
|
*/
|
*/
|
|
|
total = csPtr->total;
|
total = csPtr->total;
|
if (cmdPtr) {
|
if (cmdPtr) {
|
/*
|
/*
|
* Get a private copy of the command so we can mutate it
|
* Get a private copy of the command so we can mutate it
|
* by adding arguments. Note that StopCopy frees our saved
|
* by adding arguments. Note that StopCopy frees our saved
|
* reference to the original command obj.
|
* reference to the original command obj.
|
*/
|
*/
|
|
|
cmdPtr = Tcl_DuplicateObj(cmdPtr);
|
cmdPtr = Tcl_DuplicateObj(cmdPtr);
|
Tcl_IncrRefCount(cmdPtr);
|
Tcl_IncrRefCount(cmdPtr);
|
StopCopy(csPtr);
|
StopCopy(csPtr);
|
Tcl_Preserve((ClientData) interp);
|
Tcl_Preserve((ClientData) interp);
|
|
|
Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewIntObj(total));
|
Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewIntObj(total));
|
if (errObj) {
|
if (errObj) {
|
Tcl_ListObjAppendElement(interp, cmdPtr, errObj);
|
Tcl_ListObjAppendElement(interp, cmdPtr, errObj);
|
}
|
}
|
if (Tcl_GlobalEvalObj(interp, cmdPtr) != TCL_OK) {
|
if (Tcl_GlobalEvalObj(interp, cmdPtr) != TCL_OK) {
|
Tcl_BackgroundError(interp);
|
Tcl_BackgroundError(interp);
|
result = TCL_ERROR;
|
result = TCL_ERROR;
|
}
|
}
|
Tcl_DecrRefCount(cmdPtr);
|
Tcl_DecrRefCount(cmdPtr);
|
Tcl_Release((ClientData) interp);
|
Tcl_Release((ClientData) interp);
|
} else {
|
} else {
|
StopCopy(csPtr);
|
StopCopy(csPtr);
|
if (errObj) {
|
if (errObj) {
|
Tcl_SetObjResult(interp, errObj);
|
Tcl_SetObjResult(interp, errObj);
|
result = TCL_ERROR;
|
result = TCL_ERROR;
|
} else {
|
} else {
|
Tcl_ResetResult(interp);
|
Tcl_ResetResult(interp);
|
Tcl_SetIntObj(Tcl_GetObjResult(interp), total);
|
Tcl_SetIntObj(Tcl_GetObjResult(interp), total);
|
}
|
}
|
}
|
}
|
return result;
|
return result;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* CopyEventProc --
|
* CopyEventProc --
|
*
|
*
|
* This routine is invoked as a channel event handler for
|
* This routine is invoked as a channel event handler for
|
* the background copy operation. It is just a trivial wrapper
|
* the background copy operation. It is just a trivial wrapper
|
* around the CopyData routine.
|
* around the CopyData routine.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
CopyEventProc(clientData, mask)
|
CopyEventProc(clientData, mask)
|
ClientData clientData;
|
ClientData clientData;
|
int mask;
|
int mask;
|
{
|
{
|
(void) CopyData((CopyState *)clientData, mask);
|
(void) CopyData((CopyState *)clientData, mask);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* StopCopy --
|
* StopCopy --
|
*
|
*
|
* This routine halts a copy that is in progress.
|
* This routine halts a copy that is in progress.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Removes any pending channel handlers and restores the blocking
|
* Removes any pending channel handlers and restores the blocking
|
* and buffering modes of the channels. The CopyState is freed.
|
* and buffering modes of the channels. The CopyState is freed.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
StopCopy(csPtr)
|
StopCopy(csPtr)
|
CopyState *csPtr; /* State for bg copy to stop . */
|
CopyState *csPtr; /* State for bg copy to stop . */
|
{
|
{
|
int nonBlocking;
|
int nonBlocking;
|
|
|
if (!csPtr) {
|
if (!csPtr) {
|
return;
|
return;
|
}
|
}
|
|
|
/*
|
/*
|
* Restore the old blocking mode and output buffering mode.
|
* Restore the old blocking mode and output buffering mode.
|
*/
|
*/
|
|
|
nonBlocking = (csPtr->readFlags & CHANNEL_NONBLOCKING);
|
nonBlocking = (csPtr->readFlags & CHANNEL_NONBLOCKING);
|
if (nonBlocking != (csPtr->readPtr->flags & CHANNEL_NONBLOCKING)) {
|
if (nonBlocking != (csPtr->readPtr->flags & CHANNEL_NONBLOCKING)) {
|
SetBlockMode(NULL, csPtr->readPtr,
|
SetBlockMode(NULL, csPtr->readPtr,
|
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
|
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
|
}
|
}
|
if (csPtr->writePtr != csPtr->writePtr) {
|
if (csPtr->writePtr != csPtr->writePtr) {
|
if (nonBlocking != (csPtr->writePtr->flags & CHANNEL_NONBLOCKING)) {
|
if (nonBlocking != (csPtr->writePtr->flags & CHANNEL_NONBLOCKING)) {
|
SetBlockMode(NULL, csPtr->writePtr,
|
SetBlockMode(NULL, csPtr->writePtr,
|
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
|
nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
|
}
|
}
|
}
|
}
|
csPtr->writePtr->flags &= ~(CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
|
csPtr->writePtr->flags &= ~(CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
|
csPtr->writePtr->flags |=
|
csPtr->writePtr->flags |=
|
csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
|
csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
|
|
|
|
|
if (csPtr->cmdPtr) {
|
if (csPtr->cmdPtr) {
|
Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->readPtr, CopyEventProc,
|
Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->readPtr, CopyEventProc,
|
(ClientData)csPtr);
|
(ClientData)csPtr);
|
if (csPtr->readPtr != csPtr->writePtr) {
|
if (csPtr->readPtr != csPtr->writePtr) {
|
Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr,
|
Tcl_DeleteChannelHandler((Tcl_Channel)csPtr->writePtr,
|
CopyEventProc, (ClientData)csPtr);
|
CopyEventProc, (ClientData)csPtr);
|
}
|
}
|
Tcl_DecrRefCount(csPtr->cmdPtr);
|
Tcl_DecrRefCount(csPtr->cmdPtr);
|
}
|
}
|
csPtr->readPtr->csPtr = NULL;
|
csPtr->readPtr->csPtr = NULL;
|
csPtr->writePtr->csPtr = NULL;
|
csPtr->writePtr->csPtr = NULL;
|
ckfree((char*) csPtr);
|
ckfree((char*) csPtr);
|
}
|
}
|
|
|
