Return to util.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / os / sysV

Annotation of researchv9/X11/src/X.V11R1/server/os/sysV/util.c, revision 1.1.1.1

1.1       root        1: /* $Header: util.c,v 1.1 87/09/11 07:50:56 toddb Exp $ */
                      2: /*
                      3:  * These are routines fould in BDS and not found in System V.  They are
                      4:  * included so that some clients can compile.
                      5:  */
                      6: 
                      7: /* Written by Jack Palevich.  
                      8:  *            HP Labs
                      9:  *            April 1987
                     10:  */
                     11: 
                     12: bcopy (b1, b2, length)
                     13: register unsigned char *b1, *b2;
                     14: register length;
                     15: {
                     16:     if (b1 < b2) {
                     17:        b2 += length;
                     18:        b1 += length;
                     19:        while (length--) {
                     20:            *--b2 = *--b1;
                     21:        }
                     22:     }
                     23:     else {
                     24:        while (length--) {
                     25:            *b2++ = *b1++;
                     26:        }
                     27:     }
                     28: }
                     29: 
                     30: bcmp (b1, b2, length)
                     31: register unsigned char *b1, *b2;
                     32: register length;
                     33: {
                     34:     while (length--) {
                     35:        if (*b1++ != *b2++) return 1;
                     36:     }
                     37:     return 0;
                     38: }
                     39: 
                     40: bzero (b, length)
                     41: register unsigned char *b;
                     42: register length;
                     43: {
                     44:     while (length--) {
                     45:        *b++ = '\0';
                     46:     }
                     47: }
                     48: 
                     49: 
                     50: /* Find the first set bit
                     51:  * i.e. least signifigant 1 bit:
                     52:  * 0 => 0
                     53:  * 1 => 1
                     54:  * 2 => 2
                     55:  * 3 => 1
                     56:  * 4 => 3
                     57:  */
                     58: 
                     59: int
                     60: ffs(mask)
                     61: unsigned int   mask;
                     62: {
                     63:     register i;
                     64: 
                     65:     if ( ! mask ) return 0;
                     66:     i = 1;
                     67:     while (! (mask & 1)) {
                     68:        i++;
                     69:        mask = mask >> 1;
                     70:     }
                     71:     return i;
                     72: }
                     73: 
                     74: char * 
                     75: index (s, c)
                     76: char *s, c;
                     77: {
                     78:     return ((char *) strchr (s, c));
                     79: }
                     80: 
                     81: char * 
                     82: rindex (s, c)
                     83: char *s, c;
                     84: {
                     85:     return ((char *) strrchr (s, c));
                     86: }
                     87: 
                     88: /*
                     89:  * insque, remque - insert/remove element from a queue
                     90:  *
                     91:  * DESCRIPTION
                     92:  *      Insque and remque manipulate queues built from doubly linked
                     93:  *      lists.  Each element in the queue must in the form of
                     94:  *      ``struct qelem''.  Insque inserts elem in a queue immedi-
                     95:  *      ately after pred; remque removes an entry elem from a queue.
                     96:  *
                     97:  * SEE ALSO
                     98:  *      ``VAX Architecture Handbook'', pp. 228-235.
                     99:  */
                    100: 
                    101: struct qelem {
                    102:     struct    qelem *q_forw;
                    103:     struct    qelem *q_back;
                    104:     char *q_data;
                    105:     };
                    106: 
                    107: insque(elem, pred)
                    108: register struct qelem *elem, *pred;
                    109: {
                    110:     register struct qelem *q;
                    111:     /* Insert locking code here */
                    112:     if ( elem->q_forw = q = (pred ? pred->q_forw : pred) )
                    113:        q->q_back = elem;
                    114:     if ( elem->q_back = pred )
                    115:        pred->q_forw = elem;
                    116:     /* Insert unlocking code here */
                    117: }
                    118: 
                    119: remque(elem)
                    120: register struct qelem *elem;
                    121: {
                    122:     register struct qelem *q;
                    123:     if ( ! elem ) return;
                    124:     /* Insert locking code here */
                    125: 
                    126:     if ( q = elem->q_back ) q->q_forw = elem->q_forw;
                    127:     if ( q = elem->q_forw ) q->q_back = elem->q_back;
                    128: 
                    129:     /* insert unlocking code here */
                    130: }

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