Lines Matching refs:statePtr
82 static int CheckChannelErrors _ANSI_ARGS_((ChannelState *statePtr,
87 ChannelState *statePtr));
97 ChannelState *statePtr, char *result,
113 static void DiscardInputQueued _ANSI_ARGS_((ChannelState *statePtr,
126 GetsState *statePtr));
135 static int ReadBytes _ANSI_ARGS_((ChannelState *statePtr,
138 static int ReadChars _ANSI_ARGS_((ChannelState *statePtr,
141 static void RecycleBuffer _ANSI_ARGS_((ChannelState *statePtr,
148 static int TranslateInputEOL _ANSI_ARGS_((ChannelState *statePtr,
151 static int TranslateOutputEOL _ANSI_ARGS_((ChannelState *statePtr,
219 ChannelState *statePtr; /* State of channel stack */
237 for (statePtr = tsdPtr->firstCSPtr;
238 statePtr != NULL;
239 statePtr = statePtr->nextCSPtr) {
240 chanPtr = statePtr->topChanPtr;
241 if (!(statePtr->flags & (CHANNEL_INCLOSE|CHANNEL_CLOSED|CHANNEL_DEAD))) {
269 statePtr->refCount--;
272 if (statePtr->refCount <= 0) {
308 statePtr->flags |= CHANNEL_DEAD;
464 ChannelState *statePtr;
467 statePtr = ((Channel *) chan)->state;
473 cbPtr->nextPtr = statePtr->closeCbPtr;
474 statePtr->closeCbPtr = cbPtr;
506 ChannelState *statePtr;
509 statePtr = ((Channel *) chan)->state;
510 for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL;
515 statePtr->closeCbPtr = cbPtr->nextPtr;
618 ChannelState *statePtr; /* State of Channel being deleted. */
635 statePtr = chanPtr->state;
641 for (sPtr = statePtr->scriptRecordPtr,
648 statePtr->scriptRecordPtr = nextPtr;
671 statePtr->refCount--;
672 if (statePtr->refCount <= 0) {
673 if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
709 ChannelState *statePtr = ((Channel *) chan)->state;
713 if (statePtr->refCount < 2) {
714 statePtr->refCount = 0;
720 if (statePtr->refCount < 2) {
721 statePtr->refCount = 0;
727 if (statePtr->refCount < 2) {
728 statePtr->refCount = 0;
797 ChannelState *statePtr; /* State of the actual channel. */
805 statePtr = chanPtr->state;
807 if (statePtr->channelName == (CONST char *) NULL) {
812 hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &new);
823 statePtr->refCount++;
858 ChannelState *statePtr; /* State of the real channel. */
860 statePtr = ((Channel *) chan)->state->bottomChanPtr->state;
862 if (statePtr->flags & CHANNEL_INCLOSE) {
875 statePtr = ((Channel *) chan)->state->bottomChanPtr->state;
891 if (statePtr->refCount <= 0) {
898 if ((statePtr->curOutPtr != NULL) &&
899 (statePtr->curOutPtr->nextAdded >
900 statePtr->curOutPtr->nextRemoved)) {
901 statePtr->flags |= BUFFER_READY;
903 Tcl_Preserve((ClientData)statePtr);
904 if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
906 if (!(statePtr->flags & CHANNEL_CLOSED)) {
908 statePtr->flags |= CHANNEL_CLOSED;
909 Tcl_Release((ClientData)statePtr);
914 statePtr->flags |= CHANNEL_CLOSED;
915 Tcl_Release((ClientData)statePtr);
1004 ChannelState *statePtr; /* State of the real channel. */
1012 statePtr = chanPtr->state;
1019 hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
1039 statePtr->refCount--;
1155 ChannelState *statePtr; /* The stack-level independent state info
1177 statePtr = (ChannelState *) ckalloc((unsigned) sizeof(ChannelState));
1178 chanPtr->state = statePtr;
1190 statePtr->channelName = tmp;
1196 statePtr->flags = mask;
1202 statePtr->encoding = NULL;
1205 statePtr->encoding = Tcl_GetEncoding(NULL, name);
1207 statePtr->inputEncodingState = NULL;
1208 statePtr->inputEncodingFlags = TCL_ENCODING_START;
1209 statePtr->outputEncodingState = NULL;
1210 statePtr->outputEncodingFlags = TCL_ENCODING_START;
1220 statePtr->inputTranslation = TCL_TRANSLATE_AUTO;
1221 statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
1222 statePtr->inEofChar = 0;
1223 statePtr->outEofChar = 0;
1225 statePtr->unreportedError = 0;
1226 statePtr->refCount = 0;
1227 statePtr->closeCbPtr = (CloseCallback *) NULL;
1228 statePtr->curOutPtr = (ChannelBuffer *) NULL;
1229 statePtr->outQueueHead = (ChannelBuffer *) NULL;
1230 statePtr->outQueueTail = (ChannelBuffer *) NULL;
1231 statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
1232 statePtr->inQueueHead = (ChannelBuffer *) NULL;
1233 statePtr->inQueueTail = (ChannelBuffer *) NULL;
1234 statePtr->chPtr = (ChannelHandler *) NULL;
1235 statePtr->interestMask = 0;
1236 statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
1237 statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE;
1238 statePtr->timer = NULL;
1239 statePtr->csPtrR = NULL;
1240 statePtr->csPtrW = NULL;
1242 statePtr->outputStage = NULL;
1243 if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
1244 statePtr->outputStage = (char *)
1245 ckalloc((unsigned) (statePtr->bufSize + 2));
1251 statePtr->topChanPtr = chanPtr;
1252 statePtr->bottomChanPtr = chanPtr;
1275 statePtr->nextCSPtr = (ChannelState *) NULL;
1343 ChannelState *statePtr;
1352 statePtr = (ChannelState *) tsdPtr->firstCSPtr;
1355 while ((statePtr != NULL) && (statePtr->topChanPtr != prevChanPtr)) {
1356 statePtr = statePtr->nextCSPtr;
1359 if (statePtr == NULL) {
1380 if ((mask & (statePtr->flags & (TCL_READABLE | TCL_WRITABLE))) == 0) {
1400 csPtrR = statePtr->csPtrR;
1401 statePtr->csPtrR = (CopyState*) NULL;
1403 csPtrW = statePtr->csPtrW;
1404 statePtr->csPtrW = (CopyState*) NULL;
1407 statePtr->csPtrR = csPtrR;
1408 statePtr->csPtrW = csPtrW;
1416 statePtr->csPtrR = csPtrR;
1417 statePtr->csPtrW = csPtrW;
1436 (statePtr->inQueueHead != (ChannelBuffer*) NULL)) {
1442 statePtr->inQueueTail->nextPtr = prevChanPtr->inQueueHead;
1443 prevChanPtr->inQueueHead = statePtr->inQueueHead;
1446 prevChanPtr->inQueueTail = statePtr->inQueueTail;
1449 statePtr->inQueueHead = (ChannelBuffer*) NULL;
1450 statePtr->inQueueTail = (ChannelBuffer*) NULL;
1462 chanPtr->state = statePtr;
1476 statePtr->topChanPtr = chanPtr;
1506 ChannelState *statePtr = chanPtr->state;
1513 chanPtr = statePtr->topChanPtr;
1532 if (statePtr->flags & TCL_WRITABLE) {
1536 csPtrR = statePtr->csPtrR;
1537 statePtr->csPtrR = (CopyState*) NULL;
1539 csPtrW = statePtr->csPtrW;
1540 statePtr->csPtrW = (CopyState*) NULL;
1543 statePtr->csPtrR = csPtrR;
1544 statePtr->csPtrW = csPtrW;
1553 statePtr->csPtrR = csPtrR;
1554 statePtr->csPtrW = csPtrW;
1567 if (((statePtr->flags & TCL_READABLE) != 0) &&
1568 ((statePtr->inQueueHead != (ChannelBuffer*) NULL) ||
1571 if ((statePtr->inQueueHead != (ChannelBuffer*) NULL) &&
1573 statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead;
1574 statePtr->inQueueTail = chanPtr->inQueueTail;
1575 statePtr->inQueueHead = statePtr->inQueueTail;
1578 statePtr->inQueueHead = chanPtr->inQueueHead;
1579 statePtr->inQueueTail = chanPtr->inQueueTail;
1585 DiscardInputQueued (statePtr, 0);
1588 statePtr->topChanPtr = downChanPtr;
1625 if (statePtr->refCount <= 0) {
1793 ChannelState *statePtr = ((Channel *) chan)->state;
1796 return (statePtr->flags & (TCL_READABLE | TCL_WRITABLE));
1822 ChannelState *statePtr; /* State of actual channel. */
1824 statePtr = ((Channel *) chan)->state;
1825 return statePtr->channelName;
1929 RecycleBuffer(statePtr, bufPtr, mustDiscard)
1930 ChannelState *statePtr; /* ChannelState in which to recycle buffers. */
1950 if ((bufPtr->bufLength - BUFFER_PADDING) < statePtr->bufSize) {
1959 if (statePtr->flags & TCL_READABLE) {
1960 if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
1961 statePtr->inQueueHead = bufPtr;
1962 statePtr->inQueueTail = bufPtr;
1965 if (statePtr->saveInBufPtr == (ChannelBuffer *) NULL) {
1966 statePtr->saveInBufPtr = bufPtr;
1975 if (statePtr->flags & TCL_WRITABLE) {
1976 if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
1977 statePtr->curOutPtr = bufPtr;
2013 DiscardOutputQueued(statePtr)
2014 ChannelState *statePtr; /* ChannelState for which to discard output. */
2018 while (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
2019 bufPtr = statePtr->outQueueHead;
2020 statePtr->outQueueHead = bufPtr->nextPtr;
2021 RecycleBuffer(statePtr, bufPtr, 0);
2023 statePtr->outQueueHead = (ChannelBuffer *) NULL;
2024 statePtr->outQueueTail = (ChannelBuffer *) NULL;
2046 CheckForDeadChannel(interp, statePtr)
2048 ChannelState *statePtr; /* The channel state to check. */
2050 if (statePtr->flags & CHANNEL_DEAD) {
2092 ChannelState *statePtr = chanPtr->state;
2112 if (CheckForDeadChannel(interp, statePtr)) return -1;
2127 if (((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
2128 (statePtr->curOutPtr->nextAdded == statePtr->curOutPtr->bufLength))
2129 || ((statePtr->flags & BUFFER_READY) &&
2130 (statePtr->outQueueHead == (ChannelBuffer *) NULL))) {
2131 statePtr->flags &= (~(BUFFER_READY));
2132 statePtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL;
2133 if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
2134 statePtr->outQueueHead = statePtr->curOutPtr;
2136 statePtr->outQueueTail->nextPtr = statePtr->curOutPtr;
2138 statePtr->outQueueTail = statePtr->curOutPtr;
2139 statePtr->curOutPtr = (ChannelBuffer *) NULL;
2141 bufPtr = statePtr->outQueueHead;
2149 (statePtr->flags & BG_FLUSH_SCHEDULED)) {
2203 if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
2204 statePtr->flags |= BG_FLUSH_SCHEDULED;
2216 if (statePtr->unreportedError == 0) {
2217 statePtr->unreportedError = errorCode;
2239 DiscardOutputQueued(statePtr);
2252 statePtr->outQueueHead = bufPtr->nextPtr;
2253 if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
2254 statePtr->outQueueTail = (ChannelBuffer *) NULL;
2256 RecycleBuffer(statePtr, bufPtr, 0);
2267 if (statePtr->flags & BG_FLUSH_SCHEDULED) {
2270 } else if (statePtr->outQueueHead == (ChannelBuffer *) NULL) {
2271 statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
2273 statePtr->interestMask);
2283 if ((statePtr->flags & CHANNEL_CLOSED) && (statePtr->refCount <= 0) &&
2284 (statePtr->outQueueHead == (ChannelBuffer *) NULL) &&
2285 ((statePtr->curOutPtr == (ChannelBuffer *) NULL) ||
2286 (statePtr->curOutPtr->nextAdded ==
2287 statePtr->curOutPtr->nextRemoved))) {
2326 ChannelState *statePtr; /* state of the channel stack. */
2332 statePtr = chanPtr->state;
2338 DiscardInputQueued(statePtr, 1);
2344 if (statePtr->curOutPtr != (ChannelBuffer *) NULL) {
2345 ckfree((char *) statePtr->curOutPtr);
2346 statePtr->curOutPtr = (ChannelBuffer *) NULL;
2354 if (statePtr->outQueueHead != (ChannelBuffer *) NULL) {
2363 if ((statePtr->outEofChar != 0) && (statePtr->flags & TCL_WRITABLE)) {
2367 c = (char) statePtr->outEofChar;
2393 if (chanPtr == statePtr->bottomChanPtr) {
2394 if (statePtr->channelName != (char *) NULL) {
2395 ckfree((char *) statePtr->channelName);
2396 statePtr->channelName = NULL;
2399 Tcl_FreeEncoding(statePtr->encoding);
2400 if (statePtr->outputStage != NULL) {
2401 ckfree((char *) statePtr->outputStage);
2402 statePtr->outputStage = (char *) NULL;
2411 if (statePtr->unreportedError != 0) {
2412 errorCode = statePtr->unreportedError;
2425 Tcl_DeleteTimerHandler(statePtr->timer);
2434 statePtr->nextCSPtr = tsdPtr->firstCSPtr;
2435 tsdPtr->firstCSPtr = statePtr;
2437 statePtr->topChanPtr = downChanPtr;
2454 Tcl_EventuallyFree((ClientData) statePtr, TCL_DYNAMIC);
2467 * (in that thread). This is actually the statePtr for the stack
2497 ChannelState *statePtr = ((Channel *) chan)->state;
2506 if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
2507 tsdPtr->firstCSPtr = statePtr->nextCSPtr;
2510 prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
2517 prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
2520 statePtr->nextCSPtr = (ChannelState *) NULL;
2564 ChannelState *statePtr = ((Channel *) chan)->state;
2567 if (statePtr->nextCSPtr != (ChannelState *) NULL) {
2571 statePtr->nextCSPtr = tsdPtr->firstCSPtr;
2572 tsdPtr->firstCSPtr = statePtr;
2580 statePtr->managingThread = Tcl_GetCurrentThread ();
2624 ChannelState *statePtr; /* State of real IO channel. */
2646 statePtr = chanPtr->state;
2647 chanPtr = statePtr->topChanPtr;
2649 if (statePtr->refCount > 0) {
2653 if (statePtr->flags & CHANNEL_INCLOSE) {
2661 statePtr->flags |= CHANNEL_INCLOSE;
2667 if ((statePtr->encoding != NULL) && (statePtr->curOutPtr != NULL)
2668 && (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) {
2669 statePtr->outputEncodingFlags |= TCL_ENCODING_END;
2679 while (statePtr->closeCbPtr != (CloseCallback *) NULL) {
2680 cbPtr = statePtr->closeCbPtr;
2681 statePtr->closeCbPtr = cbPtr->nextPtr;
2686 statePtr->flags &= ~CHANNEL_INCLOSE;
2692 if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
2693 (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
2694 statePtr->flags |= BUFFER_READY;
2715 statePtr->flags |= CHANNEL_CLOSED;
2748 ChannelState *statePtr; /* State of real IO channel. */
2757 statePtr = chanPtr->state;
2758 chanPtr = statePtr->topChanPtr;
2764 Tcl_DeleteTimerHandler(statePtr->timer);
2785 for (chPtr = statePtr->chPtr;
2791 statePtr->chPtr = (ChannelHandler *) NULL;
2797 StopCopy(statePtr->csPtrR);
2798 StopCopy(statePtr->csPtrW);
2807 statePtr->interestMask = 0;
2813 for (ePtr = statePtr->scriptRecordPtr;
2820 statePtr->scriptRecordPtr = (EventScriptRecord *) NULL;
2859 ChannelState *statePtr; /* state info for channel */
2861 statePtr = ((Channel *) chan)->state;
2862 chanPtr = statePtr->topChanPtr;
2864 if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
2907 ChannelState *statePtr = chanPtr->state; /* state info for channel */
2910 if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) {
2964 ChannelState *statePtr; /* state info for channel */
2966 statePtr = ((Channel *) chan)->state;
2968 if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
3009 ChannelState *statePtr; /* state info for channel */
3011 statePtr = chanPtr->state;
3012 chanPtr = statePtr->topChanPtr;
3017 if (statePtr->encoding == NULL) {
3070 ChannelState *statePtr; /* state info for channel */
3074 statePtr = ((Channel *) chan)->state;
3075 chanPtr = statePtr->topChanPtr;
3077 if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
3080 if (statePtr->encoding == NULL) {
3117 ChannelState *statePtr = chanPtr->state; /* state info for channel */
3132 bufPtr = statePtr->curOutPtr;
3134 bufPtr = AllocChannelBuffer(statePtr->bufSize);
3135 statePtr->curOutPtr = bufPtr;
3157 sawLF += TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite);
3206 ChannelState *statePtr = chanPtr->state; /* state info for channel */
3219 encoding = statePtr->encoding;
3225 endEncoding = ((statePtr->outputEncodingFlags & TCL_ENCODING_END) != 0);
3235 stage = statePtr->outputStage;
3236 stageMax = statePtr->bufSize;
3256 sawLF += TranslateOutputEOL(statePtr, stage, src, &stageLen, &toWrite);
3275 bufPtr = statePtr->curOutPtr;
3277 bufPtr = AllocChannelBuffer(statePtr->bufSize);
3278 statePtr->curOutPtr = bufPtr;
3298 statePtr->outputEncodingFlags,
3299 &statePtr->outputEncodingState, dst,
3317 statePtr->outputEncodingFlags &= ~TCL_ENCODING_START;
3425 TranslateOutputEOL(statePtr, dst, src, dstLenPtr, srcLenPtr)
3426 ChannelState *statePtr; /* Channel being read, for translation and
3445 switch (statePtr->outputTranslation) {
3538 ChannelState *statePtr = chanPtr->state; /* state info for channel */
3546 if ((statePtr->flags & BUFFER_READY) == 0) {
3548 statePtr->flags |= BUFFER_READY;
3549 } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
3551 statePtr->flags |= BUFFER_READY;
3553 } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
3554 statePtr->flags |= BUFFER_READY;
3557 if (statePtr->flags & BUFFER_READY) {
3641 ChannelState *statePtr = chanPtr->state; /* state info for channel */
3652 chanPtr = statePtr->topChanPtr;
3654 if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
3659 bufPtr = statePtr->inQueueHead;
3660 encoding = statePtr->encoding;
3668 oldFlags = statePtr->inputEncodingFlags;
3669 oldState = statePtr->inputEncodingState;
3705 inEofChar = statePtr->inEofChar;
3735 switch (statePtr->inputTranslation) {
3785 if (statePtr->flags & INPUT_SAW_CR) {
3786 statePtr->flags &= ~INPUT_SAW_CR;
3798 gs.rawRead, statePtr->inputEncodingFlags,
3826 statePtr->flags |= INPUT_SAW_CR;
3849 statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
3850 statePtr->inputEncodingFlags |= TCL_ENCODING_END;
3852 if (statePtr->flags & CHANNEL_EOF) {
3881 statePtr->inputEncodingState = gs.state;
3883 gs.rawRead, statePtr->inputEncodingFlags,
3884 &statePtr->inputEncodingState, dst,
3895 statePtr->flags &= ~CHANNEL_BLOCKED;
3906 bufPtr = statePtr->inQueueHead;
3914 statePtr->inputEncodingState = oldState;
3915 statePtr->inputEncodingFlags = oldFlags;
3929 statePtr->flags |= CHANNEL_NEED_MORE_DATA;
3971 ChannelState *statePtr = chanPtr->state; /* state info for channel */
4008 if (statePtr->flags & CHANNEL_BLOCKED) {
4009 if (statePtr->flags & CHANNEL_NONBLOCKING) {
4014 statePtr->flags &= ~CHANNEL_BLOCKED;
4021 bufPtr = statePtr->inQueueTail;
4055 gsPtr->state = statePtr->inputEncodingState;
4057 statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
4065 statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
4085 } else if (statePtr->flags & CHANNEL_EOF) {
4102 nextPtr = AllocChannelBuffer(statePtr->bufSize);
4104 statePtr->inQueueTail = nextPtr;
4148 ChannelState *statePtr = chanPtr->state; /* state info for channel */
4174 if ((statePtr->flags & CHANNEL_NONBLOCKING) == 0) {
4226 ChannelState *statePtr = chanPtr->state; /* state info for channel */
4229 bufPtr = statePtr->inQueueHead;
4235 RecycleBuffer(statePtr, bufPtr, 0);
4237 statePtr->inQueueHead = bufPtr;
4239 statePtr->inQueueTail = NULL;
4265 if (statePtr->encoding == NULL) {
4300 ChannelState *statePtr = chanPtr->state; /* state info for channel */
4306 chanPtr = statePtr->topChanPtr;
4308 if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
4345 ChannelState *statePtr = chanPtr->state; /* state info for channel */
4361 if (CheckChannelErrors(statePtr, TCL_READABLE | CHANNEL_RAW_MODE) != 0) {
4375 if (statePtr->flags & CHANNEL_EOF) {
4378 if (statePtr->flags & CHANNEL_BLOCKED) {
4379 if (statePtr->flags & CHANNEL_NONBLOCKING) {
4382 statePtr->flags &= (~(CHANNEL_BLOCKED));
4393 if ((statePtr->flags & CHANNEL_NONBLOCKING) &&
4395 !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) {
4426 statePtr->flags |= CHANNEL_BLOCKED;
4433 statePtr->flags &= ~CHANNEL_HAS_MORE_DATA;
4437 statePtr->flags |= CHANNEL_EOF;
4438 statePtr->inputEncodingFlags |= TCL_ENCODING_END;
4449 statePtr->flags |= CHANNEL_BLOCKED;
4502 ChannelState* statePtr = chanPtr->state; /* state info for channel */
4508 chanPtr = statePtr->topChanPtr;
4510 if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
4556 ChannelState *statePtr = chanPtr->state; /* state info for channel */
4566 chanPtr = statePtr->topChanPtr;
4567 encoding = statePtr->encoding;
4593 if (statePtr->inQueueHead != NULL) {
4595 copiedNow = ReadBytes(statePtr, objPtr, toRead, &offset);
4597 copiedNow = ReadChars(statePtr, objPtr, toRead, &offset,
4605 bufPtr = statePtr->inQueueHead;
4610 RecycleBuffer(statePtr, bufPtr, 0);
4611 statePtr->inQueueHead = nextPtr;
4613 statePtr->inQueueTail = NULL;
4618 if (statePtr->flags & CHANNEL_EOF) {
4621 if (statePtr->flags & CHANNEL_BLOCKED) {
4622 if (statePtr->flags & CHANNEL_NONBLOCKING) {
4625 statePtr->flags &= ~CHANNEL_BLOCKED;
4640 statePtr->flags &= ~CHANNEL_BLOCKED;
4683 ReadBytes(statePtr, objPtr, bytesToRead, offsetPtr)
4684 ChannelState *statePtr; /* State of the channel to read. */
4709 bufPtr = statePtr->inQueueHead;
4734 if (statePtr->flags & INPUT_NEED_NL) {
4735 statePtr->flags &= ~INPUT_NEED_NL;
4749 if (TranslateInputEOL(statePtr, dst, src, &dstWrote, &srcRead) != 0) {
4788 ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr)
4789 ChannelState *statePtr; /* State of channel to read. */
4822 bufPtr = statePtr->inQueueHead;
4903 if ((statePtr->inputEncodingFlags & TCL_ENCODING_END) &&
4911 statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
4915 oldState = statePtr->inputEncodingState;
4916 if (statePtr->flags & INPUT_NEED_NL) {
4921 statePtr->flags &= ~INPUT_NEED_NL;
4922 Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
4923 statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
4938 statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
4942 statePtr->inputEncodingFlags |= TCL_ENCODING_END;
4947 Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
4948 statePtr->inputEncodingFlags, &statePtr->inputEncodingState, dst,
4952 statePtr->inputEncodingFlags |= TCL_ENCODING_END;
4981 statePtr->flags |= CHANNEL_NEED_MORE_DATA;
5005 RecycleBuffer(statePtr, bufPtr, 0);
5006 statePtr->inQueueHead = nextPtr;
5007 return ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr);
5011 if (TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead) != 0) {
5022 statePtr->inputEncodingState = oldState;
5023 Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
5024 statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
5026 TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead);
5045 statePtr->inputEncodingState = oldState;
5046 Tcl_ExternalToUtf(NULL, statePtr->encoding, src, srcLen,
5047 statePtr->inputEncodingFlags, &statePtr->inputEncodingState,
5050 TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead);
5053 statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
5083 TranslateInputEOL(statePtr, dstStart, srcStart, dstLenPtr, srcLenPtr)
5084 ChannelState *statePtr; /* Channel being read, for EOL translation
5104 inEofChar = statePtr->inEofChar;
5128 switch (statePtr->inputTranslation) {
5164 statePtr->flags |= INPUT_NEED_NL;
5187 if ((statePtr->flags & INPUT_SAW_CR) && (src < srcMax)) {
5191 statePtr->flags &= ~INPUT_SAW_CR;
5197 statePtr->flags |= INPUT_SAW_CR;
5226 statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
5227 statePtr->inputEncodingFlags |= TCL_ENCODING_END;
5228 statePtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
5263 ChannelState *statePtr; /* State of actual channel. */
5268 statePtr = chanPtr->state;
5274 chanPtr = statePtr->topChanPtr;
5280 flags = statePtr->flags;
5281 if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
5285 statePtr->flags = flags;
5295 if (statePtr->flags & CHANNEL_STICKY_EOF) {
5298 statePtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
5305 if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
5307 statePtr->inQueueHead = bufPtr;
5308 statePtr->inQueueTail = bufPtr;
5311 statePtr->inQueueTail->nextPtr = bufPtr;
5312 statePtr->inQueueTail = bufPtr;
5314 bufPtr->nextPtr = statePtr->inQueueHead;
5315 statePtr->inQueueHead = bufPtr;
5351 ChannelState *statePtr = chanPtr->state; /* State of actual channel. */
5357 chanPtr = statePtr->topChanPtr;
5359 if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
5367 if ((statePtr->curOutPtr != NULL)
5368 && (statePtr->curOutPtr->nextAdded > 0)) {
5369 statePtr->flags |= BUFFER_READY;
5400 DiscardInputQueued(statePtr, discardSavedBuffers)
5401 ChannelState *statePtr; /* Channel on which to discard
5408 bufPtr = statePtr->inQueueHead;
5409 statePtr->inQueueHead = (ChannelBuffer *) NULL;
5410 statePtr->inQueueTail = (ChannelBuffer *) NULL;
5413 RecycleBuffer(statePtr, bufPtr, discardSavedBuffers);
5422 if (statePtr->saveInBufPtr != (ChannelBuffer *) NULL) {
5423 ckfree((char *) statePtr->saveInBufPtr);
5424 statePtr->saveInBufPtr = (ChannelBuffer *) NULL;
5455 ChannelState *statePtr = chanPtr->state; /* state info for channel */
5464 if (CheckForDeadChannel(NULL, statePtr)) {
5479 if (statePtr->inQueueHead != (ChannelBuffer*) NULL) {
5480 RecycleBuffer(statePtr, statePtr->inQueueHead, 0);
5481 statePtr->inQueueHead = (ChannelBuffer*) NULL;
5484 statePtr->inQueueHead = chanPtr->inQueueHead;
5485 statePtr->inQueueTail = chanPtr->inQueueTail;
5502 bufPtr = statePtr->inQueueTail;
5506 bufPtr = statePtr->saveInBufPtr;
5507 statePtr->saveInBufPtr = NULL;
5516 if ((bufPtr != NULL) && ((bufPtr->bufLength - BUFFER_PADDING) < statePtr->bufSize)) {
5522 bufPtr = AllocChannelBuffer(statePtr->bufSize);
5541 if (statePtr->inQueueTail == NULL) {
5542 statePtr->inQueueHead = bufPtr;
5544 statePtr->inQueueTail->nextPtr = bufPtr;
5546 statePtr->inQueueTail = bufPtr;
5554 if (statePtr->flags & CHANNEL_EOF) {
5565 if ((statePtr->flags & CHANNEL_NONBLOCKING) &&
5567 !(statePtr->flags & CHANNEL_HAS_MORE_DATA)) {
5593 statePtr->flags |= CHANNEL_BLOCKED;
5600 statePtr->flags &= ~CHANNEL_HAS_MORE_DATA;
5605 statePtr->flags |= CHANNEL_EOF;
5606 statePtr->inputEncodingFlags |= TCL_ENCODING_END;
5609 statePtr->flags |= CHANNEL_BLOCKED;
5644 ChannelState *statePtr = chanPtr->state; /* state info for channel */
5653 if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
5664 if (CheckForDeadChannel(NULL, statePtr)) {
5672 chanPtr = statePtr->topChanPtr;
5711 DiscardInputQueued(statePtr, 0);
5718 statePtr->flags &=
5729 if (statePtr->flags & CHANNEL_NONBLOCKING) {
5735 statePtr->flags &= (~(CHANNEL_NONBLOCKING));
5736 if (statePtr->flags & BG_FLUSH_SCHEDULED) {
5737 statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
5785 statePtr->flags |= CHANNEL_NONBLOCKING;
5820 ChannelState *statePtr = chanPtr->state; /* state info for channel */
5825 if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
5836 if (CheckForDeadChannel(NULL, statePtr)) {
5844 chanPtr = statePtr->topChanPtr;
5956 CheckChannelErrors(statePtr, flags)
5957 ChannelState *statePtr; /* Channel to check. */
5969 if (statePtr->unreportedError != 0) {
5970 Tcl_SetErrno(statePtr->unreportedError);
5971 statePtr->unreportedError = 0;
5980 if ((statePtr->flags & CHANNEL_CLOSED) &&
5990 if ((statePtr->flags & direction) == 0) {
6003 if (BUSY_STATE(statePtr,flags) && ((flags & CHANNEL_RAW_MODE) == 0)) {
6016 if ((statePtr->flags & CHANNEL_STICKY_EOF) == 0) {
6017 statePtr->flags &= ~CHANNEL_EOF;
6019 statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
6046 ChannelState *statePtr = ((Channel *) chan)->state;
6049 return ((statePtr->flags & CHANNEL_STICKY_EOF) ||
6050 ((statePtr->flags & CHANNEL_EOF) &&
6075 ChannelState *statePtr = ((Channel *) chan)->state;
6078 return (statePtr->flags & CHANNEL_BLOCKED) ? 1 : 0;
6104 ChannelState *statePtr = ((Channel *) chan)->state;
6109 for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead;
6119 for (bufPtr = statePtr->topChanPtr->inQueueHead;
6151 ChannelState *statePtr = ((Channel *) chan)->state;
6156 for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead;
6161 if ((statePtr->curOutPtr != (ChannelBuffer *) NULL) &&
6162 (statePtr->curOutPtr->nextAdded > statePtr->curOutPtr->nextRemoved)) {
6163 statePtr->flags |= BUFFER_READY;
6165 (statePtr->curOutPtr->nextAdded - statePtr->curOutPtr->nextRemoved);
6232 ChannelState *statePtr; /* State of real channel structure. */
6244 statePtr = ((Channel *) chan)->state;
6245 statePtr->bufSize = sz;
6247 if (statePtr->outputStage != NULL) {
6248 ckfree((char *) statePtr->outputStage);
6249 statePtr->outputStage = NULL;
6251 if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
6252 statePtr->outputStage = (char *)
6253 ckalloc((unsigned) (statePtr->bufSize + 2));
6279 ChannelState *statePtr = ((Channel *) chan)->state;
6282 return statePtr->bufSize;
6387 ChannelState *statePtr = chanPtr->state; /* state info for channel */
6397 if (CheckForDeadChannel(interp, statePtr)) {
6405 chanPtr = statePtr->topChanPtr;
6411 if (statePtr->csPtrR) {
6412 flags = statePtr->csPtrR->readFlags;
6413 } else if (statePtr->csPtrW) {
6414 flags = statePtr->csPtrW->writeFlags;
6416 flags = statePtr->flags;
6462 TclFormatInt(optionVal, statePtr->bufSize);
6474 if (statePtr->encoding == NULL) {
6478 Tcl_GetEncodingName(statePtr->encoding));
6495 if (statePtr->inEofChar == 0) {
6500 sprintf(buf, "%c", statePtr->inEofChar);
6505 if (statePtr->outEofChar == 0) {
6510 sprintf(buf, "%c", statePtr->outEofChar);
6537 if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) {
6539 } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
6541 } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) {
6548 if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) {
6550 } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) {
6552 } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) {
6616 ChannelState *statePtr = chanPtr->state; /* state info for channel */
6625 if (statePtr->csPtrR || statePtr->csPtrW) {
6641 if (CheckForDeadChannel(NULL, statePtr)) {
6649 chanPtr = statePtr->topChanPtr;
6669 statePtr->flags &=
6673 statePtr->flags &= (~(CHANNEL_UNBUFFERED));
6674 statePtr->flags |= CHANNEL_LINEBUFFERED;
6677 statePtr->flags &= (~(CHANNEL_LINEBUFFERED));
6678 statePtr->flags |= CHANNEL_UNBUFFERED;
6711 if ((statePtr->encoding != NULL) && (statePtr->curOutPtr != NULL)
6712 && (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) {
6713 statePtr->outputEncodingFlags |= TCL_ENCODING_END;
6716 Tcl_FreeEncoding(statePtr->encoding);
6717 statePtr->encoding = encoding;
6718 statePtr->inputEncodingState = NULL;
6719 statePtr->inputEncodingFlags = TCL_ENCODING_START;
6720 statePtr->outputEncodingState = NULL;
6721 statePtr->outputEncodingFlags = TCL_ENCODING_START;
6722 statePtr->flags &= ~CHANNEL_NEED_MORE_DATA;
6730 statePtr->inEofChar = 0;
6731 statePtr->outEofChar = 0;
6733 if (statePtr->flags & TCL_WRITABLE) {
6734 statePtr->outEofChar = (int) argv[0][0];
6736 if (statePtr->flags & TCL_READABLE) {
6737 statePtr->inEofChar = (int) argv[0][0];
6748 if (statePtr->flags & TCL_READABLE) {
6749 statePtr->inEofChar = (int) argv[0][0];
6751 if (statePtr->flags & TCL_WRITABLE) {
6752 statePtr->outEofChar = (int) argv[1][0];
6765 statePtr->flags &= (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED));
6777 readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
6778 writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[0] : NULL;
6780 readMode = (statePtr->flags & TCL_READABLE) ? argv[0] : NULL;
6781 writeMode = (statePtr->flags & TCL_WRITABLE) ? argv[1] : NULL;
6795 translation = statePtr->inputTranslation;
6800 statePtr->inEofChar = 0;
6801 Tcl_FreeEncoding(statePtr->encoding);
6802 statePtr->encoding = NULL;
6828 if (translation != statePtr->inputTranslation) {
6829 statePtr->inputTranslation = translation;
6830 statePtr->flags &= ~(INPUT_SAW_CR);
6831 statePtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
6847 statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
6849 statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
6852 statePtr->outEofChar = 0;
6853 statePtr->outputTranslation = TCL_TRANSLATE_LF;
6854 Tcl_FreeEncoding(statePtr->encoding);
6855 statePtr->encoding = NULL;
6857 statePtr->outputTranslation = TCL_TRANSLATE_LF;
6859 statePtr->outputTranslation = TCL_TRANSLATE_CR;
6861 statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
6863 statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
6888 if (statePtr->saveInBufPtr != NULL) {
6889 RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1);
6890 statePtr->saveInBufPtr = NULL;
6892 if (statePtr->inQueueHead != NULL) {
6893 if ((statePtr->inQueueHead->nextPtr == NULL)
6894 && (statePtr->inQueueHead->nextAdded ==
6895 statePtr->inQueueHead->nextRemoved)) {
6896 RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
6897 statePtr->inQueueHead = NULL;
6898 statePtr->inQueueTail = NULL;
6906 if (statePtr->outputStage != NULL) {
6907 ckfree((char *) statePtr->outputStage);
6908 statePtr->outputStage = NULL;
6910 if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
6911 statePtr->outputStage = (char *)
6912 ckalloc((unsigned) (statePtr->bufSize + 2));
6943 ChannelState *statePtr = chanPtr->state; /* state info for channel */
6951 for (sPtr = statePtr->scriptRecordPtr,
6958 statePtr->scriptRecordPtr = nextPtr;
7002 ChannelState *statePtr = chanPtr->state; /* state info for channel */
7017 (statePtr->flags & CHANNEL_NONBLOCKING) &&
7019 !(statePtr->flags & CHANNEL_TIMER_FEV)) {
7021 statePtr->flags |= CHANNEL_HAS_MORE_DATA;
7075 Tcl_Preserve((ClientData) statePtr);
7084 if ((statePtr->flags & BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
7098 for (chPtr = statePtr->chPtr; chPtr != (ChannelHandler *) NULL; ) {
7123 Tcl_Release((ClientData) statePtr);
7151 ChannelState *statePtr = chanPtr->state; /* state info for channel */
7152 int mask = statePtr->interestMask;
7159 if (statePtr->flags & BG_FLUSH_SCHEDULED) {
7171 if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
7172 && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
7173 && (statePtr->inQueueHead->nextRemoved <
7174 statePtr->inQueueHead->nextAdded)) {
7219 if (!statePtr->timer) {
7220 statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
7251 ChannelState *statePtr = chanPtr->state; /* state info for channel */
7253 if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
7254 && (statePtr->interestMask & TCL_READABLE)
7255 && (statePtr->inQueueHead != (ChannelBuffer *) NULL)
7256 && (statePtr->inQueueHead->nextRemoved <
7257 statePtr->inQueueHead->nextAdded)) {
7263 statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
7274 if ((statePtr->flags & CHANNEL_NONBLOCKING) &&
7276 statePtr->flags |= CHANNEL_TIMER_FEV;
7280 Tcl_Preserve((ClientData) statePtr);
7284 statePtr->flags &= ~CHANNEL_TIMER_FEV;
7287 Tcl_Release((ClientData) statePtr);
7289 statePtr->timer = NULL;
7331 ChannelState *statePtr = chanPtr->state; /* state info for channel */
7339 for (chPtr = statePtr->chPtr;
7353 chPtr->nextPtr = statePtr->chPtr;
7354 statePtr->chPtr = chPtr;
7370 statePtr->interestMask = 0;
7371 for (chPtr = statePtr->chPtr;
7374 statePtr->interestMask |= chPtr->mask;
7377 UpdateInterest(statePtr->topChanPtr);
7412 ChannelState *statePtr = chanPtr->state; /* state info for channel */
7419 for (prevChPtr = (ChannelHandler *) NULL, chPtr = statePtr->chPtr;
7455 statePtr->chPtr = chPtr->nextPtr;
7467 statePtr->interestMask = 0;
7468 for (chPtr = statePtr->chPtr;
7471 statePtr->interestMask |= chPtr->mask;
7474 UpdateInterest(statePtr->topChanPtr);
7504 ChannelState *statePtr = chanPtr->state; /* state info for channel */
7507 for (esPtr = statePtr->scriptRecordPtr,
7512 if (esPtr == statePtr->scriptRecordPtr) {
7513 statePtr->scriptRecordPtr = esPtr->nextPtr;
7557 ChannelState *statePtr = chanPtr->state; /* state info for channel */
7560 for (esPtr = statePtr->scriptRecordPtr;
7574 esPtr->nextPtr = statePtr->scriptRecordPtr;
7575 statePtr->scriptRecordPtr = esPtr;
7678 ChannelState *statePtr; /* state info for channel */
7702 statePtr = chanPtr->state;
7703 if ((statePtr->flags & mask) == 0) {
7716 for (esPtr = statePtr->scriptRecordPtr;
8185 ChannelState *statePtr = chanPtr->state; /* state info for channel */
8198 if (!(statePtr->flags & CHANNEL_STICKY_EOF)) {
8199 statePtr->flags &= ~CHANNEL_EOF;
8201 statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA);
8204 copiedNow = CopyAndTranslateBuffer(statePtr, bufPtr + copied,
8207 if (statePtr->flags & CHANNEL_EOF) {
8210 if (statePtr->flags & CHANNEL_BLOCKED) {
8211 if (statePtr->flags & CHANNEL_NONBLOCKING) {
8214 statePtr->flags &= (~(CHANNEL_BLOCKED));
8226 statePtr->flags &= (~(CHANNEL_BLOCKED));
8259 CopyAndTranslateBuffer(statePtr, result, space)
8260 ChannelState *statePtr; /* Channel state from which to read input. */
8280 if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
8283 bufPtr = statePtr->inQueueHead;
8287 switch (statePtr->inputTranslation) {
8344 if ((statePtr->flags & (INPUT_SAW_CR | CHANNEL_EOF)) ==
8347 statePtr->flags &= ~INPUT_SAW_CR;
8372 statePtr->flags &= ~INPUT_SAW_CR;
8373 } else if (statePtr->flags & INPUT_SAW_CR) {
8374 statePtr->flags &= ~INPUT_SAW_CR;
8379 statePtr->flags |= INPUT_SAW_CR;
8415 statePtr->flags |= INPUT_SAW_CR;
8420 !(statePtr->flags & INPUT_SAW_CR)) {
8424 statePtr->flags &= ~INPUT_SAW_CR;
8441 if (statePtr->inEofChar != 0) {
8443 if (result[i] == (char) statePtr->inEofChar) {
8449 statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
8450 statePtr->inputEncodingFlags |= TCL_ENCODING_END;
8462 statePtr->inQueueHead = bufPtr->nextPtr;
8463 if (statePtr->inQueueHead == (ChannelBuffer *) NULL) {
8464 statePtr->inQueueTail = (ChannelBuffer *) NULL;
8466 RecycleBuffer(statePtr, bufPtr, 0);
8599 ChannelState *statePtr = chanPtr->state; /* state info for channel */
8639 if (statePtr->curOutPtr == (ChannelBuffer *) NULL) {
8640 statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize);
8643 outBufPtr = statePtr->curOutPtr;
8651 switch (statePtr->outputTranslation) {
8696 if (!(statePtr->flags & BUFFER_READY)) {
8698 statePtr->flags |= BUFFER_READY;
8699 } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
8709 statePtr->flags |= BUFFER_READY;
8711 } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
8712 statePtr->flags |= BUFFER_READY;
8720 if (statePtr->flags & BUFFER_READY) {
8896 ChannelState *statePtr = chanPtr->state; /* state info for channel */
8908 statePtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
8910 statePtr->flags |= CHANNEL_NONBLOCKING;
8964 ChannelState *statePtr;
8986 statePtr = ((Channel *) Tcl_GetHashValue(hPtr))->state;
8987 if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
8989 } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
8991 } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) {
8996 * but it's simpler to just grab the name from the statePtr.
8998 name = statePtr->channelName;
9036 ChannelState *statePtr; /* State of the real channel. */
9043 statePtr = chanPtr->state;
9049 hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
9081 ChannelState *statePtr = ((Channel *) chan)->state;
9084 return ((statePtr->refCount > 1) ? 1 : 0);
9110 ChannelState *statePtr;
9116 for (statePtr = tsdPtr->firstCSPtr;
9117 statePtr != NULL;
9118 statePtr = statePtr->nextCSPtr) {
9119 if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
9121 } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
9123 } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) {
9126 name = statePtr->channelName;