Return to maskbits.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mfb

Annotation of researchv9/X11/src/X.V11R1/server/ddx/mfb/maskbits.c, revision 1.1

1.1     ! root        1: /* $Header: maskbits.c,v 1.2 87/09/07 19:04:44 rws Exp $ */
        !             2: /***********************************************************
        !             3: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
        !             4: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
        !             5: 
        !             6:                         All Rights Reserved
        !             7: 
        !             8: Permission to use, copy, modify, and distribute this software and its 
        !             9: documentation for any purpose and without fee is hereby granted, 
        !            10: provided that the above copyright notice appear in all copies and that
        !            11: both that copyright notice and this permission notice appear in 
        !            12: supporting documentation, and that the names of Digital or MIT not be
        !            13: used in advertising or publicity pertaining to distribution of the
        !            14: software without specific, written prior permission.  
        !            15: 
        !            16: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
        !            17: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
        !            18: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
        !            19: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
        !            20: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
        !            21: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
        !            22: SOFTWARE.
        !            23: 
        !            24: ******************************************************************/
        !            25: #include "maskbits.h"
        !            26: #include "servermd.h"
        !            27: 
        !            28: /*
        !            29:    these tables are used by several macros in the mfb code.
        !            30: 
        !            31:    the vax numbers everything left to right, so bit indices on the
        !            32: screen match bit indices in longwords.  the pc-rt and Sun number
        !            33: bits on the screen the way they would be written on paper,
        !            34: (i.e. msb to the left), and so a bit index n on the screen is
        !            35: bit index 32-n in a longword
        !            36: 
        !            37:    see also maskbits.h
        !            38: */
        !            39: 
        !            40: #if (BITMAP_BIT_ORDER == MSBFirst)
        !            41: /* NOTE:
        !            42: the first element in starttab could be 0xffffffff.  making it 0
        !            43: lets us deal with a full first word in the middle loop, rather
        !            44: than having to do the multiple reads and masks that we'd
        !            45: have to do if we thought it was partial.
        !            46: */
        !            47: int starttab[32] =
        !            48:     {
        !            49:        0x00000000,
        !            50:        0x7FFFFFFF,
        !            51:        0x3FFFFFFF,
        !            52:        0x1FFFFFFF,
        !            53:        0x0FFFFFFF,
        !            54:        0x07FFFFFF,
        !            55:        0x03FFFFFF,
        !            56:        0x01FFFFFF,
        !            57:        0x00FFFFFF,
        !            58:        0x007FFFFF,
        !            59:        0x003FFFFF,
        !            60:        0x001FFFFF,
        !            61:        0x000FFFFF,
        !            62:        0x0007FFFF,
        !            63:        0x0003FFFF,
        !            64:        0x0001FFFF,
        !            65:        0x0000FFFF,
        !            66:        0x00007FFF,
        !            67:        0x00003FFF,
        !            68:        0x00001FFF,
        !            69:        0x00000FFF,
        !            70:        0x000007FF,
        !            71:        0x000003FF,
        !            72:        0x000001FF,
        !            73:        0x000000FF,
        !            74:        0x0000007F,
        !            75:        0x0000003F,
        !            76:        0x0000001F,
        !            77:        0x0000000F,
        !            78:        0x00000007,
        !            79:        0x00000003,
        !            80:        0x00000001
        !            81:     };
        !            82: 
        !            83: int endtab[32] =
        !            84:     {
        !            85:        0x00000000,
        !            86:        0x80000000,
        !            87:        0xC0000000,
        !            88:        0xE0000000,
        !            89:        0xF0000000,
        !            90:        0xF8000000,
        !            91:        0xFC000000,
        !            92:        0xFE000000,
        !            93:        0xFF000000,
        !            94:        0xFF800000,
        !            95:        0xFFC00000,
        !            96:        0xFFE00000,
        !            97:        0xFFF00000,
        !            98:        0xFFF80000,
        !            99:        0xFFFC0000,
        !           100:        0xFFFE0000,
        !           101:        0xFFFF0000,
        !           102:        0xFFFF8000,
        !           103:        0xFFFFC000,
        !           104:        0xFFFFE000,
        !           105:        0xFFFFF000,
        !           106:        0xFFFFF800,
        !           107:        0xFFFFFC00,
        !           108:        0xFFFFFE00,
        !           109:        0xFFFFFF00,
        !           110:        0xFFFFFF80,
        !           111:        0xFFFFFFC0,
        !           112:        0xFFFFFFE0,
        !           113:        0xFFFFFFF0,
        !           114:        0xFFFFFFF8,
        !           115:        0xFFFFFFFC,
        !           116:        0xFFFFFFFE
        !           117:     };
        !           118: 
        !           119: /* a hack, for now, since the entries for 0 need to be all
        !           120:    1 bits, not all zeros.
        !           121:    this means the code DOES NOT WORK for segments of length
        !           122:    0 (which is only a problem in the horizontal line code.)
        !           123: */
        !           124: int startpartial[32] =
        !           125:     {
        !           126:        0xFFFFFFFF,
        !           127:        0x7FFFFFFF,
        !           128:        0x3FFFFFFF,
        !           129:        0x1FFFFFFF,
        !           130:        0x0FFFFFFF,
        !           131:        0x07FFFFFF,
        !           132:        0x03FFFFFF,
        !           133:        0x01FFFFFF,
        !           134:        0x00FFFFFF,
        !           135:        0x007FFFFF,
        !           136:        0x003FFFFF,
        !           137:        0x001FFFFF,
        !           138:        0x000FFFFF,
        !           139:        0x0007FFFF,
        !           140:        0x0003FFFF,
        !           141:        0x0001FFFF,
        !           142:        0x0000FFFF,
        !           143:        0x00007FFF,
        !           144:        0x00003FFF,
        !           145:        0x00001FFF,
        !           146:        0x00000FFF,
        !           147:        0x000007FF,
        !           148:        0x000003FF,
        !           149:        0x000001FF,
        !           150:        0x000000FF,
        !           151:        0x0000007F,
        !           152:        0x0000003F,
        !           153:        0x0000001F,
        !           154:        0x0000000F,
        !           155:        0x00000007,
        !           156:        0x00000003,
        !           157:        0x00000001
        !           158:     };
        !           159: 
        !           160: int endpartial[32] =
        !           161:     {
        !           162:        0xFFFFFFFF,
        !           163:        0x80000000,
        !           164:        0xC0000000,
        !           165:        0xE0000000,
        !           166:        0xF0000000,
        !           167:        0xF8000000,
        !           168:        0xFC000000,
        !           169:        0xFE000000,
        !           170:        0xFF000000,
        !           171:        0xFF800000,
        !           172:        0xFFC00000,
        !           173:        0xFFE00000,
        !           174:        0xFFF00000,
        !           175:        0xFFF80000,
        !           176:        0xFFFC0000,
        !           177:        0xFFFE0000,
        !           178:        0xFFFF0000,
        !           179:        0xFFFF8000,
        !           180:        0xFFFFC000,
        !           181:        0xFFFFE000,
        !           182:        0xFFFFF000,
        !           183:        0xFFFFF800,
        !           184:        0xFFFFFC00,
        !           185:        0xFFFFFE00,
        !           186:        0xFFFFFF00,
        !           187:        0xFFFFFF80,
        !           188:        0xFFFFFFC0,
        !           189:        0xFFFFFFE0,
        !           190:        0xFFFFFFF0,
        !           191:        0xFFFFFFF8,
        !           192:        0xFFFFFFFC,
        !           193:        0xFFFFFFFE
        !           194:     };
        !           195: #else          /* LSBFirst */
        !           196: /* NOTE:
        !           197: the first element in starttab could be 0xffffffff.  making it 0
        !           198: lets us deal with a full first word in the middle loop, rather
        !           199: than having to do the multiple reads and masks that we'd
        !           200: have to do if we thought it was partial.
        !           201: */
        !           202: int starttab[32] = 
        !           203:        {
        !           204:        0x00000000,
        !           205:        0xFFFFFFFE,
        !           206:        0xFFFFFFFC,
        !           207:        0xFFFFFFF8,
        !           208:        0xFFFFFFF0,
        !           209:        0xFFFFFFE0,
        !           210:        0xFFFFFFC0,
        !           211:        0xFFFFFF80,
        !           212:        0xFFFFFF00,
        !           213:        0xFFFFFE00,
        !           214:        0xFFFFFC00,
        !           215:        0xFFFFF800,
        !           216:        0xFFFFF000,
        !           217:        0xFFFFE000,
        !           218:        0xFFFFC000,
        !           219:        0xFFFF8000,
        !           220:        0xFFFF0000,
        !           221:        0xFFFE0000,
        !           222:        0xFFFC0000,
        !           223:        0xFFF80000,
        !           224:        0xFFF00000,
        !           225:        0xFFE00000,
        !           226:        0xFFC00000,
        !           227:        0xFF800000,
        !           228:        0xFF000000,
        !           229:        0xFE000000,
        !           230:        0xFC000000,
        !           231:        0xF8000000,
        !           232:        0xF0000000,
        !           233:        0xE0000000,
        !           234:        0xC0000000,
        !           235:        0x80000000
        !           236:        };
        !           237: 
        !           238: int endtab[32] = 
        !           239:        {
        !           240:        0x00000000,
        !           241:        0x00000001,
        !           242:        0x00000003,
        !           243:        0x00000007,
        !           244:        0x0000000F,
        !           245:        0x0000001F,
        !           246:        0x0000003F,
        !           247:        0x0000007F,
        !           248:        0x000000FF,
        !           249:        0x000001FF,
        !           250:        0x000003FF,
        !           251:        0x000007FF,
        !           252:        0x00000FFF,
        !           253:        0x00001FFF,
        !           254:        0x00003FFF,
        !           255:        0x00007FFF,
        !           256:        0x0000FFFF,
        !           257:        0x0001FFFF,
        !           258:        0x0003FFFF,
        !           259:        0x0007FFFF,
        !           260:        0x000FFFFF,
        !           261:        0x001FFFFF,
        !           262:        0x003FFFFF,
        !           263:        0x007FFFFF,
        !           264:        0x00FFFFFF,
        !           265:        0x01FFFFFF,
        !           266:        0x03FFFFFF,
        !           267:        0x07FFFFFF,
        !           268:        0x0FFFFFFF,
        !           269:        0x1FFFFFFF,
        !           270:        0x3FFFFFFF,
        !           271:        0x7FFFFFFF
        !           272:        };
        !           273: 
        !           274: /* a hack, for now, since the entries for 0 need to be all
        !           275:    1 bits, not all zeros.
        !           276:    this means the code DOES NOT WORK for segments of length
        !           277:    0 (which is only a problem in the horizontal line code.)
        !           278: */
        !           279: int startpartial[32] = 
        !           280:        {
        !           281:        0xFFFFFFFF,
        !           282:        0xFFFFFFFE,
        !           283:        0xFFFFFFFC,
        !           284:        0xFFFFFFF8,
        !           285:        0xFFFFFFF0,
        !           286:        0xFFFFFFE0,
        !           287:        0xFFFFFFC0,
        !           288:        0xFFFFFF80,
        !           289:        0xFFFFFF00,
        !           290:        0xFFFFFE00,
        !           291:        0xFFFFFC00,
        !           292:        0xFFFFF800,
        !           293:        0xFFFFF000,
        !           294:        0xFFFFE000,
        !           295:        0xFFFFC000,
        !           296:        0xFFFF8000,
        !           297:        0xFFFF0000,
        !           298:        0xFFFE0000,
        !           299:        0xFFFC0000,
        !           300:        0xFFF80000,
        !           301:        0xFFF00000,
        !           302:        0xFFE00000,
        !           303:        0xFFC00000,
        !           304:        0xFF800000,
        !           305:        0xFF000000,
        !           306:        0xFE000000,
        !           307:        0xFC000000,
        !           308:        0xF8000000,
        !           309:        0xF0000000,
        !           310:        0xE0000000,
        !           311:        0xC0000000,
        !           312:        0x80000000
        !           313:        };
        !           314: 
        !           315: int endpartial[32] = 
        !           316:        {
        !           317:        0xFFFFFFFF,
        !           318:        0x00000001,
        !           319:        0x00000003,
        !           320:        0x00000007,
        !           321:        0x0000000F,
        !           322:        0x0000001F,
        !           323:        0x0000003F,
        !           324:        0x0000007F,
        !           325:        0x000000FF,
        !           326:        0x000001FF,
        !           327:        0x000003FF,
        !           328:        0x000007FF,
        !           329:        0x00000FFF,
        !           330:        0x00001FFF,
        !           331:        0x00003FFF,
        !           332:        0x00007FFF,
        !           333:        0x0000FFFF,
        !           334:        0x0001FFFF,
        !           335:        0x0003FFFF,
        !           336:        0x0007FFFF,
        !           337:        0x000FFFFF,
        !           338:        0x001FFFFF,
        !           339:        0x003FFFFF,
        !           340:        0x007FFFFF,
        !           341:        0x00FFFFFF,
        !           342:        0x01FFFFFF,
        !           343:        0x03FFFFFF,
        !           344:        0x07FFFFFF,
        !           345:        0x0FFFFFFF,
        !           346:        0x1FFFFFFF,
        !           347:        0x3FFFFFFF,
        !           348:        0x7FFFFFFF
        !           349:        };
        !           350: #endif
        !           351: 
        !           352: 
        !           353: /* used for masking bits in bresenham lines
        !           354:    mask[n] is used to mask out all but bit n in a longword (n is a
        !           355: screen position).
        !           356:    rmask[n] is used to mask out the single bit at position n (n
        !           357: is a screen posiotion.)
        !           358: */
        !           359: 
        !           360: #if (BITMAP_BIT_ORDER == MSBFirst)
        !           361: int mask[] =
        !           362:     {
        !           363:     1<<31, 1<<30, 1<<29, 1<<28, 1<<27, 1<<26, 1<<25, 1<<24,
        !           364:     1<<23, 1<<22, 1<<21, 1<<20, 1<<19, 1<<18, 1<<17, 1<<16,
        !           365:     1<<15, 1<<14, 1<<13, 1<<12, 1<<11, 1<<10, 1<<9, 1<<8,
        !           366:     1<<7, 1<<6, 1<<5, 1<<4, 1<<3, 1<<2, 1<<1, 1<<0
        !           367:     }; 
        !           368: int rmask[] = 
        !           369:     {
        !           370:     0xffffffff ^ (1<<31), 0xffffffff ^ (1<<30), 0xffffffff ^ (1<<29),
        !           371:     0xffffffff ^ (1<<28), 0xffffffff ^ (1<<27), 0xffffffff ^ (1<<26),
        !           372:     0xffffffff ^ (1<<25), 0xffffffff ^ (1<<24), 0xffffffff ^ (1<<23),
        !           373:     0xffffffff ^ (1<<22), 0xffffffff ^ (1<<21), 0xffffffff ^ (1<<20),
        !           374:     0xffffffff ^ (1<<19), 0xffffffff ^ (1<<18), 0xffffffff ^ (1<<17),
        !           375:     0xffffffff ^ (1<<16), 0xffffffff ^ (1<<15), 0xffffffff ^ (1<<14),
        !           376:     0xffffffff ^ (1<<13), 0xffffffff ^ (1<<12), 0xffffffff ^ (1<<11),
        !           377:     0xffffffff ^ (1<<10), 0xffffffff ^ (1<<9),  0xffffffff ^ (1<<8),
        !           378:     0xffffffff ^ (1<<7),  0xffffffff ^ (1<<6),  0xffffffff ^ (1<<5),
        !           379:     0xffffffff ^ (1<<4),  0xffffffff ^ (1<<3),  0xffffffff ^ (1<<2),
        !           380:     0xffffffff ^ (1<<1),  0xffffffff ^ (1<<0)
        !           381:     };
        !           382: #else  /* LSBFirst */
        !           383: int mask[] =
        !           384:     {
        !           385:     1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
        !           386:     1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
        !           387:     1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
        !           388:     1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30, 1<<31
        !           389:     }; 
        !           390: int rmask[] = 
        !           391:     {
        !           392:     0xffffffff ^ (1<<0), 0xffffffff ^ (1<<1), 0xffffffff ^ (1<<2),
        !           393:     0xffffffff ^ (1<<3), 0xffffffff ^ (1<<4), 0xffffffff ^ (1<<5),
        !           394:     0xffffffff ^ (1<<6), 0xffffffff ^ (1<<7), 0xffffffff ^ (1<<8),
        !           395:     0xffffffff ^ (1<<9), 0xffffffff ^ (1<<10), 0xffffffff ^ (1<<11),
        !           396:     0xffffffff ^ (1<<12), 0xffffffff ^ (1<<13), 0xffffffff ^ (1<<14),
        !           397:     0xffffffff ^ (1<<15), 0xffffffff ^ (1<<16), 0xffffffff ^ (1<<17),
        !           398:     0xffffffff ^ (1<<18), 0xffffffff ^ (1<<19), 0xffffffff ^ (1<<20),
        !           399:     0xffffffff ^ (1<<21), 0xffffffff ^ (1<<22), 0xffffffff ^ (1<<23),
        !           400:     0xffffffff ^ (1<<24), 0xffffffff ^ (1<<25), 0xffffffff ^ (1<<26),
        !           401:     0xffffffff ^ (1<<27), 0xffffffff ^ (1<<28), 0xffffffff ^ (1<<29),
        !           402:     0xffffffff ^ (1<<30), 0xffffffff ^ (1<<31)
        !           403:     };
        !           404: #endif
        !           405: 

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