Return to add.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / sunlib

Annotation of researchv9/jtools/src/sunlib/add.c, revision 1.1.1.1

1.1       root        1: #include "jerq.h"
                      2: /* These routines are NOT portable, but they are fast. */
                      3: 
                      4: Point
                      5: add (a, b)
                      6: Point a, b;
                      7: {
                      8:        register short *ap= &a.x, *bp= &b.x;
                      9:        *ap++ += *bp++;
                     10:        *ap += *bp;
                     11:        return a;
                     12: }
                     13: 
                     14: Point
                     15: sub (a, b)
                     16: Point a, b;
                     17: {
                     18:        register short *ap= &a.x, *bp= &b.x;
                     19:        *ap++ -= *bp++;
                     20:        *ap -= *bp;
                     21:        return a;
                     22: }
                     23: 
                     24: Point
                     25: mul (a, b)
                     26: Point a;
                     27: register b;
                     28: {
                     29:        register short *ap= &a.x;       
                     30:        *(ap++)*=b;
                     31:        *ap*=b;
                     32:        return a;
                     33: }
                     34: 
                     35: Point
                     36: div (a, b)
                     37: Point a;
                     38: register b;
                     39: {
                     40:        register short *ap= &a.x;
                     41:        *(ap++)/=b;
                     42:        *ap/=b;
                     43:        return a;
                     44: }
                     45: 
                     46: eqpt (p, q)
                     47: Point p, q;
                     48: {
                     49:        register long *pp=(long *)&p, *qq=(long *)&q;
                     50:        return *pp==*qq;
                     51: }
                     52: 
                     53: eqrect (r, s)
                     54: Rectangle r, s;
                     55: {
                     56:        register long *rr=(long *)&r, *ss=(long *)&s;
                     57:        return *rr++==*ss++ && *rr==*ss;
                     58: }
                     59: 
                     60: Rectangle
                     61: inset (r,n)
                     62: Rectangle r;
                     63: register n;
                     64: {
                     65:        register short *rp= &r.origin.x;
                     66:        *rp++ += n;
                     67:        *rp++ += n;
                     68:        *rp++ -= n;
                     69:        *rp   -= n;
                     70:        return r;
                     71: }
                     72: 
                     73: /* muldiv is a macro in jerq.h */
                     74: 
                     75: ptinrect (p, r)
                     76: Point p;
                     77: Rectangle r;
                     78: {
                     79:        return(p.x >= r.origin.x && p.x < r.corner.x
                     80:            && p.y >= r.origin.y && p.y < r.corner.y);
                     81: }
                     82: 
                     83: Rectangle
                     84: raddp (r, p)
                     85: Rectangle r;
                     86: Point p;
                     87: {
                     88:        register short *rp= &r.origin.x, *pp= &p.x;
                     89:        *rp++ += *pp++;
                     90:        *rp++ += *pp--;
                     91:        *rp++ += *pp++;
                     92:        *rp   += *pp;
                     93:        return r;
                     94: }
                     95: 
                     96: Rectangle
                     97: rsubp (r, p)
                     98: Rectangle r;
                     99: Point p;
                    100: {
                    101:        register short *rp= &r.origin.x, *pp= &p.x;
                    102:        *rp++ -= *pp++;
                    103:        *rp++ -= *pp--;
                    104:        *rp++ -= *pp++;
                    105:        *rp   -= *pp;
                    106:        return r;
                    107: }
                    108: 
                    109: rectXrect(r, s)
                    110: Rectangle r, s;
                    111: {
                    112: #define c corner
                    113: #define o origin
                    114:        return(r.o.x<s.c.x && s.o.x<r.c.x && r.o.y<s.c.y && s.o.y<r.c.y);
                    115: }
                    116: 
                    117: rectclip (rp, b)       /* first by reference, second by value */
                    118: register Rectangle *rp;
                    119: Rectangle b;
                    120: {
                    121:        register Rectangle *bp= &b;
                    122:        /*
                    123:         * Expand rectXrect() in line for speed
                    124:         */
                    125:        if((rp->o.x<bp->c.x && bp->o.x<rp->c.x &&
                    126:            rp->o.y<bp->c.y && bp->o.y<rp->c.y)==0)
                    127:                return 0;
                    128:        /* They must overlap */
                    129:        if(rp->origin.x<bp->origin.x)
                    130:                rp->origin.x=bp->origin.x;
                    131:        if(rp->origin.y<bp->origin.y)
                    132:                rp->origin.y=bp->origin.y;
                    133:        if(rp->corner.x>bp->corner.x)
                    134:                rp->corner.x=bp->corner.x;
                    135:        if(rp->corner.y>bp->corner.y)
                    136:                rp->corner.y=bp->corner.y;
                    137:        return 1;
                    138: }

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