Return to tnas.s CVS log

Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.286

Annotation of coherent/d/PS2_KERNEL/io.286/tnas.s, revision 1.1

1.1     ! root        1: / (lgl-
        !             2: /      COHERENT Driver Kit Version 1.1.0
        !             3: /      Copyright (c) 1982, 1990 by Mark Williams Company.
        !             4: /      All rights reserved. May not be copied without permission.
        !             5: / -lgl)
        !             6: ////////
        !             7: /
        !             8: / Tiac Network Assembler Support
        !             9: /
        !            10: /      tngetc( np )            -- get a character from a tiac network buffer
        !            11: /      tnputc( np, c)          -- put a character into a tiac network buffer
        !            12: /      tucopy( np, up, n)      -- copy n bytes from tiac buffer to user space
        !            13: /      utcopy( up, np, n)      -- copy n bytes from user space to tiac buffer
        !            14: /
        !            15: ////////
        !            16: 
        !            17:        .globl  tngetc_
        !            18:        .globl  tnputc_
        !            19:        .globl  tucopy_
        !            20:        .globl  utcopy_
        !            21: 
        !            22: ////////
        !            23: /
        !            24: / Tngetc ( np )
        !            25: /
        !            26: /      Input:  np = pointer to seg:offset pair for tiac network buffer
        !            27: /
        !            28: /      Action: Read character from network buffer, increment offset.
        !            29: /
        !            30: /      Return: Character.
        !            31: /
        !            32: ////////
        !            33: 
        !            34: tngetc_:                               / tngetc( np )
        !            35:        push    si                      / char **np;
        !            36:        push    bp                      / {
        !            37:        mov     bp, sp                  /       register char c;        /* AX */
        !            38:        mov     bx, 6(bp)               /       register char *cp;      /* SI */
        !            39:        push    ds                      /
        !            40:        lds     si, (bx)                /       cp = *np;
        !            41:        cld                             /
        !            42:        lodsb                           /       c = *cp++;
        !            43:        pop     ds                      /
        !            44:        mov     (bx), si                /       *np = cp;
        !            45:        subb    ah, ah                  /
        !            46:        pop     bp                      /       return( c );
        !            47:        pop     si                      / }
        !            48:        ret
        !            49: 
        !            50: ////////
        !            51: /
        !            52: / Tnputc ( np, c )
        !            53: / char **np;
        !            54: / char c;
        !            55: /
        !            56: /      Input:  np = pointer to seg:offset pair for tiac network buffer
        !            57: /              c  = character to transfer
        !            58: /
        !            59: /      Action: Transfer character C to network buffer, increment offset.
        !            60: /
        !            61: /      Return: Character C.
        !            62: /
        !            63: ////////
        !            64: 
        !            65: tnputc_:                               / tnputc( np, c )
        !            66:        push    di                      / char **np;                    /* BX */
        !            67:        push    bp                      / char c;                       /* AX */
        !            68:        mov     bp, sp                  / {
        !            69:        mov     ax, 8(bp)               /       register char *cp;      /* DI */
        !            70:        mov     bx, 6(bp)               /
        !            71:        push    es                      /
        !            72:        les     di, (bx)                /       cp = *np;
        !            73:        cld                             /
        !            74:        stosb                           /       *cp++ = c;
        !            75:        pop     es                      /
        !            76:        mov     (bx), di                /       *np = cp;
        !            77:        pop     bp                      /
        !            78:        pop     di                      /       return c;
        !            79:        ret                             / }
        !            80: 
        !            81: ////////
        !            82: /
        !            83: / utcopy( up, np, n )
        !            84: / char * up;
        !            85: / char **np;
        !            86: / unsigned n;
        !            87: /
        !            88: /      Input:  up = offset in user data space for source data
        !            89: /              np = pointer to seg:offset pair for tiac network buffer
        !            90: /              n  = number of bytes to transfer
        !            91: /
        !            92: /      Action: Copy N bytes from user data space to network data space.
        !            93: /              Add N to network data space offset.
        !            94: /
        !            95: /      Return: None.
        !            96: /
        !            97: ////////
        !            98: 
        !            99: utcopy_:                               / utcopy( up, np, n )
        !           100:        push    si                      /
        !           101:        push    di                      / register char *  up;          /* SI */
        !           102:        push    bp                      / register char ** np;          /* BX */
        !           103:        mov     bp, sp                  / register unsigned n;          /* CX */
        !           104:        push    ds                      /
        !           105:        push    es                      / {
        !           106:        mov     bx, 10(bp)              /       register char * cp;     /* DI */
        !           107:                                        /
        !           108:        les     di, (bx)                /       cp = *np;
        !           109:                                        /
        !           110:        mov     si, 8(bp)               /       up;
        !           111:        mov     ds, uds_                /
        !           112:                                        /
        !           113:        mov     cx, 12(bp)              /       n;
        !           114:                                        /
        !           115:        cld                             /
        !           116:        clc                             /
        !           117:        rcr     cx, $1                  /
        !           118:        rep                             /       for ( ; n != 0; --n )
        !           119:        movsw                           /               *cp++ = *up++;
        !           120:        rcl     cx, $1                  /
        !           121:        rep                             /
        !           122:        movsb                           /
        !           123:                                        /
        !           124:        pop     es                      /
        !           125:        pop     ds                      /
        !           126:        mov     (bx), di                /       *np = cp;
        !           127:        pop     bp                      / }
        !           128:        pop     di
        !           129:        pop     si
        !           130:        ret
        !           131: 
        !           132: ////////
        !           133: /
        !           134: / tucopy( np, up, n )
        !           135: / char **np;
        !           136: / char * up;
        !           137: / unsigned n;
        !           138: /
        !           139: /      Input:  np = pointer to seg:offset pair for tiac network buffer
        !           140: /              up = offset in user data space for destination
        !           141: /              n  = number of bytes to transfer
        !           142: /
        !           143: /      Action: Copy N bytes from network data space to user data space.
        !           144: /              Add N to network data space offset.
        !           145: /
        !           146: /      Return: None.
        !           147: /
        !           148: ////////
        !           149: 
        !           150: tucopy_:                               / tucopy( np, up, n )
        !           151:        push    si                      /
        !           152:        push    di                      / register char ** np;          /* BX */
        !           153:        push    bp                      / register char *  up;          /* DI */
        !           154:        mov     bp, sp                  / register unsigned n;          /* CX */
        !           155:        push    ds                      /
        !           156:        push    es                      / {
        !           157:        mov     bx, 8(bp)               /       register char * cp;     /* SI */
        !           158:                                        /
        !           159:        mov     di, 10(bp)              /       up;
        !           160:        mov     es, uds_                /
        !           161:                                        /
        !           162:        lds     si, (bx)                /       cp = *np;
        !           163:                                        /
        !           164:        mov     cx, 12(bp)              /       n;
        !           165:                                        /
        !           166:        cld                             /
        !           167:        clc                             /
        !           168:        rcr     cx, $1                  /
        !           169:        rep                             /       for ( ; n != 0; --n )
        !           170:        movsw                           /               *up++ = *cp++;
        !           171:        rcl     cx, $1                  /
        !           172:        rep                             /
        !           173:        movsb                           /
        !           174:                                        /
        !           175:        pop     es                      /
        !           176:        pop     ds                      /
        !           177:        mov     (bx), si                /       *np = cp;
        !           178:        pop     bp                      / }
        !           179:        pop     di
        !           180:        pop     si
        !           181:        ret

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