Return to gpoint.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / libgnot

Annotation of lucent/sys/src/libgnot/gpoint.c, revision 1.1.1.1

1.1       root        1: #include <u.h>
                      2: #include <libc.h>
                      3: #include <libg.h>
                      4: #include <gnot.h>
                      5: 
                      6: void
                      7: gpoint(GBitmap *b, Point p, int s, Fcode c)
                      8: {
                      9:        uchar *d;
                     10:        uchar mask;
                     11:        int l;
                     12: 
                     13:        if(!ptinrect(p, b->clipr))
                     14:                return;
                     15:        d = gbaddr(b, p);
                     16:        l = b->ldepth;
                     17:        if(LENDIAN){
                     18:                mask = (1<<(1<<l))-1;
                     19:                l = (p.x&(0x7>>l))<<l;
                     20:                mask <<= l;
                     21:                s <<= l;
                     22:        }else{
                     23:                s <<= (8-(1<<l));
                     24:                mask = (~0UL)<<(8-(1<<l));
                     25:                l = (p.x&(0x7>>l))<<l;
                     26:                s >>= l;
                     27:                mask >>= l;
                     28:        }
                     29: 
                     30:        switch(c&0x1F){
                     31:        case Zero:
                     32:                *d &= ~mask;
                     33:                break;
                     34: 
                     35:        case DnorS:
                     36:                *d ^= (*d|~s)&mask;
                     37:                break;
                     38: 
                     39:        case DandnotS:
                     40:                *d ^= (*d&s)&mask;
                     41:                break;
                     42: 
                     43:        case notS:
                     44:                *d ^= (*d^~s)&mask;
                     45:                break;
                     46: 
                     47:        case notDandS:
                     48:                *d ^= (s|*d)&mask;
                     49:                break;
                     50: 
                     51:        case notD:
                     52:                *d ^= mask;
                     53:                break;
                     54: 
                     55:        case DxorS:
                     56:                *d ^= s&mask;
                     57:                break;
                     58: 
                     59:        case DnandS:
                     60:                *d ^= (s|~*d)&mask;
                     61:                break;
                     62: 
                     63:        case DandS:
                     64:                *d &= s|~mask;
                     65:                break;
                     66: 
                     67:        case DxnorS:
                     68:                *d ^= (~s)&mask;
                     69:                break;
                     70: 
                     71:        case D:
                     72:                break;
                     73: 
                     74:        case DornotS:
                     75:                *d |= (~s)&mask;
                     76:                break;
                     77: 
                     78:        case S:
                     79:                *d ^= (s^*d)&mask;
                     80:                break;
                     81: 
                     82:        case notDorS:
                     83:                *d ^= (~(*d&s))&mask;
                     84:                break;
                     85: 
                     86:        case DorS:
                     87:                *d |= s&mask;
                     88:                break;
                     89: 
                     90:        case F:
                     91:                *d |= mask;
                     92:                break;
                     93:        }
                     94: }

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