Return to util.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X

Annotation of researchv9/X11/src/X.V11R1/lib/X/util.c, revision 1.1.1.1

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

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