Parent Directory | Revision Log
Set EOL properties appropriately to facilitate simultaneous Linux and Windows development.
1 | /* $Header$ */ |
2 | /* |
3 | * tclIO.c -- |
4 | * |
5 | * This file provides the generic portions (those that are the same on |
6 | * all platforms and for all channel types) of Tcl's IO facilities. |
7 | * |
8 | * Copyright (c) 1998 Scriptics Corporation |
9 | * Copyright (c) 1995-1997 Sun Microsystems, Inc. |
10 | * |
11 | * See the file "license.terms" for information on usage and redistribution |
12 | * of this file, and for a DISCLAIMER OF ALL WARRANTIES. |
13 | * |
14 | * RCS: @(#) $Id: tclio.c,v 1.1.1.1 2001/06/13 04:42:01 dtashley Exp $ |
15 | */ |
16 | |
17 | #include "tclInt.h" |
18 | #include "tclPort.h" |
19 | |
20 | /* |
21 | * Make sure that both EAGAIN and EWOULDBLOCK are defined. This does not |
22 | * compile on systems where neither is defined. We want both defined so |
23 | * that we can test safely for both. In the code we still have to test for |
24 | * both because there may be systems on which both are defined and have |
25 | * different values. |
26 | */ |
27 | |
28 | #if ((!defined(EWOULDBLOCK)) && (defined(EAGAIN))) |
29 | # define EWOULDBLOCK EAGAIN |
30 | #endif |
31 | #if ((!defined(EAGAIN)) && (defined(EWOULDBLOCK))) |
32 | # define EAGAIN EWOULDBLOCK |
33 | #endif |
34 | #if ((!defined(EAGAIN)) && (!defined(EWOULDBLOCK))) |
35 | error one of EWOULDBLOCK or EAGAIN must be defined |
36 | #endif |
37 | |
38 | /* |
39 | * The following structure encapsulates the state for a background channel |
40 | * copy. Note that the data buffer for the copy will be appended to this |
41 | * structure. |
42 | */ |
43 | |
44 | typedef struct CopyState { |
45 | struct Channel *readPtr; /* Pointer to input channel. */ |
46 | struct Channel *writePtr; /* Pointer to output channel. */ |
47 | int readFlags; /* Original read channel flags. */ |
48 | int writeFlags; /* Original write channel flags. */ |
49 | int toRead; /* Number of bytes to copy, or -1. */ |
50 | int total; /* Total bytes transferred (written). */ |
51 | Tcl_Interp *interp; /* Interp that started the copy. */ |
52 | Tcl_Obj *cmdPtr; /* Command to be invoked at completion. */ |
53 | int bufSize; /* Size of appended buffer. */ |
54 | char buffer[1]; /* Copy buffer, this must be the last |
55 | * field. */ |
56 | } CopyState; |
57 | |
58 | /* |
59 | * struct ChannelBuffer: |
60 | * |
61 | * Buffers data being sent to or from a channel. |
62 | */ |
63 | |
64 | typedef struct ChannelBuffer { |
65 | int nextAdded; /* The next position into which a character |
66 | * will be put in the buffer. */ |
67 | int nextRemoved; /* Position of next byte to be removed |
68 | * from the buffer. */ |
69 | int bufLength; /* How big is the buffer? */ |
70 | struct ChannelBuffer *nextPtr; |
71 | /* Next buffer in chain. */ |
72 | char buf[4]; /* Placeholder for real buffer. The real |
73 | * buffer occuppies this space + bufSize-4 |
74 | * bytes. This must be the last field in |
75 | * the structure. */ |
76 | } ChannelBuffer; |
77 | |
78 | #define CHANNELBUFFER_HEADER_SIZE (sizeof(ChannelBuffer) - 4) |
79 | |
80 | /* |
81 | * How much extra space to allocate in buffer to hold bytes from previous |
82 | * buffer (when converting to UTF-8) or to hold bytes that will go to |
83 | * next buffer (when converting from UTF-8). |
84 | */ |
85 | |
86 | #define BUFFER_PADDING 16 |
87 | |
88 | /* |
89 | * The following defines the *default* buffer size for channels. |
90 | */ |
91 | |
92 | #define CHANNELBUFFER_DEFAULT_SIZE (1024 * 4) |
93 | |
94 | /* |
95 | * Structure to record a close callback. One such record exists for |
96 | * each close callback registered for a channel. |
97 | */ |
98 | |
99 | typedef struct CloseCallback { |
100 | Tcl_CloseProc *proc; /* The procedure to call. */ |
101 | ClientData clientData; /* Arbitrary one-word data to pass |
102 | * to the callback. */ |
103 | struct CloseCallback *nextPtr; /* For chaining close callbacks. */ |
104 | } CloseCallback; |
105 | |
106 | /* |
107 | * The following structure describes the information saved from a call to |
108 | * "fileevent". This is used later when the event being waited for to |
109 | * invoke the saved script in the interpreter designed in this record. |
110 | */ |
111 | |
112 | typedef struct EventScriptRecord { |
113 | struct Channel *chanPtr; /* The channel for which this script is |
114 | * registered. This is used only when an |
115 | * error occurs during evaluation of the |
116 | * script, to delete the handler. */ |
117 | Tcl_Obj *scriptPtr; /* Script to invoke. */ |
118 | Tcl_Interp *interp; /* In what interpreter to invoke script? */ |
119 | int mask; /* Events must overlap current mask for the |
120 | * stored script to be invoked. */ |
121 | struct EventScriptRecord *nextPtr; |
122 | /* Next in chain of records. */ |
123 | } EventScriptRecord; |
124 | |
125 | /* |
126 | * struct Channel: |
127 | * |
128 | * One of these structures is allocated for each open channel. It contains data |
129 | * specific to the channel but which belongs to the generic part of the Tcl |
130 | * channel mechanism, and it points at an instance specific (and type |
131 | * specific) * instance data, and at a channel type structure. |
132 | */ |
133 | |
134 | typedef struct Channel { |
135 | char *channelName; /* The name of the channel instance in Tcl |
136 | * commands. Storage is owned by the generic IO |
137 | * code, is dynamically allocated. */ |
138 | int flags; /* ORed combination of the flags defined |
139 | * below. */ |
140 | Tcl_Encoding encoding; /* Encoding to apply when reading or writing |
141 | * data on this channel. NULL means no |
142 | * encoding is applied to data. */ |
143 | Tcl_EncodingState inputEncodingState; |
144 | /* Current encoding state, used when converting |
145 | * input data bytes to UTF-8. */ |
146 | int inputEncodingFlags; /* Encoding flags to pass to conversion |
147 | * routine when converting input data bytes to |
148 | * UTF-8. May be TCL_ENCODING_START before |
149 | * converting first byte and TCL_ENCODING_END |
150 | * when EOF is seen. */ |
151 | Tcl_EncodingState outputEncodingState; |
152 | /* Current encoding state, used when converting |
153 | * UTF-8 to output data bytes. */ |
154 | int outputEncodingFlags; /* Encoding flags to pass to conversion |
155 | * routine when converting UTF-8 to output |
156 | * data bytes. May be TCL_ENCODING_START |
157 | * before converting first byte and |
158 | * TCL_ENCODING_END when EOF is seen. */ |
159 | Tcl_EolTranslation inputTranslation; |
160 | /* What translation to apply for end of line |
161 | * sequences on input? */ |
162 | Tcl_EolTranslation outputTranslation; |
163 | /* What translation to use for generating |
164 | * end of line sequences in output? */ |
165 | int inEofChar; /* If nonzero, use this as a signal of EOF |
166 | * on input. */ |
167 | int outEofChar; /* If nonzero, append this to the channel |
168 | * when it is closed if it is open for |
169 | * writing. */ |
170 | int unreportedError; /* Non-zero if an error report was deferred |
171 | * because it happened in the background. The |
172 | * value is the POSIX error code. */ |
173 | ClientData instanceData; /* Instance-specific data provided by |
174 | * creator of channel. */ |
175 | |
176 | Tcl_ChannelType *typePtr; /* Pointer to channel type structure. */ |
177 | int refCount; /* How many interpreters hold references to |
178 | * this IO channel? */ |
179 | CloseCallback *closeCbPtr; /* Callbacks registered to be called when the |
180 | * channel is closed. */ |
181 | char *outputStage; /* Temporary staging buffer used when |
182 | * translating EOL before converting from |
183 | * UTF-8 to external form. */ |
184 | ChannelBuffer *curOutPtr; /* Current output buffer being filled. */ |
185 | ChannelBuffer *outQueueHead;/* Points at first buffer in output queue. */ |
186 | ChannelBuffer *outQueueTail;/* Points at last buffer in output queue. */ |
187 | |
188 | ChannelBuffer *saveInBufPtr;/* Buffer saved for input queue - eliminates |
189 | * need to allocate a new buffer for "gets" |
190 | * that crosses buffer boundaries. */ |
191 | ChannelBuffer *inQueueHead; /* Points at first buffer in input queue. */ |
192 | ChannelBuffer *inQueueTail; /* Points at last buffer in input queue. */ |
193 | |
194 | struct ChannelHandler *chPtr;/* List of channel handlers registered |
195 | * for this channel. */ |
196 | int interestMask; /* Mask of all events this channel has |
197 | * handlers for. */ |
198 | struct Channel *nextChanPtr;/* Next in list of channels currently open. */ |
199 | EventScriptRecord *scriptRecordPtr; |
200 | /* Chain of all scripts registered for |
201 | * event handlers ("fileevent") on this |
202 | * channel. */ |
203 | int bufSize; /* What size buffers to allocate? */ |
204 | Tcl_TimerToken timer; /* Handle to wakeup timer for this channel. */ |
205 | CopyState *csPtr; /* State of background copy, or NULL. */ |
206 | struct Channel* supercedes; /* Refers to channel this one was stacked upon. |
207 | This reference is NULL for normal channels. |
208 | See Tcl_StackChannel. */ |
209 | |
210 | } Channel; |
211 | |
212 | /* |
213 | * Values for the flags field in Channel. Any ORed combination of the |
214 | * following flags can be stored in the field. These flags record various |
215 | * options and state bits about the channel. In addition to the flags below, |
216 | * the channel can also have TCL_READABLE (1<<1) and TCL_WRITABLE (1<<2) set. |
217 | */ |
218 | |
219 | #define CHANNEL_NONBLOCKING (1<<3) /* Channel is currently in |
220 | * nonblocking mode. */ |
221 | #define CHANNEL_LINEBUFFERED (1<<4) /* Output to the channel must be |
222 | * flushed after every newline. */ |
223 | #define CHANNEL_UNBUFFERED (1<<5) /* Output to the channel must always |
224 | * be flushed immediately. */ |
225 | #define BUFFER_READY (1<<6) /* Current output buffer (the |
226 | * curOutPtr field in the |
227 | * channel structure) should be |
228 | * output as soon as possible even |
229 | * though it may not be full. */ |
230 | #define BG_FLUSH_SCHEDULED (1<<7) /* A background flush of the |
231 | * queued output buffers has been |
232 | * scheduled. */ |
233 | #define CHANNEL_CLOSED (1<<8) /* Channel has been closed. No |
234 | * further Tcl-level IO on the |
235 | * channel is allowed. */ |
236 | #define CHANNEL_EOF (1<<9) /* EOF occurred on this channel. |
237 | * This bit is cleared before every |
238 | * input operation. */ |
239 | #define CHANNEL_STICKY_EOF (1<<10) /* EOF occurred on this channel because |
240 | * we saw the input eofChar. This bit |
241 | * prevents clearing of the EOF bit |
242 | * before every input operation. */ |
243 | #define CHANNEL_BLOCKED (1<<11) /* EWOULDBLOCK or EAGAIN occurred |
244 | * on this channel. This bit is |
245 | * cleared before every input or |
246 | * output operation. */ |
247 | #define INPUT_SAW_CR (1<<12) /* Channel is in CRLF eol input |
248 | * translation mode and the last |
249 | * byte seen was a "\r". */ |
250 | #define INPUT_NEED_NL (1<<15) /* Saw a '\r' at end of last buffer, |
251 | * and there should be a '\n' at |
252 | * beginning of next buffer. */ |
253 | #define CHANNEL_DEAD (1<<13) /* The channel has been closed by |
254 | * the exit handler (on exit) but |
255 | * not deallocated. When any IO |
256 | * operation sees this flag on a |
257 | * channel, it does not call driver |
258 | * level functions to avoid referring |
259 | * to deallocated data. */ |
260 | #define CHANNEL_NEED_MORE_DATA (1<<14) /* The last input operation failed |
261 | * because there was not enough data |
262 | * to complete the operation. This |
263 | * flag is set when gets fails to |
264 | * get a complete line or when read |
265 | * fails to get a complete character. |
266 | * When set, file events will not be |
267 | * delivered for buffered data until |
268 | * the state of the channel changes. */ |
269 | |
270 | /* |
271 | * For each channel handler registered in a call to Tcl_CreateChannelHandler, |
272 | * there is one record of the following type. All of records for a specific |
273 | * channel are chained together in a singly linked list which is stored in |
274 | * the channel structure. |
275 | */ |
276 | |
277 | typedef struct ChannelHandler { |
278 | Channel *chanPtr; /* The channel structure for this channel. */ |
279 | int mask; /* Mask of desired events. */ |
280 | Tcl_ChannelProc *proc; /* Procedure to call in the type of |
281 | * Tcl_CreateChannelHandler. */ |
282 | ClientData clientData; /* Argument to pass to procedure. */ |
283 | struct ChannelHandler *nextPtr; |
284 | /* Next one in list of registered handlers. */ |
285 | } ChannelHandler; |
286 | |
287 | /* |
288 | * This structure keeps track of the current ChannelHandler being invoked in |
289 | * the current invocation of ChannelHandlerEventProc. There is a potential |
290 | * problem if a ChannelHandler is deleted while it is the current one, since |
291 | * ChannelHandlerEventProc needs to look at the nextPtr field. To handle this |
292 | * problem, structures of the type below indicate the next handler to be |
293 | * processed for any (recursively nested) dispatches in progress. The |
294 | * nextHandlerPtr field is updated if the handler being pointed to is deleted. |
295 | * The nextPtr field is used to chain together all recursive invocations, so |
296 | * that Tcl_DeleteChannelHandler can find all the recursively nested |
297 | * invocations of ChannelHandlerEventProc and compare the handler being |
298 | * deleted against the NEXT handler to be invoked in that invocation; when it |
299 | * finds such a situation, Tcl_DeleteChannelHandler updates the nextHandlerPtr |
300 | * field of the structure to the next handler. |
301 | */ |
302 | |
303 | typedef struct NextChannelHandler { |
304 | ChannelHandler *nextHandlerPtr; /* The next handler to be invoked in |
305 | * this invocation. */ |
306 | struct NextChannelHandler *nestedHandlerPtr; |
307 | /* Next nested invocation of |
308 | * ChannelHandlerEventProc. */ |
309 | } NextChannelHandler; |
310 | |
311 | |
312 | /* |
313 | * The following structure describes the event that is added to the Tcl |
314 | * event queue by the channel handler check procedure. |
315 | */ |
316 | |
317 | typedef struct ChannelHandlerEvent { |
318 | Tcl_Event header; /* Standard header for all events. */ |
319 | Channel *chanPtr; /* The channel that is ready. */ |
320 | int readyMask; /* Events that have occurred. */ |
321 | } ChannelHandlerEvent; |
322 | |
323 | /* |
324 | * The following structure is used by Tcl_GetsObj() to encapsulates the |
325 | * state for a "gets" operation. |
326 | */ |
327 | |
328 | typedef struct GetsState { |
329 | Tcl_Obj *objPtr; /* The object to which UTF-8 characters |
330 | * will be appended. */ |
331 | char **dstPtr; /* Pointer into objPtr's string rep where |
332 | * next character should be stored. */ |
333 | Tcl_Encoding encoding; /* The encoding to use to convert raw bytes |
334 | * to UTF-8. */ |
335 | ChannelBuffer *bufPtr; /* The current buffer of raw bytes being |
336 | * emptied. */ |
337 | Tcl_EncodingState state; /* The encoding state just before the last |
338 | * external to UTF-8 conversion in |
339 | * FilterInputBytes(). */ |
340 | int rawRead; /* The number of bytes removed from bufPtr |
341 | * in the last call to FilterInputBytes(). */ |
342 | int bytesWrote; /* The number of bytes of UTF-8 data |
343 | * appended to objPtr during the last call to |
344 | * FilterInputBytes(). */ |
345 | int charsWrote; /* The corresponding number of UTF-8 |
346 | * characters appended to objPtr during the |
347 | * last call to FilterInputBytes(). */ |
348 | int totalChars; /* The total number of UTF-8 characters |
349 | * appended to objPtr so far, just before the |
350 | * last call to FilterInputBytes(). */ |
351 | } GetsState; |
352 | |
353 | /* |
354 | * All static variables used in this file are collected into a single |
355 | * instance of the following structure. For multi-threaded implementations, |
356 | * there is one instance of this structure for each thread. |
357 | * |
358 | * Notice that different structures with the same name appear in other |
359 | * files. The structure defined below is used in this file only. |
360 | */ |
361 | |
362 | typedef struct ThreadSpecificData { |
363 | |
364 | /* |
365 | * This variable holds the list of nested ChannelHandlerEventProc |
366 | * invocations. |
367 | */ |
368 | NextChannelHandler *nestedHandlerPtr; |
369 | |
370 | /* |
371 | * List of all channels currently open. |
372 | */ |
373 | Channel *firstChanPtr; |
374 | #ifdef oldcode |
375 | /* |
376 | * Has a channel exit handler been created yet? |
377 | */ |
378 | int channelExitHandlerCreated; |
379 | |
380 | /* |
381 | * Has the channel event source been created and registered with the |
382 | * notifier? |
383 | */ |
384 | int channelEventSourceCreated; |
385 | #endif |
386 | /* |
387 | * Static variables to hold channels for stdin, stdout and stderr. |
388 | */ |
389 | Tcl_Channel stdinChannel; |
390 | int stdinInitialized; |
391 | Tcl_Channel stdoutChannel; |
392 | int stdoutInitialized; |
393 | Tcl_Channel stderrChannel; |
394 | int stderrInitialized; |
395 | |
396 | } ThreadSpecificData; |
397 | |
398 | static Tcl_ThreadDataKey dataKey; |
399 | |
400 | |
401 | /* |
402 | * Static functions in this file: |
403 | */ |
404 | |
405 | static ChannelBuffer * AllocChannelBuffer _ANSI_ARGS_((int length)); |
406 | static void ChannelEventScriptInvoker _ANSI_ARGS_(( |
407 | ClientData clientData, int flags)); |
408 | static void ChannelTimerProc _ANSI_ARGS_(( |
409 | ClientData clientData)); |
410 | static int CheckChannelErrors _ANSI_ARGS_((Channel *chanPtr, |
411 | int direction)); |
412 | static int CheckFlush _ANSI_ARGS_((Channel *chanPtr, |
413 | ChannelBuffer *bufPtr, int newlineFlag)); |
414 | static int CheckForDeadChannel _ANSI_ARGS_((Tcl_Interp *interp, |
415 | Channel *chan)); |
416 | static void CheckForStdChannelsBeingClosed _ANSI_ARGS_(( |
417 | Tcl_Channel chan)); |
418 | static void CleanupChannelHandlers _ANSI_ARGS_(( |
419 | Tcl_Interp *interp, Channel *chanPtr)); |
420 | static int CloseChannel _ANSI_ARGS_((Tcl_Interp *interp, |
421 | Channel *chanPtr, int errorCode)); |
422 | static void CommonGetsCleanup _ANSI_ARGS_((Channel *chanPtr, |
423 | Tcl_Encoding encoding)); |
424 | static int CopyAndTranslateBuffer _ANSI_ARGS_(( |
425 | Channel *chanPtr, char *result, int space)); |
426 | static int CopyData _ANSI_ARGS_((CopyState *csPtr, int mask)); |
427 | static void CopyEventProc _ANSI_ARGS_((ClientData clientData, |
428 | int mask)); |
429 | static void CreateScriptRecord _ANSI_ARGS_(( |
430 | Tcl_Interp *interp, Channel *chanPtr, |
431 | int mask, Tcl_Obj *scriptPtr)); |
432 | static void DeleteChannelTable _ANSI_ARGS_(( |
433 | ClientData clientData, Tcl_Interp *interp)); |
434 | static void DeleteScriptRecord _ANSI_ARGS_((Tcl_Interp *interp, |
435 | Channel *chanPtr, int mask)); |
436 | static void DiscardInputQueued _ANSI_ARGS_(( |
437 | Channel *chanPtr, int discardSavedBuffers)); |
438 | static void DiscardOutputQueued _ANSI_ARGS_(( |
439 | Channel *chanPtr)); |
440 | static int DoRead _ANSI_ARGS_((Channel *chanPtr, char *srcPtr, |
441 | int slen)); |
442 | static int DoWrite _ANSI_ARGS_((Channel *chanPtr, char *src, |
443 | int srcLen)); |
444 | static int FilterInputBytes _ANSI_ARGS_((Channel *chanPtr, |
445 | GetsState *statePtr)); |
446 | static int FlushChannel _ANSI_ARGS_((Tcl_Interp *interp, |
447 | Channel *chanPtr, int calledFromAsyncFlush)); |
448 | static Tcl_HashTable * GetChannelTable _ANSI_ARGS_((Tcl_Interp *interp)); |
449 | static int GetInput _ANSI_ARGS_((Channel *chanPtr)); |
450 | static void PeekAhead _ANSI_ARGS_((Channel *chanPtr, |
451 | char **dstEndPtr, GetsState *gsPtr)); |
452 | static int ReadBytes _ANSI_ARGS_((Channel *chanPtr, |
453 | Tcl_Obj *objPtr, int charsLeft, int *offsetPtr)); |
454 | static int ReadChars _ANSI_ARGS_((Channel *chanPtr, |
455 | Tcl_Obj *objPtr, int charsLeft, int *offsetPtr, |
456 | int *factorPtr)); |
457 | static void RecycleBuffer _ANSI_ARGS_((Channel *chanPtr, |
458 | ChannelBuffer *bufPtr, int mustDiscard)); |
459 | static int SetBlockMode _ANSI_ARGS_((Tcl_Interp *interp, |
460 | Channel *chanPtr, int mode)); |
461 | static void StopCopy _ANSI_ARGS_((CopyState *csPtr)); |
462 | static int TranslateInputEOL _ANSI_ARGS_((Channel *chanPtr, |
463 | char *dst, CONST char *src, int *dstLenPtr, |
464 | int *srcLenPtr)); |
465 | static int TranslateOutputEOL _ANSI_ARGS_((Channel *chanPtr, |
466 | char *dst, CONST char *src, int *dstLenPtr, |
467 | int *srcLenPtr)); |
468 | static void UpdateInterest _ANSI_ARGS_((Channel *chanPtr)); |
469 | static int WriteBytes _ANSI_ARGS_((Channel *chanPtr, |
470 | CONST char *src, int srcLen)); |
471 | static int WriteChars _ANSI_ARGS_((Channel *chanPtr, |
472 | CONST char *src, int srcLen)); |
473 | |
474 | |
475 | /* |
476 | *--------------------------------------------------------------------------- |
477 | * |
478 | * TclInitIOSubsystem -- |
479 | * |
480 | * Initialize all resources used by this subsystem on a per-process |
481 | * basis. |
482 | * |
483 | * Results: |
484 | * None. |
485 | * |
486 | * Side effects: |
487 | * Depends on the memory subsystems. |
488 | * |
489 | *--------------------------------------------------------------------------- |
490 | */ |
491 | |
492 | void |
493 | TclInitIOSubsystem() |
494 | { |
495 | /* |
496 | * By fetching thread local storage we take care of |
497 | * allocating it for each thread. |
498 | */ |
499 | (void) TCL_TSD_INIT(&dataKey); |
500 | } |
501 | |
502 | /* |
503 | *------------------------------------------------------------------------- |
504 | * |
505 | * TclFinalizeIOSubsystem -- |
506 | * |
507 | * Releases all resources used by this subsystem on a per-process |
508 | * basis. Closes all extant channels that have not already been |
509 | * closed because they were not owned by any interp. |
510 | * |
511 | * Results: |
512 | * None. |
513 | * |
514 | * Side effects: |
515 | * Depends on encoding and memory subsystems. |
516 | * |
517 | *------------------------------------------------------------------------- |
518 | */ |
519 | |
520 | /* ARGSUSED */ |
521 | void |
522 | TclFinalizeIOSubsystem() |
523 | { |
524 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
525 | Channel *chanPtr; /* Iterates over open channels. */ |
526 | Channel *nextChanPtr; /* Iterates over open channels. */ |
527 | |
528 | |
529 | for (chanPtr = tsdPtr->firstChanPtr; chanPtr != (Channel *) NULL; |
530 | chanPtr = nextChanPtr) { |
531 | nextChanPtr = chanPtr->nextChanPtr; |
532 | |
533 | /* |
534 | * Set the channel back into blocking mode to ensure that we wait |
535 | * for all data to flush out. |
536 | */ |
537 | |
538 | (void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr, |
539 | "-blocking", "on"); |
540 | |
541 | if ((chanPtr == (Channel *) tsdPtr->stdinChannel) || |
542 | (chanPtr == (Channel *) tsdPtr->stdoutChannel) || |
543 | (chanPtr == (Channel *) tsdPtr->stderrChannel)) { |
544 | |
545 | /* |
546 | * Decrement the refcount which was earlier artificially bumped |
547 | * up to keep the channel from being closed. |
548 | */ |
549 | |
550 | chanPtr->refCount--; |
551 | } |
552 | |
553 | if (chanPtr->refCount <= 0) { |
554 | |
555 | /* |
556 | * Close it only if the refcount indicates that the channel is not |
557 | * referenced from any interpreter. If it is, that interpreter will |
558 | * close the channel when it gets destroyed. |
559 | */ |
560 | |
561 | (void) Tcl_Close((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); |
562 | |
563 | } else { |
564 | |
565 | /* |
566 | * The refcount is greater than zero, so flush the channel. |
567 | */ |
568 | |
569 | Tcl_Flush((Tcl_Channel) chanPtr); |
570 | |
571 | /* |
572 | * Call the device driver to actually close the underlying |
573 | * device for this channel. |
574 | */ |
575 | |
576 | if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { |
577 | (chanPtr->typePtr->closeProc)(chanPtr->instanceData, |
578 | (Tcl_Interp *) NULL); |
579 | } else { |
580 | (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, |
581 | (Tcl_Interp *) NULL, 0); |
582 | } |
583 | |
584 | /* |
585 | * Finally, we clean up the fields in the channel data structure |
586 | * since all of them have been deleted already. We mark the |
587 | * channel with CHANNEL_DEAD to prevent any further IO operations |
588 | * on it. |
589 | */ |
590 | |
591 | chanPtr->instanceData = (ClientData) NULL; |
592 | chanPtr->flags |= CHANNEL_DEAD; |
593 | } |
594 | } |
595 | } |
596 | |
597 | |
598 | /* |
599 | *---------------------------------------------------------------------- |
600 | * |
601 | * Tcl_SetStdChannel -- |
602 | * |
603 | * This function is used to change the channels that are used |
604 | * for stdin/stdout/stderr in new interpreters. |
605 | * |
606 | * Results: |
607 | * None |
608 | * |
609 | * Side effects: |
610 | * None. |
611 | * |
612 | *---------------------------------------------------------------------- |
613 | */ |
614 | |
615 | void |
616 | Tcl_SetStdChannel(channel, type) |
617 | Tcl_Channel channel; |
618 | int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ |
619 | { |
620 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
621 | switch (type) { |
622 | case TCL_STDIN: |
623 | tsdPtr->stdinInitialized = 1; |
624 | tsdPtr->stdinChannel = channel; |
625 | break; |
626 | case TCL_STDOUT: |
627 | tsdPtr->stdoutInitialized = 1; |
628 | tsdPtr->stdoutChannel = channel; |
629 | break; |
630 | case TCL_STDERR: |
631 | tsdPtr->stderrInitialized = 1; |
632 | tsdPtr->stderrChannel = channel; |
633 | break; |
634 | } |
635 | } |
636 | |
637 | /* |
638 | *---------------------------------------------------------------------- |
639 | * |
640 | * Tcl_GetStdChannel -- |
641 | * |
642 | * Returns the specified standard channel. |
643 | * |
644 | * Results: |
645 | * Returns the specified standard channel, or NULL. |
646 | * |
647 | * Side effects: |
648 | * May cause the creation of a standard channel and the underlying |
649 | * file. |
650 | * |
651 | *---------------------------------------------------------------------- |
652 | */ |
653 | Tcl_Channel |
654 | Tcl_GetStdChannel(type) |
655 | int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ |
656 | { |
657 | Tcl_Channel channel = NULL; |
658 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
659 | |
660 | /* |
661 | * If the channels were not created yet, create them now and |
662 | * store them in the static variables. |
663 | */ |
664 | |
665 | switch (type) { |
666 | case TCL_STDIN: |
667 | if (!tsdPtr->stdinInitialized) { |
668 | tsdPtr->stdinChannel = TclpGetDefaultStdChannel(TCL_STDIN); |
669 | tsdPtr->stdinInitialized = 1; |
670 | |
671 | /* |
672 | * Artificially bump the refcount to ensure that the channel |
673 | * is only closed on exit. |
674 | * |
675 | * NOTE: Must only do this if stdinChannel is not NULL. It |
676 | * can be NULL in situations where Tcl is unable to connect |
677 | * to the standard input. |
678 | */ |
679 | |
680 | if (tsdPtr->stdinChannel != (Tcl_Channel) NULL) { |
681 | (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, |
682 | tsdPtr->stdinChannel); |
683 | } |
684 | } |
685 | channel = tsdPtr->stdinChannel; |
686 | break; |
687 | case TCL_STDOUT: |
688 | if (!tsdPtr->stdoutInitialized) { |
689 | tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT); |
690 | tsdPtr->stdoutInitialized = 1; |
691 | if (tsdPtr->stdoutChannel != (Tcl_Channel) NULL) { |
692 | (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, |
693 | tsdPtr->stdoutChannel); |
694 | } |
695 | } |
696 | channel = tsdPtr->stdoutChannel; |
697 | break; |
698 | case TCL_STDERR: |
699 | if (!tsdPtr->stderrInitialized) { |
700 | tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR); |
701 | tsdPtr->stderrInitialized = 1; |
702 | if (tsdPtr->stderrChannel != (Tcl_Channel) NULL) { |
703 | (void) Tcl_RegisterChannel((Tcl_Interp *) NULL, |
704 | tsdPtr->stderrChannel); |
705 | } |
706 | } |
707 | channel = tsdPtr->stderrChannel; |
708 | break; |
709 | } |
710 | return channel; |
711 | } |
712 | |
713 | |
714 | /* |
715 | *---------------------------------------------------------------------- |
716 | * |
717 | * Tcl_CreateCloseHandler |
718 | * |
719 | * Creates a close callback which will be called when the channel is |
720 | * closed. |
721 | * |
722 | * Results: |
723 | * None. |
724 | * |
725 | * Side effects: |
726 | * Causes the callback to be called in the future when the channel |
727 | * will be closed. |
728 | * |
729 | *---------------------------------------------------------------------- |
730 | */ |
731 | |
732 | void |
733 | Tcl_CreateCloseHandler(chan, proc, clientData) |
734 | Tcl_Channel chan; /* The channel for which to create the |
735 | * close callback. */ |
736 | Tcl_CloseProc *proc; /* The callback routine to call when the |
737 | * channel will be closed. */ |
738 | ClientData clientData; /* Arbitrary data to pass to the |
739 | * close callback. */ |
740 | { |
741 | Channel *chanPtr; |
742 | CloseCallback *cbPtr; |
743 | |
744 | chanPtr = (Channel *) chan; |
745 | |
746 | cbPtr = (CloseCallback *) ckalloc((unsigned) sizeof(CloseCallback)); |
747 | cbPtr->proc = proc; |
748 | cbPtr->clientData = clientData; |
749 | |
750 | cbPtr->nextPtr = chanPtr->closeCbPtr; |
751 | chanPtr->closeCbPtr = cbPtr; |
752 | } |
753 | |
754 | /* |
755 | *---------------------------------------------------------------------- |
756 | * |
757 | * Tcl_DeleteCloseHandler -- |
758 | * |
759 | * Removes a callback that would have been called on closing |
760 | * the channel. If there is no matching callback then this |
761 | * function has no effect. |
762 | * |
763 | * Results: |
764 | * None. |
765 | * |
766 | * Side effects: |
767 | * The callback will not be called in the future when the channel |
768 | * is eventually closed. |
769 | * |
770 | *---------------------------------------------------------------------- |
771 | */ |
772 | |
773 | void |
774 | Tcl_DeleteCloseHandler(chan, proc, clientData) |
775 | Tcl_Channel chan; /* The channel for which to cancel the |
776 | * close callback. */ |
777 | Tcl_CloseProc *proc; /* The procedure for the callback to |
778 | * remove. */ |
779 | ClientData clientData; /* The callback data for the callback |
780 | * to remove. */ |
781 | { |
782 | Channel *chanPtr; |
783 | CloseCallback *cbPtr, *cbPrevPtr; |
784 | |
785 | chanPtr = (Channel *) chan; |
786 | for (cbPtr = chanPtr->closeCbPtr, cbPrevPtr = (CloseCallback *) NULL; |
787 | cbPtr != (CloseCallback *) NULL; |
788 | cbPtr = cbPtr->nextPtr) { |
789 | if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) { |
790 | if (cbPrevPtr == (CloseCallback *) NULL) { |
791 | chanPtr->closeCbPtr = cbPtr->nextPtr; |
792 | } |
793 | ckfree((char *) cbPtr); |
794 | break; |
795 | } else { |
796 | cbPrevPtr = cbPtr; |
797 | } |
798 | } |
799 | } |
800 | |
801 | /* |
802 | *---------------------------------------------------------------------- |
803 | * |
804 | * GetChannelTable -- |
805 | * |
806 | * Gets and potentially initializes the channel table for an |
807 | * interpreter. If it is initializing the table it also inserts |
808 | * channels for stdin, stdout and stderr if the interpreter is |
809 | * trusted. |
810 | * |
811 | * Results: |
812 | * A pointer to the hash table created, for use by the caller. |
813 | * |
814 | * Side effects: |
815 | * Initializes the channel table for an interpreter. May create |
816 | * channels for stdin, stdout and stderr. |
817 | * |
818 | *---------------------------------------------------------------------- |
819 | */ |
820 | |
821 | static Tcl_HashTable * |
822 | GetChannelTable(interp) |
823 | Tcl_Interp *interp; |
824 | { |
825 | Tcl_HashTable *hTblPtr; /* Hash table of channels. */ |
826 | Tcl_Channel stdinChan, stdoutChan, stderrChan; |
827 | |
828 | hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL); |
829 | if (hTblPtr == (Tcl_HashTable *) NULL) { |
830 | hTblPtr = (Tcl_HashTable *) ckalloc((unsigned) sizeof(Tcl_HashTable)); |
831 | Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS); |
832 | |
833 | (void) Tcl_SetAssocData(interp, "tclIO", |
834 | (Tcl_InterpDeleteProc *) DeleteChannelTable, |
835 | (ClientData) hTblPtr); |
836 | |
837 | /* |
838 | * If the interpreter is trusted (not "safe"), insert channels |
839 | * for stdin, stdout and stderr (possibly creating them in the |
840 | * process). |
841 | */ |
842 | |
843 | if (Tcl_IsSafe(interp) == 0) { |
844 | stdinChan = Tcl_GetStdChannel(TCL_STDIN); |
845 | if (stdinChan != NULL) { |
846 | Tcl_RegisterChannel(interp, stdinChan); |
847 | } |
848 | stdoutChan = Tcl_GetStdChannel(TCL_STDOUT); |
849 | if (stdoutChan != NULL) { |
850 | Tcl_RegisterChannel(interp, stdoutChan); |
851 | } |
852 | stderrChan = Tcl_GetStdChannel(TCL_STDERR); |
853 | if (stderrChan != NULL) { |
854 | Tcl_RegisterChannel(interp, stderrChan); |
855 | } |
856 | } |
857 | |
858 | } |
859 | return hTblPtr; |
860 | } |
861 | |
862 | /* |
863 | *---------------------------------------------------------------------- |
864 | * |
865 | * DeleteChannelTable -- |
866 | * |
867 | * Deletes the channel table for an interpreter, closing any open |
868 | * channels whose refcount reaches zero. This procedure is invoked |
869 | * when an interpreter is deleted, via the AssocData cleanup |
870 | * mechanism. |
871 | * |
872 | * Results: |
873 | * None. |
874 | * |
875 | * Side effects: |
876 | * Deletes the hash table of channels. May close channels. May flush |
877 | * output on closed channels. Removes any channeEvent handlers that were |
878 | * registered in this interpreter. |
879 | * |
880 | *---------------------------------------------------------------------- |
881 | */ |
882 | |
883 | static void |
884 | DeleteChannelTable(clientData, interp) |
885 | ClientData clientData; /* The per-interpreter data structure. */ |
886 | Tcl_Interp *interp; /* The interpreter being deleted. */ |
887 | { |
888 | Tcl_HashTable *hTblPtr; /* The hash table. */ |
889 | Tcl_HashSearch hSearch; /* Search variable. */ |
890 | Tcl_HashEntry *hPtr; /* Search variable. */ |
891 | Channel *chanPtr; /* Channel being deleted. */ |
892 | EventScriptRecord *sPtr, *prevPtr, *nextPtr; |
893 | /* Variables to loop over all channel events |
894 | * registered, to delete the ones that refer |
895 | * to the interpreter being deleted. */ |
896 | |
897 | /* |
898 | * Delete all the registered channels - this will close channels whose |
899 | * refcount reaches zero. |
900 | */ |
901 | |
902 | hTblPtr = (Tcl_HashTable *) clientData; |
903 | for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); |
904 | hPtr != (Tcl_HashEntry *) NULL; |
905 | hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) { |
906 | |
907 | chanPtr = (Channel *) Tcl_GetHashValue(hPtr); |
908 | |
909 | /* |
910 | * Remove any fileevents registered in this interpreter. |
911 | */ |
912 | |
913 | for (sPtr = chanPtr->scriptRecordPtr, |
914 | prevPtr = (EventScriptRecord *) NULL; |
915 | sPtr != (EventScriptRecord *) NULL; |
916 | sPtr = nextPtr) { |
917 | nextPtr = sPtr->nextPtr; |
918 | if (sPtr->interp == interp) { |
919 | if (prevPtr == (EventScriptRecord *) NULL) { |
920 | chanPtr->scriptRecordPtr = nextPtr; |
921 | } else { |
922 | prevPtr->nextPtr = nextPtr; |
923 | } |
924 | |
925 | Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, |
926 | ChannelEventScriptInvoker, (ClientData) sPtr); |
927 | |
928 | Tcl_DecrRefCount(sPtr->scriptPtr); |
929 | ckfree((char *) sPtr); |
930 | } else { |
931 | prevPtr = sPtr; |
932 | } |
933 | } |
934 | |
935 | /* |
936 | * Cannot call Tcl_UnregisterChannel because that procedure calls |
937 | * Tcl_GetAssocData to get the channel table, which might already |
938 | * be inaccessible from the interpreter structure. Instead, we |
939 | * emulate the behavior of Tcl_UnregisterChannel directly here. |
940 | */ |
941 | |
942 | Tcl_DeleteHashEntry(hPtr); |
943 | chanPtr->refCount--; |
944 | if (chanPtr->refCount <= 0) { |
945 | if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) { |
946 | (void) Tcl_Close(interp, (Tcl_Channel) chanPtr); |
947 | } |
948 | } |
949 | } |
950 | Tcl_DeleteHashTable(hTblPtr); |
951 | ckfree((char *) hTblPtr); |
952 | } |
953 | |
954 | /* |
955 | *---------------------------------------------------------------------- |
956 | * |
957 | * CheckForStdChannelsBeingClosed -- |
958 | * |
959 | * Perform special handling for standard channels being closed. When |
960 | * given a standard channel, if the refcount is now 1, it means that |
961 | * the last reference to the standard channel is being explicitly |
962 | * closed. Now bump the refcount artificially down to 0, to ensure the |
963 | * normal handling of channels being closed will occur. Also reset the |
964 | * static pointer to the channel to NULL, to avoid dangling references. |
965 | * |
966 | * Results: |
967 | * None. |
968 | * |
969 | * Side effects: |
970 | * Manipulates the refcount on standard channels. May smash the global |
971 | * static pointer to a standard channel. |
972 | * |
973 | *---------------------------------------------------------------------- |
974 | */ |
975 | |
976 | static void |
977 | CheckForStdChannelsBeingClosed(chan) |
978 | Tcl_Channel chan; |
979 | { |
980 | Channel *chanPtr = (Channel *) chan; |
981 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
982 | |
983 | if ((chan == tsdPtr->stdinChannel) && (tsdPtr->stdinInitialized)) { |
984 | if (chanPtr->refCount < 2) { |
985 | chanPtr->refCount = 0; |
986 | tsdPtr->stdinChannel = NULL; |
987 | return; |
988 | } |
989 | } else if ((chan == tsdPtr->stdoutChannel) && (tsdPtr->stdoutInitialized)) { |
990 | if (chanPtr->refCount < 2) { |
991 | chanPtr->refCount = 0; |
992 | tsdPtr->stdoutChannel = NULL; |
993 | return; |
994 | } |
995 | } else if ((chan == tsdPtr->stderrChannel) && (tsdPtr->stderrInitialized)) { |
996 | if (chanPtr->refCount < 2) { |
997 | chanPtr->refCount = 0; |
998 | tsdPtr->stderrChannel = NULL; |
999 | return; |
1000 | } |
1001 | } |
1002 | } |
1003 | |
1004 | /* |
1005 | *---------------------------------------------------------------------- |
1006 | * |
1007 | * Tcl_RegisterChannel -- |
1008 | * |
1009 | * Adds an already-open channel to the channel table of an interpreter. |
1010 | * If the interpreter passed as argument is NULL, it only increments |
1011 | * the channel refCount. |
1012 | * |
1013 | * Results: |
1014 | * None. |
1015 | * |
1016 | * Side effects: |
1017 | * May increment the reference count of a channel. |
1018 | * |
1019 | *---------------------------------------------------------------------- |
1020 | */ |
1021 | |
1022 | void |
1023 | Tcl_RegisterChannel(interp, chan) |
1024 | Tcl_Interp *interp; /* Interpreter in which to add the channel. */ |
1025 | Tcl_Channel chan; /* The channel to add to this interpreter |
1026 | * channel table. */ |
1027 | { |
1028 | Tcl_HashTable *hTblPtr; /* Hash table of channels. */ |
1029 | Tcl_HashEntry *hPtr; /* Search variable. */ |
1030 | int new; /* Is the hash entry new or does it exist? */ |
1031 | Channel *chanPtr; /* The actual channel. */ |
1032 | |
1033 | chanPtr = (Channel *) chan; |
1034 | |
1035 | if (chanPtr->channelName == (char *) NULL) { |
1036 | panic("Tcl_RegisterChannel: channel without name"); |
1037 | } |
1038 | if (interp != (Tcl_Interp *) NULL) { |
1039 | hTblPtr = GetChannelTable(interp); |
1040 | hPtr = Tcl_CreateHashEntry(hTblPtr, chanPtr->channelName, &new); |
1041 | if (new == 0) { |
1042 | if (chan == (Tcl_Channel) Tcl_GetHashValue(hPtr)) { |
1043 | return; |
1044 | } |
1045 | |
1046 | /* Andreas Kupries <a.kupries@westend.com>, 12/13/1998 |
1047 | * "Trf-Patch for filtering channels" |
1048 | * |
1049 | * This is the change to 'Tcl_RegisterChannel'. |
1050 | * |
1051 | * Explanation: |
1052 | * The moment a channel is stacked upon another he |
1053 | * takes the identity of the channel he supercedes, |
1054 | * i.e. he gets the *same* name. Because of this we |
1055 | * cannot check for duplicate names anymore, they |
1056 | * have to be allowed now. |
1057 | */ |
1058 | |
1059 | /* panic("Tcl_RegisterChannel: duplicate channel names"); */ |
1060 | } |
1061 | Tcl_SetHashValue(hPtr, (ClientData) chanPtr); |
1062 | } |
1063 | chanPtr->refCount++; |
1064 | } |
1065 | |
1066 | /* |
1067 | *---------------------------------------------------------------------- |
1068 | * |
1069 | * Tcl_UnregisterChannel -- |
1070 | * |
1071 | * Deletes the hash entry for a channel associated with an interpreter. |
1072 | * If the interpreter given as argument is NULL, it only decrements the |
1073 | * reference count. |
1074 | * |
1075 | * Results: |
1076 | * A standard Tcl result. |
1077 | * |
1078 | * Side effects: |
1079 | * Deletes the hash entry for a channel associated with an interpreter. |
1080 | * |
1081 | *---------------------------------------------------------------------- |
1082 | */ |
1083 | |
1084 | int |
1085 | Tcl_UnregisterChannel(interp, chan) |
1086 | Tcl_Interp *interp; /* Interpreter in which channel is defined. */ |
1087 | Tcl_Channel chan; /* Channel to delete. */ |
1088 | { |
1089 | Tcl_HashTable *hTblPtr; /* Hash table of channels. */ |
1090 | Tcl_HashEntry *hPtr; /* Search variable. */ |
1091 | Channel *chanPtr; /* The real IO channel. */ |
1092 | |
1093 | chanPtr = (Channel *) chan; |
1094 | |
1095 | if (interp != (Tcl_Interp *) NULL) { |
1096 | hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL); |
1097 | if (hTblPtr == (Tcl_HashTable *) NULL) { |
1098 | return TCL_OK; |
1099 | } |
1100 | hPtr = Tcl_FindHashEntry(hTblPtr, chanPtr->channelName); |
1101 | if (hPtr == (Tcl_HashEntry *) NULL) { |
1102 | return TCL_OK; |
1103 | } |
1104 | if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) { |
1105 | return TCL_OK; |
1106 | } |
1107 | Tcl_DeleteHashEntry(hPtr); |
1108 | |
1109 | /* |
1110 | * Remove channel handlers that refer to this interpreter, so that they |
1111 | * will not be present if the actual close is delayed and more events |
1112 | * happen on the channel. This may occur if the channel is shared |
1113 | * between several interpreters, or if the channel has async |
1114 | * flushing active. |
1115 | */ |
1116 | |
1117 | CleanupChannelHandlers(interp, chanPtr); |
1118 | } |
1119 | |
1120 | chanPtr->refCount--; |
1121 | |
1122 | /* |
1123 | * Perform special handling for standard channels being closed. If the |
1124 | * refCount is now 1 it means that the last reference to the standard |
1125 | * channel is being explicitly closed, so bump the refCount down |
1126 | * artificially to 0. This will ensure that the channel is actually |
1127 | * closed, below. Also set the static pointer to NULL for the channel. |
1128 | */ |
1129 | |
1130 | CheckForStdChannelsBeingClosed(chan); |
1131 | |
1132 | /* |
1133 | * If the refCount reached zero, close the actual channel. |
1134 | */ |
1135 | |
1136 | if (chanPtr->refCount <= 0) { |
1137 | |
1138 | /* |
1139 | * Ensure that if there is another buffer, it gets flushed |
1140 | * whether or not we are doing a background flush. |
1141 | */ |
1142 | |
1143 | if ((chanPtr->curOutPtr != NULL) && |
1144 | (chanPtr->curOutPtr->nextAdded > |
1145 | chanPtr->curOutPtr->nextRemoved)) { |
1146 | chanPtr->flags |= BUFFER_READY; |
1147 | } |
1148 | chanPtr->flags |= CHANNEL_CLOSED; |
1149 | if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) { |
1150 | if (Tcl_Close(interp, chan) != TCL_OK) { |
1151 | return TCL_ERROR; |
1152 | } |
1153 | } |
1154 | } |
1155 | return TCL_OK; |
1156 | } |
1157 | |
1158 | /* |
1159 | *--------------------------------------------------------------------------- |
1160 | * |
1161 | * Tcl_GetChannel -- |
1162 | * |
1163 | * Finds an existing Tcl_Channel structure by name in a given |
1164 | * interpreter. This function is public because it is used by |
1165 | * channel-type-specific functions. |
1166 | * |
1167 | * Results: |
1168 | * A Tcl_Channel or NULL on failure. If failed, interp's result |
1169 | * object contains an error message. *modePtr is filled with the |
1170 | * modes in which the channel was opened. |
1171 | * |
1172 | * Side effects: |
1173 | * None. |
1174 | * |
1175 | *--------------------------------------------------------------------------- |
1176 | */ |
1177 | |
1178 | Tcl_Channel |
1179 | Tcl_GetChannel(interp, chanName, modePtr) |
1180 | Tcl_Interp *interp; /* Interpreter in which to find or create |
1181 | * the channel. */ |
1182 | char *chanName; /* The name of the channel. */ |
1183 | int *modePtr; /* Where to store the mode in which the |
1184 | * channel was opened? Will contain an ORed |
1185 | * combination of TCL_READABLE and |
1186 | * TCL_WRITABLE, if non-NULL. */ |
1187 | { |
1188 | Channel *chanPtr; /* The actual channel. */ |
1189 | Tcl_HashTable *hTblPtr; /* Hash table of channels. */ |
1190 | Tcl_HashEntry *hPtr; /* Search variable. */ |
1191 | char *name; /* Translated name. */ |
1192 | |
1193 | /* |
1194 | * Substitute "stdin", etc. Note that even though we immediately |
1195 | * find the channel using Tcl_GetStdChannel, we still need to look |
1196 | * it up in the specified interpreter to ensure that it is present |
1197 | * in the channel table. Otherwise, safe interpreters would always |
1198 | * have access to the standard channels. |
1199 | */ |
1200 | |
1201 | name = chanName; |
1202 | if ((chanName[0] == 's') && (chanName[1] == 't')) { |
1203 | chanPtr = NULL; |
1204 | if (strcmp(chanName, "stdin") == 0) { |
1205 | chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDIN); |
1206 | } else if (strcmp(chanName, "stdout") == 0) { |
1207 | chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDOUT); |
1208 | } else if (strcmp(chanName, "stderr") == 0) { |
1209 | chanPtr = (Channel *)Tcl_GetStdChannel(TCL_STDERR); |
1210 | } |
1211 | if (chanPtr != NULL) { |
1212 | name = chanPtr->channelName; |
1213 | } |
1214 | } |
1215 | |
1216 | hTblPtr = GetChannelTable(interp); |
1217 | hPtr = Tcl_FindHashEntry(hTblPtr, name); |
1218 | if (hPtr == (Tcl_HashEntry *) NULL) { |
1219 | Tcl_AppendResult(interp, "can not find channel named \"", |
1220 | chanName, "\"", (char *) NULL); |
1221 | return NULL; |
1222 | } |
1223 | |
1224 | chanPtr = (Channel *) Tcl_GetHashValue(hPtr); |
1225 | if (modePtr != NULL) { |
1226 | *modePtr = (chanPtr->flags & (TCL_READABLE|TCL_WRITABLE)); |
1227 | } |
1228 | |
1229 | return (Tcl_Channel) chanPtr; |
1230 | } |
1231 | |
1232 | /* |
1233 | *---------------------------------------------------------------------- |
1234 | * |
1235 | * Tcl_CreateChannel -- |
1236 | * |
1237 | * Creates a new entry in the hash table for a Tcl_Channel |
1238 | * record. |
1239 | * |
1240 | * Results: |
1241 | * Returns the new Tcl_Channel. |
1242 | * |
1243 | * Side effects: |
1244 | * Creates a new Tcl_Channel instance and inserts it into the |
1245 | * hash table. |
1246 | * |
1247 | *---------------------------------------------------------------------- |
1248 | */ |
1249 | |
1250 | Tcl_Channel |
1251 | Tcl_CreateChannel(typePtr, chanName, instanceData, mask) |
1252 | Tcl_ChannelType *typePtr; /* The channel type record. */ |
1253 | char *chanName; /* Name of channel to record. */ |
1254 | ClientData instanceData; /* Instance specific data. */ |
1255 | int mask; /* TCL_READABLE & TCL_WRITABLE to indicate |
1256 | * if the channel is readable, writable. */ |
1257 | { |
1258 | Channel *chanPtr; /* The channel structure newly created. */ |
1259 | CONST char *name; |
1260 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
1261 | |
1262 | chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel)); |
1263 | |
1264 | if (chanName != (char *) NULL) { |
1265 | chanPtr->channelName = ckalloc((unsigned) (strlen(chanName) + 1)); |
1266 | strcpy(chanPtr->channelName, chanName); |
1267 | } else { |
1268 | panic("Tcl_CreateChannel: NULL channel name"); |
1269 | } |
1270 | |
1271 | chanPtr->flags = mask; |
1272 | |
1273 | /* |
1274 | * Set the channel to system default encoding. |
1275 | */ |
1276 | |
1277 | chanPtr->encoding = NULL; |
1278 | name = Tcl_GetEncodingName(NULL); |
1279 | if (strcmp(name, "binary") != 0) { |
1280 | chanPtr->encoding = Tcl_GetEncoding(NULL, name); |
1281 | } |
1282 | chanPtr->inputEncodingState = NULL; |
1283 | chanPtr->inputEncodingFlags = TCL_ENCODING_START; |
1284 | chanPtr->outputEncodingState = NULL; |
1285 | chanPtr->outputEncodingFlags = TCL_ENCODING_START; |
1286 | |
1287 | /* |
1288 | * Set the channel up initially in AUTO input translation mode to |
1289 | * accept "\n", "\r" and "\r\n". Output translation mode is set to |
1290 | * a platform specific default value. The eofChar is set to 0 for both |
1291 | * input and output, so that Tcl does not look for an in-file EOF |
1292 | * indicator (e.g. ^Z) and does not append an EOF indicator to files. |
1293 | */ |
1294 | |
1295 | chanPtr->inputTranslation = TCL_TRANSLATE_AUTO; |
1296 | chanPtr->outputTranslation = TCL_PLATFORM_TRANSLATION; |
1297 | chanPtr->inEofChar = 0; |
1298 | chanPtr->outEofChar = 0; |
1299 | |
1300 | chanPtr->unreportedError = 0; |
1301 | chanPtr->instanceData = instanceData; |
1302 | chanPtr->typePtr = typePtr; |
1303 | chanPtr->refCount = 0; |
1304 | chanPtr->closeCbPtr = (CloseCallback *) NULL; |
1305 | chanPtr->curOutPtr = (ChannelBuffer *) NULL; |
1306 | chanPtr->outQueueHead = (ChannelBuffer *) NULL; |
1307 | chanPtr->outQueueTail = (ChannelBuffer *) NULL; |
1308 | chanPtr->saveInBufPtr = (ChannelBuffer *) NULL; |
1309 | chanPtr->inQueueHead = (ChannelBuffer *) NULL; |
1310 | chanPtr->inQueueTail = (ChannelBuffer *) NULL; |
1311 | chanPtr->chPtr = (ChannelHandler *) NULL; |
1312 | chanPtr->interestMask = 0; |
1313 | chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL; |
1314 | chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE; |
1315 | chanPtr->timer = NULL; |
1316 | chanPtr->csPtr = NULL; |
1317 | chanPtr->supercedes = (Channel*) NULL; |
1318 | |
1319 | chanPtr->outputStage = NULL; |
1320 | if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) { |
1321 | chanPtr->outputStage = (char *) |
1322 | ckalloc((unsigned) (chanPtr->bufSize + 2)); |
1323 | } |
1324 | |
1325 | /* |
1326 | * Link the channel into the list of all channels; create an on-exit |
1327 | * handler if there is not one already, to close off all the channels |
1328 | * in the list on exit. |
1329 | */ |
1330 | |
1331 | chanPtr->nextChanPtr = tsdPtr->firstChanPtr; |
1332 | tsdPtr->firstChanPtr = chanPtr; |
1333 | |
1334 | /* |
1335 | * Install this channel in the first empty standard channel slot, if |
1336 | * the channel was previously closed explicitly. |
1337 | */ |
1338 | |
1339 | if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) { |
1340 | Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDIN); |
1341 | Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); |
1342 | } else if ((tsdPtr->stdoutChannel == NULL) && (tsdPtr->stdoutInitialized == 1)) { |
1343 | Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDOUT); |
1344 | Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); |
1345 | } else if ((tsdPtr->stderrChannel == NULL) && (tsdPtr->stderrInitialized == 1)) { |
1346 | Tcl_SetStdChannel((Tcl_Channel)chanPtr, TCL_STDERR); |
1347 | Tcl_RegisterChannel((Tcl_Interp *) NULL, (Tcl_Channel) chanPtr); |
1348 | } |
1349 | return (Tcl_Channel) chanPtr; |
1350 | } |
1351 | |
1352 | /* |
1353 | *---------------------------------------------------------------------- |
1354 | * |
1355 | * Tcl_StackChannel -- |
1356 | * |
1357 | * Replaces an entry in the hash table for a Tcl_Channel |
1358 | * record. The replacement is a new channel with same name, |
1359 | * it supercedes the replaced channel. Input and output of |
1360 | * the superceded channel is now going through the newly |
1361 | * created channel and allows the arbitrary filtering/manipulation |
1362 | * of the dataflow. |
1363 | * |
1364 | * Andreas Kupries <a.kupries@westend.com>, 12/13/1998 |
1365 | * "Trf-Patch for filtering channels" |
1366 | * |
1367 | * Results: |
1368 | * Returns the new Tcl_Channel, which actually contains the |
1369 | * saved information about prevChan. |
1370 | * |
1371 | * Side effects: |
1372 | * A new channel structure is allocated and linked below |
1373 | * the existing channel. The channel operations and client |
1374 | * data of the existing channel are copied down to the newly |
1375 | * created channel, and the current channel has its operations |
1376 | * replaced by the new typePtr. |
1377 | * |
1378 | *---------------------------------------------------------------------- |
1379 | */ |
1380 | |
1381 | Tcl_Channel |
1382 | Tcl_StackChannel(interp, typePtr, instanceData, mask, prevChan) |
1383 | Tcl_Interp* interp; /* The interpreter we are working in */ |
1384 | Tcl_ChannelType *typePtr; /* The channel type record for the new |
1385 | * channel. */ |
1386 | ClientData instanceData; /* Instance specific data for the new |
1387 | * channel. */ |
1388 | int mask; /* TCL_READABLE & TCL_WRITABLE to indicate |
1389 | * if the channel is readable, writable. */ |
1390 | Tcl_Channel prevChan; /* The channel structure to replace */ |
1391 | { |
1392 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
1393 | Channel *chanPtr, *pt; |
1394 | int interest = 0; |
1395 | |
1396 | /* |
1397 | * AK, 06/30/1999 |
1398 | * |
1399 | * Tcl_StackChannel differs from Tcl_ReplaceChannel of the |
1400 | * original "Trf" patch. Instead of seeing the |
1401 | * newly created structure as the *new* channel to cover the specified |
1402 | * one use it to *save* the current state of the specified channel and |
1403 | * then reinitialize the current structure for the given transformation. |
1404 | * |
1405 | * Advantages: |
1406 | * - No splicing into the (thread-)global list of channels (or the per- |
1407 | * interp hash-tables). |
1408 | * - Users of the C-API still have valid channel references even after |
1409 | * the call to this procedure. |
1410 | * |
1411 | * Disadvantages: |
1412 | * - Untested code. |
1413 | */ |
1414 | |
1415 | /* |
1416 | * Find the given channel in the list of all channels. |
1417 | */ |
1418 | |
1419 | pt = (Channel*) tsdPtr->firstChanPtr; |
1420 | |
1421 | while (pt != (Channel *) prevChan) { |
1422 | pt = pt->nextChanPtr; |
1423 | } |
1424 | |
1425 | /* |
1426 | * 'pt == prevChan' now (or NULL, if not found). |
1427 | */ |
1428 | |
1429 | if (!pt) { |
1430 | return (Tcl_Channel) NULL; |
1431 | } |
1432 | |
1433 | /* |
1434 | * Here we check if the given "mask" matches the "flags" |
1435 | * of the already existing channel. |
1436 | * |
1437 | * | - | R | W | RW | |
1438 | * --+---+---+---+----+ <=> 0 != (chan->mask & prevChan->mask) |
1439 | * - | | | | | |
1440 | * R | | + | | + | The superceding channel is allowed to |
1441 | * W | | | + | + | restrict the capabilities of the |
1442 | * RW| | + | + | + | superceded one ! |
1443 | * --+---+---+---+----+ |
1444 | */ |
1445 | |
1446 | if ((mask & Tcl_GetChannelMode (prevChan)) == 0) { |
1447 | return (Tcl_Channel) NULL; |
1448 | } |
1449 | |
1450 | chanPtr = (Channel *) ckalloc((unsigned) sizeof(Channel)); |
1451 | |
1452 | /* |
1453 | * If there is some interest in the channel, remove it, break |
1454 | * down the whole chain. It will be reconstructed later. |
1455 | */ |
1456 | |
1457 | interest = pt->interestMask; |
1458 | |
1459 | pt->interestMask = 0; |
1460 | |
1461 | if (interest) { |
1462 | (pt->typePtr->watchProc) (pt->instanceData, 0); |
1463 | } |
1464 | |
1465 | /* |
1466 | * Save some of the current state into the new structure, |
1467 | * reinitialize the parts which will stay with the transformation. |
1468 | * |
1469 | * Remarks: |
1470 | * - We cannot discard the buffers, and they cannot be used from the |
1471 | * transformation placed later into the 'pt' structure. Save them, |
1472 | * and believe that Tcl_SetChannelOption (buffering, none) will do |
1473 | * the right thing. |
1474 | * - encoding and EOL-translation control information is initialized |
1475 | * to values for 'binary'. This is later reinforced via |
1476 | * Tcl_SetChanneloption to get the handling of flags and the event |
1477 | * system right. |
1478 | * - The 'interestMask' of the saved channel is cleared, but the |
1479 | * transformations WatchProc is used to establish the connection |
1480 | * between transformation and underlying channel. This should |
1481 | * reestablish the correct mask. |
1482 | * - TTO = Transform Takes Over. The hidden channel no longer |
1483 | * needs to perform this function. |
1484 | */ |
1485 | |
1486 | chanPtr->channelName = (char *) ckalloc (strlen(pt->channelName)+1); |
1487 | strcpy (chanPtr->channelName, pt->channelName); |
1488 | |
1489 | chanPtr->flags = pt->flags; /* Save */ |
1490 | |
1491 | chanPtr->encoding = (Tcl_Encoding) NULL; /* == 'binary' */ |
1492 | chanPtr->inputEncodingState = (Tcl_EncodingState) NULL; |
1493 | chanPtr->inputEncodingFlags = TCL_ENCODING_START; |
1494 | chanPtr->outputEncodingState = (Tcl_EncodingState) NULL; |
1495 | chanPtr->outputEncodingFlags = TCL_ENCODING_START; |
1496 | |
1497 | chanPtr->inputTranslation = TCL_TRANSLATE_LF; /* == 'binary' */ |
1498 | chanPtr->outputTranslation = TCL_TRANSLATE_LF; /* == 'binary' */ |
1499 | chanPtr->inEofChar = pt->inEofChar; /* Save */ |
1500 | chanPtr->outEofChar = pt->outEofChar; /* Save */ |
1501 | |
1502 | chanPtr->unreportedError = pt->unreportedError; /* Save */ |
1503 | chanPtr->instanceData = pt->instanceData; /* Save */ |
1504 | chanPtr->typePtr = pt->typePtr; /* Save */ |
1505 | chanPtr->refCount = 0; /* None, as the structure is covered */ |
1506 | chanPtr->closeCbPtr = (CloseCallback*) NULL; /* TTO */ |
1507 | |
1508 | chanPtr->outputStage = (char*) NULL; |
1509 | chanPtr->curOutPtr = pt->curOutPtr; /* Save */ |
1510 | chanPtr->outQueueHead = pt->outQueueHead; /* Save */ |
1511 | chanPtr->outQueueTail = pt->outQueueTail; /* Save */ |
1512 | chanPtr->saveInBufPtr = pt->saveInBufPtr; /* Save */ |
1513 | chanPtr->inQueueHead = pt->inQueueHead; /* Save */ |
1514 | chanPtr->inQueueTail = pt->inQueueTail; /* Save */ |
1515 | |
1516 | chanPtr->chPtr = (ChannelHandler *) NULL; /* TTO */ |
1517 | chanPtr->interestMask = 0; |
1518 | chanPtr->nextChanPtr = (Channel*) NULL; /* Is not in list! */ |
1519 | chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL; /* TTO */ |
1520 | chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE; |
1521 | chanPtr->timer = (Tcl_TimerToken) NULL; /* TTO */ |
1522 | chanPtr->csPtr = (CopyState*) NULL; /* TTO */ |
1523 | |
1524 | /* |
1525 | * Place new block at the head of a possibly existing list of previously |
1526 | * stacked channels, then do the missing initializations of translation |
1527 | * and buffer system. |
1528 | */ |
1529 | |
1530 | chanPtr->supercedes = pt->supercedes; |
1531 | |
1532 | Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr, |
1533 | "-translation", "binary"); |
1534 | Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr, |
1535 | "-buffering", "none"); |
1536 | |
1537 | /* |
1538 | * Save accomplished, now reinitialize the (old) structure for the |
1539 | * transformation. |
1540 | * |
1541 | * - The information about encoding and eol-translation is taken |
1542 | * without change. There is no need to fiddle with |
1543 | * refCount et. al. |
1544 | * |
1545 | * Don't forget to use the same blocking mode as the old channel. |
1546 | */ |
1547 | |
1548 | pt->flags = mask | (chanPtr->flags & CHANNEL_NONBLOCKING); |
1549 | |
1550 | /* |
1551 | * EDITORS NOTE: all the lines with "take it as is" should get |
1552 | * deleted once this code has been debugged. |
1553 | */ |
1554 | |
1555 | /* pt->encoding, take it as is */ |
1556 | /* pt->inputEncodingState, take it as is */ |
1557 | /* pt->inputEncodingFlags, take it as is */ |
1558 | /* pt->outputEncodingState, take it as is */ |
1559 | /* pt->outputEncodingFlags, take it as is */ |
1560 | |
1561 | /* pt->inputTranslation, take it as is */ |
1562 | /* pt->outputTranslation, take it as is */ |
1563 | |
1564 | /* |
1565 | * No special EOF character, that condition is determined by the |
1566 | * old channel |
1567 | */ |
1568 | |
1569 | pt->inEofChar = 0; |
1570 | pt->outEofChar = 0; |
1571 | |
1572 | pt->unreportedError = 0; /* No errors yet */ |
1573 | pt->instanceData = instanceData; /* Transformation state */ |
1574 | pt->typePtr = typePtr; /* Transformation type */ |
1575 | /* pt->refCount, take it as it is */ |
1576 | /* pt->closeCbPtr, take it as it is */ |
1577 | |
1578 | /* pt->outputStage, take it as it is */ |
1579 | pt->curOutPtr = (ChannelBuffer *) NULL; |
1580 | pt->outQueueHead = (ChannelBuffer *) NULL; |
1581 | pt->outQueueTail = (ChannelBuffer *) NULL; |
1582 | pt->saveInBufPtr = (ChannelBuffer *) NULL; |
1583 | pt->inQueueHead = (ChannelBuffer *) NULL; |
1584 | pt->inQueueTail = (ChannelBuffer *) NULL; |
1585 | |
1586 | /* pt->chPtr, take it as it is */ |
1587 | /* pt->interestMask, take it as it is */ |
1588 | /* pt->nextChanPtr, take it as it is */ |
1589 | /* pt->scriptRecordPtr, take it as it is */ |
1590 | pt->bufSize = CHANNELBUFFER_DEFAULT_SIZE; |
1591 | /* pt->timer, take it as it is */ |
1592 | /* pt->csPtr, take it as it is */ |
1593 | |
1594 | /* |
1595 | * Have the transformation reference the new structure containing |
1596 | * the saved channel. |
1597 | */ |
1598 | |
1599 | pt->supercedes = chanPtr; |
1600 | |
1601 | /* |
1602 | * Don't forget to reinitialize the output buffer used for encodings. |
1603 | */ |
1604 | |
1605 | if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) { |
1606 | chanPtr->outputStage = (char *) |
1607 | ckalloc((unsigned) (chanPtr->bufSize + 2)); |
1608 | } |
1609 | |
1610 | /* |
1611 | * Event handling: If the information in the old channel shows |
1612 | * that there was interest in some events call the 'WatchProc' |
1613 | * of the transformation to establish the proper connection |
1614 | * between them. |
1615 | */ |
1616 | |
1617 | if (interest) { |
1618 | (pt->typePtr->watchProc) (pt->instanceData, interest); |
1619 | } |
1620 | |
1621 | /* |
1622 | * The superceded channel is effectively unregistered |
1623 | * We cannot decrement its reference count because that |
1624 | * can cause it to get garbage collected out from under us. |
1625 | * Don't add the following code: |
1626 | * |
1627 | * chanPtr->supercedes->refCount --; |
1628 | */ |
1629 | |
1630 | return (Tcl_Channel) chanPtr; |
1631 | } |
1632 | |
1633 | /* |
1634 | *---------------------------------------------------------------------- |
1635 | * |
1636 | * Tcl_UnstackChannel -- |
1637 | * |
1638 | * Unstacks an entry in the hash table for a Tcl_Channel |
1639 | * record. This is the reverse to 'Tcl_StackChannel'. |
1640 | * The old, superceded channel is uncovered and re-registered |
1641 | * in the appropriate data structures. |
1642 | * |
1643 | * Results: |
1644 | * Returns the old Tcl_Channel, i.e. the one which was stacked over. |
1645 | * |
1646 | * Side effects: |
1647 | * See above. |
1648 | * |
1649 | *---------------------------------------------------------------------- |
1650 | */ |
1651 | |
1652 | void |
1653 | Tcl_UnstackChannel (interp, chan) |
1654 | Tcl_Interp* interp; /* The interpreter we are working in */ |
1655 | Tcl_Channel chan; /* The channel to unstack */ |
1656 | { |
1657 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
1658 | Channel* chanPtr = (Channel*) chan; |
1659 | |
1660 | if (chanPtr->supercedes != (Channel*) NULL) { |
1661 | /* |
1662 | * Instead of manipulating the per-thread / per-interp list/hashtable |
1663 | * of registered channels we wind down the state of the transformation, |
1664 | * and then restore the state of underlying channel into the old |
1665 | * structure. |
1666 | */ |
1667 | |
1668 | Tcl_DString dsTrans; /* storage to save option information */ |
1669 | Tcl_DString dsBuf; /* storage to save option information */ |
1670 | Channel top; /* Save area for current transformation */ |
1671 | Channel* chanDownPtr = chanPtr->supercedes; |
1672 | int interest; /* interest mask of transformation |
1673 | * before destruct. */ |
1674 | int saveInputEncodingFlags; /* Save area for encoding */ |
1675 | int saveOutputEncodingFlags; /* related information */ |
1676 | Tcl_EncodingState saveInputEncodingState; |
1677 | Tcl_EncodingState saveOutputEncodingState; |
1678 | Tcl_Encoding saveEncoding; |
1679 | |
1680 | /* |
1681 | * Event handling: Disallow the delivery of events from the |
1682 | * old, now uncovered channel to the transformation. |
1683 | * |
1684 | * This is done before everything else to avoid problems |
1685 | * after our heavy-duty shuffling of pointers around. |
1686 | */ |
1687 | |
1688 | interest = chanPtr->interestMask; |
1689 | (chanPtr->typePtr->watchProc) (chanPtr->instanceData, 0); |
1690 | |
1691 | /* 1. Swap the information in the top channel (the transformation) |
1692 | * and the channel below, with some exceptions. This additionally |
1693 | * cuts the top channel out of the chain. Without the latter |
1694 | * a Tcl_Close on the transformation would be impossible, as that |
1695 | * procedure will free the structure, making 'top' unusable. |
1696 | * |
1697 | * chanPtr -> top channel, transformation. |
1698 | * chanDownPtr -> channel immediately below the transformation. |
1699 | */ |
1700 | |
1701 | memcpy ((void*) &top, (void*) chanPtr, sizeof (Channel)); |
1702 | memcpy ((void*) chanPtr, (void*) chanDownPtr, sizeof (Channel)); |
1703 | top.supercedes = (Channel*) NULL; |
1704 | memcpy ((void*) chanDownPtr, (void*) &top, sizeof (Channel)); |
1705 | |
1706 | /* Now: |
1707 | * chanPtr -> channel immediately below the transformation, now top |
1708 | * chanDownPtr -> transformation, cut loose. |
1709 | * |
1710 | * Handle the exceptions mentioned above, i.e. move the information |
1711 | * from the transformation into the new top, and reinitialize it to |
1712 | * safe values in the transformation. |
1713 | */ |
1714 | |
1715 | chanPtr->refCount = chanDownPtr->refCount; |
1716 | chanPtr->closeCbPtr = chanDownPtr->closeCbPtr; |
1717 | chanPtr->chPtr = chanDownPtr->chPtr; |
1718 | chanPtr->nextChanPtr = chanDownPtr->nextChanPtr; |
1719 | chanPtr->scriptRecordPtr = chanDownPtr->scriptRecordPtr; |
1720 | chanPtr->timer = chanDownPtr->timer; |
1721 | chanPtr->csPtr = chanDownPtr->csPtr; |
1722 | |
1723 | chanDownPtr->refCount = 0; |
1724 | chanDownPtr->closeCbPtr = (CloseCallback*) NULL; |
1725 | chanDownPtr->chPtr = (ChannelHandler*) NULL; |
1726 | chanDownPtr->nextChanPtr = (Channel*) NULL; |
1727 | chanDownPtr->scriptRecordPtr = (EventScriptRecord*) NULL; |
1728 | chanDownPtr->timer = (Tcl_TimerToken) NULL; |
1729 | chanDownPtr->csPtr = (CopyState*) NULL; |
1730 | |
1731 | /* The now uncovered channel still has encoding and eol-translation |
1732 | * deactivated, i.e. switched to 'binary'. *Don't* touch this until |
1733 | * after the transformation is closed for good, as it may write |
1734 | * information into it during that (-> flushing of data waiting in |
1735 | * internal buffers!) and rely on these settings. Thanks to Matt |
1736 | * Newman <matt@sensus.org> for finding this goof. |
1737 | * |
1738 | * But we also have to protect the state of the encoding from removal |
1739 | * during the close. So we save it in some local variables. |
1740 | * Additionally the current value of the options is lost after we |
1741 | * close, we have to save them now. |
1742 | */ |
1743 | |
1744 | saveEncoding = chanDownPtr->encoding; |
1745 | saveInputEncodingState = chanDownPtr->inputEncodingState; |
1746 | saveInputEncodingFlags = chanDownPtr->inputEncodingFlags; |
1747 | saveOutputEncodingState = chanDownPtr->outputEncodingState; |
1748 | saveOutputEncodingFlags = chanDownPtr->outputEncodingFlags; |
1749 | |
1750 | Tcl_DStringInit (&dsTrans); |
1751 | Tcl_GetChannelOption (interp, (Tcl_Channel) chanDownPtr, |
1752 | "-translation", &dsTrans); |
1753 | |
1754 | Tcl_DStringInit (&dsBuf); |
1755 | Tcl_GetChannelOption (interp, (Tcl_Channel) chanDownPtr, |
1756 | "-buffering", &dsBuf); |
1757 | |
1758 | /* |
1759 | * Prevent the accidential removal of the encoding during |
1760 | * the destruction of the transformation channel. |
1761 | */ |
1762 | |
1763 | chanDownPtr->encoding = (Tcl_Encoding) NULL; |
1764 | chanDownPtr->inputEncodingState = (Tcl_EncodingState) NULL; |
1765 | chanDownPtr->inputEncodingFlags = TCL_ENCODING_START; |
1766 | chanDownPtr->outputEncodingState = (Tcl_EncodingState) NULL; |
1767 | chanDownPtr->outputEncodingFlags = TCL_ENCODING_START; |
1768 | |
1769 | /* |
1770 | * A little trick: Add the transformation structure to the |
1771 | * per-thread list of existing channels (which it never were |
1772 | * part of so far), or Tcl_Close/FlushChannel will panic |
1773 | * ("damaged channel list"). |
1774 | * |
1775 | * Afterward do a regular close upon the transformation. |
1776 | * This may cause flushing of data into the old channel (if the |
1777 | * transformation remembered its own channel in itself). |
1778 | * |
1779 | * We know that its refCount dropped to 0. |
1780 | */ |
1781 | |
1782 | chanDownPtr->nextChanPtr = tsdPtr->firstChanPtr; |
1783 | tsdPtr->firstChanPtr = chanDownPtr; |
1784 | |
1785 | Tcl_Close (interp, (Tcl_Channel)chanDownPtr); |
1786 | |
1787 | /* |
1788 | * Now it is possible to wind down the transformation (in 'top'), |
1789 | * especially to copy the current encoding and translation control |
1790 | * information down. |
1791 | */ |
1792 | |
1793 | /* |
1794 | * Move the currently active encoding from the save area |
1795 | * to the now uncovered channel. We assume here that this |
1796 | * channel uses 'encoding binary' (==> encoding == NULL, etc. |
1797 | * This allows us to simply copy the pointers without having to |
1798 | * think about refcounts and deallocation of the old encoding. |
1799 | * |
1800 | * And don't forget to reenable the EOL-translation used by the |
1801 | * transformation. Using a DString to do this *is* a bit awkward, |
1802 | * but still the best way to handle the complexities here, like |
1803 | * flag manipulation and event system. |
1804 | */ |
1805 | |
1806 | chanPtr->encoding = saveEncoding; |
1807 | chanPtr->inputEncodingState = saveInputEncodingState; |
1808 | chanPtr->inputEncodingFlags = saveInputEncodingFlags; |
1809 | chanPtr->outputEncodingState = saveOutputEncodingState; |
1810 | chanPtr->outputEncodingFlags = saveOutputEncodingFlags; |
1811 | |
1812 | Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr, |
1813 | "-translation", dsTrans.string); |
1814 | |
1815 | Tcl_SetChannelOption (interp, (Tcl_Channel) chanPtr, |
1816 | "-buffering", dsBuf.string); |
1817 | |
1818 | Tcl_DStringFree (&dsTrans); |
1819 | Tcl_DStringFree (&dsBuf); |
1820 | |
1821 | /* |
1822 | * Event handling: If the information from the now destroyed |
1823 | * transformation shows that there was interest in some events |
1824 | * call the 'WatchProc' of the now uncovered channel to renew |
1825 | * that interest with underlying channels or the driver. |
1826 | */ |
1827 | |
1828 | if (interest) { |
1829 | chanPtr->interestMask = 0; |
1830 | (chanPtr->typePtr->watchProc) (chanPtr->instanceData, |
1831 | interest); |
1832 | chanPtr->interestMask = interest; |
1833 | } |
1834 | |
1835 | } else { |
1836 | /* This channel does not cover another one. |
1837 | * Simply do a close, if necessary. |
1838 | */ |
1839 | |
1840 | if (chanPtr->refCount == 0) { |
1841 | Tcl_Close (interp, chan); |
1842 | } |
1843 | } |
1844 | } |
1845 | |
1846 | /* |
1847 | *---------------------------------------------------------------------- |
1848 | * |
1849 | * Tcl_GetStackedChannel -- |
1850 | * |
1851 | * Determines wether the specified channel is stacked upon another. |
1852 | * |
1853 | * Results: |
1854 | * NULL if the channel is not stacked upon another one, or a reference |
1855 | * to the channel it is stacked upon. This reference can be used in |
1856 | * queries, but modification is not allowed. |
1857 | * |
1858 | * Side effects: |
1859 | * None. |
1860 | * |
1861 | *---------------------------------------------------------------------- |
1862 | */ |
1863 | |
1864 | Tcl_Channel |
1865 | Tcl_GetStackedChannel(chan) |
1866 | Tcl_Channel chan; |
1867 | { |
1868 | Channel* chanPtr = (Channel*) chan; |
1869 | return (Tcl_Channel) chanPtr->supercedes; |
1870 | } |
1871 | |
1872 | /* |
1873 | *---------------------------------------------------------------------- |
1874 | * |
1875 | * Tcl_GetChannelMode -- |
1876 | * |
1877 | * Computes a mask indicating whether the channel is open for |
1878 | * reading and writing. |
1879 | * |
1880 | * Results: |
1881 | * An OR-ed combination of TCL_READABLE and TCL_WRITABLE. |
1882 | * |
1883 | * Side effects: |
1884 | * None. |
1885 | * |
1886 | *---------------------------------------------------------------------- |
1887 | */ |
1888 | |
1889 | int |
1890 | Tcl_GetChannelMode(chan) |
1891 | Tcl_Channel chan; /* The channel for which the mode is |
1892 | * being computed. */ |
1893 | { |
1894 | Channel *chanPtr; /* The actual channel. */ |
1895 | |
1896 | chanPtr = (Channel *) chan; |
1897 | return (chanPtr->flags & (TCL_READABLE | TCL_WRITABLE)); |
1898 | } |
1899 | |
1900 | /* |
1901 | *---------------------------------------------------------------------- |
1902 | * |
1903 | * Tcl_GetChannelName -- |
1904 | * |
1905 | * Returns the string identifying the channel name. |
1906 | * |
1907 | * Results: |
1908 | * The string containing the channel name. This memory is |
1909 | * owned by the generic layer and should not be modified by |
1910 | * the caller. |
1911 | * |
1912 | * Side effects: |
1913 | * None. |
1914 | * |
1915 | *---------------------------------------------------------------------- |
1916 | */ |
1917 | |
1918 | char * |
1919 | Tcl_GetChannelName(chan) |
1920 | Tcl_Channel chan; /* The channel for which to return the name. */ |
1921 | { |
1922 | Channel *chanPtr; /* The actual channel. */ |
1923 | |
1924 | chanPtr = (Channel *) chan; |
1925 | return chanPtr->channelName; |
1926 | } |
1927 | |
1928 | /* |
1929 | *---------------------------------------------------------------------- |
1930 | * |
1931 | * Tcl_GetChannelType -- |
1932 | * |
1933 | * Given a channel structure, returns the channel type structure. |
1934 | * |
1935 | * Results: |
1936 | * Returns a pointer to the channel type structure. |
1937 | * |
1938 | * Side effects: |
1939 | * None. |
1940 | * |
1941 | *---------------------------------------------------------------------- |
1942 | */ |
1943 | |
1944 | Tcl_ChannelType * |
1945 | Tcl_GetChannelType(chan) |
1946 | Tcl_Channel chan; /* The channel to return type for. */ |
1947 | { |
1948 | Channel *chanPtr; /* The actual channel. */ |
1949 | |
1950 | chanPtr = (Channel *) chan; |
1951 | return chanPtr->typePtr; |
1952 | } |
1953 | |
1954 | /* |
1955 | *---------------------------------------------------------------------- |
1956 | * |
1957 | * Tcl_GetChannelHandle -- |
1958 | * |
1959 | * Returns an OS handle associated with a channel. |
1960 | * |
1961 | * Results: |
1962 | * Returns TCL_OK and places the handle in handlePtr, or returns |
1963 | * TCL_ERROR on failure. |
1964 | * |
1965 | * Side effects: |
1966 | * None. |
1967 | * |
1968 | *---------------------------------------------------------------------- |
1969 | */ |
1970 | |
1971 | int |
1972 | Tcl_GetChannelHandle(chan, direction, handlePtr) |
1973 | Tcl_Channel chan; /* The channel to get file from. */ |
1974 | int direction; /* TCL_WRITABLE or TCL_READABLE. */ |
1975 | ClientData *handlePtr; /* Where to store handle */ |
1976 | { |
1977 | Channel *chanPtr; /* The actual channel. */ |
1978 | ClientData handle; |
1979 | int result; |
1980 | |
1981 | chanPtr = (Channel *) chan; |
1982 | result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData, |
1983 | direction, &handle); |
1984 | if (handlePtr) { |
1985 | *handlePtr = handle; |
1986 | } |
1987 | return result; |
1988 | } |
1989 | |
1990 | /* |
1991 | *---------------------------------------------------------------------- |
1992 | * |
1993 | * Tcl_GetChannelInstanceData -- |
1994 | * |
1995 | * Returns the client data associated with a channel. |
1996 | * |
1997 | * Results: |
1998 | * The client data. |
1999 | * |
2000 | * Side effects: |
2001 | * None. |
2002 | * |
2003 | *---------------------------------------------------------------------- |
2004 | */ |
2005 | |
2006 | ClientData |
2007 | Tcl_GetChannelInstanceData(chan) |
2008 | Tcl_Channel chan; /* Channel for which to return client data. */ |
2009 | { |
2010 | Channel *chanPtr; /* The actual channel. */ |
2011 | |
2012 | chanPtr = (Channel *) chan; |
2013 | return chanPtr->instanceData; |
2014 | } |
2015 | |
2016 | /* |
2017 | *--------------------------------------------------------------------------- |
2018 | * |
2019 | * AllocChannelBuffer -- |
2020 | * |
2021 | * A channel buffer has BUFFER_PADDING bytes extra at beginning to |
2022 | * hold any bytes of a native-encoding character that got split by |
2023 | * the end of the previous buffer and need to be moved to the |
2024 | * beginning of the next buffer to make a contiguous string so it |
2025 | * can be converted to UTF-8. |
2026 | * |
2027 | * A channel buffer has BUFFER_PADDING bytes extra at the end to |
2028 | * hold any bytes of a native-encoding character (generated from a |
2029 | * UTF-8 character) that overflow past the end of the buffer and |
2030 | * need to be moved to the next buffer. |
2031 | * |
2032 | * Results: |
2033 | * A newly allocated channel buffer. |
2034 | * |
2035 | * Side effects: |
2036 | * None. |
2037 | * |
2038 | *--------------------------------------------------------------------------- |
2039 | */ |
2040 | |
2041 | static ChannelBuffer * |
2042 | AllocChannelBuffer(length) |
2043 | int length; /* Desired length of channel buffer. */ |
2044 | { |
2045 | ChannelBuffer *bufPtr; |
2046 | int n; |
2047 | |
2048 | n = length + CHANNELBUFFER_HEADER_SIZE + BUFFER_PADDING + BUFFER_PADDING; |
2049 | bufPtr = (ChannelBuffer *) ckalloc((unsigned) n); |
2050 | bufPtr->nextAdded = BUFFER_PADDING; |
2051 | bufPtr->nextRemoved = BUFFER_PADDING; |
2052 | bufPtr->bufLength = length + BUFFER_PADDING; |
2053 | bufPtr->nextPtr = (ChannelBuffer *) NULL; |
2054 | return bufPtr; |
2055 | } |
2056 | |
2057 | /* |
2058 | *---------------------------------------------------------------------- |
2059 | * |
2060 | * RecycleBuffer -- |
2061 | * |
2062 | * Helper function to recycle input and output buffers. Ensures |
2063 | * that two input buffers are saved (one in the input queue and |
2064 | * another in the saveInBufPtr field) and that curOutPtr is set |
2065 | * to a buffer. Only if these conditions are met is the buffer |
2066 | * freed to the OS. |
2067 | * |
2068 | * Results: |
2069 | * None. |
2070 | * |
2071 | * Side effects: |
2072 | * May free a buffer to the OS. |
2073 | * |
2074 | *---------------------------------------------------------------------- |
2075 | */ |
2076 | |
2077 | static void |
2078 | RecycleBuffer(chanPtr, bufPtr, mustDiscard) |
2079 | Channel *chanPtr; /* Channel for which to recycle buffers. */ |
2080 | ChannelBuffer *bufPtr; /* The buffer to recycle. */ |
2081 | int mustDiscard; /* If nonzero, free the buffer to the |
2082 | * OS, always. */ |
2083 | { |
2084 | /* |
2085 | * Do we have to free the buffer to the OS? |
2086 | */ |
2087 | |
2088 | if (mustDiscard) { |
2089 | ckfree((char *) bufPtr); |
2090 | return; |
2091 | } |
2092 | |
2093 | /* |
2094 | * Only save buffers for the input queue if the channel is readable. |
2095 | */ |
2096 | |
2097 | if (chanPtr->flags & TCL_READABLE) { |
2098 | if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) { |
2099 | chanPtr->inQueueHead = bufPtr; |
2100 | chanPtr->inQueueTail = bufPtr; |
2101 | goto keepit; |
2102 | } |
2103 | if (chanPtr->saveInBufPtr == (ChannelBuffer *) NULL) { |
2104 | chanPtr->saveInBufPtr = bufPtr; |
2105 | goto keepit; |
2106 | } |
2107 | } |
2108 | |
2109 | /* |
2110 | * Only save buffers for the output queue if the channel is writable. |
2111 | */ |
2112 | |
2113 | if (chanPtr->flags & TCL_WRITABLE) { |
2114 | if (chanPtr->curOutPtr == (ChannelBuffer *) NULL) { |
2115 | chanPtr->curOutPtr = bufPtr; |
2116 | goto keepit; |
2117 | } |
2118 | } |
2119 | |
2120 | /* |
2121 | * If we reached this code we return the buffer to the OS. |
2122 | */ |
2123 | |
2124 | ckfree((char *) bufPtr); |
2125 | return; |
2126 | |
2127 | keepit: |
2128 | bufPtr->nextRemoved = BUFFER_PADDING; |
2129 | bufPtr->nextAdded = BUFFER_PADDING; |
2130 | bufPtr->nextPtr = (ChannelBuffer *) NULL; |
2131 | } |
2132 | |
2133 | /* |
2134 | *---------------------------------------------------------------------- |
2135 | * |
2136 | * DiscardOutputQueued -- |
2137 | * |
2138 | * Discards all output queued in the output queue of a channel. |
2139 | * |
2140 | * Results: |
2141 | * None. |
2142 | * |
2143 | * Side effects: |
2144 | * Recycles buffers. |
2145 | * |
2146 | *---------------------------------------------------------------------- |
2147 | */ |
2148 | |
2149 | static void |
2150 | DiscardOutputQueued(chanPtr) |
2151 | Channel *chanPtr; /* The channel for which to discard output. */ |
2152 | { |
2153 | ChannelBuffer *bufPtr; |
2154 | |
2155 | while (chanPtr->outQueueHead != (ChannelBuffer *) NULL) { |
2156 | bufPtr = chanPtr->outQueueHead; |
2157 | chanPtr->outQueueHead = bufPtr->nextPtr; |
2158 | RecycleBuffer(chanPtr, bufPtr, 0); |
2159 | } |
2160 | chanPtr->outQueueHead = (ChannelBuffer *) NULL; |
2161 | chanPtr->outQueueTail = (ChannelBuffer *) NULL; |
2162 | } |
2163 | |
2164 | /* |
2165 | *---------------------------------------------------------------------- |
2166 | * |
2167 | * CheckForDeadChannel -- |
2168 | * |
2169 | * This function checks is a given channel is Dead. |
2170 | * (A channel that has been closed but not yet deallocated.) |
2171 | * |
2172 | * Results: |
2173 | * True (1) if channel is Dead, False (0) if channel is Ok |
2174 | * |
2175 | * Side effects: |
2176 | * None |
2177 | * |
2178 | *---------------------------------------------------------------------- |
2179 | */ |
2180 | |
2181 | static int |
2182 | CheckForDeadChannel(interp, chanPtr) |
2183 | Tcl_Interp *interp; /* For error reporting (can be NULL) */ |
2184 | Channel *chanPtr; /* The channel to check. */ |
2185 | { |
2186 | if (chanPtr->flags & CHANNEL_DEAD) { |
2187 | Tcl_SetErrno(EINVAL); |
2188 | if (interp) { |
2189 | Tcl_AppendResult(interp, |
2190 | "unable to access channel: invalid channel", |
2191 | (char *) NULL); |
2192 | } |
2193 | return 1; |
2194 | } |
2195 | return 0; |
2196 | } |
2197 | |
2198 | /* |
2199 | *---------------------------------------------------------------------- |
2200 | * |
2201 | * FlushChannel -- |
2202 | * |
2203 | * This function flushes as much of the queued output as is possible |
2204 | * now. If calledFromAsyncFlush is nonzero, it is being called in an |
2205 | * event handler to flush channel output asynchronously. |
2206 | * |
2207 | * Results: |
2208 | * 0 if successful, else the error code that was returned by the |
2209 | * channel type operation. |
2210 | * |
2211 | * Side effects: |
2212 | * May produce output on a channel. May block indefinitely if the |
2213 | * channel is synchronous. May schedule an async flush on the channel. |
2214 | * May recycle memory for buffers in the output queue. |
2215 | * |
2216 | *---------------------------------------------------------------------- |
2217 | */ |
2218 | |
2219 | static int |
2220 | FlushChannel(interp, chanPtr, calledFromAsyncFlush) |
2221 | Tcl_Interp *interp; /* For error reporting during close. */ |
2222 | Channel *chanPtr; /* The channel to flush on. */ |
2223 | int calledFromAsyncFlush; /* If nonzero then we are being |
2224 | * called from an asynchronous |
2225 | * flush callback. */ |
2226 | { |
2227 | ChannelBuffer *bufPtr; /* Iterates over buffered output |
2228 | * queue. */ |
2229 | int toWrite; /* Amount of output data in current |
2230 | * buffer available to be written. */ |
2231 | int written; /* Amount of output data actually |
2232 | * written in current round. */ |
2233 | int errorCode = 0; /* Stores POSIX error codes from |
2234 | * channel driver operations. */ |
2235 | int wroteSome = 0; /* Set to one if any data was |
2236 | * written to the driver. */ |
2237 | |
2238 | /* |
2239 | * Prevent writing on a dead channel -- a channel that has been closed |
2240 | * but not yet deallocated. This can occur if the exit handler for the |
2241 | * channel deallocation runs before all channels are deregistered in |
2242 | * all interpreters. |
2243 | */ |
2244 | |
2245 | if (CheckForDeadChannel(interp,chanPtr)) return -1; |
2246 | |
2247 | /* |
2248 | * Loop over the queued buffers and attempt to flush as |
2249 | * much as possible of the queued output to the channel. |
2250 | */ |
2251 | |
2252 | while (1) { |
2253 | |
2254 | /* |
2255 | * If the queue is empty and there is a ready current buffer, OR if |
2256 | * the current buffer is full, then move the current buffer to the |
2257 | * queue. |
2258 | */ |
2259 | |
2260 | if (((chanPtr->curOutPtr != (ChannelBuffer *) NULL) && |
2261 | (chanPtr->curOutPtr->nextAdded == chanPtr->curOutPtr->bufLength)) |
2262 | || ((chanPtr->flags & BUFFER_READY) && |
2263 | (chanPtr->outQueueHead == (ChannelBuffer *) NULL))) { |
2264 | chanPtr->flags &= (~(BUFFER_READY)); |
2265 | chanPtr->curOutPtr->nextPtr = (ChannelBuffer *) NULL; |
2266 | if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) { |
2267 | chanPtr->outQueueHead = chanPtr->curOutPtr; |
2268 | } else { |
2269 | chanPtr->outQueueTail->nextPtr = chanPtr->curOutPtr; |
2270 | } |
2271 | chanPtr->outQueueTail = chanPtr->curOutPtr; |
2272 | chanPtr->curOutPtr = (ChannelBuffer *) NULL; |
2273 | } |
2274 | bufPtr = chanPtr->outQueueHead; |
2275 | |
2276 | /* |
2277 | * If we are not being called from an async flush and an async |
2278 | * flush is active, we just return without producing any output. |
2279 | */ |
2280 | |
2281 | if ((!calledFromAsyncFlush) && |
2282 | (chanPtr->flags & BG_FLUSH_SCHEDULED)) { |
2283 | return 0; |
2284 | } |
2285 | |
2286 | /* |
2287 | * If the output queue is still empty, break out of the while loop. |
2288 | */ |
2289 | |
2290 | if (bufPtr == (ChannelBuffer *) NULL) { |
2291 | break; /* Out of the "while (1)". */ |
2292 | } |
2293 | |
2294 | /* |
2295 | * Produce the output on the channel. |
2296 | */ |
2297 | |
2298 | toWrite = bufPtr->nextAdded - bufPtr->nextRemoved; |
2299 | written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData, |
2300 | (char *) bufPtr->buf + bufPtr->nextRemoved, toWrite, |
2301 | &errorCode); |
2302 | |
2303 | /* |
2304 | * If the write failed completely attempt to start the asynchronous |
2305 | * flush mechanism and break out of this loop - do not attempt to |
2306 | * write any more output at this time. |
2307 | */ |
2308 | |
2309 | if (written < 0) { |
2310 | |
2311 | /* |
2312 | * If the last attempt to write was interrupted, simply retry. |
2313 | */ |
2314 | |
2315 | if (errorCode == EINTR) { |
2316 | errorCode = 0; |
2317 | continue; |
2318 | } |
2319 | |
2320 | /* |
2321 | * If the channel is non-blocking and we would have blocked, |
2322 | * start a background flushing handler and break out of the loop. |
2323 | */ |
2324 | |
2325 | if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) { |
2326 | /* |
2327 | * This used to check for CHANNEL_NONBLOCKING, and panic |
2328 | * if the channel was blocking. However, it appears |
2329 | * that setting stdin to -blocking 0 has some effect on |
2330 | * the stdout when it's a tty channel (dup'ed underneath) |
2331 | */ |
2332 | if (!(chanPtr->flags & BG_FLUSH_SCHEDULED)) { |
2333 | chanPtr->flags |= BG_FLUSH_SCHEDULED; |
2334 | UpdateInterest(chanPtr); |
2335 | } |
2336 | errorCode = 0; |
2337 | break; |
2338 | } |
2339 | |
2340 | /* |
2341 | * Decide whether to report the error upwards or defer it. |
2342 | */ |
2343 | |
2344 | if (calledFromAsyncFlush) { |
2345 | if (chanPtr->unreportedError == 0) { |
2346 | chanPtr->unreportedError = errorCode; |
2347 | } |
2348 | } else { |
2349 | Tcl_SetErrno(errorCode); |
2350 | if (interp != NULL) { |
2351 | Tcl_SetResult(interp, |
2352 | Tcl_PosixError(interp), TCL_VOLATILE); |
2353 | } |
2354 | } |
2355 | |
2356 | /* |
2357 | * When we get an error we throw away all the output |
2358 | * currently queued. |
2359 | */ |
2360 | |
2361 | DiscardOutputQueued(chanPtr); |
2362 | continue; |
2363 | } else { |
2364 | wroteSome = 1; |
2365 | } |
2366 | |
2367 | bufPtr->nextRemoved += written; |
2368 | |
2369 | /* |
2370 | * If this buffer is now empty, recycle it. |
2371 | */ |
2372 | |
2373 | if (bufPtr->nextRemoved == bufPtr->nextAdded) { |
2374 | chanPtr->outQueueHead = bufPtr->nextPtr; |
2375 | if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) { |
2376 | chanPtr->outQueueTail = (ChannelBuffer *) NULL; |
2377 | } |
2378 | RecycleBuffer(chanPtr, bufPtr, 0); |
2379 | } |
2380 | } /* Closes "while (1)". */ |
2381 | |
2382 | /* |
2383 | * If we wrote some data while flushing in the background, we are done. |
2384 | * We can't finish the background flush until we run out of data and |
2385 | * the channel becomes writable again. This ensures that all of the |
2386 | * pending data has been flushed at the system level. |
2387 | */ |
2388 | |
2389 | if (chanPtr->flags & BG_FLUSH_SCHEDULED) { |
2390 | if (wroteSome) { |
2391 | return errorCode; |
2392 | } else if (chanPtr->outQueueHead == (ChannelBuffer *) NULL) { |
2393 | chanPtr->flags &= (~(BG_FLUSH_SCHEDULED)); |
2394 | (chanPtr->typePtr->watchProc)(chanPtr->instanceData, |
2395 | chanPtr->interestMask); |
2396 | } |
2397 | } |
2398 | |
2399 | /* |
2400 | * If the channel is flagged as closed, delete it when the refCount |
2401 | * drops to zero, the output queue is empty and there is no output |
2402 | * in the current output buffer. |
2403 | */ |
2404 | |
2405 | if ((chanPtr->flags & CHANNEL_CLOSED) && (chanPtr->refCount <= 0) && |
2406 | (chanPtr->outQueueHead == (ChannelBuffer *) NULL) && |
2407 | ((chanPtr->curOutPtr == (ChannelBuffer *) NULL) || |
2408 | (chanPtr->curOutPtr->nextAdded == |
2409 | chanPtr->curOutPtr->nextRemoved))) { |
2410 | return CloseChannel(interp, chanPtr, errorCode); |
2411 | } |
2412 | return errorCode; |
2413 | } |
2414 | |
2415 | /* |
2416 | *---------------------------------------------------------------------- |
2417 | * |
2418 | * CloseChannel -- |
2419 | * |
2420 | * Utility procedure to close a channel and free its associated |
2421 | * resources. |
2422 | * |
2423 | * Results: |
2424 | * 0 on success or a POSIX error code if the operation failed. |
2425 | * |
2426 | * Side effects: |
2427 | * May close the actual channel; may free memory. |
2428 | * |
2429 | *---------------------------------------------------------------------- |
2430 | */ |
2431 | |
2432 | static int |
2433 | CloseChannel(interp, chanPtr, errorCode) |
2434 | Tcl_Interp *interp; /* For error reporting. */ |
2435 | Channel *chanPtr; /* The channel to close. */ |
2436 | int errorCode; /* Status of operation so far. */ |
2437 | { |
2438 | int result = 0; /* Of calling driver close |
2439 | * operation. */ |
2440 | Channel *prevChanPtr; /* Preceding channel in list of |
2441 | * all channels - used to splice a |
2442 | * channel out of the list on close. */ |
2443 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
2444 | |
2445 | if (chanPtr == NULL) { |
2446 | return result; |
2447 | } |
2448 | |
2449 | /* |
2450 | * No more input can be consumed so discard any leftover input. |
2451 | */ |
2452 | |
2453 | DiscardInputQueued(chanPtr, 1); |
2454 | |
2455 | /* |
2456 | * Discard a leftover buffer in the current output buffer field. |
2457 | */ |
2458 | |
2459 | if (chanPtr->curOutPtr != (ChannelBuffer *) NULL) { |
2460 | ckfree((char *) chanPtr->curOutPtr); |
2461 | chanPtr->curOutPtr = (ChannelBuffer *) NULL; |
2462 | } |
2463 | |
2464 | /* |
2465 | * The caller guarantees that there are no more buffers |
2466 | * queued for output. |
2467 | */ |
2468 | |
2469 | if (chanPtr->outQueueHead != (ChannelBuffer *) NULL) { |
2470 | panic("TclFlush, closed channel: queued output left"); |
2471 | } |
2472 | |
2473 | /* |
2474 | * If the EOF character is set in the channel, append that to the |
2475 | * output device. |
2476 | */ |
2477 | |
2478 | if ((chanPtr->outEofChar != 0) && (chanPtr->flags & TCL_WRITABLE)) { |
2479 | int dummy; |
2480 | char c; |
2481 | |
2482 | c = (char) chanPtr->outEofChar; |
2483 | (chanPtr->typePtr->outputProc) (chanPtr->instanceData, &c, 1, &dummy); |
2484 | } |
2485 | |
2486 | /* |
2487 | * Remove TCL_READABLE and TCL_WRITABLE from chanPtr->flags, so |
2488 | * that close callbacks can not do input or output (assuming they |
2489 | * squirreled the channel away in their clientData). This also |
2490 | * prevents infinite loops if the callback calls any C API that |
2491 | * could call FlushChannel. |
2492 | */ |
2493 | |
2494 | chanPtr->flags &= (~(TCL_READABLE|TCL_WRITABLE)); |
2495 | |
2496 | /* |
2497 | * Splice this channel out of the list of all channels. |
2498 | */ |
2499 | |
2500 | if (chanPtr == tsdPtr->firstChanPtr) { |
2501 | tsdPtr->firstChanPtr = chanPtr->nextChanPtr; |
2502 | } else { |
2503 | for (prevChanPtr = tsdPtr->firstChanPtr; |
2504 | (prevChanPtr != (Channel *) NULL) && |
2505 | (prevChanPtr->nextChanPtr != chanPtr); |
2506 | prevChanPtr = prevChanPtr->nextChanPtr) { |
2507 | /* Empty loop body. */ |
2508 | } |
2509 | if (prevChanPtr == (Channel *) NULL) { |
2510 | panic("FlushChannel: damaged channel list"); |
2511 | } |
2512 | prevChanPtr->nextChanPtr = chanPtr->nextChanPtr; |
2513 | } |
2514 | |
2515 | /* |
2516 | * Close and free the channel driver state. |
2517 | */ |
2518 | |
2519 | if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { |
2520 | result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp); |
2521 | } else { |
2522 | result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp, |
2523 | 0); |
2524 | } |
2525 | |
2526 | if (chanPtr->channelName != (char *) NULL) { |
2527 | ckfree(chanPtr->channelName); |
2528 | } |
2529 | Tcl_FreeEncoding(chanPtr->encoding); |
2530 | if (chanPtr->outputStage != NULL) { |
2531 | ckfree((char *) chanPtr->outputStage); |
2532 | } |
2533 | |
2534 | /* |
2535 | * If we are being called synchronously, report either |
2536 | * any latent error on the channel or the current error. |
2537 | */ |
2538 | |
2539 | if (chanPtr->unreportedError != 0) { |
2540 | errorCode = chanPtr->unreportedError; |
2541 | } |
2542 | if (errorCode == 0) { |
2543 | errorCode = result; |
2544 | if (errorCode != 0) { |
2545 | Tcl_SetErrno(errorCode); |
2546 | } |
2547 | } |
2548 | |
2549 | /* Andreas Kupries <a.kupries@westend.com>, 12/13/1998 |
2550 | * "Trf-Patch for filtering channels" |
2551 | * |
2552 | * This is the change to 'CloseChannel'. |
2553 | * |
2554 | * Explanation |
2555 | * Closing a filtering channel closes the one it |
2556 | * superceded too. This basically ripples through |
2557 | * the whole chain of filters until it reaches |
2558 | * the underlying normal channel. |
2559 | * |
2560 | * This is done by reintegrating the superceded |
2561 | * channel into the (thread) global list of open |
2562 | * channels and then invoking a regular close. |
2563 | * There is no need to handle the complexities of |
2564 | * this process by ourselves. |
2565 | * |
2566 | * *Note* |
2567 | * This has to be done after the call to the |
2568 | * 'closeProc' of the filtering channel to allow |
2569 | * that one to flush internal buffers into |
2570 | * the underlying channel. |
2571 | */ |
2572 | |
2573 | if (chanPtr->supercedes != (Channel*) NULL) { |
2574 | /* |
2575 | * Insert the channel we were stacked upon back into |
2576 | * the list of open channels, then do a regular close. |
2577 | */ |
2578 | |
2579 | chanPtr->supercedes->nextChanPtr = tsdPtr->firstChanPtr; |
2580 | tsdPtr->firstChanPtr = chanPtr->supercedes; |
2581 | chanPtr->supercedes->refCount --; /* is deregistered */ |
2582 | Tcl_Close (interp, (Tcl_Channel) chanPtr->supercedes); |
2583 | } |
2584 | |
2585 | /* |
2586 | * Cancel any outstanding timer. |
2587 | */ |
2588 | |
2589 | Tcl_DeleteTimerHandler(chanPtr->timer); |
2590 | |
2591 | /* |
2592 | * Mark the channel as deleted by clearing the type structure. |
2593 | */ |
2594 | |
2595 | chanPtr->typePtr = NULL; |
2596 | |
2597 | Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC); |
2598 | |
2599 | return errorCode; |
2600 | } |
2601 | |
2602 | /* |
2603 | *---------------------------------------------------------------------- |
2604 | * |
2605 | * Tcl_Close -- |
2606 | * |
2607 | * Closes a channel. |
2608 | * |
2609 | * Results: |
2610 | * A standard Tcl result. |
2611 | * |
2612 | * Side effects: |
2613 | * Closes the channel if this is the last reference. |
2614 | * |
2615 | * NOTE: |
2616 | * Tcl_Close removes the channel as far as the user is concerned. |
2617 | * However, it may continue to exist for a while longer if it has |
2618 | * a background flush scheduled. The device itself is eventually |
2619 | * closed and the channel record removed, in CloseChannel, above. |
2620 | * |
2621 | *---------------------------------------------------------------------- |
2622 | */ |
2623 | |
2624 | /* ARGSUSED */ |
2625 | int |
2626 | Tcl_Close(interp, chan) |
2627 | Tcl_Interp *interp; /* Interpreter for errors. */ |
2628 | Tcl_Channel chan; /* The channel being closed. Must |
2629 | * not be referenced in any |
2630 | * interpreter. */ |
2631 | { |
2632 | ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */ |
2633 | CloseCallback *cbPtr; /* Iterate over close callbacks |
2634 | * for this channel. */ |
2635 | EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */ |
2636 | Channel *chanPtr; /* The real IO channel. */ |
2637 | int result; /* Of calling FlushChannel. */ |
2638 | ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); |
2639 | NextChannelHandler *nhPtr; |
2640 | |
2641 | if (chan == (Tcl_Channel) NULL) { |
2642 | return TCL_OK; |
2643 | } |
2644 | |
2645 | /* |
2646 | * Perform special handling for standard channels being closed. If the |
2647 | * refCount is now 1 it means that the last reference to the standard |
2648 | * channel is being explicitly closed, so bump the refCount down |
2649 | * artificially to 0. This will ensure that the channel is actually |
2650 | * closed, below. Also set the static pointer to NULL for the channel. |
2651 | */ |
2652 | |
2653 | CheckForStdChannelsBeingClosed(chan); |
2654 | |
2655 | chanPtr = (Channel *) chan; |
2656 | if (chanPtr->refCount > 0) { |
2657 | panic("called Tcl_Close on channel with refCount > 0"); |
2658 | } |
2659 | |
2660 | /* |
2661 | * Remove any references to channel handlers for this channel that |
2662 | * may be about to be invoked. |
2663 | */ |
2664 | |
2665 | for (nhPtr = tsdPtr->nestedHandlerPtr; |
2666 | nhPtr != (NextChannelHandler *) NULL; |
2667 | nhPtr = nhPtr->nestedHandlerPtr) { |
2668 | if (nhPtr->nextHandlerPtr && |
2669 | (nhPtr->nextHandlerPtr->chanPtr == chanPtr)) { |
2670 | nhPtr->nextHandlerPtr = NULL; |
2671 | } |
2672 | } |
2673 | |
2674 | /* |
2675 | * Remove all the channel handler records attached to the channel |
2676 | * itself. |
2677 | */ |
2678 | |
2679 | for (chPtr = chanPtr->chPtr; |
2680 | chPtr != (ChannelHandler *) NULL; |
2681 | chPtr = chNext) { |
2682 | chNext = chPtr->nextPtr; |
2683 | ckfree((char *) chPtr); |
2684 | } |
2685 | chanPtr->chPtr = (ChannelHandler *) NULL; |
2686 | |
2687 | |
2688 | /* |
2689 | * Cancel any pending copy operation. |
2690 | */ |
2691 | |
2692 | StopCopy(chanPtr->csPtr); |
2693 | |
2694 | /* |
2695 | * Must set the interest mask now to 0, otherwise infinite loops |
2696 | * will occur if Tcl_DoOneEvent is called before the channel is |
2697 | * finally deleted in FlushChannel. This can happen if the channel |
2698 | * has a background flush active. |
2699 | */ |
2700 | |
2701 | chanPtr->interestMask = 0; |
2702 | |
2703 | /* |
2704 | * Remove any EventScript records for this channel. |
2705 | */ |
2706 | |
2707 | for (ePtr = chanPtr->scriptRecordPtr; |
2708 | ePtr != (EventScriptRecord *) NULL; |
2709 | ePtr = eNextPtr) { |
2710 | eNextPtr = ePtr->nextPtr; |
2711 | Tcl_DecrRefCount(ePtr->scriptPtr); |
2712 | ckfree((char *) ePtr); |
2713 | } |
2714 | chanPtr->scriptRecordPtr = (EventScriptRecord *) NULL; |
2715 | |
2716 | /* |
2717 | * Invoke the registered close callbacks and delete their records. |
2718 | */ |
2719 | |
2720 | while (chanPtr->closeCbPtr != (CloseCallback *) NULL) { |
2721 | cbPtr = chanPtr->closeCbPtr; |
2722 | chanPtr->closeCbPtr = cbPtr->nextPtr; |
2723 | (cbPtr->proc) (cbPtr->clientData); |
2724 | ckfree((char *) cbPtr); |
2725 | } |
2726 | |
2727 | /* |
2728 | * Ensure that the last output buffer will be flushed. |
2729 | */ |
2730 | |
2731 | if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) && |
2732 | (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) { |
2733 | chanPtr->flags |= BUFFER_READY; |
2734 | } |
2735 | |
2736 | /* |
2737 | * If this channel supports it, close the read side, since we don't need it |
2738 | * anymore and this will help avoid deadlocks on some channel types. |
2739 | */ |
2740 | |
2741 | if (chanPtr->typePtr->closeProc == TCL_CLOSE2PROC) { |
2742 | result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp, |
2743 | TCL_CLOSE_READ); |
2744 | } else { |
2745 | result = 0; |
2746 | } |
2747 | |
2748 | /* |
2749 | * The call to FlushChannel will flush any queued output and invoke |
2750 | * the close function of the channel driver, or it will set up the |
2751 | * channel to be flushed and closed asynchronously. |
2752 | */ |
2753 | |
2754 | chanPtr->flags |= CHANNEL_CLOSED; |
2755 | if ((FlushChannel(interp, chanPtr, 0) != 0) || (result != 0)) { |
2756 | return TCL_ERROR; |
2757 | } |
2758 | return TCL_OK; |
2759 | } |
2760 | |
2761 | /* |
2762 | *---------------------------------------------------------------------- |
2763 | * |
2764 | * Tcl_Write -- |
2765 | * |
2766 | * Puts a sequence of bytes into an output buffer, may queue the |
2767 | * buffer for output if it gets full, and also remembers whether the |
2768 | * current buffer is ready e.g. if it contains a newline and we are in |
2769 | * line buffering mode. |
2770 | * |
2771 | * Results: |
2772 | * The number of bytes written or -1 in case of error. If -1, |
2773 | * Tcl_GetErrno will return the error code. |
2774 | * |
2775 | * Side effects: |
2776 | * May buffer up output and may cause output to be produced on the |
2777 | * channel. |
2778 | * |
2779 | *---------------------------------------------------------------------- |
2780 | */ |
2781 | |
2782 | int |
2783 | Tcl_Write(chan, src, srcLen) |
2784 | Tcl_Channel chan; /* The channel to buffer output for. */ |
2785 | char *src; /* Data to queue in output buffer. */ |
2786 | int srcLen; /* Length of data in bytes, or < 0 for |
2787 | * strlen(). */ |
2788 | { |
2789 | Channel *chanPtr; |
2790 | |
2791 | chanPtr = (Channel *) chan; |
2792 | if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) { |
2793 | return -1; |
2794 | } |
2795 | if (srcLen < 0) { |
2796 | srcLen = strlen(src); |
2797 | } |
2798 | return DoWrite(chanPtr, src, srcLen); |
2799 | } |
2800 | |
2801 | /* |
2802 | *--------------------------------------------------------------------------- |
2803 | * |
2804 | * Tcl_WriteChars -- |
2805 | * |
2806 | * Takes a sequence of UTF-8 characters and converts them for output |
2807 | * using the channel's current encoding, may queue the buffer for |
2808 | * output if it gets full, and also remembers whether the current |
2809 | * buffer is ready e.g. if it contains a newline and we are in |
2810 | * line buffering mode. |
2811 | * |
2812 | * Results: |
2813 | * The number of bytes written or -1 in case of error. If -1, |
2814 | * Tcl_GetErrno will return the error code. |
2815 | * |
2816 | * Side effects: |
2817 | * May buffer up output and may cause output to be produced on the |
2818 | * channel. |
2819 | * |
2820 | *---------------------------------------------------------------------- |
2821 | */ |
2822 | |
2823 | int |
2824 | Tcl_WriteChars(chan, src, len) |
2825 | Tcl_Channel chan; /* The channel to buffer output for. */ |
2826 | CONST char *src; /* UTF-8 characters to queue in output buffer. */ |
2827 | int len; /* Length of string in bytes, or < 0 for |
2828 | * strlen(). */ |
2829 | { |
2830 | Channel *chanPtr; |
2831 | |
2832 | chanPtr = (Channel *) chan; |
2833 | if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) { |
2834 | return -1; |
2835 | } |
2836 | if (len < 0) { |
2837 | len = strlen(src); |
2838 | } |
2839 | if (chanPtr->encoding == NULL) { |
2840 | /* |
2841 | * Inefficient way to convert UTF-8 to byte-array, but the |
2842 | * code parallels the way it is done for objects. |
2843 | */ |
2844 | |
2845 | Tcl_Obj *objPtr; |
2846 | int result; |
2847 | |
2848 | objPtr = Tcl_NewStringObj(src, len); |
2849 | src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len); |
2850 | result = WriteBytes(chanPtr, src, len); |
2851 | Tcl_DecrRefCount(objPtr); |
2852 | return result; |
2853 | } |
2854 | return WriteChars(chanPtr, src, len); |
2855 | } |
2856 | |
2857 | /* |
2858 | *--------------------------------------------------------------------------- |
2859 | * |
2860 | * Tcl_WriteObj -- |
2861 | * |
2862 | * Takes the Tcl object and queues its contents for output. If the |
2863 | * encoding of the channel is NULL, takes the byte-array representation |
2864 | * of the object and queues those bytes for output. Otherwise, takes |
2865 | * the characters in the UTF-8 (string) representation of the object |
2866 | * and converts them for output using the channel's current encoding. |
2867 | * May flush internal buffers to output if one becomes full or is ready |
2868 | * for some other reason, e.g. if it contains a newline and the channel |
2869 | * is in line buffering mode. |
2870 | * |
2871 | * Results: |
2872 | * The number of bytes written or -1 in case of error. If -1, |
2873 | * Tcl_GetErrno() will return the error code. |
2874 | * |
2875 | * Side effects: |
2876 | * May buffer up output and may cause output to be produced on the |
2877 | * channel. |
2878 | * |
2879 | *---------------------------------------------------------------------- |
2880 | */ |
2881 | |
2882 | int |
2883 | Tcl_WriteObj(chan, objPtr) |
2884 | Tcl_Channel chan; /* The channel to buffer output for. */ |
2885 | Tcl_Obj *objPtr; /* The object to write. */ |
2886 | { |
2887 | Channel *chanPtr; |
2888 | char *src; |
2889 | int srcLen; |
2890 | |
2891 | chanPtr = (Channel *) chan; |
2892 | if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) { |
2893 | return -1; |
2894 | } |
2895 | if (chanPtr->encoding == NULL) { |
2896 | src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen); |
2897 | return WriteBytes(chanPtr, src, srcLen); |
2898 | } else { |
2899 | src = Tcl_GetStringFromObj(objPtr, &srcLen); |
2900 | return WriteChars(chanPtr, src, srcLen); |
2901 | } |
2902 | } |
2903 | |
2904 | /* |
2905 | *---------------------------------------------------------------------- |
2906 | * |
2907 | * WriteBytes -- |
2908 | * |
2909 | * Write a sequence of bytes into an output buffer, may queue the |
2910 | * buffer for output if it gets full, and also remembers whether the |
2911 | * current buffer is ready e.g. if it contains a newline and we are in |
2912 | * line buffering mode. |
2913 | * |
2914 | * Results: |
2915 | * The number of bytes written or -1 in case of error. If -1, |
2916 | * Tcl_GetErrno will return the error code. |
2917 | * |
2918 | * Side effects: |
2919 | * May buffer up output and may cause output to be produced on the |
2920 | * channel. |
2921 | * |
2922 | *---------------------------------------------------------------------- |
2923 | */ |
2924 | |
2925 | static int |
2926 | WriteBytes(chanPtr, src, srcLen) |
2927 | Channel *chanPtr; /* The channel to buffer output for. */ |
2928 | CONST char *src; /* Bytes to write. */ |
2929 | int srcLen; /* Number of bytes to write. */ |
2930 | { |
2931 | ChannelBuffer *bufPtr; |
2932 | char *dst; |
2933 | int dstLen, dstMax, sawLF, savedLF, total, toWrite; |
2934 | |
2935 | total = 0; |
2936 | sawLF = 0; |
2937 | savedLF = 0; |
2938 | |
2939 | /* |
2940 | * Loop over all bytes in src, storing them in output buffer with |
2941 | * proper EOL translation. |
2942 | */ |
2943 | |
2944 | while (srcLen + savedLF > 0) { |
2945 | bufPtr = chanPtr->curOutPtr; |
2946 | if (bufPtr == NULL) { |
2947 | bufPtr = AllocChannelBuffer(chanPtr->bufSize); |
2948 | chanPtr->curOutPtr = bufPtr; |
2949 | } |
2950 | dst = bufPtr->buf + bufPtr->nextAdded; |
2951 | dstMax = bufPtr->bufLength - bufPtr->nextAdded; |
2952 | dstLen = dstMax; |
2953 | |
2954 | toWrite = dstLen; |
2955 | if (toWrite > srcLen) { |
2956 | toWrite = srcLen; |
2957 | } |
2958 | |
2959 | if (savedLF) { |
2960 | /* |
2961 | * A '\n' was left over from last call to TranslateOutputEOL() |
2962 | * and we need to store it in this buffer. If the channel is |
2963 | * line-based, we will need to flush it. |
2964 | */ |
2965 | |
2966 | *dst++ = '\n'; |
2967 | dstLen--; |
2968 | sawLF++; |
2969 | } |
2970 | sawLF += TranslateOutputEOL(chanPtr, dst, src, &dstLen, &toWrite); |
2971 | dstLen += savedLF; |
2972 | savedLF = 0; |
2973 | |
2974 | if (dstLen > dstMax) { |
2975 | savedLF = 1; |
2976 | dstLen = dstMax; |
2977 | } |
2978 | bufPtr->nextAdded += dstLen; |
2979 | if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) { |
2980 | return -1; |
2981 | } |
2982 | total += dstLen; |
2983 | src += toWrite; |
2984 | srcLen -= toWrite; |
2985 | sawLF = 0; |
2986 | } |
2987 | return total; |
2988 | } |
2989 | |
2990 | /* |
2991 | *---------------------------------------------------------------------- |
2992 | * |
2993 | * WriteChars -- |
2994 | * |
2995 | * Convert UTF-8 bytes to the channel's external encoding and |
2996 | * write the produced bytes into an output buffer, may queue the |
2997 | * buffer for output if it gets full, and also remembers whether the |
2998 | * current buffer is ready e.g. if it contains a newline and we are in |
2999 | * line buffering mode. |
3000 | * |
3001 | * Results: |
3002 | * The number of bytes written or -1 in case of error. If -1, |
3003 | * Tcl_GetErrno will return the error code. |
3004 | * |
3005 | * Side effects: |
3006 | * May buffer up output and may cause output to be produced on the |
3007 | * channel. |
3008 | * |
3009 | *---------------------------------------------------------------------- |
3010 | */ |
3011 | |
3012 | static int |
3013 | WriteChars(chanPtr, src, srcLen) |
3014 | Channel *chanPtr; /* The channel to buffer output for. */ |
3015 | CONST char *src; /* UTF-8 string to write. */ |
3016 | int srcLen; /* Length of UTF-8 string in bytes. */ |
3017 | { |
3018 | ChannelBuffer *bufPtr; |
3019 | char *dst, *stage; |
3020 | int saved, savedLF, sawLF, total, toWrite, flags; |
3021 | int dstWrote, dstLen, stageLen, stageMax, stageRead; |
3022 | Tcl_Encoding encoding; |
3023 | char safe[BUFFER_PADDING]; |
3024 | |
3025 | total = 0; |
3026 | sawLF = 0; |
3027 | savedLF = 0; |
3028 | saved = 0; |
3029 | encoding = chanPtr->encoding; |
3030 | |
3031 | /* |
3032 | * Loop over all UTF-8 characters in src, storing them in staging buffer |
3033 | * with proper EOL translation. |
3034 | */ |
3035 | |
3036 | while (srcLen + savedLF > 0) { |
3037 | stage = chanPtr->outputStage; |
3038 | stageMax = chanPtr->bufSize; |
3039 | stageLen = stageMax; |
3040 | |
3041 | toWrite = stageLen; |
3042 | if (toWrite > srcLen) { |
3043 | toWrite = srcLen; |
3044 | } |
3045 | |
3046 | if (savedLF) { |
3047 | /* |
3048 | * A '\n' was left over from last call to TranslateOutputEOL() |
3049 | * and we need to store it in the staging buffer. If the |
3050 | * channel is line-based, we will need to flush the output |
3051 | * buffer (after translating the staging buffer). |
3052 | */ |
3053 | |
3054 | *stage++ = '\n'; |
3055 | stageLen--; |
3056 | sawLF++; |
3057 | } |
3058 | sawLF += TranslateOutputEOL(chanPtr, stage, src, &stageLen, &toWrite); |
3059 | |
3060 | stage -= savedLF; |
3061 | stageLen += savedLF; |
3062 | savedLF = 0; |
3063 | |
3064 | if (stageLen > stageMax) { |
3065 | savedLF = 1; |
3066 | stageLen = stageMax; |
3067 | } |
3068 | src += toWrite; |
3069 | srcLen -= toWrite; |
3070 | |
3071 | flags = chanPtr->outputEncodingFlags; |
3072 | if (srcLen == 0) { |
3073 | flags |= TCL_ENCODING_END; |
3074 | } |
3075 | |
3076 | /* |
3077 | * Loop over all UTF-8 characters in staging buffer, converting them |
3078 | * to external encoding, storing them in output buffer. |
3079 | */ |
3080 | |
3081 | while (stageLen + saved > 0) { |
3082 | bufPtr = chanPtr->curOutPtr; |
3083 | if (bufPtr == NULL) { |
3084 | bufPtr = AllocChannelBuffer(chanPtr->bufSize); |
3085 | chanPtr->curOutPtr = bufPtr; |
3086 | } |
3087 | dst = bufPtr->buf + bufPtr->nextAdded; |
3088 | dstLen = bufPtr->bufLength - bufPtr->nextAdded; |
3089 | |
3090 | if (saved != 0) { |
3091 | /* |
3092 | * Here's some translated bytes left over from the last |
3093 | * buffer that we need to stick at the beginning of this |
3094 | * buffer. |
3095 | */ |
3096 | |
3097 | memcpy((VOID *) dst, (VOID *) safe, (size_t) saved); |
3098 | bufPtr->nextAdded += saved; |
3099 | dst += saved; |
3100 | dstLen -= saved; |
3101 | saved = 0; |
3102 | } |
3103 | |
3104 | Tcl_UtfToExternal(NULL, encoding, stage, stageLen, flags, |
3105 | &chanPtr->outputEncodingState, dst, |
3106 | dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL); |
3107 | if (stageRead + dstWrote == 0) { |
3108 | /* |
3109 | * We have an incomplete UTF-8 character at the end of the |
3110 | * staging buffer. It will get moved to the beginning of the |
3111 | * staging buffer followed by more bytes from src. |
3112 | */ |
3113 | |
3114 | src -= stageLen; |
3115 | srcLen += stageLen; |
3116 | stageLen = 0; |
3117 | savedLF = 0; |
3118 | break; |
3119 | } |
3120 | bufPtr->nextAdded += dstWrote; |
3121 | if (bufPtr->nextAdded > bufPtr->bufLength) { |
3122 | /* |
3123 | * When translating from UTF-8 to external encoding, we |
3124 | * allowed the translation to produce a character that |
3125 | * crossed the end of the output buffer, so that we would |
3126 | * get a completely full buffer before flushing it. The |
3127 | * extra bytes will be moved to the beginning of the next |
3128 | * buffer. |
3129 | */ |
3130 | |
3131 | saved = bufPtr->nextAdded - bufPtr->bufLength; |
3132 | memcpy((VOID *) safe, (VOID *) (dst + dstLen), (size_t) saved); |
3133 | bufPtr->nextAdded = bufPtr->bufLength; |
3134 | } |
3135 | if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) { |
3136 | return -1; |
3137 | } |
3138 | |
3139 | total += dstWrote; |
3140 | stage += stageRead; |
3141 | stageLen -= stageRead; |
3142 | sawLF = 0; |
3143 | } |
3144 | } |
3145 | return total; |
3146 | } |
3147 | |
3148 | /* |
3149 | *--------------------------------------------------------------------------- |
3150 | * |
3151 | * TranslateOutputEOL -- |
3152 | * |
3153 | * Helper function for WriteBytes() and WriteChars(). Converts the |
3154 | * '\n' characters in the source buffer into the appropriate EOL |
3155 | * form specified by the output translation mode. |
3156 | * |
3157 | * EOL translation stops either when the source buffer is empty |
3158 | * or the output buffer is full. |
3159 | * |
3160 | * When converting to CRLF mode and there is only 1 byte left in |
3161 | * the output buffer, this routine stores the '\r' in the last |
3162 | * byte and then stores the '\n' in the byte just past the end of the |
3163 | * buffer. The caller is responsible for passing in a buffer that |
3164 | * is large enough to hold the extra byte. |
3165 | * |
3166 | * Results: |
3167 | * The return value is 1 if a '\n' was translated from the source |
3168 | * buffer, or 0 otherwise -- this can be used by the caller to |
3169 | * decide to flush a line-based channel even though the channel |
3170 | * buffer is not full. |
3171 | * |
3172 | * *dstLenPtr is filled with how many bytes of the output buffer |
3173 | * were used. As mentioned above, this can be one more that |
3174 | * the output buffer's specified length if a CRLF was stored. |
3175 | * |
3176 | * *srcLenPtr is filled with how many bytes of the source buffer |
3177 | * were consumed. |
3178 | * |
3179 | * Side effects: |
3180 | * It may be obvious, but bears mentioning that when converting |
3181 | * in CRLF mode (which requires two bytes of storage in the output |
3182 | * buffer), the number of bytes consumed from the source buffer |
3183 | * will be less than the number of bytes stored in the output buffer. |
3184 | * |
3185 | *--------------------------------------------------------------------------- |
3186 | */ |
3187 | |
3188 | static int |
3189 | TranslateOutputEOL(chanPtr, dst, src, dstLenPtr, srcLenPtr) |
3190 | Channel *chanPtr; /* Channel being read, for translation and |
3191 | * buffering modes. */ |
3192 | char *dst; /* Output buffer filled with UTF-8 chars by |
3193 | * applying appropriate EOL translation to |
3194 | * source characters. */ |
3195 | CONST char *src; /* Source UTF-8 characters. */ |
3196 | int *dstLenPtr; /* On entry, the maximum length of output |
3197 | * buffer in bytes. On exit, the number of |
3198 | * bytes actually used in output buffer. */ |
3199 | int *srcLenPtr; /* On entry, the length of source buffer. |
3200 | * On exit, the number of bytes read from |
3201 | * the source buffer. */ |
3202 | { |
3203 | char *dstEnd; |
3204 | int srcLen, newlineFound; |
3205 | |
3206 | newlineFound = 0; |
3207 | srcLen = *srcLenPtr; |
3208 | |
3209 | switch (chanPtr->outputTranslation) { |
3210 | case TCL_TRANSLATE_LF: { |
3211 | for (dstEnd = dst + srcLen; dst < dstEnd; ) { |
3212 | if (*src == '\n') { |
3213 | newlineFound = 1; |
3214 | } |
3215 | *dst++ = *src++; |
3216 | } |
3217 | *dstLenPtr = srcLen; |
3218 | break; |
3219 | } |
3220 | case TCL_TRANSLATE_CR: { |
3221 | for (dstEnd = dst + srcLen; dst < dstEnd;) { |
3222 | if (*src == '\n') { |
3223 | *dst++ = '\r'; |
3224 | newlineFound = 1; |
3225 | src++; |
3226 | } else { |
3227 | *dst++ = *src++; |
3228 | } |
3229 | } |
3230 | *dstLenPtr = srcLen; |
3231 | break; |
3232 | } |
3233 | case TCL_TRANSLATE_CRLF: { |
3234 | /* |
3235 | * Since this causes the number of bytes to grow, we |
3236 | * start off trying to put 'srcLen' bytes into the |
3237 | * output buffer, but allow it to store more bytes, as |
3238 | * long as there's still source bytes and room in the |
3239 | * output buffer. |
3240 | */ |
3241 | |
3242 | char *dstStart, *dstMax; |
3243 | CONST char *srcStart; |
3244 | |
3245 | dstStart = dst; |
3246 | dstMax = dst + *dstLenPtr; |
3247 | |
3248 | srcStart = src; |
3249 | |
3250 | if (srcLen < *dstLenPtr) { |
3251 | dstEnd = dst + srcLen; |
3252 | } else { |
3253 | dstEnd = dst + *dstLenPtr; |
3254 | } |
3255 | while (dst < dstEnd) { |
3256 | if (*src == '\n') { |
3257 | if (dstEnd < dstMax) { |
3258 | dstEnd++; |
3259 | } |
3260 | *dst++ = '\r'; |
3261 | newlineFound = 1; |
3262 | } |
3263 | *dst++ = *src++; |
3264 | } |
3265 | *srcLenPtr = src - srcStart; |
3266 | *dstLenPtr = dst - dstStart; |
3267 | break; |
3268 | } |
3269 | default: { |
3270 | break; |
3271 | } |
3272 | } |
3273 | return newlineFound; |
3274 | } |
3275 | |
3276 | /* |
3277 | *--------------------------------------------------------------------------- |
3278 | * |
3279 | * CheckFlush -- |
3280 | * |
3281 | * Helper function for WriteBytes() and WriteChars(). If the |
3282 | * channel buffer is ready to be flushed, flush it. |
3283 | * |
3284 | * Results: |
3285 | * The return value is -1 if there was a problem flushing the |
3286 | * channel buffer, or 0 otherwise. |
3287 | * |
3288 | * Side effects: |
3289 | * The buffer will be recycled if it is flushed. |
3290 | * |
3291 | *--------------------------------------------------------------------------- |
3292 | */ |
3293 | |
3294 | static int |
3295 | CheckFlush(chanPtr, bufPtr, newlineFlag) |
3296 | Channel *chanPtr; /* Channel being read, for buffering mode. */ |
3297 | ChannelBuffer *bufPtr; /* Channel buffer to possibly flush. */ |
3298 | int newlineFlag; /* Non-zero if a the channel buffer |
3299 | * contains a newline. */ |
3300 | { |
3301 | /* |
3302 | * The current buffer is ready for output: |
3303 | * 1. if it is full. |
3304 | * 2. if it contains a newline and this channel is line-buffered. |
3305 | * 3. if it contains any output and this channel is unbuffered. |
3306 | */ |
3307 | |
3308 | if ((chanPtr->flags & BUFFER_READY) == 0) { |
3309 | if (bufPtr->nextAdded == bufPtr->bufLength) { |
3310 | chanPtr->flags |= BUFFER_READY; |
3311 | } else if (chanPtr->flags & CHANNEL_LINEBUFFERED) { |
3312 | if (newlineFlag != 0) { |
3313 | chanPtr->flags |= BUFFER_READY; |
3314 | } |
3315 | } else if (chanPtr->flags & CHANNEL_UNBUFFERED) { |
3316 | chanPtr->flags |= BUFFER_READY; |
3317 | } |
3318 | } |
3319 | if (chanPtr->flags & BUFFER_READY) { |
3320 | if (FlushChannel(NULL, chanPtr, 0) != 0) { |
3321 | return -1; |
3322 | } |
3323 | } |
3324 | return 0; |
3325 | } |
3326 | |
3327 | /* |
3328 | *--------------------------------------------------------------------------- |
3329 | * |
3330 | * Tcl_Gets -- |
3331 | * |
3332 | * Reads a complete line of input from the channel into a Tcl_DString. |
3333 | * |
3334 | * Results: |
3335 | * Length of line read (in characters) or -1 if error, EOF, or blocked. |
3336 | * If -1, use Tcl_GetErrno() to retrieve the POSIX error code for the |
3337 | * error or condition that occurred. |
3338 | * |
3339 | * Side effects: |
3340 | * May flush output on the channel. May cause input to be consumed |
3341 | * from the channel. |
3342 | * |
3343 | *--------------------------------------------------------------------------- |
3344 | */ |
3345 | |
3346 | int |
3347 | Tcl_Gets(chan, lineRead) |
3348 | Tcl_Channel chan; /* Channel from which to read. */ |
3349 | Tcl_DString *lineRead; /* The line read will be appended to this |
3350 | * DString as UTF-8 characters. The caller |
3351 | * must have initialized it and is responsible |
3352 | * for managing the storage. */ |
3353 | { |
3354 | Tcl_Obj *objPtr; |
3355 | int charsStored, length; |
3356 | char *string; |
3357 | |
3358 | objPtr = Tcl_NewObj(); |
3359 | charsStored = Tcl_GetsObj(chan, objPtr); |
3360 | if (charsStored > 0) { |
3361 | string = Tcl_GetStringFromObj(objPtr, &length); |
3362 | Tcl_DStringAppend(lineRead, string, length); |
3363 | } |
3364 | Tcl_DecrRefCount(objPtr); |
3365 | return charsStored; |
3366 | } |
3367 | |
3368 | /* |
3369 | *--------------------------------------------------------------------------- |
3370 | * |
3371 | * Tcl_GetsObj -- |
3372 | * |
3373 | * Accumulate input from the input channel until end-of-line or |
3374 | * end-of-file has been seen. Bytes read from the input channel |
3375 | * are converted to UTF-8 using the encoding specified by the |
3376 | * channel. |
3377 | * |
3378 | * Results: |
3379 | * Number of characters accumulated in the object or -1 if error, |
3380 | * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the |
3381 | * POSIX error code for the error or condition that occurred. |
3382 | * |
3383 | * Side effects: |
3384 | * Consumes input from the channel. |
3385 | * |
3386 | * On reading EOF, leave channel pointing at EOF char. |
3387 | * On reading EOL, leave channel pointing after EOL, but don't |
3388 | * return EOL in dst buffer. |
3389 | * |
3390 | *--------------------------------------------------------------------------- |
3391 | */ |
3392 | |
3393 | int |
3394 | Tcl_GetsObj(chan, objPtr) |
3395 | Tcl_Channel chan; /* Channel from which to read. */ |
3396 | Tcl_Obj *objPtr; /* The line read will be appended to this |
3397 | * object as UTF-8 characters. */ |
3398 | { |
3399 | GetsState gs; |
3400 | Channel *chanPtr; |
3401 | int inEofChar, skip, copiedTotal; |
3402 | ChannelBuffer *bufPtr; |
3403 | Tcl_Encoding encoding; |
3404 | char *dst, *dstEnd, *eol, *eof; |
3405 | Tcl_EncodingState oldState; |
3406 | int oldLength, oldFlags, oldRemoved; |
3407 | |
3408 | chanPtr = (Channel *) chan; |
3409 | if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) { |
3410 | copiedTotal = -1; |
3411 | goto done; |
3412 | } |
3413 | |
3414 | bufPtr = chanPtr->inQueueHead; |
3415 | encoding = chanPtr->encoding; |
3416 | |
3417 | /* |
3418 | * Preserved so we can restore the channel's state in case we don't |
3419 | * find a newline in the available input. |
3420 | */ |
3421 | |
3422 | Tcl_GetStringFromObj(objPtr, &oldLength); |
3423 | oldFlags = chanPtr->inputEncodingFlags; |
3424 | oldState = chanPtr->inputEncodingState; |
3425 | oldRemoved = BUFFER_PADDING; |
3426 | if (bufPtr != NULL) { |
3427 | oldRemoved = bufPtr->nextRemoved; |
3428 | } |
3429 | |
3430 | /* |
3431 | * If there is no encoding, use "iso8859-1" -- Tcl_GetsObj() doesn't |
3432 | * produce ByteArray objects. To avoid circularity problems, |
3433 | * "iso8859-1" is builtin to Tcl. |
3434 | */ |
3435 | |
3436 | if (encoding == NULL) { |
3437 | encoding = Tcl_GetEncoding(NULL, "iso8859-1"); |
3438 | } |
3439 | |
3440 | /* |
3441 | * Object used by FilterInputBytes to keep track of how much data has |
3442 | * been consumed from the channel buffers. |
3443 | */ |
3444 | |
3445 | gs.objPtr = objPtr; |
3446 | gs.dstPtr = &dst; |
3447 | gs.encoding = encoding; |
3448 | gs.bufPtr = bufPtr; |
3449 | gs.state = oldState; |
3450 | gs.rawRead = 0; |
3451 | gs.bytesWrote = 0; |
3452 | gs.charsWrote = 0; |
3453 | gs.totalChars = 0; |
3454 | |
3455 | dst = objPtr->bytes + oldLength; |
3456 | dstEnd = dst; |
3457 | |
3458 | skip = 0; |
3459 | eof = NULL; |
3460 | inEofChar = chanPtr->inEofChar; |
3461 | |
3462 | while (1) { |
3463 | if (dst >= dstEnd) { |
3464 | if (FilterInputBytes(chanPtr, &gs) != 0) { |
3465 | goto restore; |
3466 | } |
3467 | dstEnd = dst + gs.bytesWrote; |
3468 | } |
3469 | |
3470 | /* |
3471 | * Remember if EOF char is seen, then look for EOL anyhow, because |
3472 | * the EOL might be before the EOF char. |
3473 | */ |
3474 | |
3475 | if (inEofChar != '\0') { |
3476 | for (eol = dst; eol < dstEnd; eol++) { |
3477 | if (*eol == inEofChar) { |
3478 | dstEnd = eol; |
3479 | eof = eol; |
3480 | break; |
3481 | } |
3482 | } |
3483 | } |
3484 | |
3485 | /* |
3486 | * On EOL, leave current file position pointing after the EOL, but |
3487 | * don't store the EOL in the output string. |
3488 | */ |
3489 | |
3490 | eol = dst; |
3491 | switch (chanPtr->inputTranslation) { |
3492 | case TCL_TRANSLATE_LF: { |
3493 | for (eol = dst; eol < dstEnd; eol++) { |
3494 | if (*eol == '\n') { |
3495 | skip = 1; |
3496 | goto goteol; |
3497 | } |
3498 | } |
3499 | break; |
3500 | } |
3501 | case TCL_TRANSLATE_CR: { |
3502 | for (eol = dst; eol < dstEnd; eol++) { |
3503 | if (*eol == '\r') { |
3504 | skip = 1; |
3505 | goto goteol; |
3506 | } |
3507 | } |
3508 | break; |
3509 | } |
3510 | case TCL_TRANSLATE_CRLF: { |
3511 | for (eol = dst; eol < dstEnd; eol++) { |
3512 | if (*eol == '\r') { |
3513 | eol++; |
3514 | if (eol >= dstEnd) { |
3515 | int offset; |
3516 | |
3517 | offset = eol - objPtr->bytes; |
3518 | dst = dstEnd; |
3519 | if (FilterInputBytes(chanPtr, &gs) != 0) { |
3520 | goto restore; |
3521 | } |
3522 | dstEnd = dst + gs.bytesWrote; |
3523 | eol = objPtr->bytes + offset; |
3524 | if (eol >= dstEnd) { |
3525 | skip = 0; |
3526 | goto goteol; |
3527 | } |
3528 | } |
3529 | if (*eol == '\n') { |
3530 | eol--; |
3531 | skip = 2; |
3532 | goto goteol; |
3533 | } |
3534 | } |
3535 | } |
3536 | break; |
3537 | } |
3538 | case TCL_TRANSLATE_AUTO: { |
3539 | skip = 1; |
3540 | if (chanPtr->flags & INPUT_SAW_CR) { |
3541 | chanPtr->flags &= ~INPUT_SAW_CR; |
3542 | if (*eol == '\n') { |
3543 | /* |
3544 | * Skip the raw bytes that make up the '\n'. |
3545 | */ |
3546 | |
3547 | char tmp[1 + TCL_UTF_MAX]; |
3548 | int rawRead; |
3549 | |
3550 | bufPtr = gs.bufPtr; |
3551 | Tcl_ExternalToUtf(NULL, gs.encoding, |
3552 | bufPtr->buf + bufPtr->nextRemoved, |
3553 | gs.rawRead, chanPtr->inputEncodingFlags, |
3554 | &gs.state, tmp, 1 + TCL_UTF_MAX, &rawRead, |
3555 | NULL, NULL); |
3556 | bufPtr->nextRemoved += rawRead; |
3557 | gs.rawRead -= rawRead; |
3558 | gs.bytesWrote--; |
3559 | gs.charsWrote--; |
3560 | memmove(dst, dst + 1, (size_t) (dstEnd - dst)); |
3561 | dstEnd--; |
3562 | } |
3563 | } |
3564 | for (eol = dst; eol < dstEnd; eol++) { |
3565 | if (*eol == '\r') { |
3566 | eol++; |
3567 | if (eol == dstEnd) { |
3568 | /* |
3569 | * If buffer ended on \r, peek ahead to see if a |
3570 | * \n is available. |
3571 | */ |
3572 | |
3573 | int offset; |
3574 | |
3575 | offset = eol - objPtr->bytes; |
3576 | dst = dstEnd; |
3577 | PeekAhead(chanPtr, &dstEnd, &gs); |
3578 | eol = objPtr->bytes + offset; |
3579 | if (eol >= dstEnd) { |
3580 | eol--; |
3581 | chanPtr->flags |= INPUT_SAW_CR; |
3582 | goto goteol; |
3583 | } |
3584 | } |
3585 | if (*eol == '\n') { |
3586 | skip++; |
3587 | } |
3588 | eol--; |
3589 | goto goteol; |
3590 | } else if (*eol == '\n') { |
3591 | goto goteol; |
3592 | } |
3593 | } |
3594 | } |
3595 | } |
3596 | if (eof != NULL) { |
3597 | /* |
3598 | * EOF character was seen. On EOF, leave current file position |
3599 | * pointing at the EOF character, but don't store the EOF |
3600 | * character in the output string. |
3601 | */ |
3602 | |
3603 | dstEnd = eof; |
3604 | chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); |
3605 | chanPtr->inputEncodingFlags |= TCL_ENCODING_END; |
3606 | } |
3607 | if (chanPtr->flags & CHANNEL_EOF) { |
3608 | skip = 0; |
3609 | eol = dstEnd; |
3610 | if (eol == objPtr->bytes) { |
3611 | /* |
3612 | * If we didn't produce any bytes before encountering EOF, |
3613 | * caller needs to see -1. |
3614 | */ |
3615 | |
3616 | Tcl_SetObjLength(objPtr, 0); |
3617 | CommonGetsCleanup(chanPtr, encoding); |
3618 | copiedTotal = -1; |
3619 | goto done; |
3620 | } |
3621 | goto goteol; |
3622 | } |
3623 | dst = dstEnd; |
3624 | } |
3625 | |
3626 | /* |
3627 | * Found EOL or EOF, but the output buffer may now contain too many |
3628 | * UTF-8 characters. We need to know how many raw bytes correspond to |
3629 | * the number of UTF-8 characters we want, plus how many raw bytes |
3630 | * correspond to the character(s) making up EOL (if any), so we can |
3631 | * remove the correct number of bytes from the channel buffer. |
3632 | */ |
3633 | |
3634 | goteol: |
3635 | bufPtr = gs.bufPtr; |
3636 | chanPtr->inputEncodingState = gs.state; |
3637 | Tcl_ExternalToUtf(NULL, gs.encoding, bufPtr->buf + bufPtr->nextRemoved, |
3638 | gs.rawRead, chanPtr->inputEncodingFlags, |
3639 | &chanPtr->inputEncodingState, dst, eol - dst + skip + TCL_UTF_MAX, |
3640 | &gs.rawRead, NULL, &gs.charsWrote); |
3641 | bufPtr->nextRemoved += gs.rawRead; |
3642 | |
3643 | /* |
3644 | * Recycle all the emptied buffers. |
3645 | */ |
3646 | |
3647 | Tcl_SetObjLength(objPtr, eol - objPtr->bytes); |
3648 | CommonGetsCleanup(chanPtr, encoding); |
3649 | chanPtr->flags &= ~CHANNEL_BLOCKED; |
3650 | copiedTotal = gs.totalChars + gs.charsWrote - skip; |
3651 | goto done; |
3652 | |
3653 | /* |
3654 | * Couldn't get a complete line. This only happens if we get a error |
3655 | * reading from the channel or we are non-blocking and there wasn't |
3656 | * an EOL or EOF in the data available. |
3657 | */ |
3658 | |
3659 | restore: |
3660 | bufPtr = chanPtr->inQueueHead; |
3661 | bufPtr->nextRemoved = oldRemoved; |
3662 | |
3663 | for (bufPtr = bufPtr->nextPtr; bufPtr != NULL; bufPtr = bufPtr->nextPtr) { |
3664 | bufPtr->nextRemoved = BUFFER_PADDING; |
3665 | } |
3666 | CommonGetsCleanup(chanPtr, encoding); |
3667 | |
3668 | chanPtr->inputEncodingState = oldState; |
3669 | chanPtr->inputEncodingFlags = oldFlags; |
3670 | Tcl_SetObjLength(objPtr, oldLength); |
3671 | |
3672 | /* |
3673 | * We didn't get a complete line so we need to indicate to UpdateInterest |
3674 | * that the gets blocked. It will wait for more data instead of firing |
3675 | * a timer, avoiding a busy wait. This is where we are assuming that the |
3676 | * next operation is a gets. No more file events will be delivered on |
3677 | * this channel until new data arrives or some operation is performed |
3678 | * on the channel (e.g. gets, read, fconfigure) that changes the blocking |
3679 | * state. Note that this means a file event will not be delivered even |
3680 | * though a read would be able to consume the buffered data. |
3681 | */ |
3682 | |
3683 | chanPtr->flags |= CHANNEL_NEED_MORE_DATA; |
3684 | copiedTotal = -1; |
3685 | |
3686 | done: |
3687 | /* |
3688 | * Update the notifier state so we don't block while there is still |
3689 | * data in the buffers. |
3690 | */ |
3691 | |
3692 | UpdateInterest(chanPtr); |
3693 | return copiedTotal; |
3694 | } |
3695 | |
3696 | /* |
3697 | *--------------------------------------------------------------------------- |
3698 | * |
3699 | * FilterInputBytes -- |
3700 | * |
3701 | * Helper function for Tcl_GetsObj. Produces UTF-8 characters from |
3702 | * raw bytes read from the channel. |
3703 | * |
3704 | * Consumes available bytes from channel buffers. When channel |
3705 | * buffers are exhausted, reads more bytes from channel device into |
3706 | * a new channel buffer. It is the caller's responsibility to |
3707 | * free the channel buffers that have been exhausted. |
3708 | * |
3709 | * Results: |
3710 | * The return value is -1 if there was an error reading from the |
3711 | * channel, 0 otherwise. |
3712 | * |
3713 | * Side effects: |
3714 | * Status object keeps track of how much data from channel buffers |
3715 | * has been consumed and where UTF-8 bytes should be stored. |
3716 | * |
3717 | *--------------------------------------------------------------------------- |
3718 | */ |
3719 | |
3720 | static int |
3721 | FilterInputBytes(chanPtr, gsPtr) |
3722 | Channel *chanPtr; /* Channel to read. */ |
3723 | GetsState *gsPtr; /* Current state of gets operation. */ |
3724 | { |
3725 | ChannelBuffer *bufPtr; |
3726 | char *raw, *rawStart, *rawEnd; |
3727 | char *dst; |
3728 | int offset, toRead, dstNeeded, spaceLeft, result, rawLen, length; |
3729 | Tcl_Obj *objPtr; |
3730 | #define ENCODING_LINESIZE 30 /* Lower bound on how many bytes to convert |
3731 | * at a time. Since we don't know a priori |
3732 | * how many bytes of storage this many source |
3733 | * bytes will use, we actually need at least |
3734 | * ENCODING_LINESIZE * TCL_MAX_UTF bytes of |
3735 | * room. */ |
3736 | |
3737 | objPtr = gsPtr->objPtr; |
3738 | |
3739 | /* |
3740 | * Subtract the number of bytes that were removed from channel buffer |
3741 | * during last call. |
3742 | */ |
3743 | |
3744 | bufPtr = gsPtr->bufPtr; |
3745 | if (bufPtr != NULL) { |
3746 | bufPtr->nextRemoved += gsPtr->rawRead; |
3747 | if (bufPtr->nextRemoved >= bufPtr->nextAdded) { |
3748 | bufPtr = bufPtr->nextPtr; |
3749 | } |
3750 | } |
3751 | gsPtr->totalChars += gsPtr->charsWrote; |
3752 | |
3753 | if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) { |
3754 | /* |
3755 | * All channel buffers were exhausted and the caller still hasn't |
3756 | * seen EOL. Need to read more bytes from the channel device. |
3757 | * Side effect is to allocate another channel buffer. |
3758 | */ |
3759 | |
3760 | read: |
3761 | if (chanPtr->flags & CHANNEL_BLOCKED) { |
3762 | if (chanPtr->flags & CHANNEL_NONBLOCKING) { |
3763 | gsPtr->charsWrote = 0; |
3764 | gsPtr->rawRead = 0; |
3765 | return -1; |
3766 | } |
3767 | chanPtr->flags &= ~CHANNEL_BLOCKED; |
3768 | } |
3769 | if (GetInput(chanPtr) != 0) { |
3770 | gsPtr->charsWrote = 0; |
3771 | gsPtr->rawRead = 0; |
3772 | return -1; |
3773 | } |
3774 | bufPtr = chanPtr->inQueueTail; |
3775 | gsPtr->bufPtr = bufPtr; |
3776 | } |
3777 | |
3778 | /* |
3779 | * Convert some of the bytes from the channel buffer to UTF-8. Space in |
3780 | * objPtr's string rep is used to hold the UTF-8 characters. Grow the |
3781 | * string rep if we need more space. |
3782 | */ |
3783 | |
3784 | rawStart = bufPtr->buf + bufPtr->nextRemoved; |
3785 | raw = rawStart; |
3786 | rawEnd = bufPtr->buf + bufPtr->nextAdded; |
3787 | rawLen = rawEnd - rawStart; |
3788 | |
3789 | dst = *gsPtr->dstPtr; |
3790 | offset = dst - objPtr->bytes; |
3791 | toRead = ENCODING_LINESIZE; |
3792 | if (toRead > rawLen) { |
3793 | toRead = rawLen; |
3794 | } |
3795 | dstNeeded = toRead * TCL_UTF_MAX + 1; |
3796 | spaceLeft = objPtr->length - offset - TCL_UTF_MAX - 1; |
3797 | if (dstNeeded > spaceLeft) { |
3798 | length = offset * 2; |
3799 | if (offset < dstNeeded) { |
3800 | length = offset + dstNeeded; |
3801 | } |
3802 | length += TCL_UTF_MAX + 1; |
3803 | Tcl_SetObjLength(objPtr, length); |
3804 | spaceLeft = length - offset; |
3805 | dst = objPtr->bytes + offset; |
3806 | *gsPtr->dstPtr = dst; |
3807 | } |
3808 | gsPtr->state = chanPtr->inputEncodingState; |
3809 | result = Tcl_ExternalToUtf(NULL, gsPtr->encoding, raw, rawLen, |
3810 | chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState, |
3811 | dst, spaceLeft, &gsPtr->rawRead, &gsPtr->bytesWrote, |
3812 | &gsPtr->charsWrote); |
3813 | if (result == TCL_CONVERT_MULTIBYTE) { |
3814 | /* |
3815 | * The last few bytes in this channel buffer were the start of a |
3816 | * multibyte sequence. If this buffer was full, then move them to |
3817 | * the next buffer so the bytes will be contiguous. |
3818 | */ |
3819 | |
3820 | ChannelBuffer *nextPtr; |
3821 | int extra; |
3822 | |
3823 | nextPtr = bufPtr->nextPtr; |
3824 | if (bufPtr->nextAdded < bufPtr->bufLength) { |
3825 | if (gsPtr->rawRead > 0) { |
3826 | /* |
3827 | * Some raw bytes were converted to UTF-8. Fall through, |
3828 | * returning those UTF-8 characters because a EOL might be |
3829 | * present in them. |
3830 | */ |
3831 | } else if (chanPtr->flags & CHANNEL_EOF) { |
3832 | /* |
3833 | * There was a partial character followed by EOF on the |
3834 | * device. Fall through, returning that nothing was found. |
3835 | */ |
3836 | |
3837 | bufPtr->nextRemoved = bufPtr->nextAdded; |
3838 | } else { |
3839 | /* |
3840 | * There are no more cached raw bytes left. See if we can |
3841 | * get some more. |
3842 | */ |
3843 | |
3844 | goto read; |
3845 | } |
3846 | } else { |
3847 | if (nextPtr == NULL) { |
3848 | nextPtr = AllocChannelBuffer(chanPtr->bufSize); |
3849 | bufPtr->nextPtr = nextPtr; |
3850 | chanPtr->inQueueTail = nextPtr; |
3851 | } |
3852 | extra = rawLen - gsPtr->rawRead; |
3853 | memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra), |
3854 | (VOID *) (raw + gsPtr->rawRead), (size_t) extra); |
3855 | nextPtr->nextRemoved -= extra; |
3856 | bufPtr->nextAdded -= extra; |
3857 | } |
3858 | } |
3859 | |
3860 | gsPtr->bufPtr = bufPtr; |
3861 | return 0; |
3862 | } |
3863 | |
3864 | /* |
3865 | *--------------------------------------------------------------------------- |
3866 | * |
3867 | * PeekAhead -- |
3868 | * |
3869 | * Helper function used by Tcl_GetsObj(). Called when we've seen a |
3870 | * \r at the end of the UTF-8 string and want to look ahead one |
3871 | * character to see if it is a \n. |
3872 | * |
3873 | * Results: |
3874 | * *gsPtr->dstPtr is filled with a pointer to the start of the range of |
3875 | * UTF-8 characters that were found by peeking and *dstEndPtr is filled |
3876 | * with a pointer to the bytes just after the end of the range. |
3877 | * |
3878 | * Side effects: |
3879 | * If no more raw bytes were available in one of the channel buffers, |
3880 | * tries to perform a non-blocking read to get more bytes from the |
3881 | * channel device. |
3882 | * |
3883 | *--------------------------------------------------------------------------- |
3884 | */ |
3885 | |
3886 | static void |
3887 | PeekAhead(chanPtr, dstEndPtr, gsPtr) |
3888 | Channel *chanPtr; /* The channel to read. */ |
3889 | char **dstEndPtr; /* Filled with pointer to end of new range |
3890 | * of UTF-8 characters. */ |
3891 | GetsState *gsPtr; /* Current state of gets operation. */ |
3892 | { |
3893 | ChannelBuffer *bufPtr; |
3894 | Tcl_DriverBlockModeProc *blockModeProc; |
3895 | int bytesLeft; |
3896 | |
3897 | bufPtr = gsPtr->bufPtr; |
3898 | |
3899 | /* |
3900 | * If there's any more raw input that's still buffered, we'll peek into |
3901 | * that. Otherwise, only get more data from the channel driver if it |
3902 | * looks like there might actually be more data. The assumption is that |
3903 | * if the channel buffer is filled right up to the end, then there |
3904 | * might be more data to read. |
3905 | */ |
3906 | |
3907 | blockModeProc = NULL; |
3908 | if (bufPtr->nextPtr == NULL) { |
3909 | bytesLeft = bufPtr->nextAdded - (bufPtr->nextRemoved + gsPtr->rawRead); |
3910 | if (bytesLeft == 0) { |
3911 | if (bufPtr->nextAdded < bufPtr->bufLength) { |
3912 | /* |
3913 | * Don't peek ahead if last read was short read. |
3914 | */ |
3915 | |
3916 | goto cleanup; |
3917 | } |
3918 | if ((chanPtr->flags & CHANNEL_NONBLOCKING) == 0) { |
3919 | blockModeProc = chanPtr->typePtr->blockModeProc; |
3920 | if (blockModeProc == NULL) { |
3921 | /* |
3922 | * Don't peek ahead if cannot set non-blocking mode. |
3923 | */ |
3924 | |
3925 | goto cleanup; |
3926 | } |
3927 | (*blockModeProc)(chanPtr->instanceData, TCL_MODE_NONBLOCKING); |
3928 | } |
3929 | } |
3930 | } |
3931 | if (FilterInputBytes(chanPtr, gsPtr) == 0) { |
3932 | *dstEndPtr = *gsPtr->dstPtr + gsPtr->bytesWrote; |
3933 | } |
3934 | if (blockModeProc != NULL) { |
3935 | (*blockModeProc)(chanPtr->instanceData, TCL_MODE_BLOCKING); |
3936 | } |
3937 | return; |
3938 | |
3939 | cleanup: |
3940 | bufPtr->nextRemoved += gsPtr->rawRead; |
3941 | gsPtr->rawRead = 0; |
3942 | gsPtr->totalChars += gsPtr->charsWrote; |
3943 | gsPtr->bytesWrote = 0; |
3944 | gsPtr->charsWrote = 0; |
3945 | } |
3946 | |
3947 | /* |
3948 | *--------------------------------------------------------------------------- |
3949 | * |
3950 | * CommonGetsCleanup -- |
3951 | * |
3952 | * Helper function for Tcl_GetsObj() to restore the channel after |
3953 | * a "gets" operation. |
3954 | * |
3955 | * Results: |
3956 | * None. |
3957 | * |
3958 | * Side effects: |
3959 | * Encoding may be freed. |
3960 | * |
3961 | *--------------------------------------------------------------------------- |
3962 | */ |
3963 | |
3964 | static void |
3965 | CommonGetsCleanup(chanPtr, encoding) |
3966 | Channel *chanPtr; |
3967 | Tcl_Encoding encoding; |
3968 | { |
3969 | ChannelBuffer *bufPtr, *nextPtr; |
3970 | |
3971 | bufPtr = chanPtr->inQueueHead; |
3972 | for ( ; bufPtr != NULL; bufPtr = nextPtr) { |
3973 | nextPtr = bufPtr->nextPtr; |
3974 | if (bufPtr->nextRemoved < bufPtr->nextAdded) { |
3975 | break; |
3976 | } |
3977 | RecycleBuffer(chanPtr, bufPtr, 0); |
3978 | } |
3979 | chanPtr->inQueueHead = bufPtr; |
3980 | if (bufPtr == NULL) { |
3981 | chanPtr->inQueueTail = NULL; |
3982 | } else { |
3983 | /* |
3984 | * If any multi-byte characters were split across channel buffer |
3985 | * boundaries, the split-up bytes were moved to the next channel |
3986 | * buffer by FilterInputBytes(). Move the bytes back to their |
3987 | * original buffer because the caller could change the channel's |
3988 | * encoding which could change the interpretation of whether those |
3989 | * bytes really made up multi-byte characters after all. |
3990 | */ |
3991 | |
3992 | nextPtr = bufPtr->nextPtr; |
3993 | for ( ; nextPtr != NULL; nextPtr = bufPtr->nextPtr) { |
3994 | int extra; |
3995 | |
3996 | extra = bufPtr->bufLength - bufPtr->nextAdded; |
3997 | if (extra > 0) { |
3998 | memcpy((VOID *) (bufPtr->buf + bufPtr->nextAdded), |
3999 | (VOID *) (nextPtr->buf + BUFFER_PADDING - extra), |
4000 | (size_t) extra); |
4001 | bufPtr->nextAdded += extra; |
4002 | nextPtr->nextRemoved = BUFFER_PADDING; |
4003 | } |
4004 | bufPtr = nextPtr; |
4005 | } |
4006 | } |
4007 | if (chanPtr->encoding == NULL) { |
4008 | Tcl_FreeEncoding(encoding); |
4009 | } |
4010 | } |
4011 | |
4012 | /* |
4013 | *---------------------------------------------------------------------- |
4014 | * |
4015 | * Tcl_Read -- |
4016 | * |
4017 | * Reads a given number of bytes from a channel. EOL and EOF |
4018 | * translation is done on the bytes being read, so the the number |
4019 | * of bytes consumed from the channel may not be equal to the |
4020 | * number of bytes stored in the destination buffer. |
4021 | * |
4022 | * No encoding conversions are applied to the bytes being read. |
4023 | * |
4024 | * Results: |
4025 | * The number of bytes read, or -1 on error. Use Tcl_GetErrno() |
4026 | * to retrieve the error code for the error that occurred. |
4027 | * |
4028 | * Side effects: |
4029 | * May cause input to be buffered. |
4030 | * |
4031 | *---------------------------------------------------------------------- |
4032 | */ |
4033 | |
4034 | int |
4035 | Tcl_Read(chan, dst, bytesToRead) |
4036 | Tcl_Channel chan; /* The channel from which to read. */ |
4037 | char *dst; /* Where to store input read. */ |
4038 | int bytesToRead; /* Maximum number of bytes to read. */ |
4039 | { |
4040 | Channel *chanPtr; |
4041 | |
4042 | chanPtr = (Channel *) chan; |
4043 | if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) { |
4044 | return -1; |
4045 | } |
4046 | |
4047 | return DoRead(chanPtr, dst, bytesToRead); |
4048 | } |
4049 | |
4050 | /* |
4051 | *--------------------------------------------------------------------------- |
4052 | * |
4053 | * Tcl_ReadChars -- |
4054 | * |
4055 | * Reads from the channel until the requested number of characters |
4056 | * have been seen, EOF is seen, or the channel would block. EOL |
4057 | * and EOF translation is done. If reading binary data, the raw |
4058 | * bytes are wrapped in a Tcl byte array object. Otherwise, the raw |
4059 | * bytes are converted to UTF-8 using the channel's current encoding |
4060 | * and stored in a Tcl string object. |
4061 | * |
4062 | * Results: |
4063 | * The number of characters read, or -1 on error. Use Tcl_GetErrno() |
4064 | * to retrieve the error code for the error that occurred. |
4065 | * |
4066 | * Side effects: |
4067 | * May cause input to be buffered. |
4068 | * |
4069 | *--------------------------------------------------------------------------- |
4070 | */ |
4071 | |
4072 | int |
4073 | Tcl_ReadChars(chan, objPtr, toRead, appendFlag) |
4074 | Tcl_Channel chan; /* The channel to read. */ |
4075 | Tcl_Obj *objPtr; /* Input data is stored in this object. */ |
4076 | int toRead; /* Maximum number of characters to store, |
4077 | * or -1 to read all available data (up to EOF |
4078 | * or when channel blocks). */ |
4079 | int appendFlag; /* If non-zero, data read from the channel |
4080 | * will be appended to the object. Otherwise, |
4081 | * the data will replace the existing contents |
4082 | * of the object. */ |
4083 | |
4084 | { |
4085 | Channel *chanPtr; |
4086 | int offset, factor, copied, copiedNow, result; |
4087 | ChannelBuffer *bufPtr; |
4088 | Tcl_Encoding encoding; |
4089 | #define UTF_EXPANSION_FACTOR 1024 |
4090 | |
4091 | chanPtr = (Channel *) chan; |
4092 | if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) { |
4093 | copied = -1; |
4094 | goto done; |
4095 | } |
4096 | |
4097 | encoding = chanPtr->encoding; |
4098 | factor = UTF_EXPANSION_FACTOR; |
4099 | |
4100 | if (appendFlag == 0) { |
4101 | if (encoding == NULL) { |
4102 | Tcl_SetByteArrayLength(objPtr, 0); |
4103 | } else { |
4104 | Tcl_SetObjLength(objPtr, 0); |
4105 | } |
4106 | offset = 0; |
4107 | } else { |
4108 | if (encoding == NULL) { |
4109 | Tcl_GetByteArrayFromObj(objPtr, &offset); |
4110 | } else { |
4111 | Tcl_GetStringFromObj(objPtr, &offset); |
4112 | } |
4113 | } |
4114 | |
4115 | for (copied = 0; (unsigned) toRead > 0; ) { |
4116 | copiedNow = -1; |
4117 | if (chanPtr->inQueueHead != NULL) { |
4118 | if (encoding == NULL) { |
4119 | copiedNow = ReadBytes(chanPtr, objPtr, toRead, &offset); |
4120 | } else { |
4121 | copiedNow = ReadChars(chanPtr, objPtr, toRead, &offset, |
4122 | &factor); |
4123 | } |
4124 | |
4125 | /* |
4126 | * If the current buffer is empty recycle it. |
4127 | */ |
4128 | |
4129 | bufPtr = chanPtr->inQueueHead; |
4130 | if (bufPtr->nextRemoved == bufPtr->nextAdded) { |
4131 | ChannelBuffer *nextPtr; |
4132 | |
4133 | nextPtr = bufPtr->nextPtr; |
4134 | RecycleBuffer(chanPtr, bufPtr, 0); |
4135 | chanPtr->inQueueHead = nextPtr; |
4136 | if (nextPtr == NULL) { |
4137 | chanPtr->inQueueTail = nextPtr; |
4138 | } |
4139 | } |
4140 | } |
4141 | if (copiedNow < 0) { |
4142 | if (chanPtr->flags & CHANNEL_EOF) { |
4143 | break; |
4144 | } |
4145 | if (chanPtr->flags & CHANNEL_BLOCKED) { |
4146 | if (chanPtr->flags & CHANNEL_NONBLOCKING) { |
4147 | break; |
4148 | } |
4149 | chanPtr->flags &= ~CHANNEL_BLOCKED; |
4150 | } |
4151 | result = GetInput(chanPtr); |
4152 | if (result != 0) { |
4153 | if (result == EAGAIN) { |
4154 | break; |
4155 | } |
4156 | copied = -1; |
4157 | goto done; |
4158 | } |
4159 | } else { |
4160 | copied += copiedNow; |
4161 | toRead -= copiedNow; |
4162 | } |
4163 | } |
4164 | chanPtr->flags &= ~CHANNEL_BLOCKED; |
4165 | if (encoding == NULL) { |
4166 | Tcl_SetByteArrayLength(objPtr, offset); |
4167 | } else { |
4168 | Tcl_SetObjLength(objPtr, offset); |
4169 | } |
4170 | |
4171 | done: |
4172 | /* |
4173 | * Update the notifier state so we don't block while there is still |
4174 | * data in the buffers. |
4175 | */ |
4176 | |
4177 | UpdateInterest(chanPtr); |
4178 | return copied; |
4179 | } |
4180 | /* |
4181 | *--------------------------------------------------------------------------- |
4182 | * |
4183 | * ReadBytes -- |
4184 | * |
4185 | * Reads from the channel until the requested number of bytes have |
4186 | * been seen, EOF is seen, or the channel would block. Bytes from |
4187 | * the channel are stored in objPtr as a ByteArray object. EOL |
4188 | * and EOF translation are done. |
4189 | * |
4190 | * 'bytesToRead' can safely be a very large number because |
4191 | * space is only allocated to hold data read from the channel |
4192 | * as needed. |
4193 | * |
4194 | * Results: |
4195 | * The return value is the number of bytes appended to the object |
4196 | * and *offsetPtr is filled with the total number of bytes in the |
4197 | * object (greater than the return value if there were already bytes |
4198 | * in the object). |
4199 | * |
4200 | * Side effects: |
4201 | * None. |
4202 | * |
4203 | *--------------------------------------------------------------------------- |
4204 | */ |
4205 | |
4206 | static int |
4207 | ReadBytes(chanPtr, objPtr, bytesToRead, offsetPtr) |
4208 | Channel *chanPtr; /* The channel to read. */ |
4209 | int bytesToRead; /* Maximum number of characters to store, |
4210 | * or < 0 to get all available characters. |
4211 | * Characters are obtained from the first |
4212 | * buffer in the queue -- even if this number |
4213 | * is larger than the number of characters |
4214 | * available in the first buffer, only the |
4215 | * characters from the first buffer are |
4216 | * returned. */ |
4217 | Tcl_Obj *objPtr; /* Input data is appended to this ByteArray |
4218 | * object. Its length is how much space |
4219 | * has been allocated to hold data, not how |
4220 | * many bytes of data have been stored in the |
4221 | * object. */ |
4222 | int *offsetPtr; /* On input, contains how many bytes of |
4223 | * objPtr have been used to hold data. On |
4224 | * output, filled with how many bytes are now |
4225 | * being used. */ |
4226 | { |
4227 | int toRead, srcLen, srcRead, dstWrote, offset, length; |
4228 | ChannelBuffer *bufPtr; |
4229 | char *src, *dst; |
4230 | |
4231 | offset = *offsetPtr; |
4232 | |
4233 | bufPtr = chanPtr->inQueueHead; |
4234 | src = bufPtr->buf + bufPtr->nextRemoved; |
4235 | srcLen = bufPtr->nextAdded - bufPtr->nextRemoved; |
4236 | |
4237 | toRead = bytesToRead; |
4238 | if ((unsigned) toRead > (unsigned) srcLen) { |
4239 | toRead = srcLen; |
4240 | } |
4241 | |
4242 | dst = (char *) Tcl_GetByteArrayFromObj(objPtr, &length); |
4243 | if (toRead > length - offset - 1) { |
4244 | /* |
4245 | * Double the existing size of the object or make enough room to |
4246 | * hold all the characters we may get from the source buffer, |
4247 | * whichever is larger. |
4248 | */ |
4249 | |
4250 | length = offset * 2; |
4251 | if (offset < toRead) { |
4252 | length = offset + toRead + 1; |
4253 | } |
4254 | dst = (char *) Tcl_SetByteArrayLength(objPtr, length); |
4255 | } |
4256 | dst += offset; |
4257 | |
4258 | if (chanPtr->flags & INPUT_NEED_NL) { |
4259 | chanPtr->flags &= ~INPUT_NEED_NL; |
4260 | if ((srcLen == 0) || (*src != '\n')) { |
4261 | *dst = '\r'; |
4262 | *offsetPtr += 1; |
4263 | return 1; |
4264 | } |
4265 | *dst++ = '\n'; |
4266 | src++; |
4267 | srcLen--; |
4268 | toRead--; |
4269 | } |
4270 | |
4271 | srcRead = srcLen; |
4272 | dstWrote = toRead; |
4273 | if (TranslateInputEOL(chanPtr, dst, src, &dstWrote, &srcRead) != 0) { |
4274 | if (dstWrote == 0) { |
4275 | return -1; |
4276 | } |
4277 | } |
4278 | bufPtr->nextRemoved += srcRead; |
4279 | *offsetPtr += dstWrote; |
4280 | return dstWrote; |
4281 | } |
4282 | |
4283 | /* |
4284 | *--------------------------------------------------------------------------- |
4285 | * |
4286 | * ReadChars -- |
4287 | * |
4288 | * Reads from the channel until the requested number of UTF-8 |
4289 | * characters have been seen, EOF is seen, or the channel would |
4290 | * block. Raw bytes from the channel are converted to UTF-8 |
4291 | * and stored in objPtr. EOL and EOF translation is done. |
4292 | * |
4293 | * 'charsToRead' can safely be a very large number because |
4294 | * space is only allocated to hold data read from the channel |
4295 | * as needed. |
4296 | * |
4297 | * Results: |
4298 | * The return value is the number of characters appended to |
4299 | * the object, *offsetPtr is filled with the number of bytes that |
4300 | * were appended, and *factorPtr is filled with the expansion |
4301 | * factor used to guess how many bytes of UTF-8 to allocate to |
4302 | * hold N source bytes. |
4303 | * |
4304 | * Side effects: |
4305 | * None. |
4306 | * |
4307 | *--------------------------------------------------------------------------- |
4308 | */ |
4309 | |
4310 | static int |
4311 | ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr) |
4312 | Channel *chanPtr; /* The channel to read. */ |
4313 | int charsToRead; /* Maximum number of characters to store, |
4314 | * or -1 to get all available characters. |
4315 | * Characters are obtained from the first |
4316 | * buffer in the queue -- even if this number |
4317 | * is larger than the number of characters |
4318 | * available in the first buffer, only the |
4319 | * characters from the first buffer are |
4320 | * returned. */ |
4321 | Tcl_Obj *objPtr; /* Input data is appended to this object. |
4322 | * objPtr->length is how much space has been |
4323 | * allocated to hold data, not how many bytes |
4324 | * of data have been stored in the object. */ |
4325 | int *offsetPtr; /* On input, contains how many bytes of |
4326 | * objPtr have been used to hold data. On |
4327 | * output, filled with how many bytes are now |
4328 | * being used. */ |
4329 | int *factorPtr; /* On input, contains a guess of how many |
4330 | * bytes need to be allocated to hold the |
4331 | * result of converting N source bytes to |
4332 | * UTF-8. On output, contains another guess |
4333 | * based on the data seen so far. */ |
4334 | { |
4335 | int toRead, factor, offset, spaceLeft, length; |
4336 | int srcLen, srcRead, dstNeeded, dstRead, dstWrote, numChars; |
4337 | ChannelBuffer *bufPtr; |
4338 | char *src, *dst; |
4339 | Tcl_EncodingState oldState; |
4340 | |
4341 | factor = *factorPtr; |
4342 | offset = *offsetPtr; |
4343 | |
4344 | bufPtr = chanPtr->inQueueHead; |
4345 | src = bufPtr->buf + bufPtr->nextRemoved; |
4346 | srcLen = bufPtr->nextAdded - bufPtr->nextRemoved; |
4347 | |
4348 | toRead = charsToRead; |
4349 | if ((unsigned) toRead > (unsigned) srcLen) { |
4350 | toRead = srcLen; |
4351 | } |
4352 | |
4353 | /* |
4354 | * 'factor' is how much we guess that the bytes in the source buffer |
4355 | * will expand when converted to UTF-8 chars. This guess comes from |
4356 | * analyzing how many characters were produced by the previous |
4357 | * pass. |
4358 | */ |
4359 | |
4360 | dstNeeded = toRead * factor / UTF_EXPANSION_FACTOR; |
4361 | spaceLeft = objPtr->length - offset - TCL_UTF_MAX - 1; |
4362 | |
4363 | if (dstNeeded > spaceLeft) { |
4364 | /* |
4365 | * Double the existing size of the object or make enough room to |
4366 | * hold all the characters we want from the source buffer, |
4367 | * whichever is larger. |
4368 | */ |
4369 | |
4370 | length = offset * 2; |
4371 | if (offset < dstNeeded) { |
4372 | length = offset + dstNeeded; |
4373 | } |
4374 | spaceLeft = length - offset; |
4375 | length += TCL_UTF_MAX + 1; |
4376 | Tcl_SetObjLength(objPtr, length); |
4377 | } |
4378 | if (toRead == srcLen) { |
4379 | /* |
4380 | * Want to convert the whole buffer in one pass. If we have |
4381 | * enough space, convert it using all available space in object |
4382 | * rather than using the factor. |
4383 | */ |
4384 | |
4385 | dstNeeded = spaceLeft; |
4386 | } |
4387 | dst = objPtr->bytes + offset; |
4388 | |
4389 | oldState = chanPtr->inputEncodingState; |
4390 | if (chanPtr->flags & INPUT_NEED_NL) { |
4391 | /* |
4392 | * We want a '\n' because the last character we saw was '\r'. |
4393 | */ |
4394 | |
4395 | chanPtr->flags &= ~INPUT_NEED_NL; |
4396 | Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen, |
4397 | chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState, |
4398 | dst, TCL_UTF_MAX + 1, &srcRead, &dstWrote, &numChars); |
4399 | if ((dstWrote > 0) && (*dst == '\n')) { |
4400 | /* |
4401 | * The next char was a '\n'. Consume it and produce a '\n'. |
4402 | */ |
4403 | |
4404 | bufPtr->nextRemoved += srcRead; |
4405 | } else { |
4406 | /* |
4407 | * The next char was not a '\n'. Produce a '\r'. |
4408 | */ |
4409 | |
4410 | *dst = '\r'; |
4411 | } |
4412 | chanPtr->inputEncodingFlags &= ~TCL_ENCODING_START; |
4413 | *offsetPtr += 1; |
4414 | return 1; |
4415 | } |
4416 | |
4417 | Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen, |
4418 | chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState, dst, |
4419 | dstNeeded + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars); |
4420 | if (srcRead == 0) { |
4421 | /* |
4422 | * Not enough bytes in src buffer to make a complete char. Copy |
4423 | * the bytes to the next buffer to make a new contiguous string, |
4424 | * then tell the caller to fill the buffer with more bytes. |
4425 | */ |
4426 | |
4427 | ChannelBuffer *nextPtr; |
4428 | |
4429 | nextPtr = bufPtr->nextPtr; |
4430 | if (nextPtr == NULL) { |
4431 | /* |
4432 | * There isn't enough data in the buffers to complete the next |
4433 | * character, so we need to wait for more data before the next |
4434 | * file event can be delivered. |
4435 | */ |
4436 | |
4437 | chanPtr->flags |= CHANNEL_NEED_MORE_DATA; |
4438 | return -1; |
4439 | } |
4440 | nextPtr->nextRemoved -= srcLen; |
4441 | memcpy((VOID *) (nextPtr->buf + nextPtr->nextRemoved), (VOID *) src, |
4442 | (size_t) srcLen); |
4443 | RecycleBuffer(chanPtr, bufPtr, 0); |
4444 | chanPtr->inQueueHead = nextPtr; |
4445 | return ReadChars(chanPtr, objPtr, charsToRead, offsetPtr, factorPtr); |
4446 | } |
4447 | |
4448 | dstRead = dstWrote; |
4449 | if (TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead) != 0) { |
4450 | /* |
4451 | * Hit EOF char. How many bytes of src correspond to where the |
4452 | * EOF was located in dst? |
4453 | */ |
4454 | |
4455 | if (dstWrote == 0) { |
4456 | return -1; |
4457 | } |
4458 | chanPtr->inputEncodingState = oldState; |
4459 | Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen, |
4460 | chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState, |
4461 | dst, dstRead + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars); |
4462 | TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead); |
4463 | } |
4464 | |
4465 | /* |
4466 | * The number of characters that we got may be less than the number |
4467 | * that we started with because "\r\n" sequences may have been |
4468 | * turned into just '\n' in dst. |
4469 | */ |
4470 | |
4471 | numChars -= (dstRead - dstWrote); |
4472 | |
4473 | if ((unsigned) numChars > (unsigned) toRead) { |
4474 | /* |
4475 | * Got too many chars. |
4476 | */ |
4477 | |
4478 | char *eof; |
4479 | |
4480 | eof = Tcl_UtfAtIndex(dst, toRead); |
4481 | chanPtr->inputEncodingState = oldState; |
4482 | Tcl_ExternalToUtf(NULL, chanPtr->encoding, src, srcLen, |
4483 | chanPtr->inputEncodingFlags, &chanPtr->inputEncodingState, |
4484 | dst, eof - dst + TCL_UTF_MAX, &srcRead, &dstWrote, &numChars); |
4485 | dstRead = dstWrote; |
4486 | TranslateInputEOL(chanPtr, dst, dst, &dstWrote, &dstRead); |
4487 | numChars -= (dstRead - dstWrote); |
4488 | } |
4489 | chanPtr->inputEncodingFlags &= ~TCL_ENCODING_START; |
4490 | |
4491 | bufPtr->nextRemoved += srcRead; |
4492 | if (dstWrote > srcRead + 1) { |
4493 | *factorPtr = dstWrote * UTF_EXPANSION_FACTOR / srcRead; |
4494 | } |
4495 | *offsetPtr += dstWrote; |
4496 | return numChars; |
4497 | } |
4498 | |
4499 | /* |
4500 | *--------------------------------------------------------------------------- |
4501 | * |
4502 | * TranslateInputEOL -- |
4503 | * |
4504 | * Perform input EOL and EOF translation on the source buffer, |
4505 | * leaving the translated result in the destination buffer. |
4506 | * |
4507 | * Results: |
4508 | * The return value is 1 if the EOF character was found when copying |
4509 | * bytes to the destination buffer, 0 otherwise. |
4510 | * |
4511 | * Side effects: |
4512 | * None. |
4513 | * |
4514 | *--------------------------------------------------------------------------- |
4515 | */ |
4516 | |
4517 | static int |
4518 | TranslateInputEOL(chanPtr, dstStart, srcStart, dstLenPtr, srcLenPtr) |
4519 | Channel *chanPtr; /* Channel being read, for EOL translation |
4520 | * and EOF character. */ |
4521 | char *dstStart; /* Output buffer filled with chars by |
4522 | * applying appropriate EOL translation to |
4523 | * source characters. */ |
4524 | CONST char *srcStart; /* Source characters. */ |
4525 | int *dstLenPtr; /* On entry, the maximum length of output |
4526 | * buffer in bytes; must be <= *srcLenPtr. On |
4527 | * exit, the number of bytes actually used in |
4528 | * output buffer. */ |
4529 | int *srcLenPtr; /* On entry, the length of source buffer. |
4530 | * On exit, the number of bytes read from |
4531 | * the source buffer. */ |
4532 | { |
4533 | int dstLen, srcLen, inEofChar; |
4534 | CONST char *eof; |
4535 | |
4536 | dstLen = *dstLenPtr; |
4537 | |
4538 | eof = NULL; |
4539 | inEofChar = chanPtr->inEofChar; |
4540 | if (inEofChar != '\0') { |
4541 | /* |
4542 | * Find EOF in translated buffer then compress out the EOL. The |
4543 | * source buffer may be much longer than the destination buffer -- |
4544 | * we only want to return EOF if the EOF has been copied to the |
4545 | * destination buffer. |
4546 | */ |
4547 | |
4548 | CONST char *src, *srcMax; |
4549 | |
4550 | srcMax = srcStart + *srcLenPtr; |
4551 | for (src = srcStart; src < srcMax; src++) { |
4552 | if (*src == inEofChar) { |
4553 | eof = src; |
4554 | srcLen = src - srcStart; |
4555 | if (srcLen < dstLen) { |
4556 | dstLen = srcLen; |
4557 | } |
4558 | *srcLenPtr = srcLen; |
4559 | break; |
4560 | } |
4561 | } |
4562 | } |
4563 | switch (chanPtr->inputTranslation) { |
4564 | case TCL_TRANSLATE_LF: { |
4565 | if (dstStart != srcStart) { |
4566 | memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); |
4567 | } |
4568 | srcLen = dstLen; |
4569 | break; |
4570 | } |
4571 | case TCL_TRANSLATE_CR: { |
4572 | char *dst, *dstEnd; |
4573 | |
4574 | if (dstStart != srcStart) { |
4575 | memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen); |
4576 | } |
4577 | dstEnd = dstStart + dstLen; |
4578 | for (dst = dstStart; dst < dstEnd; dst++) { |
4579 | if (*dst == '\r') { |
4580 | *dst = '\n'; |
4581 | } |
4582 | } |
4583 | srcLen = dstLen; |
4584 | break; |
4585 | } |
4586 | case TCL_TRANSLATE_CRLF: { |
4587 | char *dst; |
4588 | CONST char *src, *srcEnd, *srcMax; |
4589 | |
4590 | dst = dstStart; |
4591 | src = srcStart; |
4592 | srcEnd = srcStart + dstLen; |
4593 | srcMax = srcStart + *srcLenPtr; |
4594 | |
4595 | for ( ; src < srcEnd; ) { |
4596 | if (*src == '\r') { |
4597 | src++; |
4598 | if (src >= srcMax) { |
4599 | chanPtr->flags |= INPUT_NEED_NL; |
4600 | } else if (*src == '\n') { |
4601 | *dst++ = *src++; |
4602 | } else { |
4603 | *dst++ = '\r'; |
4604 | } |
4605 | } else { |
4606 | *dst++ = *src++; |
4607 | } |
4608 | } |
4609 | srcLen = src - srcStart; |
4610 | dstLen = dst - dstStart; |
4611 | break; |
4612 | } |
4613 | case TCL_TRANSLATE_AUTO: { |
4614 | char *dst; |
4615 | CONST char *src, *srcEnd, *srcMax; |
4616 | |
4617 | dst = dstStart; |
4618 | src = srcStart; |
4619 | srcEnd = srcStart + dstLen; |
4620 | srcMax = srcStart + *srcLenPtr; |
4621 | |
4622 | if ((chanPtr->flags & INPUT_SAW_CR) && (src < srcMax)) { |
4623 | if (*src == '\n') { |
4624 | src++; |
4625 | } |
4626 | chanPtr->flags &= ~INPUT_SAW_CR; |
4627 | } |
4628 | for ( ; src < srcEnd; ) { |
4629 | if (*src == '\r') { |
4630 | src++; |
4631 | if (src >= srcMax) { |
4632 | chanPtr->flags |= INPUT_SAW_CR; |
4633 | } else if (*src == '\n') { |
4634 | if (srcEnd < srcMax) { |
4635 | srcEnd++; |
4636 | } |
4637 | src++; |
4638 | } |
4639 | *dst++ = '\n'; |
4640 | } else { |
4641 | *dst++ = *src++; |
4642 | } |
4643 | } |
4644 | srcLen = src - srcStart; |
4645 | dstLen = dst - dstStart; |
4646 | break; |
4647 | } |
4648 | default: { /* lint. */ |
4649 | return 0; |
4650 | } |
4651 | } |
4652 | *dstLenPtr = dstLen; |
4653 | |
4654 | if ((eof != NULL) && (srcStart + srcLen >= eof)) { |
4655 | /* |
4656 | * EOF character was seen in EOL translated range. Leave current |
4657 | * file position pointing at the EOF character, but don't store the |
4658 | * EOF character in the output string. |
4659 | */ |
4660 | |
4661 | chanPtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF); |
4662 | chanPtr->inputEncodingFlags |= TCL_ENCODING_END; |
4663 | chanPtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL); |
4664 | return 1; |
4665 | } |
4666 | |
4667 | *srcLenPtr = srcLen; |
4668 | return 0; |
4669 | } |
4670 | |
4671 | /* |
4672 | *---------------------------------------------------------------------- |
4673 | * |
4674 | * Tcl_Ungets -- |
4675 | * |
4676 | * Causes the supplied string to be added to the input queue of |
4677 | * the channel, at either the head or tail of the queue. |
4678 | * |
4679 | * Results: |
4680 | * The number of bytes stored in the channel, or -1 on error. |
4681 | * |
4682 | * Side effects: |
4683 | * Adds input to the input queue of a channel. |
4684 | * |
4685 | *---------------------------------------------------------------------- |
4686 | */ |
4687 | |
4688 | int |
4689 | Tcl_Ungets(chan, str, len, atEnd) |
4690 | Tcl_Channel chan; /* The channel for which to add the input. */ |
4691 | char *str; /* The input itself. */ |
4692 | int len; /* The length of the input. */ |
4693 | int atEnd; /* If non-zero, add at end of queue; otherwise |
4694 | * add at head of queue. */ |
4695 | { |
4696 | Channel *chanPtr; /* The real IO channel. */ |
4697 | ChannelBuffer *bufPtr; /* Buffer to contain the data. */ |
4698 | int i, flags; |
4699 | |
4700 | chanPtr = (Channel *) chan; |
4701 | |
4702 | /* |
4703 | * CheckChannelErrors clears too many flag bits in this one case. |
4704 | */ |
4705 | |
4706 | flags = chanPtr->flags; |
4707 | if (CheckChannelErrors(chanPtr, TCL_READABLE) != 0) { |
4708 | len = -1; |
4709 | goto done; |
4710 | } |
4711 | chanPtr->flags = flags; |
4712 | |
4713 | /* |
4714 | * If we have encountered a sticky EOF, just punt without storing. |
4715 | * (sticky EOF is set if we have seen the input eofChar, to prevent |
4716 | * reading beyond the eofChar). Otherwise, clear the EOF flags, and |
4717 | * clear the BLOCKED bit. We want to discover these conditions anew |
4718 | * in each operation. |
4719 | */ |
4720 | |
4721 | if (chanPtr->flags & CHANNEL_STICKY_EOF) { |
4722 | goto done; |
4723 | } |
4724 | chanPtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF)); |
4725 | |
4726 | bufPtr = AllocChannelBuffer(len); |
4727 | for (i = 0; i < len; i++) { |
4728 | bufPtr->buf[i] = str[i]; |
4729 | } |
4730 | bufPtr->nextAdded += len; |
4731 | |
4732 | if (chanPtr->inQueueHead == (ChannelBuffer *) NULL) { |
4733 | bufPtr->nextPtr = (ChannelBuffer *) NULL; |
4734 | chanPtr->inQueueHead = bufPtr; |
4735 | chanPtr->inQueueTail = bufPtr; |
4736 | } else if (atEnd) { |
4737 | bufPtr->nextPtr = (ChannelBuffer *) NULL; |
4738 | chanPtr->inQueueTail->nextPtr = bufPtr; |
4739 | chanPtr->inQueueTail = bufPtr; |
4740 | } else { |
4741 | bufPtr->nextPtr = chanPtr->inQueueHead; |
4742 | chanPtr->inQueueHead = bufPtr; |
4743 | } |
4744 | |
4745 | done: |
4746 | /* |
4747 | * Update the notifier state so we don't block while there is still |
4748 | * data in the buffers. |
4749 | */ |
4750 | |
4751 | UpdateInterest(chanPtr); |
4752 | return len; |
4753 | } |
4754 | |
4755 | /* |
4756 | *---------------------------------------------------------------------- |
4757 | * |
4758 | * Tcl_Flush -- |
4759 | * |
4760 | * Flushes output data on a channel. |
4761 | * |
4762 | * Results: |
4763 | * A standard Tcl result. |
4764 | * |
4765 | * Side effects: |
4766 | * May flush output queued on this channel. |
4767 | * |
4768 | *---------------------------------------------------------------------- |
4769 | */ |
4770 | |
4771 | int |
4772 | Tcl_Flush(chan) |
4773 | Tcl_Channel chan; /* The Channel to flush. */ |
4774 | { |
4775 | int result; /* Of calling FlushChannel. */ |
4776 | Channel *chanPtr; /* The actual channel. */ |
4777 | |
4778 | chanPtr = (Channel *) chan; |
4779 | if (CheckChannelErrors(chanPtr, TCL_WRITABLE) != 0) { |
4780 | return -1; |
4781 | } |
4782 | |
4783 | /* |
4784 | * Force current output buffer to be output also. |
4785 | */ |
4786 | |
4787 | if ((chanPtr->curOutPtr != NULL) |
4788 | && (chanPtr->curOutPtr->nextAdded > 0)) { |
4789 | chanPtr->flags |= BUFFER_READY; |
4790 | } |
4791 | |
4792 | result = FlushChannel(NULL, chanPtr, 0); |
4793 | if (result != 0) { |
4794 | return TCL_ERROR; |
4795 | } |
4796 | |
4797 | return TCL_OK; |
4798 | } |
4799 | |
4800 | /* |
4801 | *---------------------------------------------------------------------- |
4802 | * |
4803 | * DiscardInputQueued -- |
4804 | * |
4805 | * Discards any input read from the channel but not yet consumed |
4806 | * by Tcl reading commands. |
4807 | * |
4808 | * Results: |
4809 | * None. |
4810 | * |
4811 | * Side effects: |
4812 | * May discard input from the channel. If discardLastBuffer is zero, |
4813 | * leaves one buffer in place for back-filling. |
4814 | * |
4815 | *---------------------------------------------------------------------- |
4816 | */ |
4817 | |
4818 | static void |
4819 | DiscardInputQueued(chanPtr, discardSavedBuffers) |
4820 | Channel *chanPtr; /* Channel on which to discard |
4821 | * the queued input. */ |
4822 | int discardSavedBuffers; /* If non-zero, discard all buffers including |
4823 | * last one. */ |
4824 | { |
4825 | ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */ |
4826 | |
4827 | bufPtr = chanPtr->inQueueHead; |
4828 | chanPtr->inQueueHead = (ChannelBuffer *) NULL; |
4829 | chanPtr->inQueueTail = (ChannelBuffer *) NULL; |
4830 | for (; bufPtr != (ChannelBuffer *) NULL; bufPtr = nxtPtr) { |
4831 | nxtPtr = bufPtr->nextPtr; |
4832 | RecycleBuffer(chanPtr, bufPtr, discardSavedBuffers); |
4833 | } |
4834 | |
4835 | /* |
4836 | * If discardSavedBuffers is nonzero, must also discard any previously |
4837 | * saved buffer in the saveInBufPtr field. |
4838 | */ |
4839 | |
4840 | if (discardSavedBuffers) { |
4841 | if (chanPtr->saveInBufPtr != (ChannelBuffer *) NULL) { |
4842 | ckfree((char *) chanPtr->saveInBufPtr); |
4843 | chanPtr->saveInBufPtr = (ChannelBuffer *) NULL; |
4844 | } |
4845 | } |
4846 | } |
4847 | |
4848 | /* |
4849 | *--------------------------------------------------------------------------- |
4850 | * |
4851 | * GetInput -- |
4852 | * |
4853 | * Reads input data from a device into a channel buffer. |
4854 | * |
4855 | * Results: |
4856 | * The return value is the Posix error code if an error occurred while |
4857 | * reading from the file, or 0 otherwise. |
4858 | * |
4859 | * Side effects: |
4860 | * Reads from the underlying device. |
4861 | * |
4862 | *--------------------------------------------------------------------------- |
4863 | */ |
4864 | |
4865 | static int |
4866 | GetInput(chanPtr) |
4867 | Channel *chanPtr; /* Channel to read input from. */ |
4868 | { |
4869 | int toRead; /* How much to read? */ |
4870 | int result; /* Of calling driver. */ |
4871 | int nread; /* How much was read from channel? */ |
4872 | ChannelBuffer *bufPtr; /* New buffer to add to input queue. */ |
4873 | |
4874 | /* |
4875 | * Prevent reading from a dead channel -- a channel that has been closed |
4876 | * but not yet deallocated, which can happen if the exit handler for |
4877 | * channel cleanup has run but the channel is still registered in some |
4878 | * interpreter. |
4879 | */ |
4880 | |
4881 | if (CheckForDeadChannel(NULL, chanPtr)) { |
4882 | return EINVAL; |
4883 | } |
4884 | |
4885 | /* |
4886 | * See if we can fill an existing buffer. If we can, read only |
4887 | * as much as will fit in it. Otherwise allocate a new buffer, |
4888 | * add it to the input queue and attempt to fill it to the max. |
4889 | */ |
4890 | |
4891 | bufPtr = chanPtr->inQueueTail; |
4892 | if ((bufPtr != NULL) && (bufPtr->nextAdded < bufPtr->bufLength)) { |
4893 | toRead = bufPtr->bufLength - bufPtr->nextAdded; |
4894 | } else { |
4895 | bufPtr = chanPtr->saveInBufPtr; |
4896 | chanPtr->saveInBufPtr = NULL; |
4897 | if (bufPtr == NULL) { |
4898 | bufPtr = AllocChannelBuffer(chanPtr->bufSize); |
4899 | } |
4900 | bufPtr->nextPtr = (ChannelBuffer *) NULL; |
4901 | |
4902 | toRead = chanPtr->bufSize; |
4903 | if (chanPtr->inQueueTail == NULL) { |
4904 | chanPtr->inQueueHead = bufPtr; |
4905 | } else { |
4906 | chanPtr->inQueueTail->nextPtr = bufPtr; |
4907 | } |
4908 | chanPtr->inQueueTail = bufPtr; |
4909 | } |
4910 | |
4911 | /* |
4912 | * If EOF is set, we should avoid calling the driver because on some |
4913 | * platforms it is impossible to read from a device after EOF. |
4914 | */ |
4915 | |
4916 | if (chanPtr->flags & CHANNEL_EOF) { |
4917 | return 0; |
4918 | } |
4919 | |
4920 | nread = (*chanPtr->typePtr->inputProc)(chanPtr->instanceData, |
4921 | bufPtr->buf + bufPtr->nextAdded, toRead, &result); |
4922 | |
4923 | if (nread > 0) { |
4924 | bufPtr->nextAdded += nread; |
4925 | |
4926 | /* |
4927 | * If we get a short read, signal up that we may be BLOCKED. We |
4928 | * should avoid calling the driver because on some platforms we |
4929 | * will block in the low level reading code even though the |
4930 | * channel is set into nonblocking mode. |
4931 | */ |
4932 | |
4933 | if (nread < toRead) { |
4934 | chanPtr->flags |= CHANNEL_BLOCKED; |
4935 | } |
4936 | } else if (nread == 0) { |
4937 | chanPtr->flags |= CHANNEL_EOF; |
4938 | chanPtr->inputEncodingFlags |= TCL_ENCODING_END; |
4939 | } else if (nread < 0) { |
4940 | if ((result == EWOULDBLOCK) || (result == EAGAIN)) { |
4941 | chanPtr->flags |= CHANNEL_BLOCKED; |
4942 | result = EAGAIN; |
4943 | } |
4944 | Tcl_SetErrno(result); |
4945 | return result; |
4946 | } |
4947 | return 0; |
4948 | } |
4949 | |
4950 | /* |
4951 | *---------------------------------------------------------------------- |
4952 | * |
4953 | * Tcl_Seek -- |
4954 | * |
4955 | * Implements seeking on Tcl Channels. This is a public function |
4956 | * so that other C facilities may be implemented on top of it. |
4957 | * |
4958 | * Results: |
4959 | * The new access point or -1 on error. If error, use Tcl_GetErrno() |
4960 | * to retrieve the POSIX error code for the error that occurred. |
4961 | * |
4962 | * Side effects: |
4963 | * May flush output on the channel. May discard queued input. |
4964 | * |
4965 | *---------------------------------------------------------------------- |
4966 | */ |
4967 | |
4968 | int |
4969 | Tcl_Seek(chan, offset, mode) |
4970 | Tcl_Channel chan; /* The channel on which to seek. */ |
4971 | int offset; /* Offset to seek to. */ |
4972 | int mode; /* Relative to which location to seek? */ |
4973 | { |
4974 | Channel *chanPtr; /* The real IO channel. */ |
4975 | ChannelBuffer *bufPtr; |
4976 | int inputBuffered, outputBuffered; |
4977 | int result; /* Of device driver operations. */ |
4978 | int curPos; /* Position on the device. */ |
4979 | int wasAsync; /* Was the channel nonblocking before the |
4980 | * seek operation? If so, must restore to |
4981 | * nonblocking mode after the seek. */ |
4982 | |
4983 | chanPtr = (Channel *) chan; |
4984 | if (CheckChannelErrors(chanPtr, TCL_WRITABLE | TCL_READABLE) != 0) { |
4985 | return -1; |
4986 | } |
4987 | |
4988 | /* |
4989 | * Disallow seek on dead channels -- channels that have been closed but |
4990 | * not yet been deallocated. Such channels can be found if the exit |
4991 | * handler for channel cleanup has run but the channel is still |
4992 | * registered in an interpreter. |
4993 | */ |
4994 | |
4995 | if (CheckForDeadChannel(NULL,chanPtr)) return -1; |
4996 | |
4997 | /* |
4998 | * Disallow seek on channels whose type does not have a seek procedure |
4999 | * defined. This means that the channel does not support seeking. |
5000 | */ |
5001 | |
5002 | if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) { |
5003 | Tcl_SetErrno(EINVAL); |
5004 | return -1; |
5005 | } |
5006 | |
5007 | /* |
5008 | * Compute how much input and output is buffered. If both input and |
5009 | * output is buffered, cannot compute the current position. |
5010 | */ |
5011 | |
5012 | for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0; |
5013 | bufPtr != (ChannelBuffer *) NULL; |
5014 | bufPtr = bufPtr->nextPtr) { |
5015 | inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); |
5016 | } |
5017 | for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0; |
5018 | bufPtr != (ChannelBuffer *) NULL; |
5019 | bufPtr = bufPtr->nextPtr) { |
5020 | outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); |
5021 | } |
5022 | if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) && |
5023 | (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) { |
5024 | chanPtr->flags |= BUFFER_READY; |
5025 | outputBuffered += |
5026 | (chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved); |
5027 | } |
5028 | |
5029 | if ((inputBuffered != 0) && (outputBuffered != 0)) { |
5030 | Tcl_SetErrno(EFAULT); |
5031 | return -1; |
5032 | } |
5033 | |
5034 | /* |
5035 | * If we are seeking relative to the current position, compute the |
5036 | * corrected offset taking into account the amount of unread input. |
5037 | */ |
5038 | |
5039 | if (mode == SEEK_CUR) { |
5040 | offset -= inputBuffered; |
5041 | } |
5042 | |
5043 | /* |
5044 | * Discard any queued input - this input should not be read after |
5045 | * the seek. |
5046 | */ |
5047 | |
5048 | DiscardInputQueued(chanPtr, 0); |
5049 | |
5050 | /* |
5051 | * Reset EOF and BLOCKED flags. We invalidate them by moving the |
5052 | * access point. Also clear CR related flags. |
5053 | */ |
5054 | |
5055 | chanPtr->flags &= |
5056 | (~(CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | INPUT_SAW_CR)); |
5057 | |
5058 | /* |
5059 | * If the channel is in asynchronous output mode, switch it back |
5060 | * to synchronous mode and cancel any async flush that may be |
5061 | * scheduled. After the flush, the channel will be put back into |
5062 | * asynchronous output mode. |
5063 | */ |
5064 | |
5065 | wasAsync = 0; |
5066 | if (chanPtr->flags & CHANNEL_NONBLOCKING) { |
5067 | wasAsync = 1; |
5068 | result = 0; |
5069 | if (chanPtr->typePtr->blockModeProc != NULL) { |
5070 | result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData, |
5071 | TCL_MODE_BLOCKING); |
5072 | } |
5073 | if (result != 0) { |
5074 | Tcl_SetErrno(result); |
5075 | return -1; |
5076 | } |
5077 | chanPtr->flags &= (~(CHANNEL_NONBLOCKING)); |
5078 | if (chanPtr->flags & BG_FLUSH_SCHEDULED) { |
5079 | chanPtr->flags &= (~(BG_FLUSH_SCHEDULED)); |
5080 | } |
5081 | } |
5082 | |
5083 | /* |
5084 | * If the flush fails we cannot recover the original position. In |
5085 | * that case the seek is not attempted because we do not know where |
5086 | * the access position is - instead we return the error. FlushChannel |
5087 | * has already called Tcl_SetErrno() to report the error upwards. |
5088 | * If the flush succeeds we do the seek also. |
5089 | */ |
5090 | |
5091 | if (FlushChannel(NULL, chanPtr, 0) != 0) { |
5092 | curPos = -1; |
5093 | } else { |
5094 | |
5095 | /* |
5096 | * Now seek to the new position in the channel as requested by the |
5097 | * caller. |
5098 | */ |
5099 | |
5100 | curPos = (chanPtr->typePtr->seekProc) (chanPtr->instanceData, |
5101 | (long) offset, mode, &result); |
5102 | if (curPos == -1) { |
5103 | Tcl_SetErrno(result); |
5104 | } |
5105 | } |
5106 | |
5107 | /* |
5108 | * Restore to nonblocking mode if that was the previous behavior. |
5109 | * |
5110 | * NOTE: Even if there was an async flush active we do not restore |
5111 | * it now because we already flushed all the queued output, above. |
5112 | */ |
5113 | |
5114 | if (wasAsync) { |
5115 | chanPtr->flags |= CHANNEL_NONBLOCKING; |
5116 | result = 0; |
5117 | if (chanPtr->typePtr->blockModeProc != NULL) { |
5118 | result = (chanPtr->typePtr->blockModeProc) (chanPtr->instanceData, |
5119 | TCL_MODE_NONBLOCKING); |
5120 | } |
5121 | if (result != 0) { |
5122 | Tcl_SetErrno(result); |
5123 | return -1; |
5124 | } |
5125 | } |
5126 | |
5127 | return curPos; |
5128 | } |
5129 | |
5130 | /* |
5131 | *---------------------------------------------------------------------- |
5132 | * |
5133 | * Tcl_Tell -- |
5134 | * |
5135 | * Returns the position of the next character to be read/written on |
5136 | * this channel. |
5137 | * |
5138 | * Results: |
5139 | * A nonnegative integer on success, -1 on failure. If failed, |
5140 | * use Tcl_GetErrno() to retrieve the POSIX error code for the |
5141 | * error that occurred. |
5142 | * |
5143 | * Side effects: |
5144 | * None. |
5145 | * |
5146 | *---------------------------------------------------------------------- |
5147 | */ |
5148 | |
5149 | int |
5150 | Tcl_Tell(chan) |
5151 | Tcl_Channel chan; /* The channel to return pos for. */ |
5152 | { |
5153 | Channel *chanPtr; /* The actual channel to tell on. */ |
5154 | ChannelBuffer *bufPtr; |
5155 | int inputBuffered, outputBuffered; |
5156 | int result; /* Of calling device driver. */ |
5157 | int curPos; /* Position on device. */ |
5158 | |
5159 | chanPtr = (Channel *) chan; |
5160 | if (CheckChannelErrors(chanPtr, TCL_WRITABLE | TCL_READABLE) != 0) { |
5161 | return -1; |
5162 | } |
5163 | |
5164 | /* |
5165 | * Disallow tell on dead channels -- channels that have been closed but |
5166 | * not yet been deallocated. Such channels can be found if the exit |
5167 | * handler for channel cleanup has run but the channel is still |
5168 | * registered in an interpreter. |
5169 | */ |
5170 | |
5171 | if (CheckForDeadChannel(NULL,chanPtr)) { |
5172 | return -1; |
5173 | } |
5174 | |
5175 | /* |
5176 | * Disallow tell on channels whose type does not have a seek procedure |
5177 | * defined. This means that the channel does not support seeking. |
5178 | */ |
5179 | |
5180 | if (chanPtr->typePtr->seekProc == (Tcl_DriverSeekProc *) NULL) { |
5181 | Tcl_SetErrno(EINVAL); |
5182 | return -1; |
5183 | } |
5184 | |
5185 | /* |
5186 | * Compute how much input and output is buffered. If both input and |
5187 | * output is buffered, cannot compute the current position. |
5188 | */ |
5189 | |
5190 | for (bufPtr = chanPtr->inQueueHead, inputBuffered = 0; |
5191 | bufPtr != (ChannelBuffer *) NULL; |
5192 | bufPtr = bufPtr->nextPtr) { |
5193 | inputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); |
5194 | } |
5195 | for (bufPtr = chanPtr->outQueueHead, outputBuffered = 0; |
5196 | bufPtr != (ChannelBuffer *) NULL; |
5197 | bufPtr = bufPtr->nextPtr) { |
5198 | outputBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); |
5199 | } |
5200 | if ((chanPtr->curOutPtr != (ChannelBuffer *) NULL) && |
5201 | (chanPtr->curOutPtr->nextAdded > chanPtr->curOutPtr->nextRemoved)) { |
5202 | chanPtr->flags |= BUFFER_READY; |
5203 | outputBuffered += |
5204 | (chanPtr->curOutPtr->nextAdded - chanPtr->curOutPtr->nextRemoved); |
5205 | } |
5206 | |
5207 | if ((inputBuffered != 0) && (outputBuffered != 0)) { |
5208 | Tcl_SetErrno(EFAULT); |
5209 | return -1; |
5210 | } |
5211 | |
5212 | /* |
5213 | * Get the current position in the device and compute the position |
5214 | * where the next character will be read or written. |
5215 | */ |
5216 | |
5217 | curPos = (chanPtr->typePtr->seekProc) (chanPtr->instanceData, |
5218 | (long) 0, SEEK_CUR, &result); |
5219 | if (curPos == -1) { |
5220 | Tcl_SetErrno(result); |
5221 | return -1; |
5222 | } |
5223 | if (inputBuffered != 0) { |
5224 | return (curPos - inputBuffered); |
5225 | } |
5226 | return (curPos + outputBuffered); |
5227 | } |
5228 | |
5229 | /* |
5230 | *--------------------------------------------------------------------------- |
5231 | * |
5232 | * CheckChannelErrors -- |
5233 | * |
5234 | * See if the channel is in an ready state and can perform the |
5235 | * desired operation. |
5236 | * |
5237 | * Results: |
5238 | * The return value is 0 if the channel is OK, otherwise the |
5239 | * return value is -1 and errno is set to indicate the error. |
5240 | * |
5241 | * Side effects: |
5242 | * May clear the EOF and/or BLOCKED bits if reading from channel. |
5243 | * |
5244 | *--------------------------------------------------------------------------- |
5245 | */ |
5246 | |
5247 | static int |
5248 | CheckChannelErrors(chanPtr, direction) |
5249 | Channel *chanPtr; /* Channel to check. */ |
5250 | int direction; /* Test if channel supports desired operation: |
5251 | * TCL_READABLE, TCL_WRITABLE. */ |
5252 | { |
5253 | /* |
5254 | * Check for unreported error. |
5255 | */ |
5256 | |
5257 | if (chanPtr->unreportedError != 0) { |
5258 | Tcl_SetErrno(chanPtr->unreportedError); |
5259 | chanPtr->unreportedError = 0; |
5260 | return -1; |
5261 | } |
5262 | |
5263 | /* |
5264 | * Fail if the channel is not opened for desired operation. |
5265 | */ |
5266 | |
5267 | if ((chanPtr->flags & direction) == 0) { |
5268 | Tcl_SetErrno(EACCES); |
5269 | return -1; |
5270 | } |
5271 | |
5272 | /* |
5273 | * Fail if the channel is in the middle of a background copy. |
5274 | */ |
5275 | |
5276 | if (chanPtr->csPtr != NULL) { |
5277 | Tcl_SetErrno(EBUSY); |
5278 | return -1; |
5279 | } |
5280 | |
5281 | if (direction == TCL_READABLE) { |
5282 | /* |
5283 | * If we have not encountered a sticky EOF, clear the EOF bit |
5284 | * (sticky EOF is set if we have seen the input eofChar, to prevent |
5285 | * reading beyond the eofChar). Also, always clear the BLOCKED bit. |
5286 | * We want to discover these conditions anew in each operation. |
5287 | */ |
5288 | |
5289 | if ((chanPtr->flags & CHANNEL_STICKY_EOF) == 0) { |
5290 | chanPtr->flags &= ~CHANNEL_EOF; |
5291 | } |
5292 | chanPtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_NEED_MORE_DATA); |
5293 | } |
5294 | |
5295 | return 0; |
5296 | } |
5297 | |
5298 | /* |
5299 | *---------------------------------------------------------------------- |
5300 | * |
5301 | * Tcl_Eof -- |
5302 | * |
5303 | * Returns 1 if the channel is at EOF, 0 otherwise. |
5304 | * |
5305 | * Results: |
5306 | * 1 or 0, always. |
5307 | * |
5308 | * Side effects: |
5309 | * None. |
5310 | * |
5311 | *---------------------------------------------------------------------- |
5312 | */ |
5313 | |
5314 | int |
5315 | Tcl_Eof(chan) |
5316 | Tcl_Channel chan; /* Does this channel have EOF? */ |
5317 | { |
5318 | Channel *chanPtr; /* The real channel structure. */ |
5319 | |
5320 | chanPtr = (Channel *) chan; |
5321 | return ((chanPtr->flags & CHANNEL_STICKY_EOF) || |
5322 | ((chanPtr->flags & CHANNEL_EOF) && (Tcl_InputBuffered(chan) == 0))) |
5323 | ? 1 : 0; |
5324 | } |
5325 | |
5326 | /* |
5327 | *---------------------------------------------------------------------- |
5328 | * |
5329 | * Tcl_InputBlocked -- |
5330 | * |
5331 | * Returns 1 if input is blocked on this channel, 0 otherwise. |
5332 | * |
5333 | * Results: |
5334 | * 0 or 1, always. |
5335 | * |
5336 | * Side effects: |
5337 | * None. |
5338 | * |
5339 | *---------------------------------------------------------------------- |
5340 | */ |
5341 | |
5342 | int |
5343 | Tcl_InputBlocked(chan) |
5344 | Tcl_Channel chan; /* Is this channel blocked? */ |
5345 | { |
5346 | Channel *chanPtr; /* The real channel structure. */ |
5347 | |
5348 | chanPtr = (Channel *) chan; |
5349 | return (chanPtr->flags & CHANNEL_BLOCKED) ? 1 : 0; |
5350 | } |
5351 | |
5352 | /* |
5353 | *---------------------------------------------------------------------- |
5354 | * |
5355 | * Tcl_InputBuffered -- |
5356 | * |
5357 | * Returns the number of bytes of input currently buffered in the |
5358 | * internal buffer of a channel. |
5359 | * |
5360 | * Results: |
5361 | * The number of input bytes buffered, or zero if the channel is not |
5362 | * open for reading. |
5363 | * |
5364 | * Side effects: |
5365 | * None. |
5366 | * |
5367 | *---------------------------------------------------------------------- |
5368 | */ |
5369 | |
5370 | int |
5371 | Tcl_InputBuffered(chan) |
5372 | Tcl_Channel chan; /* The channel to query. */ |
5373 | { |
5374 | Channel *chanPtr; |
5375 | int bytesBuffered; |
5376 | ChannelBuffer *bufPtr; |
5377 | |
5378 | chanPtr = (Channel *) chan; |
5379 | for (bytesBuffered = 0, bufPtr = chanPtr->inQueueHead; |
5380 | bufPtr != (ChannelBuffer *) NULL; |
5381 | bufPtr = bufPtr->nextPtr) { |
5382 | bytesBuffered += (bufPtr->nextAdded - bufPtr->nextRemoved); |
5383 | } |
5384 | return bytesBuffered; |
5385 | } |
5386 | |
5387 | /* |
5388 | *---------------------------------------------------------------------- |
5389 | * |
5390 | * Tcl_SetChannelBufferSize -- |
5391 | * |
5392 | * Sets the size of buffers to allocate to store input or output |
5393 | * in the channel. The size must be between 10 bytes and 1 MByte. |
5394 | * |
5395 | * Results: |
5396 | * None. |
5397 | * |
5398 | * Side effects: |
5399 | * Sets the size of buffers subsequently allocated for this channel. |
5400 | * |
5401 | *---------------------------------------------------------------------- |
5402 | */ |
5403 | |
5404 | void |
5405 | Tcl_SetChannelBufferSize(chan, sz) |
5406 | Tcl_Channel chan; /* The channel whose buffer size |
5407 | * to set. */ |
5408 | int sz; /* The size to set. */ |
5409 | { |
5410 | Channel *chanPtr; |
5411 | |
5412 | /* |
5413 | * If the buffer size is smaller than 10 bytes or larger than one MByte, |
5414 | * do not accept the requested size and leave the current buffer size. |
5415 | */ |
5416 | |
5417 | if (sz < 10) { |
5418 | return; |
5419 | } |
5420 | if (sz > (1024 * 1024)) { |
5421 | return; |
5422 | } |
5423 | |
5424 | chanPtr = (Channel *) chan; |
5425 | chanPtr->bufSize = sz; |
5426 | |
5427 | if (chanPtr->outputStage != NULL) { |
5428 | ckfree((char *) chanPtr->outputStage); |
5429 | chanPtr->outputStage = NULL; |
5430 | } |
5431 | if ((chanPtr->encoding != NULL) && (chanPtr->flags & TCL_WRITABLE)) { |
5432 | chanPtr->outputStage = (char *) |
5433 | ckalloc((unsigned) (chanPtr->bufSize + 2)); |
5434 | } |
5435 | } |
5436 | |
5437 | /* |
5438 | *---------------------------------------------------------------------- |
5439 | * |
5440 | * Tcl_GetChannelBufferSize -- |
5441 | * |
5442 | * Retrieves the size of buffers to allocate for this channel. |
5443 | * |
5444 | * Results: |
5445 | * The size. |
5446 | * |
5447 | * Side effects: |
5448 | * None. |
5449 | * |
5450 | *---------------------------------------------------------------------- |
5451 | */ |
5452 | |
5453 | int |
5454 | Tcl_GetChannelBufferSize(chan) |
5455 | Tcl_Channel chan; /* The channel for which to find the |
5456 | * buffer size. */ |
5457 | { |
5458 | Channel *chanPtr; |
5459 | |
5460 | chanPtr = (Channel *) chan; |
5461 | return chanPtr->bufSize; |
5462 | } |
5463 | |
5464 | /* |
5465 | *---------------------------------------------------------------------- |
5466 | * |
5467 | * Tcl_BadChannelOption -- |
5468 | * |
5469 | * This procedure generates a "bad option" error message in an |
5470 | * (optional) interpreter. It is used by channel drivers when |
5471 | * a invalid Set/Get option is requested. Its purpose is to concatenate |
5472 | * the generic options list to the specific ones and factorize |
5473 | * the generic options error message string. |
5474 | * |
5475 | * Results: |
5476 | * TCL_ERROR. |
5477 | * |
5478 | * Side effects: |
5479 | * An error message is generated in interp's result object to |
5480 | * indicate that a command was invoked with the a bad option |
5481 | * The message has the form |
5482 | * bad option "blah": should be one of |
5483 | * <...generic options...>+<...specific options...> |
5484 | * "blah" is the optionName argument and "<specific options>" |
5485 | * is a space separated list of specific option words. |
5486 | * The function takes good care of inserting minus signs before |
5487 | * each option, commas after, and an "or" before the last option. |
5488 | * |
5489 | *---------------------------------------------------------------------- |
5490 | */ |
5491 | |
5492 | int |
5493 | Tcl_BadChannelOption(interp, optionName, optionList) |
5494 | Tcl_Interp *interp; /* Current interpreter. (can be NULL)*/ |
5495 | char *optionName; /* 'bad option' name */ |
5496 | char *optionList; /* Specific options list to append |
5497 | * to the standard generic options. |
5498 | * can be NULL for generic options |
5499 | * only. |
5500 | */ |
5501 | { |
5502 | if (interp) { |
5503 | CONST char *genericopt = |
5504 | "blocking buffering buffersize encoding eofchar translation"; |
5505 | char **argv; |
5506 | int argc, i; |
5507 | Tcl_DString ds; |
5508 | |
5509 | Tcl_DStringInit(&ds); |
5510 | Tcl_DStringAppend(&ds, (char *) genericopt, -1); |
5511 | if (optionList && (*optionList)) { |
5512 | Tcl_DStringAppend(&ds, " ", 1); |
5513 | Tcl_DStringAppend(&ds, optionList, -1); |
5514 | } |
5515 | if (Tcl_SplitList(interp, Tcl_DStringValue(&ds), |
5516 | &argc, &argv) != TCL_OK) { |
5517 | panic("malformed option list in channel driver"); |
5518 | } |
5519 | Tcl_ResetResult(interp); |
5520 | Tcl_AppendResult(interp, "bad option \"", optionName, |
5521 | "\": should be one of ", (char *) NULL); |
5522 | argc--; |
5523 | for (i = 0; i < argc; i++) { |
5524 | Tcl_AppendResult(interp, "-", argv[i], ", ", (char *) NULL); |
5525 | } |
5526 | Tcl_AppendResult(interp, "or -", argv[i], (char *) NULL); |
5527 | Tcl_DStringFree(&ds); |
5528 | ckfree((char *) argv); |
5529 | } |
5530 | Tcl_SetErrno(EINVAL); |
5531 | return TCL_ERROR; |
5532 | } |
5533 | |
5534 | /* |
5535 | *---------------------------------------------------------------------- |
5536 | * |
5537 | * Tcl_GetChannelOption -- |
5538 | * |
5539 | * Gets a mode associated with an IO channel. If the optionName arg |
5540 | * is non NULL, retrieves the value of that option. If the optionName |
5541 | * arg is NULL, retrieves a list of alternating option names and |
5542 | * values for the given channel. |
5543 | * |
5544 | * Results: |
5545 | * A standard Tcl result. Also sets the supplied DString to the |
5546 | * string value of the option(s) returned. |
5547 | * |
5548 | * Side effects: |
5549 | * None. |
5550 | * |
5551 | *---------------------------------------------------------------------- |
5552 | */ |
5553 | |
5554 | int |
5555 | Tcl_GetChannelOption(interp, chan, optionName, dsPtr) |
5556 | Tcl_Interp *interp; /* For error reporting - can be NULL. */ |
5557 | Tcl_Channel chan; /* Channel on which to get option. */ |
5558 | char *optionName; /* Option to get. */ |
5559 | Tcl_DString *dsPtr; /* Where to store value(s). */ |
5560 | { |
5561 | size_t len; /* Length of optionName string. */ |
5562 | char optionVal[128]; /* Buffer for sprintf. */ |
5563 | Channel *chanPtr = (Channel *) chan; |
5564 | int flags; |
5565 | |
5566 | /* |
5567 | * If we are in the middle of a background copy, use the saved flags. |
5568 | */ |
5569 | |
5570 | if (chanPtr->csPtr) { |
5571 | if (chanPtr == chanPtr->csPtr->readPtr) { |
5572 | flags = chanPtr->csPtr->readFlags; |
5573 | } else { |
5574 | flags = chanPtr->csPtr->writeFlags; |
5575 | } |
5576 | } else { |
5577 | flags = chanPtr->flags; |
5578 | } |
5579 | |
5580 | /* |
5581 | * Disallow options on dead channels -- channels that have been closed but |
5582 | * not yet been deallocated. Such channels can be found if the exit |
5583 | * handler for channel cleanup has run but the channel is still |
5584 | * registered in an interpreter. |
5585 | */ |
5586 | |
5587 | if (CheckForDeadChannel(interp,chanPtr)) return TCL_ERROR; |
5588 | |
5589 | /* |
5590 | * If the optionName is NULL it means that we want a list of all |
5591 | * options and values. |
5592 | */ |
5593 | |
5594 | if (optionName == (char *) NULL) { |
5595 | len = 0; |
5596 | } else { |
5597 | len = strlen(optionName); |
5598 | } |
5599 | |
5600 | if ((len == 0) || ((len > 2) && (optionName[1] == 'b') && |
5601 | (strncmp(optionName, "-blocking", len) == 0))) { |
5602 | if (len == 0) { |
5603 | Tcl_DStringAppendElement(dsPtr, "-blocking"); |
5604 | } |
5605 | Tcl_DStringAppendElement(dsPtr, |
5606 | (flags & CHANNEL_NONBLOCKING) ? "0" : "1"); |
5607 | if (len > 0) { |
5608 | return TCL_OK; |
5609 | } |
5610 | } |
5611 | if ((len == 0) || ((len > 7) && (optionName[1] == 'b') && |
5612 | (strncmp(optionName, "-buffering", len) == 0))) { |
5613 | if (len == 0) { |
5614 | Tcl_DStringAppendElement(dsPtr, "-buffering"); |
5615 | } |
5616 | if (flags & CHANNEL_LINEBUFFERED) { |
5617 | Tcl_DStringAppendElement(dsPtr, "line"); |
5618 | } else if (flags & CHANNEL_UNBUFFERED) { |
5619 | Tcl_DStringAppendElement(dsPtr, "none"); |
5620 | } else { |
5621 | Tcl_DStringAppendElement(dsPtr, "full"); |
5622 | } |
5623 | if (len > 0) { |
5624 | return TCL_OK; |
5625 | } |
5626 | } |
5627 | if ((len == 0) || ((len > 7) && (optionName[1] == 'b') && |
5628 | (strncmp(optionName, "-buffersize", len) == 0))) { |
5629 | if (len == 0) { |
5630 | Tcl_DStringAppendElement(dsPtr, "-buffersize"); |
5631 | } |
5632 | TclFormatInt(optionVal, chanPtr->bufSize); |
5633 | Tcl_DStringAppendElement(dsPtr, optionVal); |
5634 | if (len > 0) { |
5635 | return TCL_OK; |
5636 | } |
5637 | } |
5638 | if ((len == 0) || |
5639 | ((len > 2) && (optionName[1] == 'e') && |
5640 | (strncmp(optionName, "-encoding", len) == 0))) { |
5641 | if (len == 0) { |
5642 | Tcl_DStringAppendElement(dsPtr, "-encoding"); |
5643 | } |
5644 | if (chanPtr->encoding == NULL) { |
5645 | Tcl_DStringAppendElement(dsPtr, "binary"); |
5646 | } else { |
5647 | Tcl_DStringAppendElement(dsPtr, |
5648 | Tcl_GetEncodingName(chanPtr->encoding)); |
5649 | } |
5650 | if (len > 0) { |
5651 | return TCL_OK; |
5652 | } |
5653 | } |
5654 | if ((len == 0) || |
5655 | ((len > 2) && (optionName[1] == 'e') && |
5656 | (strncmp(optionName, "-eofchar", len) == 0))) { |
5657 | if (len == 0) { |
5658 | Tcl_DStringAppendElement(dsPtr, "-eofchar"); |
5659 | } |
5660 | if (((flags & (TCL_READABLE|TCL_WRITABLE)) == |
5661 | (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { |
5662 | Tcl_DStringStartSublist(dsPtr); |
5663 | } |
5664 | if (flags & TCL_READABLE) { |
5665 | if (chanPtr->inEofChar == 0) { |
5666 | Tcl_DStringAppendElement(dsPtr, ""); |
5667 | } else { |
5668 | char buf[4]; |
5669 | |
5670 | sprintf(buf, "%c", chanPtr->inEofChar); |
5671 | Tcl_DStringAppendElement(dsPtr, buf); |
5672 | } |
5673 | } |
5674 | if (flags & TCL_WRITABLE) { |
5675 | if (chanPtr->outEofChar == 0) { |
5676 | Tcl_DStringAppendElement(dsPtr, ""); |
5677 | } else { |
5678 | char buf[4]; |
5679 | |
5680 | sprintf(buf, "%c", chanPtr->outEofChar); |
5681 | Tcl_DStringAppendElement(dsPtr, buf); |
5682 | } |
5683 | } |
5684 | if (((flags & (TCL_READABLE|TCL_WRITABLE)) == |
5685 | (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { |
5686 | Tcl_DStringEndSublist(dsPtr); |
5687 | } |
5688 | if (len > 0) { |
5689 | return TCL_OK; |
5690 | } |
5691 | } |
5692 | if ((len == 0) || |
5693 | ((len > 1) && (optionName[1] == 't') && |
5694 | (strncmp(optionName, "-translation", len) == 0))) { |
5695 | if (len == 0) { |
5696 | Tcl_DStringAppendElement(dsPtr, "-translation"); |
5697 | } |
5698 | if (((flags & (TCL_READABLE|TCL_WRITABLE)) == |
5699 | (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { |
5700 | Tcl_DStringStartSublist(dsPtr); |
5701 | } |
5702 | if (flags & TCL_READABLE) { |
5703 | if (chanPtr->inputTranslation == TCL_TRANSLATE_AUTO) { |
5704 | Tcl_DStringAppendElement(dsPtr, "auto"); |
5705 | } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CR) { |
5706 | Tcl_DStringAppendElement(dsPtr, "cr"); |
5707 | } else if (chanPtr->inputTranslation == TCL_TRANSLATE_CRLF) { |
5708 | Tcl_DStringAppendElement(dsPtr, "crlf"); |
5709 | } else { |
5710 | Tcl_DStringAppendElement(dsPtr, "lf"); |
5711 | } |
5712 | } |
5713 | if (flags & TCL_WRITABLE) { |
5714 | if (chanPtr->outputTranslation == TCL_TRANSLATE_AUTO) { |
5715 | Tcl_DStringAppendElement(dsPtr, "auto"); |
5716 | } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CR) { |
5717 | Tcl_DStringAppendElement(dsPtr, "cr"); |
5718 | } else if (chanPtr->outputTranslation == TCL_TRANSLATE_CRLF) { |
5719 | Tcl_DStringAppendElement(dsPtr, "crlf"); |
5720 | } else { |
5721 | Tcl_DStringAppendElement(dsPtr, "lf"); |
5722 | } |
5723 | } |
5724 | if (((flags & (TCL_READABLE|TCL_WRITABLE)) == |
5725 | (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { |
5726 | Tcl_DStringEndSublist(dsPtr); |
5727 | } |
5728 | if (len > 0) { |
5729 | return TCL_OK; |
5730 | } |
5731 | } |
5732 | if (chanPtr->typePtr->getOptionProc != (Tcl_DriverGetOptionProc *) NULL) { |
5733 | /* |
5734 | * let the driver specific handle additional options |
5735 | * and result code and message. |
5736 | */ |
5737 | |
5738 | return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData, |
5739 | interp, optionName, dsPtr); |
5740 | } else { |
5741 | /* |
5742 | * no driver specific options case. |
5743 | */ |
5744 | |
5745 | if (len == 0) { |
5746 | return TCL_OK; |
5747 | } |
5748 | return Tcl_BadChannelOption(interp, optionName, NULL); |
5749 | } |
5750 | } |
5751 | |
5752 | /* |
5753 | *--------------------------------------------------------------------------- |
5754 | * |
5755 | * Tcl_SetChannelOption -- |
5756 | * |
5757 | * Sets an option on a channel. |
5758 | * |
5759 | * Results: |
5760 | * A standard Tcl result. On error, sets interp's result object |
5761 | * if interp is not NULL. |
5762 | * |
5763 | * Side effects: |
5764 | * May modify an option on a device. |
5765 | * |
5766 | *--------------------------------------------------------------------------- |
5767 | */ |
5768 | |
5769 | int |
5770 | Tcl_SetChannelOption(interp, chan, optionName, newValue) |
5771 | Tcl_Interp *interp; /* For error reporting - can be NULL. */ |
5772 | Tcl_Channel chan; /* Channel on which to set mode. */ |
5773 | char *optionName; /* Which option to set? */ |
5774 | char *newValue; /* New value for option. */ |
5775 | { |
5776 | int newMode; /* New (numeric) mode to sert. */ |
5777 | Channel *chanPtr; /* The real IO channel. */ |
5778 | size_t len; /* Length of optionName string. */ |
5779 | int argc; |
5780 | char **argv; |
5781 | |
5782 | chanPtr = (Channel *) chan; |
5783 | |
5784 | /* |
5785 | * If the channel is in the middle of a background copy, fail. |
5786 | */ |
5787 | |
5788 | if (chanPtr->csPtr) { |
5789 | if (interp) { |
5790 | Tcl_AppendResult(interp, |
5791 | "unable to set channel options: background copy in progress", |
5792 | (char *) NULL); |
5793 | } |
5794 | return TCL_ERROR; |
5795 | } |
5796 | |
5797 | |
5798 | /* |
5799 | * Disallow options on dead channels -- channels that have been closed but |
5800 | * not yet been deallocated. Such channels can be found if the exit |
5801 | * handler for channel cleanup has run but the channel is still |
5802 | * registered in an interpreter. |
5803 | */ |
5804 | |
5805 | if (CheckForDeadChannel(NULL,chanPtr)) return TCL_ERROR; |
5806 | |
5807 | len = strlen(optionName); |
5808 | |
5809 | if ((len > 2) && (optionName[1] == 'b') && |
5810 | (strncmp(optionName, "-blocking", len) == 0)) { |
5811 | if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) { |
5812 | return TCL_ERROR; |
5813 | } |
5814 | if (newMode) { |
5815 | newMode = TCL_MODE_BLOCKING; |
5816 | } else { |
5817 | newMode = TCL_MODE_NONBLOCKING; |
5818 | } |
5819 | return SetBlockMode(interp, chanPtr, newMode); |
5820 | } else if ((len > 7) && (optionName[1] == 'b') && |
5821 | (strncmp(optionName, "-buffering", len) == 0)) { |
5822 | len = strlen(newValue); |
5823 | if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) { |
5824 | chanPtr->flags &= |
5825 | (~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED)); |
5826 | } else if ((newValue[0] == 'l') && |
5827 | (strncmp(newValue, "line", len) == 0)) { |
5828 | chanPtr->flags &= (~(CHANNEL_UNBUFFERED)); |
5829 | chanPtr->flags |= CHANNEL_LINEBUFFERED; |
5830 | } else if ((newValue[0] == 'n') && |
5831 | (strncmp(newValue, "none", len) == 0)) { |
5832 | chanPtr->flags &= (~(CHANNEL_LINEBUFFERED)); |
5833 | chanPtr->flags |= CHANNEL_UNBUFFERED; |
5834 | } else { |
5835 | if (interp) { |
5836 | Tcl_AppendResult(interp, "bad value for -buffering: ", |
5837 | "must be one of full, line, or none", |
5838 | (char *) NULL); |
5839 | return TCL_ERROR; |
5840 | } |
5841 | } |
5842 | return TCL_OK; |
5843 | } else if ((len > 7) && (optionName[1] == 'b') && |
5844 | (strncmp(optionName, "-buffersize", len) == 0)) { |
5845 | chanPtr->bufSize = atoi(newValue); /* INTL: "C", UTF safe. */ |
5846 | if ((chanPtr->bufSize < 10) || (chanPtr->bufSize > (1024 * 1024))) { |
5847 | chanPtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE; |
5848 | } |
5849 | } else if ((len > 2) && (optionName[1] == 'e') && |
5850 | (strncmp(optionName, "-encoding", len) == 0)) { |
5851 | Tcl_Encodi |