NAME

Tcl_OpenFileChannel, Tcl_OpenCommandChannel, Tcl_MakeFileChannel,
  Tcl_GetChannel, Tcl_GetChannelNames, Tcl_GetChannelNamesEx,
  Tcl_RegisterChannel, Tcl_UnregisterChannel, Tcl_DetachChannel,
  Tcl_IsStandardChannel, Tcl_Close, Tcl_ReadChars, Tcl_Read, Tcl_GetsObj,
  Tcl_Gets, Tcl_WriteObj, Tcl_WriteChars, Tcl_Write, Tcl_Flush, Tcl_Seek,
  Tcl_Tell, Tcl_TruncateChannel, Tcl_GetChannelOption, Tcl_SetChannelOption,
  Tcl_Eof, Tcl_InputBlocked, Tcl_InputBuffered, Tcl_OutputBuffered, Tcl_Ungets,
  Tcl_ReadRaw, Tcl_WriteRaw - buffered I/O facilities using channels

SYNOPSIS


#include <tcl.h>

 

Tcl_Channel
Tcl_OpenFileChannel(interp, fileName, mode, permissions)

 

Tcl_Channel
Tcl_OpenCommandChannel(interp, argc, argv, flags)

 

Tcl_Channel
Tcl_MakeFileChannel(handle, readOrWrite)

 

Tcl_Channel
Tcl_GetChannel(interp, channelName, modePtr)

 

int
Tcl_GetChannelNames(interp)

 

int
Tcl_GetChannelNamesEx(interp, pattern)

 

void
Tcl_RegisterChannel(interp, channel)

 

int
Tcl_UnregisterChannel(interp, channel)

 

int
Tcl_DetachChannel(interp, channel)

 

int
Tcl_IsStandardChannel(channel)

 

int
Tcl_Close(interp, channel)

 

int
Tcl_ReadChars(channel, readObjPtr, charsToRead, appendFlag)

 

int
Tcl_Read(channel, readBuf, bytesToRead)

 

int
Tcl_GetsObj(channel, lineObjPtr)

 

int
Tcl_Gets(channel, lineRead)

 

int
Tcl_Ungets(channel, input, inputLen, addAtEnd)

 

int
Tcl_WriteObj(channel, writeObjPtr)

 

int
Tcl_WriteChars(channel, charBuf, bytesToWrite)

 

int
Tcl_Write(channel, byteBuf, bytesToWrite)

 

int
Tcl_ReadRaw(channel, readBuf, bytesToRead)

 

int
Tcl_WriteRaw(channel, byteBuf, bytesToWrite)

 

int
Tcl_Eof(channel)

 

int
Tcl_Flush(channel)

 

int
Tcl_InputBlocked(channel)

 

int
Tcl_InputBuffered(channel)

 

int
Tcl_OutputBuffered(channel)

 

Tcl_WideInt
Tcl_Seek(channel, offset, seekMode)

 

Tcl_WideInt
Tcl_Tell(channel)

 

int
Tcl_TruncateChannel(channel, length)

 

int
Tcl_GetChannelOption(interp, channel, optionName, optionValue)

 

int
Tcl_SetChannelOption(interp, channel, optionName, newValue)

 




ARGUMENTS



  
Tcl_Interp *interp (in)

  
Used for error reporting and to look up a channel
      registered in it.





  
const char *fileName (in)

  
The name of a local or network file.





  
const char *mode (in)

  
Specifies how the file is to be accessed. May have any of
      the values allowed for the mode argument to the Tcl open
      command.





  
int permissions (in)

  
POSIX-style permission flags such as 0644. If a new file is
      created, these permissions will be set on the created file.





  
int argc (in)

  
The number of elements in argv.





  
const char **argv (in)

  
Arguments for constructing a command pipeline. These values
      have the same meaning as the non-switch arguments to the Tcl exec
      command.





  
int flags (in)

  
Specifies the disposition of the stdio handles in pipeline:
      OR-ed combination of TCL_STDIN, TCL_STDOUT,
      TCL_STDERR, and TCL_ENFORCE_MODE. If TCL_STDIN is
      set, stdin for the first child in the pipe is the pipe channel, otherwise
      it is the same as the standard input of the invoking process; likewise for
      TCL_STDOUT and TCL_STDERR. If TCL_ENFORCE_MODE is not
      set, then the pipe can redirect stdio handles to override the stdio
      handles for which TCL_STDIN, TCL_STDOUT and
      TCL_STDERR have been set. If it is set, then such redirections
      cause an error.





  
ClientData handle (in)

  
Operating system specific handle for I/O to a file. For
      Unix this is a file descriptor, for Windows it is a HANDLE.





  
int readOrWrite (in)

  
OR-ed combination of TCL_READABLE and
      TCL_WRITABLE to indicate what operations are valid on
      handle.





  
const char *channelName (in)

  
The name of the channel.





  
int *modePtr (out)

  
Points at an integer variable that will receive an OR-ed
      combination of TCL_READABLE and TCL_WRITABLE denoting
      whether the channel is open for reading and writing.





  
const char *pattern (in)

  
The pattern to match on, passed to Tcl_StringMatch, or
      NULL.





  
Tcl_Channel channel (in)

  
A Tcl channel for input or output. Must have been the
      return value from a procedure such as Tcl_OpenFileChannel.





  
Tcl_Obj *readObjPtr (in/out)

  
A pointer to a Tcl value in which to store the characters
      read from the channel.





  
int charsToRead (in)

  
The number of characters to read from the channel. If the
      channel's encoding is binary, this is equivalent to the number of
      bytes to read from the channel.





  
int appendFlag (in)

  
If non-zero, data read from the channel will be appended to
      the value. Otherwise, the data will replace the existing contents of the
      value.





  
char *readBuf (out)

  
A buffer in which to store the bytes read from the
    channel.





  
int bytesToRead (in)

  
The number of bytes to read from the channel. The buffer
      readBuf must be large enough to hold this many bytes.





  
Tcl_Obj *lineObjPtr (in/out)

  
A pointer to a Tcl value in which to store the line read
      from the channel. The line read will be appended to the current value of
      the value.





  
Tcl_DString *lineRead (in/out)

  
A pointer to a Tcl dynamic string in which to store the
      line read from the channel. Must have been initialized by the caller. The
      line read will be appended to any data already in the dynamic string.





  
const char *input (in)

  
The input to add to a channel buffer.





  
int inputLen (in)

  
Length of the input





  
int addAtEnd (in)

  
Flag indicating whether the input should be added to the
      end or beginning of the channel buffer.





  
Tcl_Obj *writeObjPtr (in)

  
A pointer to a Tcl value whose contents will be output to
      the channel.





  
const char *charBuf (in)

  
A buffer containing the characters to output to the
      channel.





  
const char *byteBuf (in)

  
A buffer containing the bytes to output to the
    channel.





  
int bytesToWrite (in)

  
The number of bytes to consume from charBuf or
      byteBuf and output to the channel.





  
Tcl_WideInt offset (in)

  
How far to move the access point in the channel at which
      the next input or output operation will be applied, measured in bytes from
      the position given by seekMode. May be either positive or
    negative.





  
int seekMode (in)

  
Relative to which point to seek; used with offset to
      calculate the new access point for the channel. Legal values are
      SEEK_SET, SEEK_CUR, and SEEK_END.





  
Tcl_WideInt length (in)

  
The (non-negative) length to truncate the channel the
      channel to.





  
const char *optionName (in)

  
The name of an option applicable to this channel, such as
      -blocking. May have any of the values accepted by the
      fconfigure command.





  
Tcl_DString *optionValue (in)

  
Where to store the value of an option or a list of all
      options and their values. Must have been initialized by the caller.





  
const char *newValue (in)

  
New value for the option given by optionName.
    
    

    
 

  




DESCRIPTION

The Tcl channel mechanism provides a device-independent and platform-independent
  mechanism for performing buffered input and output operations on a variety of
  file, socket, and device types. The channel mechanism is extensible to new
  channel types, by providing a low-level channel driver for the new type; the
  channel driver interface is described in the manual entry for
  Tcl_CreateChannel. The channel mechanism provides a buffering scheme
  modeled after Unix's standard I/O, and it also allows for nonblocking I/O on
  channels.


The procedures described in this manual entry comprise the C APIs of the generic
  layer of the channel architecture. For a description of the channel driver
  architecture and how to implement channel drivers for new types of channels,
  see the manual entry for Tcl_CreateChannel.

TCL_OPENFILECHANNEL

Tcl_OpenFileChannel opens a file specified by fileName and returns
  a channel handle that can be used to perform input and output on the file.
  This API is modeled after the fopen procedure of the Unix standard I/O
  library. The syntax and meaning of all arguments is similar to those given in
  the Tcl open command when opening a file. If an error occurs while
  opening the channel, Tcl_OpenFileChannel returns NULL and records a
  POSIX error code that can be retrieved with Tcl_GetErrno. In addition,
  if interp is non-NULL, Tcl_OpenFileChannel leaves an error
  message in interp's result after any error. As of Tcl 8.4, the
  value-based API Tcl_FSOpenFileChannel should be used in preference to
  Tcl_OpenFileChannel wherever possible.


The newly created channel is not registered in the supplied interpreter; to
  register it, use Tcl_RegisterChannel, described below. If one of the
  standard channels, stdin, stdout or stderr was previously
  closed, the act of creating the new channel also assigns it as a replacement
  for the standard channel.

TCL_OPENCOMMANDCHANNEL

Tcl_OpenCommandChannel provides a C-level interface to the functions of
  the exec and open commands. It creates a sequence of
  subprocesses specified by the argv and argc arguments and
  returns a channel that can be used to communicate with these subprocesses. The
  flags argument indicates what sort of communication will exist with the
  command pipeline.


If the TCL_STDIN flag is set then the standard input for the first
  subprocess will be tied to the channel: writing to the channel will provide
  input to the subprocess. If TCL_STDIN is not set, then standard input
  for the first subprocess will be the same as this application's standard
  input. If TCL_STDOUT is set then standard output from the last
  subprocess can be read from the channel; otherwise it goes to this
  application's standard output. If TCL_STDERR is set, standard error
  output for all subprocesses is returned to the channel and results in an error
  when the channel is closed; otherwise it goes to this application's standard
  error. If TCL_ENFORCE_MODE is not set, then argc and argv
  can redirect the stdio handles to override TCL_STDIN,
  TCL_STDOUT, and TCL_STDERR; if it is set, then it is an error
  for argc and argv to override stdio channels for which TCL_STDIN,
  TCL_STDOUT, and TCL_STDERR have been set.


If an error occurs while opening the channel, Tcl_OpenCommandChannel
  returns NULL and records a POSIX error code that can be retrieved with
  Tcl_GetErrno. In addition, Tcl_OpenCommandChannel leaves an
  error message in the interpreter's result. interp cannot be NULL.


The newly created channel is not registered in the supplied interpreter; to
  register it, use Tcl_RegisterChannel, described below. If one of the
  standard channels, stdin, stdout or stderr was previously
  closed, the act of creating the new channel also assigns it as a replacement
  for the standard channel.

TCL_MAKEFILECHANNEL

Tcl_MakeFileChannel makes a Tcl_Channel from an existing,
  platform-specific, file handle. The newly created channel is not registered in
  the supplied interpreter; to register it, use Tcl_RegisterChannel,
  described below. If one of the standard channels, stdin, stdout
  or stderr was previously closed, the act of creating the new channel
  also assigns it as a replacement for the standard channel.

TCL_GETCHANNEL

Tcl_GetChannel returns a channel given the channelName used to
  create it with Tcl_CreateChannel and a pointer to a Tcl interpreter in
  interp. If a channel by that name is not registered in that
  interpreter, the procedure returns NULL. If the modePtr argument is not
  NULL, it points at an integer variable that will receive an OR-ed combination
  of TCL_READABLE and TCL_WRITABLE describing whether the channel
  is open for reading and writing.


Tcl_GetChannelNames and Tcl_GetChannelNamesEx write the names of
  the registered channels to the interpreter's result as a list value.
  Tcl_GetChannelNamesEx will filter these names according to the
  pattern. If pattern is NULL, then it will not do any filtering.
  The return value is TCL_OK if no errors occurred writing to the result,
  otherwise it is TCL_ERROR, and the error message is left in the
  interpreter's result.

TCL_REGISTERCHANNEL

Tcl_RegisterChannel adds a channel to the set of channels accessible in
  interp. After this call, Tcl programs executing in that interpreter can
  refer to the channel in input or output operations using the name given in the
  call to Tcl_CreateChannel. After this call, the channel becomes the
  property of the interpreter, and the caller should not call Tcl_Close
  for the channel; the channel will be closed automatically when it is
  unregistered from the interpreter.


Code executing outside of any Tcl interpreter can call
  Tcl_RegisterChannel with interp as NULL, to indicate that it
  wishes to hold a reference to this channel. Subsequently, the channel can be
  registered in a Tcl interpreter and it will only be closed when the matching
  number of calls to Tcl_UnregisterChannel have been made. This allows
  code executing outside of any interpreter to safely hold a reference to a
  channel that is also registered in a Tcl interpreter.


This procedure interacts with the code managing the standard channels. If no
  standard channels were initialized before the first call to
  Tcl_RegisterChannel, they will get initialized by that call. See
  Tcl_StandardChannels for a general treatise about standard channels and
  the behavior of the Tcl library with regard to them.

TCL_UNREGISTERCHANNEL

Tcl_UnregisterChannel removes a channel from the set of channels
  accessible in interp. After this call, Tcl programs will no longer be
  able to use the channel's name to refer to the channel in that interpreter. If
  this operation removed the last registration of the channel in any
  interpreter, the channel is also closed and destroyed.


Code not associated with a Tcl interpreter can call Tcl_UnregisterChannel
  with interp as NULL, to indicate to Tcl that it no longer holds a
  reference to that channel. If this is the last reference to the channel, it
  will now be closed. Tcl_UnregisterChannel is very similar to
  Tcl_DetachChannel except that it will also close the channel if no
  further references to it exist.

TCL_DETACHCHANNEL

Tcl_DetachChannel removes a channel from the set of channels accessible
  in interp. After this call, Tcl programs will no longer be able to use
  the channel's name to refer to the channel in that interpreter. Beyond that,
  this command has no further effect. It cannot be used on the standard channels
  ( stdout, stderr, stdin), and will return
  TCL_ERROR if passed one of those channels.


Code not associated with a Tcl interpreter can call Tcl_DetachChannel
  with interp as NULL, to indicate to Tcl that it no longer holds a
  reference to that channel. If this is the last reference to the channel,
  unlike Tcl_UnregisterChannel, it will not be closed.

TCL_ISSTANDARDCHANNEL

Tcl_IsStandardChannel tests whether a channel is one of the three
  standard channels, stdin, stdout or stderr. If so, it
  returns 1, otherwise 0.


No attempt is made to check whether the given channel or the standard channels
  are initialized or otherwise valid.

TCL_CLOSE

Tcl_Close destroys the channel channel, which must denote a
  currently open channel. The channel should not be registered in any
  interpreter when Tcl_Close is called. Buffered output is flushed to the
  channel's output device prior to destroying the channel, and any buffered
  input is discarded. If this is a blocking channel, the call does not return
  until all buffered data is successfully sent to the channel's output device.
  If this is a nonblocking channel and there is buffered output that cannot be
  written without blocking, the call returns immediately; output is flushed in
  the background and the channel will be closed once all of the buffered data
  has been output. In this case errors during flushing are not reported.


If the channel was closed successfully, Tcl_Close returns TCL_OK.
  If an error occurs, Tcl_Close returns TCL_ERROR and records a
  POSIX error code that can be retrieved with Tcl_GetErrno. If the
  channel is being closed synchronously and an error occurs during closing of
  the channel and interp is not NULL, an error message is left in the
  interpreter's result.


Note: it is not safe to call Tcl_Close on a channel that has been
  registered using Tcl_RegisterChannel; see the documentation for
  Tcl_RegisterChannel, above, for details. If the channel has ever been
  given as the chan argument in a call to Tcl_RegisterChannel, you
  should instead use Tcl_UnregisterChannel, which will internally call
  Tcl_Close when all calls to Tcl_RegisterChannel have been
  matched by corresponding calls to Tcl_UnregisterChannel.

TCL_READCHARS
  AND TCL_READ

Tcl_ReadChars consumes bytes from channel, converting the bytes to
  UTF-8 based on the channel's encoding and storing the produced data in
  readObjPtr's string representation. The return value of
  Tcl_ReadChars is the number of characters, up to charsToRead,
  that were stored in readObjPtr. If an error occurs while reading, the
  return value is -1 and Tcl_ReadChars records a POSIX error code that
  can be retrieved with Tcl_GetErrno.


Setting charsToRead to -1 will cause the command to read all
  characters currently available (non-blocking) or everything until eof
  (blocking mode).


The return value may be smaller than the value to read, indicating that less
  data than requested was available. This is called a short read. In
  blocking mode, this can only happen on an end-of-file. In nonblocking mode, a
  short read can also occur if there is not enough input currently available:
  Tcl_ReadChars returns a short count rather than waiting for more data.


If the channel is in blocking mode, a return value of zero indicates an
  end-of-file condition. If the channel is in nonblocking mode, a return value
  of zero indicates either that no input is currently available or an
  end-of-file condition. Use Tcl_Eof and Tcl_InputBlocked to tell
  which of these conditions actually occurred.


Tcl_ReadChars translates the various end-of-line representations into the
  canonical \n internal representation according to the current
  end-of-line recognition mode. End-of-line recognition and the various
  platform-specific modes are described in the manual entry for the Tcl
  fconfigure command.


As a performance optimization, when reading from a channel with the encoding
  binary, the bytes are not converted to UTF-8 as they are read. Instead,
  they are stored in readObjPtr's internal representation as a byte-array
  value. The string representation of this value will only be constructed if it
  is needed (e.g., because of a call to Tcl_GetStringFromObj). In this
  way, byte-oriented data can be read from a channel, manipulated by calling
  Tcl_GetByteArrayFromObj and related functions, and then written to a
  channel without the expense of ever converting to or from UTF-8.


Tcl_Read is similar to Tcl_ReadChars, except that it does not do
  encoding conversions, regardless of the channel's encoding. It is deprecated
  and exists for backwards compatibility with non-internationalized Tcl
  extensions. It consumes bytes from channel and stores them in
  readBuf, performing end-of-line translations on the way. The return
  value of Tcl_Read is the number of bytes, up to bytesToRead,
  written in readBuf. The buffer produced by Tcl_Read is not
  null-terminated. Its contents are valid from the zeroth position up to and
  excluding the position indicated by the return value.


Tcl_ReadRaw is the same as Tcl_Read but does not compensate for
  stacking. While Tcl_Read (and the other functions in the API) always
  get their data from the topmost channel in the stack the supplied channel is
  part of, Tcl_ReadRaw does not. Thus this function is only usable
  for transformational channel drivers, i.e. drivers used in the middle of a
  stack of channels, to move data from the channel below into the
  transformation.

TCL_GETSOBJ
  AND TCL_GETS

Tcl_GetsObj consumes bytes from channel, converting the bytes to
  UTF-8 based on the channel's encoding, until a full line of input has been
  seen. If the channel's encoding is binary, each byte read from the
  channel is treated as an individual Unicode character. All of the characters
  of the line except for the terminating end-of-line character(s) are appended
  to lineObjPtr's string representation. The end-of-line character(s) are
  read and discarded.


If a line was successfully read, the return value is greater than or equal to
  zero and indicates the number of bytes stored in lineObjPtr. If an
  error occurs, Tcl_GetsObj returns -1 and records a POSIX error code
  that can be retrieved with Tcl_GetErrno. Tcl_GetsObj also
  returns -1 if the end of the file is reached; the Tcl_Eof procedure can
  be used to distinguish an error from an end-of-file condition.


If the channel is in nonblocking mode, the return value can also be -1 if no
  data was available or the data that was available did not contain an
  end-of-line character. When -1 is returned, the Tcl_InputBlocked
  procedure may be invoked to determine if the channel is blocked because of
  input unavailability.


Tcl_Gets is the same as Tcl_GetsObj except the resulting
  characters are appended to the dynamic string given by lineRead rather
  than a Tcl value.

TCL_UNGETS

Tcl_Ungets is used to add data to the input queue of a channel, at either
  the head or tail of the queue. The pointer input points to the data
  that is to be added. The length of the input to add is given by
  inputLen. A non-zero value of addAtEnd indicates that the data
  is to be added at the end of queue; otherwise it will be added at the head of
  the queue. If channel has a “sticky” EOF set, no data
  will be added to the input queue. Tcl_Ungets returns inputLen or
  -1 if an error occurs.

TCL_WRITECHARS,
  TCL_WRITEOBJ, AND TCL_WRITE

Tcl_WriteChars accepts bytesToWrite bytes of character data at
  charBuf. The UTF-8 characters in the buffer are converted to the
  channel's encoding and queued for output to channel. If
  bytesToWrite is negative, Tcl_WriteChars expects charBuf
  to be null-terminated and it outputs everything up to the null.


Data queued for output may not appear on the output device immediately, due to
  internal buffering. If the data should appear immediately, call
  Tcl_Flush after the call to Tcl_WriteChars, or set the
  -buffering option on the channel to none. If you wish the data
  to appear as soon as a complete line is accepted for output, set the
  -buffering option on the channel to line mode.


The return value of Tcl_WriteChars is a count of how many bytes were
  accepted for output to the channel. This is either greater than zero to
  indicate success or -1 to indicate that an error occurred. If an error occurs,
  Tcl_WriteChars records a POSIX error code that may be retrieved with
  Tcl_GetErrno.


Newline characters in the output data are translated to platform-specific
  end-of-line sequences according to the -translation option for the
  channel. This is done even if the channel has no encoding.


Tcl_WriteObj is similar to Tcl_WriteChars except it accepts a Tcl
  value whose contents will be output to the channel. The UTF-8 characters in
  writeObjPtr's string representation are converted to the channel's
  encoding and queued for output to channel. As a performance
  optimization, when writing to a channel with the encoding binary, UTF-8
  characters are not converted as they are written. Instead, the bytes in
  writeObjPtr's internal representation as a byte-array value are written
  to the channel. The byte-array representation of the value will be constructed
  if it is needed. In this way, byte-oriented data can be read from a channel,
  manipulated by calling Tcl_GetByteArrayFromObj and related functions,
  and then written to a channel without the expense of ever converting to or
  from UTF-8.


Tcl_Write is similar to Tcl_WriteChars except that it does not do
  encoding conversions, regardless of the channel's encoding. It is deprecated
  and exists for backwards compatibility with non-internationalized Tcl
  extensions. It accepts bytesToWrite bytes of data at byteBuf and
  queues them for output to channel. If bytesToWrite is negative,
  Tcl_Write expects byteBuf to be null-terminated and it outputs
  everything up to the null.


Tcl_WriteRaw is the same as Tcl_Write but does not compensate for
  stacking. While Tcl_Write (and the other functions in the API) always
  feed their input to the topmost channel in the stack the supplied channel is
  part of, Tcl_WriteRaw does not. Thus this function is only
  usable for transformational channel drivers, i.e. drivers used in the middle
  of a stack of channels, to move data from the transformation into the channel
  below it.

TCL_FLUSH

Tcl_Flush causes all of the buffered output data for channel to be
  written to its underlying file or device as soon as possible. If the channel
  is in blocking mode, the call does not return until all the buffered data has
  been sent to the channel or some error occurred. The call returns immediately
  if the channel is nonblocking; it starts a background flush that will write
  the buffered data to the channel eventually, as fast as the channel is able to
  absorb it.


The return value is normally TCL_OK. If an error occurs, Tcl_Flush
  returns TCL_ERROR and records a POSIX error code that can be retrieved
  with Tcl_GetErrno.

TCL_SEEK

Tcl_Seek moves the access point in channel where subsequent data
  will be read or written. Buffered output is flushed to the channel and
  buffered input is discarded, prior to the seek operation.


Tcl_Seek normally returns the new access point. If an error occurs,
  Tcl_Seek returns -1 and records a POSIX error code that can be
  retrieved with Tcl_GetErrno. After an error, the access point may or
  may not have been moved.

TCL_TELL

Tcl_Tell returns the current access point for a channel. The returned
  value is -1 if the channel does not support seeking.

TCL_TRUNCATECHANNEL

Tcl_TruncateChannel truncates the file underlying channel to a
  given length of bytes. It returns TCL_OK if the operation
  succeeded, and TCL_ERROR otherwise.

TCL_GETCHANNELOPTION

Tcl_GetChannelOption retrieves, in optionValue, the value of one
  of the options currently in effect for a channel, or a list of all options and
  their values. The channel argument identifies the channel for which to
  query an option or retrieve all options and their values. If optionName
  is not NULL, it is the name of the option to query; the option's value is
  copied to the Tcl dynamic string denoted by optionValue. If
  optionName is NULL, the function stores an alternating list of option
  names and their values in optionValue, using a series of calls to
  Tcl_DStringAppendElement. The various preexisting options and their
  possible values are described in the manual entry for the Tcl
  fconfigure command. Other options can be added by each channel type.
  These channel type specific options are described in the manual entry for the
  Tcl command that creates a channel of that type; for example, the additional
  options for TCP based channels are described in the manual entry for the Tcl
  socket command. The procedure normally returns TCL_OK. If an
  error occurs, it returns TCL_ERROR and calls Tcl_SetErrno to
  store an appropriate POSIX error code.

TCL_SETCHANNELOPTION

Tcl_SetChannelOption sets a new value newValue for an option
  optionName on channel. The procedure normally returns
  TCL_OK. If an error occurs, it returns TCL_ERROR; in addition,
  if interp is non-NULL, Tcl_SetChannelOption leaves an error
  message in the interpreter's result.

TCL_EOF

Tcl_Eof returns a nonzero value if channel encountered an end of
  file during the last input operation.

TCL_INPUTBLOCKED

Tcl_InputBlocked returns a nonzero value if channel is in
  nonblocking mode and the last input operation returned less data than
  requested because there was insufficient data available. The call always
  returns zero if the channel is in blocking mode.

TCL_INPUTBUFFERED

Tcl_InputBuffered returns the number of bytes of input currently buffered
  in the internal buffers for a channel. If the channel is not open for reading,
  this function always returns zero.

TCL_OUTPUTBUFFERED

Tcl_OutputBuffered returns the number of bytes of output currently
  buffered in the internal buffers for a channel. If the channel is not open for
  writing, this function always returns zero.

PLATFORM
  ISSUES

The handles returned from Tcl_GetChannelHandle depend on the platform and
  the channel type. On Unix platforms, the handle is always a Unix file
  descriptor as returned from the open system call. On Windows platforms,
  the handle is a file HANDLE when the channel was created with
  Tcl_OpenFileChannel, Tcl_OpenCommandChannel, or
  Tcl_MakeFileChannel. Other channel types may return a different type of
  handle on Windows platforms.

SEE
  ALSO

DString(3tcl), fconfigure(3tcl), filename(3tcl), fopen(3),
  Tcl_CreateChannel(3tcl)

KEYWORDS

access point, blocking, buffered I/O, channel, channel driver, end of file,
  flush, input, nonblocking, output, read, seek, write



  

    
    
  




      

      


      
    


    

      

        
        

          
Recommended readings

          
Pages related to Tcl_GetChannel you should read also:

          

            
            
            
            DString(3tcl)
            
            
            
            Tcl_CreateChannel(3tcl)
            
            
            
            fconfigure(3tcl)
            
            
            
            filename(3tcl)
            
            
            
            fopen(3)
            
          

        

        
        
      
        

          
Questions & Answers

          
Helpful answers and articles about Tcl_GetChannel you may found on these sites:

          
          
             Stack Overflow
          
          
          
             Server Fault
          
          
          
             Super User
          
          
          
             Unix & Linux
          
          
          
             Ask Ubuntu
          
          
          
             Network Engineering
          
          
          
             DevOps
          
          
          
             Raspberry Pi
          
          
          
             Webmasters
          
          
          
             Google Search