Return to gets.s CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / lib / libc / stdio / stdio.vax

Annotation of 43BSDTahoe/lib/libc/stdio/stdio.vax/gets.s, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1985 Regents of the University of California.
                      3:  * All rights reserved.
                      4:  *
                      5:  * Redistribution and use in source and binary forms are permitted
                      6:  * provided that the above copyright notice and this paragraph are
                      7:  * duplicated in all such forms and that any documentation,
                      8:  * advertising materials, and other materials related to such
                      9:  * distribution and use acknowledge that the software was developed
                     10:  * by the University of California, Berkeley.  The name of the
                     11:  * University may not be used to endorse or promote products derived
                     12:  * from this software without specific prior written permission.
                     13:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
                     14:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
                     15:  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
                     16:  */
                     17: 
                     18: #if defined(LIBC_SCCS) && !defined(lint)
                     19:        .asciz "@(#)gets.s      5.4 (Berkeley) 6/27/88"
                     20: #endif /* LIBC_SCCS and not lint */
                     21: 
                     22: /*
                     23:  * char *gets(s);
                     24:  * char *s;
                     25:  *
                     26:  * argument: a target string
                     27:  * side effects: reads bytes up to and including a newline from the
                     28:  *     standard input into the target string and replaces the newline
                     29:  *     with a null to null-terminate the string.
                     30:  * result: the target string if successful, 0 otherwise.
                     31:  */
                     32: 
                     33: #include "DEFS.h"
                     34: 
                     35: #define                NL      0xa
                     36: 
                     37: ENTRY(gets, R11|R10)
                     38: 
                     39: #define                S       r11
                     40:        movl    4(ap),S
                     41: #define                IPTR    r10
                     42: #define                _CNT
                     43: #define                _PTR    4
                     44: #define                _BASE   8
                     45: #define                _BUFSIZ 12
                     46: #define                _FLAG   16
                     47:        movab   __iob,IPTR
                     48: 
                     49: #define                OLD_S   4(ap)
                     50: 
                     51:        /*
                     52:         * If no characters, call _filbuf() to get some.
                     53:         */
                     54:        tstl    _CNT(IPTR)
                     55:        jgtr    Lscan
                     56: 
                     57: Lloop:
                     58:        pushl   IPTR
                     59:        calls   $1,__filbuf
                     60:        tstl    r0                      /* What did _filbuf() return? */
                     61:        jlss    Leof
                     62:        cmpb    r0,$NL
                     63:        jneq    1f
                     64:        clrb    (S)
                     65:        jbr     Lret
                     66: 1:
                     67:        movb    r0,(S)+                 /* Save the returned character */
                     68:        tstl    _BASE(IPTR)             /* Is input buffered? */
                     69:        jeql    Lloop
                     70: 
                     71:        /*
                     72:         * Look for a newline in the buffer.
                     73:         */
                     74: Lscan:
                     75:        locc    $NL,_CNT(IPTR),*_PTR(IPTR)
                     76:        jeql    Lagain
                     77: 
                     78:        /*
                     79:         * Success -- copy the data and return.
                     80:         */
                     81:        subl3   r0,_CNT(IPTR),r2
                     82:        subl2   r2,_CNT(IPTR)
                     83:        movc3   r2,*_PTR(IPTR),(S)      /* Copy the data */
                     84:        clrb    (r3)
                     85:        movl    r1,_PTR(IPTR)
                     86:        decl    _CNT(IPTR)              /* Skip the newline */
                     87:        incl    _PTR(IPTR)
                     88: 
                     89:        /*
                     90:         * Normal return.
                     91:         */
                     92: Lret:
                     93:        movl    OLD_S,r0
                     94:        ret
                     95: 
                     96:        /*
                     97:         * If we run out of characters, copy the buffer and loop.
                     98:         */
                     99: Lagain:
                    100:        movc3   _CNT(IPTR),*_PTR(IPTR),(S)      /* Copy the data */
                    101:        movl    r3,S
                    102:        movl    _BASE(IPTR),_PTR(IPTR)          /* Reset stdio */
                    103:        clrl    _CNT(IPTR)
                    104:        jbr     Lloop
                    105: 
                    106:        /*
                    107:         * End of file?  Check to see if we copied any data.
                    108:         */
                    109: Leof:
                    110:        cmpl    S,OLD_S
                    111:        jeql    Lerror
                    112:        clrb    (S)
                    113:        jbr     Lret
                    114: 
                    115:        /*
                    116:         * Error/eof return -- null pointer.
                    117:         */
                    118: Lerror:
                    119:        clrl    r0
                    120:        ret

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