<h2>Editing File: /opt/alt/libicu/usr/share/doc/alt-libicu-devel/samples/uciter8/uciter8.c</h2><form method='post'><textarea name='content' class='file-edit'>/*
*******************************************************************************
*
*   © 2016 and later: Unicode, Inc. and others.
*   License &amp; terms of use: http://www.unicode.org/copyright.html#License
*
*******************************************************************************
*******************************************************************************
*
*   Copyright (C) 2003-2014, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  uciter8.c
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2003jan10
*   created by: Markus W. Scherer
*
*   This file contains sample code that illustrates reading
*   8-bit Unicode text leniently, accepting a mix of UTF-8 and CESU-8
*   and also accepting single surrogates.
*/

#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &quot;unicode/utypes.h&quot;
#include &quot;unicode/uiter.h&quot;
#include &quot;uit_len8.h&quot;

#ifndef UPRV_LENGTHOF
#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
#endif

#define log_err printf

/* UCharIterator test ------------------------------------------------------- */

/*
 * The following code is a copy of the UCharIterator test code in
 * source/test/cintltst/custrtst.c,
 * testing the lenient-8 iterator instead of the UTF-8 one.
 */

/*
 * Compare results from two iterators, should be same.
 * Assume that the text is not empty and that
 * iteration start==0 and iteration limit==length.
 */
static void
compareIterators(UCharIterator *iter1, const char *n1,
                 UCharIterator *iter2, const char *n2) {
    int32_t i, pos1, pos2, middle, length;
    UChar32 c1, c2;

    /* compare lengths */
    length=iter1-&gt;getIndex(iter1, UITER_LENGTH);
    pos2=iter2-&gt;getIndex(iter2, UITER_LENGTH);
    if(length!=pos2) {
        log_err(&quot;%s-&gt;getIndex(length)=%d != %d=%s-&gt;getIndex(length)\n&quot;, n1, length, pos2, n2);
        return;
    }

    /* set into the middle */
    middle=length/2;

    pos1=iter1-&gt;move(iter1, middle, UITER_ZERO);
    if(pos1!=middle) {
        log_err(&quot;%s-&gt;move(from 0 to middle %d)=%d does not move to the middle\n&quot;, n1, middle, pos1);
        return;
    }

    pos2=iter2-&gt;move(iter2, middle, UITER_ZERO);
    if(pos2!=middle) {
        log_err(&quot;%s-&gt;move(from 0 to middle %d)=%d does not move to the middle\n&quot;, n2, middle, pos2);
        return;
    }

    /* test current() */
    c1=iter1-&gt;current(iter1);
    c2=iter2-&gt;current(iter2);
    if(c1!=c2) {
        log_err(&quot;%s-&gt;current()=U+%04x != U+%04x=%s-&gt;current() at middle=%d\n&quot;, n1, c1, c2, n2, middle);
        return;
    }

    /* move forward 3 UChars */
    for(i=0; i&lt;3; ++i) {
        c1=iter1-&gt;next(iter1);
        c2=iter2-&gt;next(iter2);
        if(c1!=c2) {
            log_err(&quot;%s-&gt;next()=U+%04x != U+%04x=%s-&gt;next() at %d (started in middle)\n&quot;, n1, c1, c2, n2, iter1-&gt;getIndex(iter1, UITER_CURRENT));
            return;
        }
    }

    /* move backward 5 UChars */
    for(i=0; i&lt;5; ++i) {
        c1=iter1-&gt;previous(iter1);
        c2=iter2-&gt;previous(iter2);
        if(c1!=c2) {
            log_err(&quot;%s-&gt;previous()=U+%04x != U+%04x=%s-&gt;previous() at %d (started in middle)\n&quot;, n1, c1, c2, n2, iter1-&gt;getIndex(iter1, UITER_CURRENT));
            return;
        }
    }

    /* iterate forward from the beginning */
    pos1=iter1-&gt;move(iter1, 0, UITER_START);
    if(pos1&lt;0) {
        log_err(&quot;%s-&gt;move(start) failed\n&quot;, n1);
        return;
    }
    if(!iter1-&gt;hasNext(iter1)) {
        log_err(&quot;%s-&gt;hasNext() at the start returns FALSE\n&quot;, n1);
        return;
    }

    pos2=iter2-&gt;move(iter2, 0, UITER_START);
    if(pos2&lt;0) {
        log_err(&quot;%s-&gt;move(start) failed\n&quot;, n2);
        return;
    }
    if(!iter2-&gt;hasNext(iter2)) {
        log_err(&quot;%s-&gt;hasNext() at the start returns FALSE\n&quot;, n2);
        return;
    }

    do {
        c1=iter1-&gt;next(iter1);
        c2=iter2-&gt;next(iter2);
        if(c1!=c2) {
            log_err(&quot;%s-&gt;next()=U+%04x != U+%04x=%s-&gt;next() at %d\n&quot;, n1, c1, c2, n2, iter1-&gt;getIndex(iter1, UITER_CURRENT));
            return;
        }
    } while(c1&gt;=0);

    if(iter1-&gt;hasNext(iter1)) {
        log_err(&quot;%s-&gt;hasNext() at the end returns TRUE\n&quot;, n1);
        return;
    }
    if(iter2-&gt;hasNext(iter2)) {
        log_err(&quot;%s-&gt;hasNext() at the end returns TRUE\n&quot;, n2);
        return;
    }

    /* back to the middle */
    pos1=iter1-&gt;move(iter1, middle, UITER_ZERO);
    if(pos1!=middle) {
        log_err(&quot;%s-&gt;move(from end to middle %d)=%d does not move to the middle\n&quot;, n1, middle, pos1);
        return;
    }

    pos2=iter2-&gt;move(iter2, middle, UITER_ZERO);
    if(pos2!=middle) {
        log_err(&quot;%s-&gt;move(from end to middle %d)=%d does not move to the middle\n&quot;, n2, middle, pos2);
        return;
    }

    /* move to index 1 */
    pos1=iter1-&gt;move(iter1, 1, UITER_ZERO);
    if(pos1!=1) {
        log_err(&quot;%s-&gt;move(from middle %d to 1)=%d does not move to 1\n&quot;, n1, middle, pos1);
        return;
    }

    pos2=iter2-&gt;move(iter2, 1, UITER_ZERO);
    if(pos2!=1) {
        log_err(&quot;%s-&gt;move(from middle %d to 1)=%d does not move to 1\n&quot;, n2, middle, pos2);
        return;
    }

    /* iterate backward from the end */
    pos1=iter1-&gt;move(iter1, 0, UITER_LIMIT);
    if(pos1&lt;0) {
        log_err(&quot;%s-&gt;move(limit) failed\n&quot;, n1);
        return;
    }
    if(!iter1-&gt;hasPrevious(iter1)) {
        log_err(&quot;%s-&gt;hasPrevious() at the end returns FALSE\n&quot;, n1);
        return;
    }

    pos2=iter2-&gt;move(iter2, 0, UITER_LIMIT);
    if(pos2&lt;0) {
        log_err(&quot;%s-&gt;move(limit) failed\n&quot;, n2);
        return;
    }
    if(!iter2-&gt;hasPrevious(iter2)) {
        log_err(&quot;%s-&gt;hasPrevious() at the end returns FALSE\n&quot;, n2);
        return;
    }

    do {
        c1=iter1-&gt;previous(iter1);
        c2=iter2-&gt;previous(iter2);
        if(c1!=c2) {
            log_err(&quot;%s-&gt;previous()=U+%04x != U+%04x=%s-&gt;previous() at %d\n&quot;, n1, c1, c2, n2, iter1-&gt;getIndex(iter1, UITER_CURRENT));
            return;
        }
    } while(c1&gt;=0);

    if(iter1-&gt;hasPrevious(iter1)) {
        log_err(&quot;%s-&gt;hasPrevious() at the start returns TRUE\n&quot;, n1);
        return;
    }
    if(iter2-&gt;hasPrevious(iter2)) {
        log_err(&quot;%s-&gt;hasPrevious() at the start returns TRUE\n&quot;, n2);
        return;
    }
}

/*
 * Test the iterator's getState() and setState() functions.
 * iter1 and iter2 must be set up for the same iterator type and the same string
 * but may be physically different structs (different addresses).
 *
 * Assume that the text is not empty and that
 * iteration start==0 and iteration limit==length.
 * It must be 2&lt;=middle&lt;=length-2.
 */
static void
testIteratorState(UCharIterator *iter1, UCharIterator *iter2, const char *n, int32_t middle) {
    UChar32 u[4];

    UErrorCode errorCode;
    UChar32 c;
    uint32_t state;
    int32_t i, j;

    /* get four UChars from the middle of the string */
    iter1-&gt;move(iter1, middle-2, UITER_ZERO);
    for(i=0; i&lt;4; ++i) {
        c=iter1-&gt;next(iter1);
        if(c&lt;0) {
            /* the test violates the assumptions, see comment above */
            log_err(&quot;test error: %s[%d]=%d\n&quot;, n, middle-2+i, c);
            return;
        }
        u[i]=c;
    }

    /* move to the middle and get the state */
    iter1-&gt;move(iter1, -2, UITER_CURRENT);
    state=uiter_getState(iter1);

    /* set the state into the second iterator and compare the results */
    errorCode=U_ZERO_ERROR;
    uiter_setState(iter2, state, &amp;errorCode);
    if(U_FAILURE(errorCode)) {
        log_err(&quot;%s-&gt;setState(0x%x) failed: %s\n&quot;, n, state, u_errorName(errorCode));
        return;
    }

    c=iter2-&gt;current(iter2);
    if(c!=u[2]) {
        log_err(&quot;%s-&gt;current(at %d)=U+%04x!=U+%04x\n&quot;, n, middle, c, u[2]);
    }

    c=iter2-&gt;previous(iter2);
    if(c!=u[1]) {
        log_err(&quot;%s-&gt;previous(at %d)=U+%04x!=U+%04x\n&quot;, n, middle-1, c, u[1]);
    }

    iter2-&gt;move(iter2, 2, UITER_CURRENT);
    c=iter2-&gt;next(iter2);
    if(c!=u[3]) {
        log_err(&quot;%s-&gt;next(at %d)=U+%04x!=U+%04x\n&quot;, n, middle+1, c, u[3]);
    }

    iter2-&gt;move(iter2, -3, UITER_CURRENT);
    c=iter2-&gt;previous(iter2);
    if(c!=u[0]) {
        log_err(&quot;%s-&gt;previous(at %d)=U+%04x!=U+%04x\n&quot;, n, middle-2, c, u[0]);
    }

    /* move the second iterator back to the middle */
    iter2-&gt;move(iter2, 1, UITER_CURRENT);
    iter2-&gt;next(iter2);

    /* check that both are in the middle */
    i=iter1-&gt;getIndex(iter1, UITER_CURRENT);
    j=iter2-&gt;getIndex(iter2, UITER_CURRENT);
    if(i!=middle) {
        log_err(&quot;%s-&gt;getIndex(current)=%d!=%d as expected\n&quot;, n, i, middle);
    }
    if(i!=j) {
        log_err(&quot;%s-&gt;getIndex(current)=%d!=%d after setState()\n&quot;, n, j, i);
    }

    /* compare lengths */
    i=iter1-&gt;getIndex(iter1, UITER_LENGTH);
    j=iter2-&gt;getIndex(iter2, UITER_LENGTH);
    if(i!=j) {
        log_err(&quot;%s-&gt;getIndex(length)=%d!=%d before/after setState()\n&quot;, n, i, j);
    }
}

static void
TestLenient8Iterator() {
    static const UChar text[]={
        0x61, 0x62, 0x63,
        /* dffd 107fd             d801    dffd - in UTF-16, U+107fd=&lt;d801 dffd&gt; */
        0xdffd, 0xd801, 0xdffd, 0xd801, 0xdffd, 
        0x78, 0x79, 0x7a, 0
    };
    static const uint8_t bytes[]={
        0x61, 0x62, 0x63,
        /* dffd            107fd                    d801               dffd - mixture */
        0xed, 0xbf, 0xbd,  0xf0, 0x90, 0x9f, 0xbd,  0xed, 0xa0, 0x81,  0xed, 0xbf, 0xbd,
        0x78, 0x79, 0x7a, 0
    };

    UCharIterator iter1, iter2;
    UChar32 c1, c2;
    int32_t length;

    puts(&quot;test a UCharIterator for lenient 8-bit Unicode (accept single surrogates)&quot;);

    /* compare the same string between UTF-16 and lenient-8 UCharIterators */
    uiter_setString(&amp;iter1, text, -1);
    uiter_setLenient8(&amp;iter2, (const char *)bytes, sizeof(bytes)-1);
    compareIterators(&amp;iter1, &quot;UTF16Iterator&quot;, &amp;iter2, &quot;Lenient8Iterator&quot;);

    /* try again with length=-1 */
    uiter_setLenient8(&amp;iter2, (const char *)bytes, -1);
    compareIterators(&amp;iter1, &quot;UTF16Iterator&quot;, &amp;iter2, &quot;Lenient8Iterator_1&quot;);

    /* test get/set state */
    length=UPRV_LENGTHOF(text)-1;
    uiter_setLenient8(&amp;iter1, (const char*)bytes, -1);
    testIteratorState(&amp;iter1, &amp;iter2, &quot;Lenient8IteratorState&quot;, length/2);
    testIteratorState(&amp;iter1, &amp;iter2, &quot;Lenient8IteratorStatePlus1&quot;, length/2+1);

    /* ---------------------------------------------------------------------- */

    puts(&quot;no output so far means that the lenient-8 iterator works fine&quot;);

    puts(&quot;iterate forward:\nUTF-16\tlenient-8&quot;);
    uiter_setString(&amp;iter1, text, -1);
    iter1.move(&amp;iter1, 0, UITER_START);
    iter2.move(&amp;iter2, 0, UITER_START);
    for(;;) {
        c1=iter1.next(&amp;iter1);
        c2=iter2.next(&amp;iter2);
        if(c1&lt;0 &amp;&amp; c2&lt;0) {
            break;
        }
        if(c1&lt;0) {
            printf(&quot;\t%04x\n&quot;, c2);
        } else if(c2&lt;0) {
            printf(&quot;%04x\n&quot;, c1);
        } else {
            printf(&quot;%04x\t%04x\n&quot;, c1, c2);
        }
    }
}

extern int
main(int argc, const char *argv[]) {
    TestLenient8Iterator();
    return 0;
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Flibicu%2Fusr%2Fshare%2Fdoc%2Falt-libicu-devel%2Fsamples%2Fuciter8'>Back to Directory</a>