Return to memccpy.s CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / string / i8086

Annotation of coherent/b/lib/libc/string/i8086/memccpy.s, revision 1.1

1.1     ! root        1: ////////
        !             2: /
        !             3: / #include <string.h>
        !             4: /
        !             5: / char *
        !             6: / memccpy(dest, src, c, n)
        !             7: / char *dest, *src;
        !             8: /
        !             9: /      Action: Copy characters from memory area src into dest, stopping
        !            10: /              after  the first occurrence of  character C has  been
        !            11: /              been copied, or after N characters have been copied.
        !            12: /
        !            13: /      Return: A pointer to the character after the copy of C in dest,
        !            14: /              or a NULL pointer  if C was not found  in the first N
        !            15: /              characters of src.
        !            16: ////////
        !            17:        .globl  memccpy_
        !            18: 
        !            19: memccpy_:                              / char *
        !            20:        push    si                      / memccpy ( dest, src, c, n )
        !            21:        push    di                      /
        !            22:        mov     bx, sp                  / char *dest, *src;
        !            23:        movb    al, 10(bx)              / register int c;               /* AX */
        !            24:        mov     dx, 12(bx)              / register unsigned n;          /* DX */
        !            25:                                        /
        !            26:        mov     di, 8(bx)               / {     register char *cp = src; /* DI */
        !            27:        mov     cx, dx                  /       register cnt = n;       /* CX */
        !            28:                                        /
        !            29:        jcxz    0f                      /       for (; cnt != 0; --cnt)
        !            30:        cld                             /               if (*cp++ == c)
        !            31:        repne                           /                       break;
        !            32:        scasb                           /
        !            33:        jne     0f                      /       if (cp[-1] == c)
        !            34:        sub     dx, cx                  /       {       n  -= cnt;
        !            35:        mov     cx, di                  /
        !            36:        sub     cx, 8(bx)               /               cnt = cp - src + dest;
        !            37:        add     cx, 6(bx)               /       }
        !            38: 0:     mov     ax, cx                  /       c = cnt;
        !            39:        mov     si, 8(bx)               /
        !            40:        mov     di, 6(bx)               /
        !            41:        mov     cx, dx                  /       for ( cnt = n; cnt != 0; --cnt)
        !            42:        rep                             /               *dest++ = *src++;
        !            43:        movsb                           /
        !            44:        pop     di                      /       return c;
        !            45:        pop     si                      / }
        !            46:        ret

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.