/[dtapublic]/projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclutil.c
ViewVC logotype

Contents of /projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclutil.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 67 - (show annotations) (download)
Mon Oct 31 00:57:34 2016 UTC (6 years, 3 months ago) by dashley
File MIME type: text/plain
File size: 67460 byte(s)
Header and footer cleanup.
1 /* $Header$ */
2 /*
3 * tclUtil.c --
4 *
5 * This file contains utility procedures that are used by many Tcl
6 * commands.
7 *
8 * Copyright (c) 1987-1993 The Regents of the University of California.
9 * Copyright (c) 1994-1998 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: tclutil.c,v 1.1.1.1 2001/06/13 04:47:21 dtashley Exp $
15 */
16
17 #include "tclInt.h"
18 #include "tclPort.h"
19
20 /*
21 * The following variable holds the full path name of the binary
22 * from which this application was executed, or NULL if it isn't
23 * know. The value of the variable is set by the procedure
24 * Tcl_FindExecutable. The storage space is dynamically allocated.
25 */
26
27 char *tclExecutableName = NULL;
28 char *tclNativeExecutableName = NULL;
29
30 /*
31 * The following values are used in the flags returned by Tcl_ScanElement
32 * and used by Tcl_ConvertElement. The value TCL_DONT_USE_BRACES is also
33 * defined in tcl.h; make sure its value doesn't overlap with any of the
34 * values below.
35 *
36 * TCL_DONT_USE_BRACES - 1 means the string mustn't be enclosed in
37 * braces (e.g. it contains unmatched braces,
38 * or ends in a backslash character, or user
39 * just doesn't want braces); handle all
40 * special characters by adding backslashes.
41 * USE_BRACES - 1 means the string contains a special
42 * character that can be handled simply by
43 * enclosing the entire argument in braces.
44 * BRACES_UNMATCHED - 1 means that braces aren't properly matched
45 * in the argument.
46 */
47
48 #define USE_BRACES 2
49 #define BRACES_UNMATCHED 4
50
51 /*
52 * The following values determine the precision used when converting
53 * floating-point values to strings. This information is linked to all
54 * of the tcl_precision variables in all interpreters via the procedure
55 * TclPrecTraceProc.
56 */
57
58 static char precisionString[10] = "12";
59 /* The string value of all the tcl_precision
60 * variables. */
61 static char precisionFormat[10] = "%.12g";
62 /* The format string actually used in calls
63 * to sprintf. */
64 TCL_DECLARE_MUTEX(precisionMutex)
65
66
67 /*
68 *----------------------------------------------------------------------
69 *
70 * TclFindElement --
71 *
72 * Given a pointer into a Tcl list, locate the first (or next)
73 * element in the list.
74 *
75 * Results:
76 * The return value is normally TCL_OK, which means that the
77 * element was successfully located. If TCL_ERROR is returned
78 * it means that list didn't have proper list structure;
79 * the interp's result contains a more detailed error message.
80 *
81 * If TCL_OK is returned, then *elementPtr will be set to point to the
82 * first element of list, and *nextPtr will be set to point to the
83 * character just after any white space following the last character
84 * that's part of the element. If this is the last argument in the
85 * list, then *nextPtr will point just after the last character in the
86 * list (i.e., at the character at list+listLength). If sizePtr is
87 * non-NULL, *sizePtr is filled in with the number of characters in the
88 * element. If the element is in braces, then *elementPtr will point
89 * to the character after the opening brace and *sizePtr will not
90 * include either of the braces. If there isn't an element in the list,
91 * *sizePtr will be zero, and both *elementPtr and *termPtr will point
92 * just after the last character in the list. Note: this procedure does
93 * NOT collapse backslash sequences.
94 *
95 * Side effects:
96 * None.
97 *
98 *----------------------------------------------------------------------
99 */
100
101 int
102 TclFindElement(interp, list, listLength, elementPtr, nextPtr, sizePtr,
103 bracePtr)
104 Tcl_Interp *interp; /* Interpreter to use for error reporting.
105 * If NULL, then no error message is left
106 * after errors. */
107 CONST char *list; /* Points to the first byte of a string
108 * containing a Tcl list with zero or more
109 * elements (possibly in braces). */
110 int listLength; /* Number of bytes in the list's string. */
111 CONST char **elementPtr; /* Where to put address of first significant
112 * character in first element of list. */
113 CONST char **nextPtr; /* Fill in with location of character just
114 * after all white space following end of
115 * argument (next arg or end of list). */
116 int *sizePtr; /* If non-zero, fill in with size of
117 * element. */
118 int *bracePtr; /* If non-zero, fill in with non-zero/zero
119 * to indicate that arg was/wasn't
120 * in braces. */
121 {
122 CONST char *p = list;
123 CONST char *elemStart; /* Points to first byte of first element. */
124 CONST char *limit; /* Points just after list's last byte. */
125 int openBraces = 0; /* Brace nesting level during parse. */
126 int inQuotes = 0;
127 int size = 0; /* lint. */
128 int numChars;
129 CONST char *p2;
130
131 /*
132 * Skim off leading white space and check for an opening brace or
133 * quote. We treat embedded NULLs in the list as bytes belonging to
134 * a list element.
135 */
136
137 limit = (list + listLength);
138 while ((p < limit) && (isspace(UCHAR(*p)))) { /* INTL: ISO space. */
139 p++;
140 }
141 if (p == limit) { /* no element found */
142 elemStart = limit;
143 goto done;
144 }
145
146 if (*p == '{') {
147 openBraces = 1;
148 p++;
149 } else if (*p == '"') {
150 inQuotes = 1;
151 p++;
152 }
153 elemStart = p;
154 if (bracePtr != 0) {
155 *bracePtr = openBraces;
156 }
157
158 /*
159 * Find element's end (a space, close brace, or the end of the string).
160 */
161
162 while (p < limit) {
163 switch (*p) {
164
165 /*
166 * Open brace: don't treat specially unless the element is in
167 * braces. In this case, keep a nesting count.
168 */
169
170 case '{':
171 if (openBraces != 0) {
172 openBraces++;
173 }
174 break;
175
176 /*
177 * Close brace: if element is in braces, keep nesting count and
178 * quit when the last close brace is seen.
179 */
180
181 case '}':
182 if (openBraces > 1) {
183 openBraces--;
184 } else if (openBraces == 1) {
185 size = (p - elemStart);
186 p++;
187 if ((p >= limit)
188 || isspace(UCHAR(*p))) { /* INTL: ISO space. */
189 goto done;
190 }
191
192 /*
193 * Garbage after the closing brace; return an error.
194 */
195
196 if (interp != NULL) {
197 char buf[100];
198
199 p2 = p;
200 while ((p2 < limit)
201 && (!isspace(UCHAR(*p2))) /* INTL: ISO space. */
202 && (p2 < p+20)) {
203 p2++;
204 }
205 sprintf(buf,
206 "list element in braces followed by \"%.*s\" instead of space",
207 (int) (p2-p), p);
208 Tcl_SetResult(interp, buf, TCL_VOLATILE);
209 }
210 return TCL_ERROR;
211 }
212 break;
213
214 /*
215 * Backslash: skip over everything up to the end of the
216 * backslash sequence.
217 */
218
219 case '\\': {
220 Tcl_UtfBackslash(p, &numChars, NULL);
221 p += (numChars - 1);
222 break;
223 }
224
225 /*
226 * Space: ignore if element is in braces or quotes; otherwise
227 * terminate element.
228 */
229
230 case ' ':
231 case '\f':
232 case '\n':
233 case '\r':
234 case '\t':
235 case '\v':
236 if ((openBraces == 0) && !inQuotes) {
237 size = (p - elemStart);
238 goto done;
239 }
240 break;
241
242 /*
243 * Double-quote: if element is in quotes then terminate it.
244 */
245
246 case '"':
247 if (inQuotes) {
248 size = (p - elemStart);
249 p++;
250 if ((p >= limit)
251 || isspace(UCHAR(*p))) { /* INTL: ISO space */
252 goto done;
253 }
254
255 /*
256 * Garbage after the closing quote; return an error.
257 */
258
259 if (interp != NULL) {
260 char buf[100];
261
262 p2 = p;
263 while ((p2 < limit)
264 && (!isspace(UCHAR(*p2))) /* INTL: ISO space */
265 && (p2 < p+20)) {
266 p2++;
267 }
268 sprintf(buf,
269 "list element in quotes followed by \"%.*s\" %s",
270 (int) (p2-p), p, "instead of space");
271 Tcl_SetResult(interp, buf, TCL_VOLATILE);
272 }
273 return TCL_ERROR;
274 }
275 break;
276 }
277 p++;
278 }
279
280
281 /*
282 * End of list: terminate element.
283 */
284
285 if (p == limit) {
286 if (openBraces != 0) {
287 if (interp != NULL) {
288 Tcl_SetResult(interp, "unmatched open brace in list",
289 TCL_STATIC);
290 }
291 return TCL_ERROR;
292 } else if (inQuotes) {
293 if (interp != NULL) {
294 Tcl_SetResult(interp, "unmatched open quote in list",
295 TCL_STATIC);
296 }
297 return TCL_ERROR;
298 }
299 size = (p - elemStart);
300 }
301
302 done:
303 while ((p < limit) && (isspace(UCHAR(*p)))) { /* INTL: ISO space. */
304 p++;
305 }
306 *elementPtr = elemStart;
307 *nextPtr = p;
308 if (sizePtr != 0) {
309 *sizePtr = size;
310 }
311 return TCL_OK;
312 }
313
314 /*
315 *----------------------------------------------------------------------
316 *
317 * TclCopyAndCollapse --
318 *
319 * Copy a string and eliminate any backslashes that aren't in braces.
320 *
321 * Results:
322 * There is no return value. Count characters get copied from src to
323 * dst. Along the way, if backslash sequences are found outside braces,
324 * the backslashes are eliminated in the copy. After scanning count
325 * chars from source, a null character is placed at the end of dst.
326 * Returns the number of characters that got copied.
327 *
328 * Side effects:
329 * None.
330 *
331 *----------------------------------------------------------------------
332 */
333
334 int
335 TclCopyAndCollapse(count, src, dst)
336 int count; /* Number of characters to copy from src. */
337 CONST char *src; /* Copy from here... */
338 char *dst; /* ... to here. */
339 {
340 register char c;
341 int numRead;
342 int newCount = 0;
343 int backslashCount;
344
345 for (c = *src; count > 0; src++, c = *src, count--) {
346 if (c == '\\') {
347 backslashCount = Tcl_UtfBackslash(src, &numRead, dst);
348 dst += backslashCount;
349 newCount += backslashCount;
350 src += numRead-1;
351 count -= numRead-1;
352 } else {
353 *dst = c;
354 dst++;
355 newCount++;
356 }
357 }
358 *dst = 0;
359 return newCount;
360 }
361
362 /*
363 *----------------------------------------------------------------------
364 *
365 * Tcl_SplitList --
366 *
367 * Splits a list up into its constituent fields.
368 *
369 * Results
370 * The return value is normally TCL_OK, which means that
371 * the list was successfully split up. If TCL_ERROR is
372 * returned, it means that "list" didn't have proper list
373 * structure; the interp's result will contain a more detailed
374 * error message.
375 *
376 * *argvPtr will be filled in with the address of an array
377 * whose elements point to the elements of list, in order.
378 * *argcPtr will get filled in with the number of valid elements
379 * in the array. A single block of memory is dynamically allocated
380 * to hold both the argv array and a copy of the list (with
381 * backslashes and braces removed in the standard way).
382 * The caller must eventually free this memory by calling free()
383 * on *argvPtr. Note: *argvPtr and *argcPtr are only modified
384 * if the procedure returns normally.
385 *
386 * Side effects:
387 * Memory is allocated.
388 *
389 *----------------------------------------------------------------------
390 */
391
392 int
393 Tcl_SplitList(interp, list, argcPtr, argvPtr)
394 Tcl_Interp *interp; /* Interpreter to use for error reporting.
395 * If NULL, no error message is left. */
396 CONST char *list; /* Pointer to string with list structure. */
397 int *argcPtr; /* Pointer to location to fill in with
398 * the number of elements in the list. */
399 char ***argvPtr; /* Pointer to place to store pointer to
400 * array of pointers to list elements. */
401 {
402 char **argv;
403 CONST char *l;
404 char *p;
405 int length, size, i, result, elSize, brace;
406 CONST char *element;
407
408 /*
409 * Figure out how much space to allocate. There must be enough
410 * space for both the array of pointers and also for a copy of
411 * the list. To estimate the number of pointers needed, count
412 * the number of space characters in the list.
413 */
414
415 for (size = 1, l = list; *l != 0; l++) {
416 if (isspace(UCHAR(*l))) { /* INTL: ISO space. */
417 size++;
418 }
419 }
420 size++; /* Leave space for final NULL pointer. */
421 argv = (char **) ckalloc((unsigned)
422 ((size * sizeof(char *)) + (l - list) + 1));
423 length = strlen(list);
424 for (i = 0, p = ((char *) argv) + size*sizeof(char *);
425 *list != 0; i++) {
426 CONST char *prevList = list;
427
428 result = TclFindElement(interp, list, length, &element,
429 &list, &elSize, &brace);
430 length -= (list - prevList);
431 if (result != TCL_OK) {
432 ckfree((char *) argv);
433 return result;
434 }
435 if (*element == 0) {
436 break;
437 }
438 if (i >= size) {
439 ckfree((char *) argv);
440 if (interp != NULL) {
441 Tcl_SetResult(interp, "internal error in Tcl_SplitList",
442 TCL_STATIC);
443 }
444 return TCL_ERROR;
445 }
446 argv[i] = p;
447 if (brace) {
448 memcpy((VOID *) p, (VOID *) element, (size_t) elSize);
449 p += elSize;
450 *p = 0;
451 p++;
452 } else {
453 TclCopyAndCollapse(elSize, element, p);
454 p += elSize+1;
455 }
456 }
457
458 argv[i] = NULL;
459 *argvPtr = argv;
460 *argcPtr = i;
461 return TCL_OK;
462 }
463
464 /*
465 *----------------------------------------------------------------------
466 *
467 * Tcl_ScanElement --
468 *
469 * This procedure is a companion procedure to Tcl_ConvertElement.
470 * It scans a string to see what needs to be done to it (e.g. add
471 * backslashes or enclosing braces) to make the string into a
472 * valid Tcl list element.
473 *
474 * Results:
475 * The return value is an overestimate of the number of characters
476 * that will be needed by Tcl_ConvertElement to produce a valid
477 * list element from string. The word at *flagPtr is filled in
478 * with a value needed by Tcl_ConvertElement when doing the actual
479 * conversion.
480 *
481 * Side effects:
482 * None.
483 *
484 *----------------------------------------------------------------------
485 */
486
487 int
488 Tcl_ScanElement(string, flagPtr)
489 register CONST char *string; /* String to convert to list element. */
490 register int *flagPtr; /* Where to store information to guide
491 * Tcl_ConvertCountedElement. */
492 {
493 return Tcl_ScanCountedElement(string, -1, flagPtr);
494 }
495
496 /*
497 *----------------------------------------------------------------------
498 *
499 * Tcl_ScanCountedElement --
500 *
501 * This procedure is a companion procedure to
502 * Tcl_ConvertCountedElement. It scans a string to see what
503 * needs to be done to it (e.g. add backslashes or enclosing
504 * braces) to make the string into a valid Tcl list element.
505 * If length is -1, then the string is scanned up to the first
506 * null byte.
507 *
508 * Results:
509 * The return value is an overestimate of the number of characters
510 * that will be needed by Tcl_ConvertCountedElement to produce a
511 * valid list element from string. The word at *flagPtr is
512 * filled in with a value needed by Tcl_ConvertCountedElement
513 * when doing the actual conversion.
514 *
515 * Side effects:
516 * None.
517 *
518 *----------------------------------------------------------------------
519 */
520
521 int
522 Tcl_ScanCountedElement(string, length, flagPtr)
523 CONST char *string; /* String to convert to Tcl list element. */
524 int length; /* Number of bytes in string, or -1. */
525 int *flagPtr; /* Where to store information to guide
526 * Tcl_ConvertElement. */
527 {
528 int flags, nestingLevel;
529 register CONST char *p, *lastChar;
530
531 /*
532 * This procedure and Tcl_ConvertElement together do two things:
533 *
534 * 1. They produce a proper list, one that will yield back the
535 * argument strings when evaluated or when disassembled with
536 * Tcl_SplitList. This is the most important thing.
537 *
538 * 2. They try to produce legible output, which means minimizing the
539 * use of backslashes (using braces instead). However, there are
540 * some situations where backslashes must be used (e.g. an element
541 * like "{abc": the leading brace will have to be backslashed.
542 * For each element, one of three things must be done:
543 *
544 * (a) Use the element as-is (it doesn't contain any special
545 * characters). This is the most desirable option.
546 *
547 * (b) Enclose the element in braces, but leave the contents alone.
548 * This happens if the element contains embedded space, or if it
549 * contains characters with special interpretation ($, [, ;, or \),
550 * or if it starts with a brace or double-quote, or if there are
551 * no characters in the element.
552 *
553 * (c) Don't enclose the element in braces, but add backslashes to
554 * prevent special interpretation of special characters. This is a
555 * last resort used when the argument would normally fall under case
556 * (b) but contains unmatched braces. It also occurs if the last
557 * character of the argument is a backslash or if the element contains
558 * a backslash followed by newline.
559 *
560 * The procedure figures out how many bytes will be needed to store
561 * the result (actually, it overestimates). It also collects information
562 * about the element in the form of a flags word.
563 *
564 * Note: list elements produced by this procedure and
565 * Tcl_ConvertCountedElement must have the property that they can be
566 * enclosing in curly braces to make sub-lists. This means, for
567 * example, that we must not leave unmatched curly braces in the
568 * resulting list element. This property is necessary in order for
569 * procedures like Tcl_DStringStartSublist to work.
570 */
571
572 nestingLevel = 0;
573 flags = 0;
574 if (string == NULL) {
575 string = "";
576 }
577 if (length == -1) {
578 length = strlen(string);
579 }
580 lastChar = string + length;
581 p = string;
582 if ((p == lastChar) || (*p == '{') || (*p == '"')) {
583 flags |= USE_BRACES;
584 }
585 for ( ; p < lastChar; p++) {
586 switch (*p) {
587 case '{':
588 nestingLevel++;
589 break;
590 case '}':
591 nestingLevel--;
592 if (nestingLevel < 0) {
593 flags |= TCL_DONT_USE_BRACES|BRACES_UNMATCHED;
594 }
595 break;
596 case '[':
597 case '$':
598 case ';':
599 case ' ':
600 case '\f':
601 case '\n':
602 case '\r':
603 case '\t':
604 case '\v':
605 flags |= USE_BRACES;
606 break;
607 case '\\':
608 if ((p+1 == lastChar) || (p[1] == '\n')) {
609 flags = TCL_DONT_USE_BRACES | BRACES_UNMATCHED;
610 } else {
611 int size;
612
613 Tcl_UtfBackslash(p, &size, NULL);
614 p += size-1;
615 flags |= USE_BRACES;
616 }
617 break;
618 }
619 }
620 if (nestingLevel != 0) {
621 flags = TCL_DONT_USE_BRACES | BRACES_UNMATCHED;
622 }
623 *flagPtr = flags;
624
625 /*
626 * Allow enough space to backslash every character plus leave
627 * two spaces for braces.
628 */
629
630 return 2*(p-string) + 2;
631 }
632
633 /*
634 *----------------------------------------------------------------------
635 *
636 * Tcl_ConvertElement --
637 *
638 * This is a companion procedure to Tcl_ScanElement. Given
639 * the information produced by Tcl_ScanElement, this procedure
640 * converts a string to a list element equal to that string.
641 *
642 * Results:
643 * Information is copied to *dst in the form of a list element
644 * identical to src (i.e. if Tcl_SplitList is applied to dst it
645 * will produce a string identical to src). The return value is
646 * a count of the number of characters copied (not including the
647 * terminating NULL character).
648 *
649 * Side effects:
650 * None.
651 *
652 *----------------------------------------------------------------------
653 */
654
655 int
656 Tcl_ConvertElement(src, dst, flags)
657 register CONST char *src; /* Source information for list element. */
658 register char *dst; /* Place to put list-ified element. */
659 register int flags; /* Flags produced by Tcl_ScanElement. */
660 {
661 return Tcl_ConvertCountedElement(src, -1, dst, flags);
662 }
663
664 /*
665 *----------------------------------------------------------------------
666 *
667 * Tcl_ConvertCountedElement --
668 *
669 * This is a companion procedure to Tcl_ScanCountedElement. Given
670 * the information produced by Tcl_ScanCountedElement, this
671 * procedure converts a string to a list element equal to that
672 * string.
673 *
674 * Results:
675 * Information is copied to *dst in the form of a list element
676 * identical to src (i.e. if Tcl_SplitList is applied to dst it
677 * will produce a string identical to src). The return value is
678 * a count of the number of characters copied (not including the
679 * terminating NULL character).
680 *
681 * Side effects:
682 * None.
683 *
684 *----------------------------------------------------------------------
685 */
686
687 int
688 Tcl_ConvertCountedElement(src, length, dst, flags)
689 register CONST char *src; /* Source information for list element. */
690 int length; /* Number of bytes in src, or -1. */
691 char *dst; /* Place to put list-ified element. */
692 int flags; /* Flags produced by Tcl_ScanElement. */
693 {
694 register char *p = dst;
695 register CONST char *lastChar;
696
697 /*
698 * See the comment block at the beginning of the Tcl_ScanElement
699 * code for details of how this works.
700 */
701
702 if (src && length == -1) {
703 length = strlen(src);
704 }
705 if ((src == NULL) || (length == 0)) {
706 p[0] = '{';
707 p[1] = '}';
708 p[2] = 0;
709 return 2;
710 }
711 lastChar = src + length;
712 if ((flags & USE_BRACES) && !(flags & TCL_DONT_USE_BRACES)) {
713 *p = '{';
714 p++;
715 for ( ; src != lastChar; src++, p++) {
716 *p = *src;
717 }
718 *p = '}';
719 p++;
720 } else {
721 if (*src == '{') {
722 /*
723 * Can't have a leading brace unless the whole element is
724 * enclosed in braces. Add a backslash before the brace.
725 * Furthermore, this may destroy the balance between open
726 * and close braces, so set BRACES_UNMATCHED.
727 */
728
729 p[0] = '\\';
730 p[1] = '{';
731 p += 2;
732 src++;
733 flags |= BRACES_UNMATCHED;
734 }
735 for (; src != lastChar; src++) {
736 switch (*src) {
737 case ']':
738 case '[':
739 case '$':
740 case ';':
741 case ' ':
742 case '\\':
743 case '"':
744 *p = '\\';
745 p++;
746 break;
747 case '{':
748 case '}':
749 /*
750 * It may not seem necessary to backslash braces, but
751 * it is. The reason for this is that the resulting
752 * list element may actually be an element of a sub-list
753 * enclosed in braces (e.g. if Tcl_DStringStartSublist
754 * has been invoked), so there may be a brace mismatch
755 * if the braces aren't backslashed.
756 */
757
758 if (flags & BRACES_UNMATCHED) {
759 *p = '\\';
760 p++;
761 }
762 break;
763 case '\f':
764 *p = '\\';
765 p++;
766 *p = 'f';
767 p++;
768 continue;
769 case '\n':
770 *p = '\\';
771 p++;
772 *p = 'n';
773 p++;
774 continue;
775 case '\r':
776 *p = '\\';
777 p++;
778 *p = 'r';
779 p++;
780 continue;
781 case '\t':
782 *p = '\\';
783 p++;
784 *p = 't';
785 p++;
786 continue;
787 case '\v':
788 *p = '\\';
789 p++;
790 *p = 'v';
791 p++;
792 continue;
793 }
794 *p = *src;
795 p++;
796 }
797 }
798 *p = '\0';
799 return p-dst;
800 }
801
802 /*
803 *----------------------------------------------------------------------
804 *
805 * Tcl_Merge --
806 *
807 * Given a collection of strings, merge them together into a
808 * single string that has proper Tcl list structured (i.e.
809 * Tcl_SplitList may be used to retrieve strings equal to the
810 * original elements, and Tcl_Eval will parse the string back
811 * into its original elements).
812 *
813 * Results:
814 * The return value is the address of a dynamically-allocated
815 * string containing the merged list.
816 *
817 * Side effects:
818 * None.
819 *
820 *----------------------------------------------------------------------
821 */
822
823 char *
824 Tcl_Merge(argc, argv)
825 int argc; /* How many strings to merge. */
826 char **argv; /* Array of string values. */
827 {
828 # define LOCAL_SIZE 20
829 int localFlags[LOCAL_SIZE], *flagPtr;
830 int numChars;
831 char *result;
832 char *dst;
833 int i;
834
835 /*
836 * Pass 1: estimate space, gather flags.
837 */
838
839 if (argc <= LOCAL_SIZE) {
840 flagPtr = localFlags;
841 } else {
842 flagPtr = (int *) ckalloc((unsigned) argc*sizeof(int));
843 }
844 numChars = 1;
845 for (i = 0; i < argc; i++) {
846 numChars += Tcl_ScanElement(argv[i], &flagPtr[i]) + 1;
847 }
848
849 /*
850 * Pass two: copy into the result area.
851 */
852
853 result = (char *) ckalloc((unsigned) numChars);
854 dst = result;
855 for (i = 0; i < argc; i++) {
856 numChars = Tcl_ConvertElement(argv[i], dst, flagPtr[i]);
857 dst += numChars;
858 *dst = ' ';
859 dst++;
860 }
861 if (dst == result) {
862 *dst = 0;
863 } else {
864 dst[-1] = 0;
865 }
866
867 if (flagPtr != localFlags) {
868 ckfree((char *) flagPtr);
869 }
870 return result;
871 }
872
873 /*
874 *----------------------------------------------------------------------
875 *
876 * Tcl_Backslash --
877 *
878 * Figure out how to handle a backslash sequence.
879 *
880 * Results:
881 * The return value is the character that should be substituted
882 * in place of the backslash sequence that starts at src. If
883 * readPtr isn't NULL then it is filled in with a count of the
884 * number of characters in the backslash sequence.
885 *
886 * Side effects:
887 * None.
888 *
889 *----------------------------------------------------------------------
890 */
891
892 char
893 Tcl_Backslash(src, readPtr)
894 CONST char *src; /* Points to the backslash character of
895 * a backslash sequence. */
896 int *readPtr; /* Fill in with number of characters read
897 * from src, unless NULL. */
898 {
899 char buf[TCL_UTF_MAX];
900 Tcl_UniChar ch;
901
902 Tcl_UtfBackslash(src, readPtr, buf);
903 Tcl_UtfToUniChar(buf, &ch);
904 return (char) ch;
905 }
906
907 /*
908 *----------------------------------------------------------------------
909 *
910 * Tcl_Concat --
911 *
912 * Concatenate a set of strings into a single large string.
913 *
914 * Results:
915 * The return value is dynamically-allocated string containing
916 * a concatenation of all the strings in argv, with spaces between
917 * the original argv elements.
918 *
919 * Side effects:
920 * Memory is allocated for the result; the caller is responsible
921 * for freeing the memory.
922 *
923 *----------------------------------------------------------------------
924 */
925
926 char *
927 Tcl_Concat(argc, argv)
928 int argc; /* Number of strings to concatenate. */
929 char **argv; /* Array of strings to concatenate. */
930 {
931 int totalSize, i;
932 char *p;
933 char *result;
934
935 for (totalSize = 1, i = 0; i < argc; i++) {
936 totalSize += strlen(argv[i]) + 1;
937 }
938 result = (char *) ckalloc((unsigned) totalSize);
939 if (argc == 0) {
940 *result = '\0';
941 return result;
942 }
943 for (p = result, i = 0; i < argc; i++) {
944 char *element;
945 int length;
946
947 /*
948 * Clip white space off the front and back of the string
949 * to generate a neater result, and ignore any empty
950 * elements.
951 */
952
953 element = argv[i];
954 while (isspace(UCHAR(*element))) { /* INTL: ISO space. */
955 element++;
956 }
957 for (length = strlen(element);
958 (length > 0)
959 && (isspace(UCHAR(element[length-1]))) /* INTL: ISO space. */
960 && ((length < 2) || (element[length-2] != '\\'));
961 length--) {
962 /* Null loop body. */
963 }
964 if (length == 0) {
965 continue;
966 }
967 memcpy((VOID *) p, (VOID *) element, (size_t) length);
968 p += length;
969 *p = ' ';
970 p++;
971 }
972 if (p != result) {
973 p[-1] = 0;
974 } else {
975 *p = 0;
976 }
977 return result;
978 }
979
980 /*
981 *----------------------------------------------------------------------
982 *
983 * Tcl_ConcatObj --
984 *
985 * Concatenate the strings from a set of objects into a single string
986 * object with spaces between the original strings.
987 *
988 * Results:
989 * The return value is a new string object containing a concatenation
990 * of the strings in objv. Its ref count is zero.
991 *
992 * Side effects:
993 * A new object is created.
994 *
995 *----------------------------------------------------------------------
996 */
997
998 Tcl_Obj *
999 Tcl_ConcatObj(objc, objv)
1000 int objc; /* Number of objects to concatenate. */
1001 Tcl_Obj *CONST objv[]; /* Array of objects to concatenate. */
1002 {
1003 int allocSize, finalSize, length, elemLength, i;
1004 char *p;
1005 char *element;
1006 char *concatStr;
1007 Tcl_Obj *objPtr;
1008
1009 /*
1010 * Check first to see if all the items are of list type. If so,
1011 * we will concat them together as lists, and return a list object.
1012 * This is only valid when the lists have no current string
1013 * representation, since we don't know what the original type was.
1014 * An original string rep may have lost some whitespace info when
1015 * converted which could be important.
1016 */
1017 for (i = 0; i < objc; i++) {
1018 objPtr = objv[i];
1019 if ((objPtr->typePtr != &tclListType) || (objPtr->bytes != NULL)) {
1020 break;
1021 }
1022 }
1023 if (i == objc) {
1024 Tcl_Obj **listv;
1025 int listc;
1026
1027 objPtr = Tcl_NewListObj(0, NULL);
1028 for (i = 0; i < objc; i++) {
1029 /*
1030 * Tcl_ListObjAppendList could be used here, but this saves
1031 * us a bit of type checking (since we've already done it)
1032 * Use of INT_MAX tells us to always put the new stuff on
1033 * the end. It will be set right in Tcl_ListObjReplace.
1034 */
1035 Tcl_ListObjGetElements(NULL, objv[i], &listc, &listv);
1036 Tcl_ListObjReplace(NULL, objPtr, INT_MAX, 0, listc, listv);
1037 }
1038 return objPtr;
1039 }
1040
1041 allocSize = 0;
1042 for (i = 0; i < objc; i++) {
1043 objPtr = objv[i];
1044 element = Tcl_GetStringFromObj(objPtr, &length);
1045 if ((element != NULL) && (length > 0)) {
1046 allocSize += (length + 1);
1047 }
1048 }
1049 if (allocSize == 0) {
1050 allocSize = 1; /* enough for the NULL byte at end */
1051 }
1052
1053 /*
1054 * Allocate storage for the concatenated result. Note that allocSize
1055 * is one more than the total number of characters, and so includes
1056 * room for the terminating NULL byte.
1057 */
1058
1059 concatStr = (char *) ckalloc((unsigned) allocSize);
1060
1061 /*
1062 * Now concatenate the elements. Clip white space off the front and back
1063 * to generate a neater result, and ignore any empty elements. Also put
1064 * a null byte at the end.
1065 */
1066
1067 finalSize = 0;
1068 if (objc == 0) {
1069 *concatStr = '\0';
1070 } else {
1071 p = concatStr;
1072 for (i = 0; i < objc; i++) {
1073 objPtr = objv[i];
1074 element = Tcl_GetStringFromObj(objPtr, &elemLength);
1075 while ((elemLength > 0)
1076 && (isspace(UCHAR(*element)))) { /* INTL: ISO space. */
1077 element++;
1078 elemLength--;
1079 }
1080
1081 /*
1082 * Trim trailing white space. But, be careful not to trim
1083 * a space character if it is preceded by a backslash: in
1084 * this case it could be significant.
1085 */
1086
1087 while ((elemLength > 0)
1088 && isspace(UCHAR(element[elemLength-1])) /* INTL: ISO space. */
1089 && ((elemLength < 2) || (element[elemLength-2] != '\\'))) {
1090 elemLength--;
1091 }
1092 if (elemLength == 0) {
1093 continue; /* nothing left of this element */
1094 }
1095 memcpy((VOID *) p, (VOID *) element, (size_t) elemLength);
1096 p += elemLength;
1097 *p = ' ';
1098 p++;
1099 finalSize += (elemLength + 1);
1100 }
1101 if (p != concatStr) {
1102 p[-1] = 0;
1103 finalSize -= 1; /* we overwrote the final ' ' */
1104 } else {
1105 *p = 0;
1106 }
1107 }
1108
1109 TclNewObj(objPtr);
1110 objPtr->bytes = concatStr;
1111 objPtr->length = finalSize;
1112 return objPtr;
1113 }
1114
1115 /*
1116 *----------------------------------------------------------------------
1117 *
1118 * Tcl_StringMatch --
1119 *
1120 * See if a particular string matches a particular pattern.
1121 *
1122 * Results:
1123 * The return value is 1 if string matches pattern, and
1124 * 0 otherwise. The matching operation permits the following
1125 * special characters in the pattern: *?\[] (see the manual
1126 * entry for details on what these mean).
1127 *
1128 * Side effects:
1129 * None.
1130 *
1131 *----------------------------------------------------------------------
1132 */
1133
1134 int
1135 Tcl_StringMatch(string, pattern)
1136 CONST char *string; /* String. */
1137 CONST char *pattern; /* Pattern, which may contain special
1138 * characters. */
1139 {
1140 int p, s;
1141 CONST char *pstart = pattern;
1142
1143 while (1) {
1144 p = *pattern;
1145 s = *string;
1146
1147 /*
1148 * See if we're at the end of both the pattern and the string. If
1149 * so, we succeeded. If we're at the end of the pattern but not at
1150 * the end of the string, we failed.
1151 */
1152
1153 if (p == '\0') {
1154 if (s == '\0') {
1155 return 1;
1156 } else {
1157 return 0;
1158 }
1159 }
1160 if ((s == '\0') && (p != '*')) {
1161 return 0;
1162 }
1163
1164 /* Check for a "*" as the next pattern character. It matches
1165 * any substring. We handle this by calling ourselves
1166 * recursively for each postfix of string, until either we
1167 * match or we reach the end of the string.
1168 */
1169
1170 if (p == '*') {
1171 pattern++;
1172 if (*pattern == '\0') {
1173 return 1;
1174 }
1175 while (1) {
1176 if (Tcl_StringMatch(string, pattern)) {
1177 return 1;
1178 }
1179 if (*string == '\0') {
1180 return 0;
1181 }
1182 string++;
1183 }
1184 }
1185
1186 /* Check for a "?" as the next pattern character. It matches
1187 * any single character.
1188 */
1189
1190 if (p == '?') {
1191 Tcl_UniChar ch;
1192
1193 pattern++;
1194 string += Tcl_UtfToUniChar(string, &ch);
1195 continue;
1196 }
1197
1198 /* Check for a "[" as the next pattern character. It is followed
1199 * by a list of characters that are acceptable, or by a range
1200 * (two characters separated by "-").
1201 */
1202
1203 if (p == '[') {
1204 Tcl_UniChar ch, startChar, endChar;
1205
1206 pattern++;
1207 string += Tcl_UtfToUniChar(string, &ch);
1208
1209 while (1) {
1210 if ((*pattern == ']') || (*pattern == '\0')) {
1211 return 0;
1212 }
1213 pattern += Tcl_UtfToUniChar(pattern, &startChar);
1214 if (*pattern == '-') {
1215 pattern++;
1216 if (*pattern == '\0') {
1217 return 0;
1218 }
1219 pattern += Tcl_UtfToUniChar(pattern, &endChar);
1220 if (((startChar <= ch) && (ch <= endChar))
1221 || ((endChar <= ch) && (ch <= startChar))) {
1222 /*
1223 * Matches ranges of form [a-z] or [z-a].
1224 */
1225
1226 break;
1227 }
1228 } else if (startChar == ch) {
1229 break;
1230 }
1231 }
1232 while (*pattern != ']') {
1233 if (*pattern == '\0') {
1234 pattern = Tcl_UtfPrev(pattern, pstart);
1235 break;
1236 }
1237 pattern++;
1238 }
1239 pattern++;
1240 continue;
1241 }
1242
1243 /* If the next pattern character is '\', just strip off the '\'
1244 * so we do exact matching on the character that follows.
1245 */
1246
1247 if (p == '\\') {
1248 pattern++;
1249 p = *pattern;
1250 if (p == '\0') {
1251 return 0;
1252 }
1253 }
1254
1255 /* There's no special character. Just make sure that the next
1256 * bytes of each string match.
1257 */
1258
1259 if (s != p) {
1260 return 0;
1261 }
1262 pattern++;
1263 string++;
1264 }
1265 }
1266
1267 /*
1268 *----------------------------------------------------------------------
1269 *
1270 * Tcl_StringCaseMatch --
1271 *
1272 * See if a particular string matches a particular pattern.
1273 * Allows case insensitivity.
1274 *
1275 * Results:
1276 * The return value is 1 if string matches pattern, and
1277 * 0 otherwise. The matching operation permits the following
1278 * special characters in the pattern: *?\[] (see the manual
1279 * entry for details on what these mean).
1280 *
1281 * Side effects:
1282 * None.
1283 *
1284 *----------------------------------------------------------------------
1285 */
1286
1287 int
1288 Tcl_StringCaseMatch(string, pattern, nocase)
1289 CONST char *string; /* String. */
1290 CONST char *pattern; /* Pattern, which may contain special
1291 * characters. */
1292 int nocase; /* 0 for case sensitive, 1 for insensitive */
1293 {
1294 int p, s;
1295 CONST char *pstart = pattern;
1296 Tcl_UniChar ch1, ch2;
1297
1298 while (1) {
1299 p = *pattern;
1300 s = *string;
1301
1302 /*
1303 * See if we're at the end of both the pattern and the string. If
1304 * so, we succeeded. If we're at the end of the pattern but not at
1305 * the end of the string, we failed.
1306 */
1307
1308 if (p == '\0') {
1309 return (s == '\0');
1310 }
1311 if ((s == '\0') && (p != '*')) {
1312 return 0;
1313 }
1314
1315 /* Check for a "*" as the next pattern character. It matches
1316 * any substring. We handle this by calling ourselves
1317 * recursively for each postfix of string, until either we
1318 * match or we reach the end of the string.
1319 */
1320
1321 if (p == '*') {
1322 pattern++;
1323 if (*pattern == '\0') {
1324 return 1;
1325 }
1326 while (1) {
1327 if (Tcl_StringCaseMatch(string, pattern, nocase)) {
1328 return 1;
1329 }
1330 if (*string == '\0') {
1331 return 0;
1332 }
1333 string++;
1334 }
1335 }
1336
1337 /* Check for a "?" as the next pattern character. It matches
1338 * any single character.
1339 */
1340
1341 if (p == '?') {
1342 pattern++;
1343 string += Tcl_UtfToUniChar(string, &ch1);
1344 continue;
1345 }
1346
1347 /* Check for a "[" as the next pattern character. It is followed
1348 * by a list of characters that are acceptable, or by a range
1349 * (two characters separated by "-").
1350 */
1351
1352 if (p == '[') {
1353 Tcl_UniChar startChar, endChar;
1354
1355 pattern++;
1356 string += Tcl_UtfToUniChar(string, &ch1);
1357 if (nocase) {
1358 ch1 = Tcl_UniCharToLower(ch1);
1359 }
1360 while (1) {
1361 if ((*pattern == ']') || (*pattern == '\0')) {
1362 return 0;
1363 }
1364 pattern += Tcl_UtfToUniChar(pattern, &startChar);
1365 if (nocase) {
1366 startChar = Tcl_UniCharToLower(startChar);
1367 }
1368 if (*pattern == '-') {
1369 pattern++;
1370 if (*pattern == '\0') {
1371 return 0;
1372 }
1373 pattern += Tcl_UtfToUniChar(pattern, &endChar);
1374 if (nocase) {
1375 endChar = Tcl_UniCharToLower(endChar);
1376 }
1377 if (((startChar <= ch1) && (ch1 <= endChar))
1378 || ((endChar <= ch1) && (ch1 <= startChar))) {
1379 /*
1380 * Matches ranges of form [a-z] or [z-a].
1381 */
1382
1383 break;
1384 }
1385 } else if (startChar == ch1) {
1386 break;
1387 }
1388 }
1389 while (*pattern != ']') {
1390 if (*pattern == '\0') {
1391 pattern = Tcl_UtfPrev(pattern, pstart);
1392 break;
1393 }
1394 pattern++;
1395 }
1396 pattern++;
1397 continue;
1398 }
1399
1400 /* If the next pattern character is '\', just strip off the '\'
1401 * so we do exact matching on the character that follows.
1402 */
1403
1404 if (p == '\\') {
1405 pattern++;
1406 p = *pattern;
1407 if (p == '\0') {
1408 return 0;
1409 }
1410 }
1411
1412 /* There's no special character. Just make sure that the next
1413 * bytes of each string match.
1414 */
1415
1416 string += Tcl_UtfToUniChar(string, &ch1);
1417 pattern += Tcl_UtfToUniChar(pattern, &ch2);
1418 if (nocase) {
1419 if (Tcl_UniCharToLower(ch1) != Tcl_UniCharToLower(ch2)) {
1420 return 0;
1421 }
1422 } else if (ch1 != ch2) {
1423 return 0;
1424 }
1425 }
1426 }
1427
1428 /*
1429 *----------------------------------------------------------------------
1430 *
1431 * Tcl_DStringInit --
1432 *
1433 * Initializes a dynamic string, discarding any previous contents
1434 * of the string (Tcl_DStringFree should have been called already
1435 * if the dynamic string was previously in use).
1436 *
1437 * Results:
1438 * None.
1439 *
1440 * Side effects:
1441 * The dynamic string is initialized to be empty.
1442 *
1443 *----------------------------------------------------------------------
1444 */
1445
1446 void
1447 Tcl_DStringInit(dsPtr)
1448 Tcl_DString *dsPtr; /* Pointer to structure for dynamic string. */
1449 {
1450 dsPtr->string = dsPtr->staticSpace;
1451 dsPtr->length = 0;
1452 dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
1453 dsPtr->staticSpace[0] = '\0';
1454 }
1455
1456 /*
1457 *----------------------------------------------------------------------
1458 *
1459 * Tcl_DStringAppend --
1460 *
1461 * Append more characters to the current value of a dynamic string.
1462 *
1463 * Results:
1464 * The return value is a pointer to the dynamic string's new value.
1465 *
1466 * Side effects:
1467 * Length bytes from string (or all of string if length is less
1468 * than zero) are added to the current value of the string. Memory
1469 * gets reallocated if needed to accomodate the string's new size.
1470 *
1471 *----------------------------------------------------------------------
1472 */
1473
1474 char *
1475 Tcl_DStringAppend(dsPtr, string, length)
1476 Tcl_DString *dsPtr; /* Structure describing dynamic string. */
1477 CONST char *string; /* String to append. If length is -1 then
1478 * this must be null-terminated. */
1479 int length; /* Number of characters from string to
1480 * append. If < 0, then append all of string,
1481 * up to null at end. */
1482 {
1483 int newSize;
1484 char *dst;
1485 CONST char *end;
1486
1487 if (length < 0) {
1488 length = strlen(string);
1489 }
1490 newSize = length + dsPtr->length;
1491
1492 /*
1493 * Allocate a larger buffer for the string if the current one isn't
1494 * large enough. Allocate extra space in the new buffer so that there
1495 * will be room to grow before we have to allocate again.
1496 */
1497
1498 if (newSize >= dsPtr->spaceAvl) {
1499 dsPtr->spaceAvl = newSize * 2;
1500 if (dsPtr->string == dsPtr->staticSpace) {
1501 char *newString;
1502
1503 newString = (char *) ckalloc((unsigned) dsPtr->spaceAvl);
1504 memcpy((VOID *) newString, (VOID *) dsPtr->string,
1505 (size_t) dsPtr->length);
1506 dsPtr->string = newString;
1507 } else {
1508 dsPtr->string = (char *) ckrealloc((VOID *) dsPtr->string,
1509 (size_t) dsPtr->spaceAvl);
1510 }
1511 }
1512
1513 /*
1514 * Copy the new string into the buffer at the end of the old
1515 * one.
1516 */
1517
1518 for (dst = dsPtr->string + dsPtr->length, end = string+length;
1519 string < end; string++, dst++) {
1520 *dst = *string;
1521 }
1522 *dst = '\0';
1523 dsPtr->length += length;
1524 return dsPtr->string;
1525 }
1526
1527 /*
1528 *----------------------------------------------------------------------
1529 *
1530 * Tcl_DStringAppendElement --
1531 *
1532 * Append a list element to the current value of a dynamic string.
1533 *
1534 * Results:
1535 * The return value is a pointer to the dynamic string's new value.
1536 *
1537 * Side effects:
1538 * String is reformatted as a list element and added to the current
1539 * value of the string. Memory gets reallocated if needed to
1540 * accomodate the string's new size.
1541 *
1542 *----------------------------------------------------------------------
1543 */
1544
1545 char *
1546 Tcl_DStringAppendElement(dsPtr, string)
1547 Tcl_DString *dsPtr; /* Structure describing dynamic string. */
1548 CONST char *string; /* String to append. Must be
1549 * null-terminated. */
1550 {
1551 int newSize, flags;
1552 char *dst;
1553
1554 newSize = Tcl_ScanElement(string, &flags) + dsPtr->length + 1;
1555
1556 /*
1557 * Allocate a larger buffer for the string if the current one isn't
1558 * large enough. Allocate extra space in the new buffer so that there
1559 * will be room to grow before we have to allocate again.
1560 * SPECIAL NOTE: must use memcpy, not strcpy, to copy the string
1561 * to a larger buffer, since there may be embedded NULLs in the
1562 * string in some cases.
1563 */
1564
1565 if (newSize >= dsPtr->spaceAvl) {
1566 dsPtr->spaceAvl = newSize * 2;
1567 if (dsPtr->string == dsPtr->staticSpace) {
1568 char *newString;
1569
1570 newString = (char *) ckalloc((unsigned) dsPtr->spaceAvl);
1571 memcpy((VOID *) newString, (VOID *) dsPtr->string,
1572 (size_t) dsPtr->length);
1573 dsPtr->string = newString;
1574 } else {
1575 dsPtr->string = (char *) ckrealloc((VOID *) dsPtr->string,
1576 (size_t) dsPtr->spaceAvl);
1577 }
1578 }
1579
1580 /*
1581 * Convert the new string to a list element and copy it into the
1582 * buffer at the end, with a space, if needed.
1583 */
1584
1585 dst = dsPtr->string + dsPtr->length;
1586 if (TclNeedSpace(dsPtr->string, dst)) {
1587 *dst = ' ';
1588 dst++;
1589 dsPtr->length++;
1590 }
1591 dsPtr->length += Tcl_ConvertElement(string, dst, flags);
1592 return dsPtr->string;
1593 }
1594
1595 /*
1596 *----------------------------------------------------------------------
1597 *
1598 * Tcl_DStringSetLength --
1599 *
1600 * Change the length of a dynamic string. This can cause the
1601 * string to either grow or shrink, depending on the value of
1602 * length.
1603 *
1604 * Results:
1605 * None.
1606 *
1607 * Side effects:
1608 * The length of dsPtr is changed to length and a null byte is
1609 * stored at that position in the string. If length is larger
1610 * than the space allocated for dsPtr, then a panic occurs.
1611 *
1612 *----------------------------------------------------------------------
1613 */
1614
1615 void
1616 Tcl_DStringSetLength(dsPtr, length)
1617 Tcl_DString *dsPtr; /* Structure describing dynamic string. */
1618 int length; /* New length for dynamic string. */
1619 {
1620 int newsize;
1621
1622 if (length < 0) {
1623 length = 0;
1624 }
1625 if (length >= dsPtr->spaceAvl) {
1626 /*
1627 * There are two interesting cases here. In the first case, the user
1628 * may be trying to allocate a large buffer of a specific size. It
1629 * would be wasteful to overallocate that buffer, so we just allocate
1630 * enough for the requested size plus the trailing null byte. In the
1631 * second case, we are growing the buffer incrementally, so we need
1632 * behavior similar to Tcl_DStringAppend. The requested length will
1633 * usually be a small delta above the current spaceAvl, so we'll end up
1634 * doubling the old size. This won't grow the buffer quite as quickly,
1635 * but it should be close enough.
1636 */
1637
1638 newsize = dsPtr->spaceAvl * 2;
1639 if (length < newsize) {
1640 dsPtr->spaceAvl = newsize;
1641 } else {
1642 dsPtr->spaceAvl = length + 1;
1643 }
1644 if (dsPtr->string == dsPtr->staticSpace) {
1645 char *newString;
1646
1647 newString = (char *) ckalloc((unsigned) dsPtr->spaceAvl);
1648 memcpy((VOID *) newString, (VOID *) dsPtr->string,
1649 (size_t) dsPtr->length);
1650 dsPtr->string = newString;
1651 } else {
1652 dsPtr->string = (char *) ckrealloc((VOID *) dsPtr->string,
1653 (size_t) dsPtr->spaceAvl);
1654 }
1655 }
1656 dsPtr->length = length;
1657 dsPtr->string[length] = 0;
1658 }
1659
1660 /*
1661 *----------------------------------------------------------------------
1662 *
1663 * Tcl_DStringFree --
1664 *
1665 * Frees up any memory allocated for the dynamic string and
1666 * reinitializes the string to an empty state.
1667 *
1668 * Results:
1669 * None.
1670 *
1671 * Side effects:
1672 * The previous contents of the dynamic string are lost, and
1673 * the new value is an empty string.
1674 *
1675 *---------------------------------------------------------------------- */
1676
1677 void
1678 Tcl_DStringFree(dsPtr)
1679 Tcl_DString *dsPtr; /* Structure describing dynamic string. */
1680 {
1681 if (dsPtr->string != dsPtr->staticSpace) {
1682 ckfree(dsPtr->string);
1683 }
1684 dsPtr->string = dsPtr->staticSpace;
1685 dsPtr->length = 0;
1686 dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
1687 dsPtr->staticSpace[0] = '\0';
1688 }
1689
1690 /*
1691 *----------------------------------------------------------------------
1692 *
1693 * Tcl_DStringResult --
1694 *
1695 * This procedure moves the value of a dynamic string into an
1696 * interpreter as its string result. Afterwards, the dynamic string
1697 * is reset to an empty string.
1698 *
1699 * Results:
1700 * None.
1701 *
1702 * Side effects:
1703 * The string is "moved" to interp's result, and any existing
1704 * string result for interp is freed. dsPtr is reinitialized to
1705 * an empty string.
1706 *
1707 *----------------------------------------------------------------------
1708 */
1709
1710 void
1711 Tcl_DStringResult(interp, dsPtr)
1712 Tcl_Interp *interp; /* Interpreter whose result is to be reset. */
1713 Tcl_DString *dsPtr; /* Dynamic string that is to become the
1714 * result of interp. */
1715 {
1716 Tcl_ResetResult(interp);
1717
1718 if (dsPtr->string != dsPtr->staticSpace) {
1719 interp->result = dsPtr->string;
1720 interp->freeProc = TCL_DYNAMIC;
1721 } else if (dsPtr->length < TCL_RESULT_SIZE) {
1722 interp->result = ((Interp *) interp)->resultSpace;
1723 strcpy(interp->result, dsPtr->string);
1724 } else {
1725 Tcl_SetResult(interp, dsPtr->string, TCL_VOLATILE);
1726 }
1727
1728 dsPtr->string = dsPtr->staticSpace;
1729 dsPtr->length = 0;
1730 dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
1731 dsPtr->staticSpace[0] = '\0';
1732 }
1733
1734 /*
1735 *----------------------------------------------------------------------
1736 *
1737 * Tcl_DStringGetResult --
1738 *
1739 * This procedure moves an interpreter's result into a dynamic string.
1740 *
1741 * Results:
1742 * None.
1743 *
1744 * Side effects:
1745 * The interpreter's string result is cleared, and the previous
1746 * contents of dsPtr are freed.
1747 *
1748 * If the string result is empty, the object result is moved to the
1749 * string result, then the object result is reset.
1750 *
1751 *----------------------------------------------------------------------
1752 */
1753
1754 void
1755 Tcl_DStringGetResult(interp, dsPtr)
1756 Tcl_Interp *interp; /* Interpreter whose result is to be reset. */
1757 Tcl_DString *dsPtr; /* Dynamic string that is to become the
1758 * result of interp. */
1759 {
1760 Interp *iPtr = (Interp *) interp;
1761
1762 if (dsPtr->string != dsPtr->staticSpace) {
1763 ckfree(dsPtr->string);
1764 }
1765
1766 /*
1767 * If the string result is empty, move the object result to the
1768 * string result, then reset the object result.
1769 */
1770
1771 if (*(iPtr->result) == 0) {
1772 Tcl_SetResult(interp, TclGetString(Tcl_GetObjResult(interp)),
1773 TCL_VOLATILE);
1774 }
1775
1776 dsPtr->length = strlen(iPtr->result);
1777 if (iPtr->freeProc != NULL) {
1778 if ((iPtr->freeProc == TCL_DYNAMIC)
1779 || (iPtr->freeProc == (Tcl_FreeProc *) free)) {
1780 dsPtr->string = iPtr->result;
1781 dsPtr->spaceAvl = dsPtr->length+1;
1782 } else {
1783 dsPtr->string = (char *) ckalloc((unsigned) (dsPtr->length+1));
1784 strcpy(dsPtr->string, iPtr->result);
1785 (*iPtr->freeProc)(iPtr->result);
1786 }
1787 dsPtr->spaceAvl = dsPtr->length+1;
1788 iPtr->freeProc = NULL;
1789 } else {
1790 if (dsPtr->length < TCL_DSTRING_STATIC_SIZE) {
1791 dsPtr->string = dsPtr->staticSpace;
1792 dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
1793 } else {
1794 dsPtr->string = (char *) ckalloc((unsigned) (dsPtr->length + 1));
1795 dsPtr->spaceAvl = dsPtr->length + 1;
1796 }
1797 strcpy(dsPtr->string, iPtr->result);
1798 }
1799
1800 iPtr->result = iPtr->resultSpace;
1801 iPtr->resultSpace[0] = 0;
1802 }
1803
1804 /*
1805 *----------------------------------------------------------------------
1806 *
1807 * Tcl_DStringStartSublist --
1808 *
1809 * This procedure adds the necessary information to a dynamic
1810 * string (e.g. " {" to start a sublist. Future element
1811 * appends will be in the sublist rather than the main list.
1812 *
1813 * Results:
1814 * None.
1815 *
1816 * Side effects:
1817 * Characters get added to the dynamic string.
1818 *
1819 *----------------------------------------------------------------------
1820 */
1821
1822 void
1823 Tcl_DStringStartSublist(dsPtr)
1824 Tcl_DString *dsPtr; /* Dynamic string. */
1825 {
1826 if (TclNeedSpace(dsPtr->string, dsPtr->string + dsPtr->length)) {
1827 Tcl_DStringAppend(dsPtr, " {", -1);
1828 } else {
1829 Tcl_DStringAppend(dsPtr, "{", -1);
1830 }
1831 }
1832
1833 /*
1834 *----------------------------------------------------------------------
1835 *
1836 * Tcl_DStringEndSublist --
1837 *
1838 * This procedure adds the necessary characters to a dynamic
1839 * string to end a sublist (e.g. "}"). Future element appends
1840 * will be in the enclosing (sub)list rather than the current
1841 * sublist.
1842 *
1843 * Results:
1844 * None.
1845 *
1846 * Side effects:
1847 * None.
1848 *
1849 *----------------------------------------------------------------------
1850 */
1851
1852 void
1853 Tcl_DStringEndSublist(dsPtr)
1854 Tcl_DString *dsPtr; /* Dynamic string. */
1855 {
1856 Tcl_DStringAppend(dsPtr, "}", -1);
1857 }
1858
1859 /*
1860 *----------------------------------------------------------------------
1861 *
1862 * Tcl_PrintDouble --
1863 *
1864 * Given a floating-point value, this procedure converts it to
1865 * an ASCII string using.
1866 *
1867 * Results:
1868 * The ASCII equivalent of "value" is written at "dst". It is
1869 * written using the current precision, and it is guaranteed to
1870 * contain a decimal point or exponent, so that it looks like
1871 * a floating-point value and not an integer.
1872 *
1873 * Side effects:
1874 * None.
1875 *
1876 *----------------------------------------------------------------------
1877 */
1878
1879 void
1880 Tcl_PrintDouble(interp, value, dst)
1881 Tcl_Interp *interp; /* Interpreter whose tcl_precision
1882 * variable used to be used to control
1883 * printing. It's ignored now. */
1884 double value; /* Value to print as string. */
1885 char *dst; /* Where to store converted value;
1886 * must have at least TCL_DOUBLE_SPACE
1887 * characters. */
1888 {
1889 char *p, c;
1890 Tcl_UniChar ch;
1891
1892 Tcl_MutexLock(&precisionMutex);
1893 sprintf(dst, precisionFormat, value);
1894 Tcl_MutexUnlock(&precisionMutex);
1895
1896 /*
1897 * If the ASCII result looks like an integer, add ".0" so that it
1898 * doesn't look like an integer anymore. This prevents floating-point
1899 * values from being converted to integers unintentionally.
1900 */
1901
1902 for (p = dst; *p != 0; ) {
1903 p += Tcl_UtfToUniChar(p, &ch);
1904 c = UCHAR(ch);
1905 if ((c == '.') || isalpha(UCHAR(c))) { /* INTL: ISO only. */
1906 return;
1907 }
1908 }
1909 p[0] = '.';
1910 p[1] = '0';
1911 p[2] = 0;
1912 }
1913
1914 /*
1915 *----------------------------------------------------------------------
1916 *
1917 * TclPrecTraceProc --
1918 *
1919 * This procedure is invoked whenever the variable "tcl_precision"
1920 * is written.
1921 *
1922 * Results:
1923 * Returns NULL if all went well, or an error message if the
1924 * new value for the variable doesn't make sense.
1925 *
1926 * Side effects:
1927 * If the new value doesn't make sense then this procedure
1928 * undoes the effect of the variable modification. Otherwise
1929 * it modifies the format string that's used by Tcl_PrintDouble.
1930 *
1931 *----------------------------------------------------------------------
1932 */
1933
1934 /* ARGSUSED */
1935 char *
1936 TclPrecTraceProc(clientData, interp, name1, name2, flags)
1937 ClientData clientData; /* Not used. */
1938 Tcl_Interp *interp; /* Interpreter containing variable. */
1939 char *name1; /* Name of variable. */
1940 char *name2; /* Second part of variable name. */
1941 int flags; /* Information about what happened. */
1942 {
1943 char *value, *end;
1944 int prec;
1945
1946 /*
1947 * If the variable is unset, then recreate the trace.
1948 */
1949
1950 if (flags & TCL_TRACE_UNSETS) {
1951 if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) {
1952 Tcl_TraceVar2(interp, name1, name2,
1953 TCL_GLOBAL_ONLY|TCL_TRACE_READS|TCL_TRACE_WRITES
1954 |TCL_TRACE_UNSETS, TclPrecTraceProc, clientData);
1955 }
1956 return (char *) NULL;
1957 }
1958
1959 /*
1960 * When the variable is read, reset its value from our shared
1961 * value. This is needed in case the variable was modified in
1962 * some other interpreter so that this interpreter's value is
1963 * out of date.
1964 */
1965
1966 Tcl_MutexLock(&precisionMutex);
1967
1968 if (flags & TCL_TRACE_READS) {
1969 Tcl_SetVar2(interp, name1, name2, precisionString,
1970 flags & TCL_GLOBAL_ONLY);
1971 Tcl_MutexUnlock(&precisionMutex);
1972 return (char *) NULL;
1973 }
1974
1975 /*
1976 * The variable is being written. Check the new value and disallow
1977 * it if it isn't reasonable or if this is a safe interpreter (we
1978 * don't want safe interpreters messing up the precision of other
1979 * interpreters).
1980 */
1981
1982 if (Tcl_IsSafe(interp)) {
1983 Tcl_SetVar2(interp, name1, name2, precisionString,
1984 flags & TCL_GLOBAL_ONLY);
1985 Tcl_MutexUnlock(&precisionMutex);
1986 return "can't modify precision from a safe interpreter";
1987 }
1988 value = Tcl_GetVar2(interp, name1, name2, flags & TCL_GLOBAL_ONLY);
1989 if (value == NULL) {
1990 value = "";
1991 }
1992 prec = strtoul(value, &end, 10);
1993 if ((prec <= 0) || (prec > TCL_MAX_PREC) || (prec > 100) ||
1994 (end == value) || (*end != 0)) {
1995 Tcl_SetVar2(interp, name1, name2, precisionString,
1996 flags & TCL_GLOBAL_ONLY);
1997 Tcl_MutexUnlock(&precisionMutex);
1998 return "improper value for precision";
1999 }
2000 TclFormatInt(precisionString, prec);
2001 sprintf(precisionFormat, "%%.%dg", prec);
2002 Tcl_MutexUnlock(&precisionMutex);
2003 return (char *) NULL;
2004 }
2005
2006 /*
2007 *----------------------------------------------------------------------
2008 *
2009 * TclNeedSpace --
2010 *
2011 * This procedure checks to see whether it is appropriate to
2012 * add a space before appending a new list element to an
2013 * existing string.
2014 *
2015 * Results:
2016 * The return value is 1 if a space is appropriate, 0 otherwise.
2017 *
2018 * Side effects:
2019 * None.
2020 *
2021 *----------------------------------------------------------------------
2022 */
2023
2024 int
2025 TclNeedSpace(start, end)
2026 char *start; /* First character in string. */
2027 char *end; /* End of string (place where space will
2028 * be added, if appropriate). */
2029 {
2030 /*
2031 * A space is needed unless either
2032 * (a) we're at the start of the string, or
2033 * (b) the trailing characters of the string consist of one or more
2034 * open curly braces preceded by a space or extending back to
2035 * the beginning of the string.
2036 * (c) the trailing characters of the string consist of a space
2037 * preceded by a character other than backslash.
2038 */
2039
2040 if (end == start) {
2041 return 0;
2042 }
2043 end--;
2044 if (*end != '{') {
2045 if (isspace(UCHAR(*end)) /* INTL: ISO space. */
2046 && ((end == start) || (end[-1] != '\\'))) {
2047 return 0;
2048 }
2049 return 1;
2050 }
2051 do {
2052 if (end == start) {
2053 return 0;
2054 }
2055 end--;
2056 } while (*end == '{');
2057 if (isspace(UCHAR(*end))) { /* INTL: ISO space. */
2058 return 0;
2059 }
2060 return 1;
2061 }
2062
2063 /*
2064 *----------------------------------------------------------------------
2065 *
2066 * TclFormatInt --
2067 *
2068 * This procedure formats an integer into a sequence of decimal digit
2069 * characters in a buffer. If the integer is negative, a minus sign is
2070 * inserted at the start of the buffer. A null character is inserted at
2071 * the end of the formatted characters. It is the caller's
2072 * responsibility to ensure that enough storage is available. This
2073 * procedure has the effect of sprintf(buffer, "%d", n) but is faster.
2074 *
2075 * Results:
2076 * An integer representing the number of characters formatted, not
2077 * including the terminating \0.
2078 *
2079 * Side effects:
2080 * The formatted characters are written into the storage pointer to
2081 * by the "buffer" argument.
2082 *
2083 *----------------------------------------------------------------------
2084 */
2085
2086 int
2087 TclFormatInt(buffer, n)
2088 char *buffer; /* Points to the storage into which the
2089 * formatted characters are written. */
2090 long n; /* The integer to format. */
2091 {
2092 long intVal;
2093 int i;
2094 int numFormatted, j;
2095 char *digits = "0123456789";
2096
2097 /*
2098 * Check first whether "n" is zero.
2099 */
2100
2101 if (n == 0) {
2102 buffer[0] = '0';
2103 buffer[1] = 0;
2104 return 1;
2105 }
2106
2107 /*
2108 * Check whether "n" is the maximum negative value. This is
2109 * -2^(m-1) for an m-bit word, and has no positive equivalent;
2110 * negating it produces the same value.
2111 */
2112
2113 if (n == -n) {
2114 sprintf(buffer, "%ld", n);
2115 return strlen(buffer);
2116 }
2117
2118 /*
2119 * Generate the characters of the result backwards in the buffer.
2120 */
2121
2122 intVal = (n < 0? -n : n);
2123 i = 0;
2124 buffer[0] = '\0';
2125 do {
2126 i++;
2127 buffer[i] = digits[intVal % 10];
2128 intVal = intVal/10;
2129 } while (intVal > 0);
2130 if (n < 0) {
2131 i++;
2132 buffer[i] = '-';
2133 }
2134 numFormatted = i;
2135
2136 /*
2137 * Now reverse the characters.
2138 */
2139
2140 for (j = 0; j < i; j++, i--) {
2141 char tmp = buffer[i];
2142 buffer[i] = buffer[j];
2143 buffer[j] = tmp;
2144 }
2145 return numFormatted;
2146 }
2147
2148 /*
2149 *----------------------------------------------------------------------
2150 *
2151 * TclLooksLikeInt --
2152 *
2153 * This procedure decides whether the leading characters of a
2154 * string look like an integer or something else (such as a
2155 * floating-point number or string).
2156 *
2157 * Results:
2158 * The return value is 1 if the leading characters of p look
2159 * like a valid Tcl integer. If they look like a floating-point
2160 * number (e.g. "e01" or "2.4"), or if they don't look like a
2161 * number at all, then 0 is returned.
2162 *
2163 * Side effects:
2164 * None.
2165 *
2166 *----------------------------------------------------------------------
2167 */
2168
2169 int
2170 TclLooksLikeInt(bytes, length)
2171 register char *bytes; /* Points to first byte of the string. */
2172 int length; /* Number of bytes in the string. If < 0
2173 * bytes up to the first null byte are
2174 * considered (if they may appear in an
2175 * integer). */
2176 {
2177 register char *p, *end;
2178
2179 if (length < 0) {
2180 length = (bytes? strlen(bytes) : 0);
2181 }
2182 end = (bytes + length);
2183
2184 p = bytes;
2185 while ((p < end) && isspace(UCHAR(*p))) { /* INTL: ISO space. */
2186 p++;
2187 }
2188 if (p == end) {
2189 return 0;
2190 }
2191
2192 if ((*p == '+') || (*p == '-')) {
2193 p++;
2194 }
2195 if ((p == end) || !isdigit(UCHAR(*p))) { /* INTL: digit */
2196 return 0;
2197 }
2198 p++;
2199 while ((p < end) && isdigit(UCHAR(*p))) { /* INTL: digit */
2200 p++;
2201 }
2202 if (p == end) {
2203 return 1;
2204 }
2205 if ((*p != '.') && (*p != 'e') && (*p != 'E')) {
2206 return 1;
2207 }
2208 return 0;
2209 }
2210
2211 /*
2212 *----------------------------------------------------------------------
2213 *
2214 * TclGetIntForIndex --
2215 *
2216 * This procedure returns an integer corresponding to the list index
2217 * held in a Tcl object. The Tcl object's value is expected to be
2218 * either an integer or a string of the form "end([+-]integer)?".
2219 *
2220 * Results:
2221 * The return value is normally TCL_OK, which means that the index was
2222 * successfully stored into the location referenced by "indexPtr". If
2223 * the Tcl object referenced by "objPtr" has the value "end", the
2224 * value stored is "endValue". If "objPtr"s values is not of the form
2225 * "end([+-]integer)?" and
2226 * can not be converted to an integer, TCL_ERROR is returned and, if
2227 * "interp" is non-NULL, an error message is left in the interpreter's
2228 * result object.
2229 *
2230 * Side effects:
2231 * The object referenced by "objPtr" might be converted to an
2232 * integer object.
2233 *
2234 *----------------------------------------------------------------------
2235 */
2236
2237 int
2238 TclGetIntForIndex(interp, objPtr, endValue, indexPtr)
2239 Tcl_Interp *interp; /* Interpreter to use for error reporting.
2240 * If NULL, then no error message is left
2241 * after errors. */
2242 Tcl_Obj *objPtr; /* Points to an object containing either
2243 * "end" or an integer. */
2244 int endValue; /* The value to be stored at "indexPtr" if
2245 * "objPtr" holds "end". */
2246 int *indexPtr; /* Location filled in with an integer
2247 * representing an index. */
2248 {
2249 char *bytes;
2250 int length, offset;
2251
2252 if (objPtr->typePtr == &tclIntType) {
2253 *indexPtr = (int)objPtr->internalRep.longValue;
2254 return TCL_OK;
2255 }
2256
2257 bytes = Tcl_GetStringFromObj(objPtr, &length);
2258
2259 if ((*bytes != 'e') || (strncmp(bytes, "end",
2260 (size_t)((length > 3) ? 3 : length)) != 0)) {
2261 if (Tcl_GetIntFromObj(NULL, objPtr, &offset) != TCL_OK) {
2262 goto intforindex_error;
2263 }
2264 *indexPtr = offset;
2265 return TCL_OK;
2266 }
2267
2268 if (length <= 3) {
2269 *indexPtr = endValue;
2270 } else if (bytes[3] == '-') {
2271 /*
2272 * This is our limited string expression evaluator
2273 */
2274 if (Tcl_GetInt(interp, bytes+3, &offset) != TCL_OK) {
2275 return TCL_ERROR;
2276 }
2277 *indexPtr = endValue + offset;
2278 } else {
2279 intforindex_error:
2280 if ((Interp *)interp != NULL) {
2281 Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
2282 "bad index \"", bytes,
2283 "\": must be integer or end?-integer?", (char *) NULL);
2284 TclCheckBadOctal(interp, bytes);
2285 }
2286 return TCL_ERROR;
2287 }
2288 return TCL_OK;
2289 }
2290
2291 /*
2292 *----------------------------------------------------------------------
2293 *
2294 * TclCheckBadOctal --
2295 *
2296 * This procedure checks for a bad octal value and appends a
2297 * meaningful error to the interp's result.
2298 *
2299 * Results:
2300 * 1 if the argument was a bad octal, else 0.
2301 *
2302 * Side effects:
2303 * The interpreter's result is modified.
2304 *
2305 *----------------------------------------------------------------------
2306 */
2307
2308 int
2309 TclCheckBadOctal(interp, value)
2310 Tcl_Interp *interp; /* Interpreter to use for error reporting.
2311 * If NULL, then no error message is left
2312 * after errors. */
2313 char *value; /* String to check. */
2314 {
2315 register char *p = value;
2316
2317 /*
2318 * A frequent mistake is invalid octal values due to an unwanted
2319 * leading zero. Try to generate a meaningful error message.
2320 */
2321
2322 while (isspace(UCHAR(*p))) { /* INTL: ISO space. */
2323 p++;
2324 }
2325 if (*p == '+' || *p == '-') {
2326 p++;
2327 }
2328 if (*p == '0') {
2329 while (isdigit(UCHAR(*p))) { /* INTL: digit. */
2330 p++;
2331 }
2332 while (isspace(UCHAR(*p))) { /* INTL: ISO space. */
2333 p++;
2334 }
2335 if (*p == '\0') {
2336 /* Reached end of string */
2337 if (interp != NULL) {
2338 Tcl_AppendResult(interp, " (looks like invalid octal number)",
2339 (char *) NULL);
2340 }
2341 return 1;
2342 }
2343 }
2344 return 0;
2345 }
2346
2347 /*
2348 *----------------------------------------------------------------------
2349 *
2350 * Tcl_GetNameOfExecutable --
2351 *
2352 * This procedure simply returns a pointer to the internal full
2353 * path name of the executable file as computed by
2354 * Tcl_FindExecutable. This procedure call is the C API
2355 * equivalent to the "info nameofexecutable" command.
2356 *
2357 * Results:
2358 * A pointer to the internal string or NULL if the internal full
2359 * path name has not been computed or unknown.
2360 *
2361 * Side effects:
2362 * The object referenced by "objPtr" might be converted to an
2363 * integer object.
2364 *
2365 *----------------------------------------------------------------------
2366 */
2367
2368 CONST char *
2369 Tcl_GetNameOfExecutable()
2370 {
2371 return (tclExecutableName);
2372 }
2373
2374 /*
2375 *----------------------------------------------------------------------
2376 *
2377 * Tcl_GetCwd --
2378 *
2379 * This function replaces the library version of getcwd().
2380 *
2381 * Results:
2382 * The result is a pointer to a string specifying the current
2383 * directory, or NULL if the current directory could not be
2384 * determined. If NULL is returned, an error message is left in the
2385 * interp's result. Storage for the result string is allocated in
2386 * bufferPtr; the caller must call Tcl_DStringFree() when the result
2387 * is no longer needed.
2388 *
2389 * Side effects:
2390 * None.
2391 *
2392 *----------------------------------------------------------------------
2393 */
2394
2395 char *
2396 Tcl_GetCwd(interp, cwdPtr)
2397 Tcl_Interp *interp;
2398 Tcl_DString *cwdPtr;
2399 {
2400 return TclpGetCwd(interp, cwdPtr);
2401 }
2402
2403 /*
2404 *----------------------------------------------------------------------
2405 *
2406 * Tcl_Chdir --
2407 *
2408 * This function replaces the library version of chdir().
2409 *
2410 * Results:
2411 * See chdir() documentation.
2412 *
2413 * Side effects:
2414 * See chdir() documentation.
2415 *
2416 *----------------------------------------------------------------------
2417 */
2418
2419 int
2420 Tcl_Chdir(dirName)
2421 CONST char *dirName;
2422 {
2423 return TclpChdir(dirName);
2424 }
2425
2426 /*
2427 *----------------------------------------------------------------------
2428 *
2429 * Tcl_Access --
2430 *
2431 * This function replaces the library version of access().
2432 *
2433 * Results:
2434 * See access() documentation.
2435 *
2436 * Side effects:
2437 * See access() documentation.
2438 *
2439 *----------------------------------------------------------------------
2440 */
2441
2442 int
2443 Tcl_Access(path, mode)
2444 CONST char *path; /* Path of file to access (UTF-8). */
2445 int mode; /* Permission setting. */
2446 {
2447 return TclAccess(path, mode);
2448 }
2449
2450 /*
2451 *----------------------------------------------------------------------
2452 *
2453 * Tcl_Stat --
2454 *
2455 * This function replaces the library version of stat().
2456 *
2457 * Results:
2458 * See stat() documentation.
2459 *
2460 * Side effects:
2461 * See stat() documentation.
2462 *
2463 *----------------------------------------------------------------------
2464 */
2465
2466 int
2467 Tcl_Stat(path, bufPtr)
2468 CONST char *path; /* Path of file to stat (in UTF-8). */
2469 struct stat *bufPtr; /* Filled with results of stat call. */
2470 {
2471 return TclStat(path, bufPtr);
2472 }
2473
2474 /* End of tclutil.c */

Properties

Name Value
svn:keywords Header

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25