Tcl Source Code

Check-in [7e909249a4]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Revert the [string reverse] rewrite in a branch for more review.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | revert-3396731
Files: files | file ages | folders
SHA1: 7e909249a439b31367bb04f57c2787c1a6f2aeeb
User & Date: dgp 2011-08-23 17:00:54
Context
2011-08-25
16:26
3396731 Another rewrite of TclStringObjReverse() to make it adopt the nijtmans approach for reversin... check-in: 61d345ff2f user: dgp tags: revert-3396731
2011-08-23
17:00
Revert the [string reverse] rewrite in a branch for more review. check-in: 7e909249a4 user: dgp tags: revert-3396731
16:58
typo check-in: ee5a20b8a0 user: dgp tags: trunk
2011-08-22
10:19
merge-mark check-in: 656a0bd6af user: jan.nijtmans tags: trunk
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Changes to ChangeLog.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2011-08-23  Don Porter  <[email protected]>

	* generic/tclIORChan.c:	[Bug 3396948] Leak of ReflectedChannelMap.

2011-08-23  Jan Nijtmans  <[email protected]>

	* generic/tclStringObj.c: [FRQ 3396731] inline string reverse

2011-08-19  Don Porter  <[email protected]>

	* generic/tclIORTrans.c: [Bugs 3393279, 3393280] ReflectClose(.) is
	missing Tcl_EventuallyFree() calls at some of its exits.

	* generic/tclIO.c: [Bugs 3394654, 3393276] Revise FlushChannel() to
	account for the possibility that the ChanWrite() call might recycle




<
<
<
<







1
2
3
4




5
6
7
8
9
10
11
2011-08-23  Don Porter  <[email protected]>

	* generic/tclIORChan.c:	[Bug 3396948] Leak of ReflectedChannelMap.





2011-08-19  Don Porter  <[email protected]>

	* generic/tclIORTrans.c: [Bugs 3393279, 3393280] ReflectClose(.) is
	missing Tcl_EventuallyFree() calls at some of its exits.

	* generic/tclIO.c: [Bugs 3394654, 3393276] Revise FlushChannel() to
	account for the possibility that the ChanWrite() call might recycle

Changes to generic/tclStringObj.c.

2653
2654
2655
2656
2657
2658
2659

2660

2661
2662


2663











2664
2665
2666
2667
2668
2669
2670
2671
2672
2673

2674
2675



2676
2677

2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706

2707
2708
2709
2710
2711

2712

2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726




2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737

2738
2739



2740
2741

2742

2743
2744
2745
2746
2747
2748



2749
2750
2751
2752
2753
2754
2755
2756
 *---------------------------------------------------------------------------
 */

Tcl_Obj *
TclStringObjReverse(
    Tcl_Obj *objPtr)
{

    char *src, *dest;

    Tcl_Obj *resultPtr = objPtr;
    char c;














    src = TclGetString(objPtr);
    if (Tcl_IsShared(objPtr)) {
	resultPtr = Tcl_NewObj();
	Tcl_SetObjLength(resultPtr, objPtr->length);
	dest = TclGetString(resultPtr);
	memcpy(dest, src, objPtr->length);
    } else {
	TclFreeIntRep(objPtr);
	dest = src;
    }


    src = dest + objPtr->length;




    /* Pass 1: reverse individual bytes of UTF-8 representation. */

    while (dest < src) {
	Tcl_UniChar ch = 0;
	switch (Tcl_UtfToUniChar(dest, &ch)) {
	case 1: {
		++dest;
		break;
	    }
	case 2: {
		c = dest[0];
		dest[0] = dest[1];
		dest[1] = c;
		dest += 2;
		break;
	    }
	case 3: {
		c = dest[0];
		dest[0] = dest[2];
		dest[2] = c;
		dest += 3;
		break;
	    }
#if TCL_UTF_MAX > 4
	case 5: {
		c = dest[0];
		dest[0] = dest[4];
		dest[4] = c;
		c = dest[1];
		dest[1] = dest[3];
		dest[3] = c;

		dest += 5;
		break;
	    }
#endif
#if TCL_UTF_MAX > 5

	case 6: {

		c = dest[0];
		dest[0] = dest[5];
		dest[5] = c;
		c = dest[1];
		dest[1] = dest[4];
		dest[4] = c;
		c = dest[0];
		dest[2] = dest[3];
		dest[3] = c;
		dest += 6;
		break;
	    }
#endif
	default: {




#if TCL_UTF_MAX > 3
		c = dest[0];
		dest[0] = dest[3];
		dest[3] = c;
		c = dest[1];
		dest[1] = dest[2];
		dest[2] = c;
		dest += 4;
#endif
		break;
	    }

	}
    }




	/* Pass 2: Reverse byte string. */

	dest = TclGetString(resultPtr);


	while (dest < --src) {
		c = *src;
		*src = *dest;
		*dest++ = c;
	}



    return resultPtr;
}

/*
 *---------------------------------------------------------------------------
 *
 * FillUnicodeRep --
 *







>
|
>
|
|
>
>

>
>
>
>
>
>
>
>
>
>
>
|
|
|
|
|
|
<
|
|
|
>
|
|
>
>
>

|
>
|
|
<
<
<
<
|
<
|
<
<
|
<

<
<
<
<
<
|
|
<
<
<
<
<
|
<
|
>
|
|
|
|
<
>
|
>
|
<
|
|
<
<
<
<
<
<
<
|
<
<
>
>
>
>
|
|
|
|
|
|
<
|
<
<
|
>
|
|
>
>
>

|
>
|
>

<
|
<
|
|
>
>
>
|







2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684

2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698




2699

2700


2701

2702





2703
2704





2705

2706
2707
2708
2709
2710
2711

2712
2713
2714
2715

2716
2717







2718


2719
2720
2721
2722
2723
2724
2725
2726
2727
2728

2729


2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742

2743

2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
 *---------------------------------------------------------------------------
 */

Tcl_Obj *
TclStringObjReverse(
    Tcl_Obj *objPtr)
{
    String *stringPtr;
    char *src = NULL, *dest = NULL;
    Tcl_UniChar *usrc = NULL, *udest = NULL;
    Tcl_Obj *resultPtr = NULL;

    SetStringFromAny(NULL, objPtr);
    stringPtr = GET_STRING(objPtr);

    if (stringPtr->hasUnicode == 0) {
	if (stringPtr->numChars == -1) {
	    TclNumUtfChars(stringPtr->numChars, objPtr->bytes, objPtr->length);
	}
	if (stringPtr->numChars <= 1) {
	    return objPtr;
	}
	if (stringPtr->numChars == objPtr->length) {
	    /*
	     * All one-byte chars. Reverse in objPtr->bytes.
	     */

	    if (Tcl_IsShared(objPtr)) {
		resultPtr = Tcl_NewObj();
		Tcl_SetObjLength(resultPtr, objPtr->length);
		dest = TclGetString(resultPtr);
		src = objPtr->bytes + objPtr->length - 1;

		while (src >= objPtr->bytes) {
		    *dest++ = *src--;
		}
		return resultPtr;
	    }

	    /*
	     * Unshared. Reverse objPtr->bytes in place.
	     */

	    dest = objPtr->bytes;
	    src = dest + objPtr->length - 1;
	    while (dest < src) {
		char tmp = *src;






		*src-- = *dest;


		*dest++ = tmp;

	    }





	    return objPtr;
	}





	FillUnicodeRep(objPtr);

	stringPtr = GET_STRING(objPtr);
    }
    if (stringPtr->numChars <= 1) {
	return objPtr;
    }


    /*
     * Reverse the Unicode rep.
     */


    if (Tcl_IsShared(objPtr)) {
	Tcl_UniChar ch = 0;










	/*
	 * Create a non-empty, pure unicode value, so we can coax
	 * Tcl_SetObjLength into growing the unicode rep buffer.
	 */

	resultPtr = Tcl_NewUnicodeObj(&ch, 1);
	Tcl_SetObjLength(resultPtr, stringPtr->numChars);
	udest = Tcl_GetUnicode(resultPtr);
	usrc = stringPtr->unicode + stringPtr->numChars - 1;
	while (usrc >= stringPtr->unicode) {

	    *udest++ = *usrc--;


	}
	return resultPtr;
    }

    /*
     * Unshared. Reverse objPtr->bytes in place.
     */

    udest = stringPtr->unicode;
    usrc = udest + stringPtr->numChars - 1;
    while (udest < usrc) {
	Tcl_UniChar tmp = *usrc;


	*usrc-- = *udest;

	*udest++ = tmp;
    }

    TclInvalidateStringRep(objPtr);
    stringPtr->allocated = 0;
    return objPtr;
}

/*
 *---------------------------------------------------------------------------
 *
 * FillUnicodeRep --
 *