![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to text.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / X / libsun|
Return to text.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / libsun |
1.1 ! root 1: #ifdef sun ! 2: /* ! 3: * The Sun X drivers are a product of Sun Microsystems, Inc. and are provided ! 4: * for unrestricted use provided that this legend is included on all tape ! 5: * media and as a part of the software program in whole or part. Users ! 6: * may copy or modify these drivers without charge, but are not authorized ! 7: * to license or distribute them to anyone else except as part of a product or ! 8: * program developed by the user. ! 9: * ! 10: * THE SUN X DRIVERS ARE PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND ! 11: * INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A ! 12: * PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE ! 13: * PRACTICE. ! 14: * ! 15: * The Sun X Drivers are provided with no support and without any obligation ! 16: * on the part of Sun Microsystems, Inc. to assist in their use, correction, ! 17: * modification or enhancement. ! 18: * ! 19: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE ! 20: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THE SUN X ! 21: * DRIVERS OR ANY PART THEREOF. ! 22: * ! 23: * In no event will Sun Microsystems, Inc. be liable for any lost revenue ! 24: * or profits or other special, indirect and consequential damages, even if ! 25: * Sun has been advised of the possibility of such damages. ! 26: * ! 27: * Sun Microsystems, Inc. ! 28: * 2550 Garcia Avenue ! 29: * Mountain View, California 94043 ! 30: */ ! 31: ! 32: #ifndef lint ! 33: static char sccsid[] = "@(#)text.c 2.1 86/01/28 Copyright 1986 Sun Micro"; ! 34: #endif ! 35: ! 36: /*- ! 37: * Copyright (c) 1986 by Sun Microsystems, Inc. ! 38: */ ! 39: ! 40: /* ! 41: * ToDo: ! 42: * Color ! 43: */ ! 44: ! 45: #include "Xsun.h" ! 46: #ifndef stdin ! 47: #include <stdio.h> ! 48: #endif ! 49: #include <pixrect/memreg.h> ! 50: #include <pixrect/cg2reg.h> ! 51: ! 52: /* I've put in some rather ugly hacks, in the name of performance. The ! 53: global variables private_* are really extra parameters to the batchrop ! 54: routines. I did this, rather than adding parameters, because I wanted to ! 55: do the least violence to the "official" specs of batchrop -- this way X ! 56: will vaguely work on displays that don't use one of the tuned batchrops. ! 57: JAG */ ! 58: ! 59: int private_fgcolor, private_bgcolor, private_czmask; ! 60: ! 61: extern struct pixrect *PixRect; ! 62: ! 63: PrintText(string, strlen, font, fore, back, charpad, spacepad, dstx, dsty, ! 64: clips, clipcount, func, zmask) ! 65: register unsigned char *string; ! 66: FONT *font; ! 67: int strlen, fore, back, charpad, spacepad, dstx, dsty; ! 68: CLIP *clips; ! 69: int clipcount, zmask; ! 70: int func; ! 71: { ! 72: extern CURSOR *CurrentCursor; ! 73: extern CursorDisplayed; ! 74: int cleft, ctop, cwidth, cheight; ! 75: int op; ! 76: extern char FBMap[]; ! 77: #define CHUNK 400 ! 78: unsigned char *limit = string + (strlen < CHUNK ? strlen : CHUNK); ! 79: register w = 0; ! 80: static struct pr_prpos bat[CHUNK]; ! 81: int bsize = 0; ! 82: int lheight; ! 83: int sbot, sright; ! 84: ! 85: private_czmask = zmask; ! 86: private_fgcolor = fore; ! 87: private_bgcolor = back; ! 88: if (fore & 1) ! 89: func += 0x20; ! 90: if (back & 1) ! 91: func += 0x10; ! 92: func = FBMap[func]; ! 93: #ifdef notdef ! 94: op = SUN_FROM_X_OP(func) /* | PIX_COLOR(fore) */ ; ! 95: #else ! 96: op = SUN_FROM_X_OP(func) | PIX_COLOR(fore); ! 97: #endif ! 98: { ! 99: register struct pixfont *pf = (struct pixfont *) font->data; ! 100: register struct pr_prpos *p = bat; ! 101: lheight = pf->pf_defaultsize.y; ! 102: if (charpad == 0 && spacepad == 0) ! 103: while (string < limit) { ! 104: register struct pixchar *pc = &(pf->pf_char[*string++]); ! 105: if (pc == 0 || pc->pc_pr == NULL) ! 106: continue; ! 107: p->pr = pc->pc_pr; ! 108: p->pos.x = pc->pc_adv.x; ! 109: w += p->pos.x; ! 110: p++; ! 111: bsize++; ! 112: } ! 113: else { ! 114: struct pixchar *space = &pf->pf_char[font->space]; ! 115: while (string < limit) { ! 116: register struct pixchar *pc = &(pf->pf_char[*string++]); ! 117: if (pc == 0 || pc->pc_pr == NULL) ! 118: continue; ! 119: p->pr = pc->pc_pr; ! 120: p->pos.x = pc->pc_adv.x + charpad; ! 121: if (pc == space) ! 122: p->pos.x += spacepad; ! 123: w += p->pos.x; ! 124: p++; ! 125: bsize++; ! 126: } ! 127: } ! 128: } ! 129: sbot = dsty + lheight; ! 130: sright = dstx + w; ! 131: if (CursorDisplayed) { ! 132: extern DEVICE *CurrentDevice; ! 133: register vsCursor *ms = CurrentDevice->mouse; ! 134: register CURSOR *cs = CurrentCursor; ! 135: if (ms->y < sbot && ms->x < sright ! 136: && ms->y + cs->height > dsty ! 137: && ms->x + cs->width > dstx) ! 138: DisplayCursor(NULL); ! 139: } ! 140: do { ! 141: GetNextClip(clips, cleft, ctop, cwidth, cheight); ! 142: if (dsty >= ctop && sbot <= ctop + cheight ! 143: && dstx >= cleft && sright <= cleft + cwidth) ! 144: pr_batchrop(PixRect, dstx - bat[0].pos.x, dsty, ! 145: op | PIX_DONTCLIP, bat, bsize); ! 146: else { ! 147: struct pixrect *region; ! 148: if (dsty > ctop + cheight) ! 149: continue; ! 150: if (dsty + lheight <= ctop) ! 151: continue; ! 152: region = pr_region(PixRect, cleft, ctop, cwidth, cheight); ! 153: pr_batchrop(region, dstx - cleft - bat[0].pos.x, ! 154: dsty - ctop, ! 155: op, bat, bsize); ! 156: pr_destroy(region); ! 157: } ! 158: } while (--clipcount > 0); ! 159: if (!CursorDisplayed) ! 160: DisplayCursor(CurrentCursor); ! 161: } ! 162: ! 163: PrintTextMask(string, strlen, font, srcpix, charpad, spacepad, dstx, dsty, ! 164: clips, clipcount, func, zmask) ! 165: unsigned char *string; ! 166: FONT *font; ! 167: int strlen, srcpix, charpad, spacepad, dstx, dsty; ! 168: CLIP *clips; ! 169: int clipcount, zmask; ! 170: register int func; ! 171: { ! 172: extern CURSOR *CurrentCursor; ! 173: extern CursorDisplayed; ! 174: int cleft, ctop, cwidth, cheight; ! 175: int op; ! 176: extern char SSMap[]; ! 177: #define CHUNK 400 ! 178: unsigned char *limit = string + (strlen < CHUNK ? strlen : CHUNK); ! 179: register w = 0; ! 180: static struct pr_prpos bat[CHUNK]; ! 181: int bsize = 0; ! 182: int lheight; ! 183: int sbot, sright; ! 184: ! 185: ! 186: SetZmask(PixRect, &zmask); ! 187: private_bgcolor = -1; ! 188: private_fgcolor = srcpix; ! 189: if (PixRect->pr_depth == 1) { ! 190: if ((srcpix & 1) == 0) ! 191: func += 0x10; ! 192: op = SUN_FROM_X_OP(SSMap[func]) & PIX_SRC | PIX_NOT(PIX_SRC) & PIX_DST; ! 193: } ! 194: else ! 195: op = SUN_FROM_X_OP(func); ! 196: if (PixRect->pr_depth > 1) ! 197: op |= PIX_COLOR(srcpix); ! 198: { ! 199: register struct pixfont *pf = (struct pixfont *) font->data; ! 200: register struct pr_prpos *p = bat; ! 201: lheight = pf->pf_defaultsize.y; ! 202: if (charpad == 0 && spacepad == 0) ! 203: while (string < limit) { ! 204: register struct pixchar *pc = &(pf->pf_char[*string++]); ! 205: if (pc == 0) ! 206: continue; ! 207: p->pr = pc->pc_pr; ! 208: p->pos.x = pc->pc_adv.x; ! 209: w += p->pos.x; ! 210: p++; ! 211: bsize++; ! 212: } ! 213: else { ! 214: struct pixchar *space = &pf->pf_char[font->space]; ! 215: while (string < limit) { ! 216: register struct pixchar *pc = &(pf->pf_char[*string++]); ! 217: if (pc == 0) ! 218: continue; ! 219: p->pr = pc->pc_pr; ! 220: p->pos.x = pc->pc_adv.x + charpad; ! 221: if (pc == space) ! 222: p->pos.x += spacepad; ! 223: w += p->pos.x; ! 224: p++; ! 225: bsize++; ! 226: } ! 227: } ! 228: } ! 229: sbot = dsty + lheight; ! 230: sright = dstx + w; ! 231: if (CursorDisplayed) { ! 232: extern DEVICE *CurrentDevice; ! 233: register vsCursor *ms = CurrentDevice->mouse; ! 234: register CURSOR *cs = CurrentCursor; ! 235: if (ms->y < sbot && ms->x < sright ! 236: && ms->y + cs->height > dsty ! 237: && ms->x + cs->width > dstx) ! 238: DisplayCursor(NULL); ! 239: } ! 240: do { ! 241: GetNextClip(clips, cleft, ctop, cwidth, cheight); ! 242: if (dsty >= ctop && sbot <= ctop + cheight ! 243: && dstx >= cleft && sright <= cleft + cwidth) ! 244: pr_batchrop(PixRect, dstx - bat[0].pos.x, dsty, ! 245: op | PIX_DONTCLIP, bat, bsize); ! 246: else { ! 247: struct pixrect *region; ! 248: if (dsty > ctop + cheight) ! 249: continue; ! 250: if (dsty + lheight <= ctop) ! 251: continue; ! 252: region = pr_region(PixRect, cleft, ctop, cwidth, cheight); ! 253: pr_batchrop(region, dstx - cleft - bat[0].pos.x, ! 254: dsty - ctop, ! 255: op, bat, bsize); ! 256: pr_destroy(region); ! 257: } ! 258: } while (--clipcount > 0); ! 259: if (!CursorDisplayed) ! 260: DisplayCursor(CurrentCursor); ! 261: { ! 262: static allmask = -1; ! 263: SetZmask(PixRect, &allmask); ! 264: } ! 265: } ! 266: ! 267: ! 268: /* ! 269: * Copyright (c) 1983 by Sun Microsystems, Inc. ! 270: */ ! 271: ! 272: /* ! 273: * Memory batchrop ! 274: */ ! 275: ! 276: ! 277: extern char pr_reversedst[]; ! 278: extern struct pixrectops mem_ops; ! 279: ! 280: ! 281: ! 282: #define MEMBATCH(IfClip, IfMask, op, IfReverse) \ ! 283: for (; --count >= 0; src++) { \ ! 284: dst.pos.x += src->pos.x; \ ! 285: dp = dp0 + (((dskew = xoff0 + dst.pos.x) >> 3) & ~1); \ ! 286: dskew &= 0xF; \ ! 287: spr = src->pr; \ ! 288: sizex = spr->pr_size.x; \ ! 289: sizey = spr->pr_size.y; \ ! 290: sprd = mpr_d(spr); \ ! 291: if (sprd->md_linebytes != 2) \ ! 292: goto hard; \ ! 293: sp = (u_short *) sprd->md_image; \ ! 294: IfClip( if (dst.pos.x + sizex > limx) \ ! 295: goto hard; \ ! 296: if (dst.pos.y + sizey > limy) \ ! 297: sizey = limy - dst.pos.y; \ ! 298: if (dst.pos.x < 0) \ ! 299: goto hard; \ ! 300: if (dst.pos.y < 0) { \ ! 301: sizey += dst.pos.y; \ ! 302: sp -= dst.pos.y; \ ! 303: dp -= pr_product(dst.pos.y, vert); \ ! 304: } \ ! 305: if (sizex <= 0) \ ! 306: continue; \ ! 307: ,) \ ! 308: if (--sizey>=0) \ ! 309: if (dskew + sizex <= 16) { \ ! 310: IfMask( register short mask; \ ! 311: mask = 0x8000; \ ! 312: sizex -= 1; \ ! 313: mask >>= sizex; \ ! 314: ((unsigned short) mask) >>= dskew; \ ! 315: IfReverse(mask = ~mask;,),) \ ! 316: do { \ ! 317: IfMask(*(u_short *) dp IfReverse(&,|)= mask;,) \ ! 318: *(u_short *) dp op (*sp++ >> dskew); \ ! 319: dp += vert; \ ! 320: } while (--sizey != -1); \ ! 321: } \ ! 322: else { \ ! 323: IfMask( register long mask; \ ! 324: mask = 0x80000000; \ ! 325: sizex -= 1; \ ! 326: mask >>= sizex; \ ! 327: ((unsigned long) mask) >>= dskew; \ ! 328: IfReverse(mask = ~mask;,),) \ ! 329: dskew = 16 - dskew; \ ! 330: do { \ ! 331: IfMask(*(u_int *) dp IfReverse(&,|)= mask;,) \ ! 332: *(u_int *) dp op (*sp++ << dskew); \ ! 333: dp += vert; \ ! 334: } while (--sizey != -1); \ ! 335: } \ ! 336: } ! 337: ! 338: #define MTRUE(a,b) a ! 339: #define MFALSE(a,b) b ! 340: ! 341: #define ClippedOp(mask,op,revmask) \ ! 342: if(clip) MEMBATCH(MTRUE,mask,op,revmask) \ ! 343: else MEMBATCH(MFALSE,mask,op,revmask) ! 344: ! 345: mem_batchrop(dst, op, src, count) ! 346: struct pr_prpos dst; ! 347: int op; ! 348: struct pr_prpos *src; ! 349: short count; ! 350: { ! 351: register u_short *sp; ! 352: register char *dp; ! 353: char *dp0; ! 354: register char *handy; ! 355: register short sizex, sizey; ! 356: register vert, dskew; ! 357: int dskew0, xoff0; ! 358: int errors = 0; ! 359: int clip, limx, limy; ! 360: int oppassed = op; ! 361: ! 362: /* ! 363: * Preliminaries: get pixrect data and image pointers; decide whether ! 364: * clipping. If not clipping, normalize op, else compute limits for ! 365: * cursors for later comparisons. ! 366: */ ! 367: ! 368: clip = 0; ! 369: if (!(op & PIX_DONTCLIP)) { ! 370: clip = 1; ! 371: limx = dst.pr->pr_size.x; ! 372: limy = dst.pr->pr_size.y; ! 373: } ! 374: op = (op >> 1) & 0xf; /* Kill dontclip, just keep useful */ ! 375: /* ! 376: * If destination is reverse video, invert function. FIXME: we dont ! 377: * deal with a reverse video source. Admittedly its unlikely that ! 378: * anyone will call batchrop with a device pixrect as source (since we ! 379: * copy the whole pixrect), but this is a bug. ! 380: */ ! 381: if (mpr_d(dst.pr)->md_flags & MP_REVERSEVIDEO) ! 382: op = pr_reversedst[op]; ! 383: ! 384: vert = mpr_d(dst.pr)->md_linebytes; ! 385: #define dprd ((struct mpr_data *)handy) ! 386: dprd = mpr_d(dst.pr); ! 387: xoff0 = dprd->md_offset.x; ! 388: dp0 = (char *) ((int) dprd->md_image ! 389: + pr_product(dprd->md_linebytes, ! 390: dst.pos.y + dprd->md_offset.y)); ! 391: #undef dprd ! 392: restart: ! 393: #define spr ((struct pixrect *)handy) ! 394: #define sprd ((struct mpr_data *)handy) ! 395: switch (op) { ! 396: case (PIX_SRC ^ PIX_DST) >> 1: ! 397: ClippedOp(MFALSE, ^=, MTRUE); ! 398: break; ! 399: case PIX_SRC >> 1: ! 400: ClippedOp(MTRUE, |=, MTRUE); ! 401: break; ! 402: case PIX_NOT(PIX_SRC) >> 1: ! 403: ClippedOp(MTRUE, ^=, MFALSE); ! 404: break; ! 405: case (PIX_SRC | PIX_DST) >> 1: ! 406: ClippedOp(MFALSE, |=, MTRUE); ! 407: break; ! 408: case (PIX_NOT(PIX_SRC) & PIX_DST) >> 1: ! 409: ClippedOp(MFALSE, &=~, MTRUE); ! 410: break; ! 411: default: ! 412: for (; --count >= 0; src++) { ! 413: dst.pos.x += src->pos.x; ! 414: errors |= mem_rop(dst.pr, dst.pos, src->pr->pr_size, ! 415: oppassed, src->pr, 0, 0); ! 416: } ! 417: } ! 418: return errors; ! 419: hard: ! 420: if (dst.pos.x + sizex <= 0) ! 421: /* ! 422: * Completely clipped on left... ! 423: */ ! 424: ; ! 425: else { ! 426: errors |= mem_rop(dst.pr, dst.pos, src->pr->pr_size, ! 427: oppassed, src->pr, 0, 0); ! 428: } ! 429: src++; ! 430: goto restart; ! 431: } ! 432: ! 433: /* ! 434: * cg2batch.c: Sun2 Color batchrop ! 435: */ ! 436: ! 437: extern struct pixrectops mem_ops; ! 438: ! 439: ! 440: extern short mrc_lmasktable[]; ! 441: extern short mrc_rmasktable[]; ! 442: ! 443: #define resolution unused, 0 ! 444: ! 445: cg2_batchrop(dst, op, src, count) ! 446: struct pr_prpos dst; ! 447: int op; ! 448: struct pr_prpos *src; ! 449: register int count; ! 450: { ! 451: register short sizey; ! 452: register int tem, w, prime, linebytes; ! 453: register short *bx, *leftx, *ma; ! 454: register struct memropc *ropregs; ! 455: short sizex; ! 456: int clip; ! 457: struct pixrect *pr; ! 458: short *ma_homey; ! 459: short homex, homey, limx, limy, dstx, dsty, by; ! 460: ! 461: struct cg2fb *fb; ! 462: struct mpr_data *md; ! 463: int oppassed = op; ! 464: int errors = 0; ! 465: short color; ! 466: ! 467: if (count <= 0) ! 468: return (0); ! 469: ! 470: /* ! 471: * Preliminaries: get pixrect data and frame buffer pointers; decide ! 472: * whether clipping. If not clipping, normalize op, else compute ! 473: * limits for cursors for later comparisons. ! 474: */ ! 475: #define dbd ((struct cg2pr *)leftx) ! 476: dbd = cg2_d(dst.pr); ! 477: homex = dbd->cgpr_offset.x; ! 478: homey = dbd->cgpr_offset.y; ! 479: #define FB ((struct cg2fb *)leftx) ! 480: FB = dbd->cgpr_va; ! 481: fb = FB; ! 482: #undef dbd ! 483: ropregs = &FB->ropcontrol[CG2_ALLROP].ropregs; ! 484: if (op & PIX_DONTCLIP) { ! 485: op &= ~PIX_DONTCLIP; ! 486: clip = 0; ! 487: } ! 488: else { ! 489: clip = 1; ! 490: limx = homex + dst.pr->pr_size.x; ! 491: limy = homey + dst.pr->pr_size.y; ! 492: } ! 493: dstx = homex + dst.pos.x; ! 494: dsty = homey + dst.pos.y; ! 495: if (private_bgcolor < 0) { ! 496: FB->ppmask.reg = private_fgcolor; /* set colored text */ ! 497: ropregs->mrc_pattern = -1; ! 498: FB->ppmask.reg = ~private_fgcolor; ! 499: ropregs->mrc_pattern = 0; ! 500: FB->ppmask.reg = private_czmask; ! 501: switch (op & 0x1E) { ! 502: case PIX_SRC ^ PIX_DST: ! 503: ropregs->mrc_op = CG_SRC & (CG_MASK ^ CG_DEST) | ~CG_SRC & CG_DEST; ! 504: break; ! 505: case PIX_NOT(PIX_DST): ! 506: ropregs->mrc_op = CG_SRC & (~CG_DEST) | ~CG_SRC & CG_DEST; ! 507: break; ! 508: default: ! 509: ropregs->mrc_op = CG_SRC & CG_MASK | ~CG_SRC & CG_DEST; ! 510: break; ! 511: } ! 512: } ! 513: else { ! 514: FB->ppmask.reg = private_fgcolor & private_bgcolor; ! 515: ropregs->mrc_op = ~0; ! 516: FB->ppmask.reg = ~(private_fgcolor | private_bgcolor); ! 517: ropregs->mrc_op = 0; ! 518: FB->ppmask.reg = private_fgcolor & ~private_bgcolor; ! 519: ropregs->mrc_op = CG_SRC; ! 520: FB->ppmask.reg = ~private_fgcolor & private_bgcolor; ! 521: ropregs->mrc_op = ~CG_SRC; ! 522: FB->ppmask.reg = private_czmask; ! 523: } ! 524: FB->status.reg.ropmode = PWWWRD; ! 525: linebytes = cg2_linebytes(FB, PWWWRD); ! 526: #undef FB ! 527: ! 528: for (; --count >= 0; src++) { ! 529: /* ! 530: * Update destination x and y by pre-advance amount. If no pixrect ! 531: * for this, then skip to next. ! 532: */ ! 533: dstx += src->pos.x; ! 534: pr = src->pr; ! 535: if (pr == 0) ! 536: continue; ! 537: sizex = pr->pr_size.x; ! 538: sizey = pr->pr_size.y; ! 539: md = mpr_d(pr); ! 540: ma = md->md_image; ! 541: ! 542: /* ! 543: * Grab sizes and address of image. If clipping (rare case ! 544: * hopefully) compare cursors against limits. ! 545: */ ! 546: by = dsty; ! 547: tem = 0; ! 548: if (clip) { ! 549: if (dstx + sizex > limx) ! 550: sizex = limx - dstx; ! 551: if (dsty + sizey > limy) ! 552: sizey = limy - dsty; ! 553: if (dsty < homey) { /* works if pr_depth = 1! */ ! 554: tem = homey - dsty; ! 555: by += tem; ! 556: ma += pr_product(tem, (md->md_linebytes >> 1)); ! 557: sizey -= tem; ! 558: tem = 0; ! 559: } ! 560: if (dstx < homex) { ! 561: tem = homex - dstx; ! 562: ma += tem >> 4; ! 563: sizex -= tem; ! 564: } ! 565: if (sizex <= 0) ! 566: continue; ! 567: } ! 568: ! 569: /* ! 570: * Hard case: characters greater than 16 wide. ! 571: */ ! 572: ma_homey = ma; ! 573: ! 574: /* set the ROP chip word width and opcount */ ! 575: ! 576: w = cg2_prskew(dstx); /* source skew is 0 */ ! 577: ropregs->mrc_shift = (w & 0xF) | (1 << 8); ! 578: prime = !w; ! 579: w = (sizex + w + (tem & 0xF) - 1) >> 4; ! 580: ropregs->mrc_width = w; ! 581: ropregs->mrc_opcount = w; ! 582: ! 583: /* set the ROP chip end masks */ ! 584: ! 585: ropregs->mrc_mask1 = ! 586: mrc_lmasktable[(tem += dstx) & 0xf]; ! 587: ropregs->mrc_mask2 = ! 588: mrc_rmasktable[(sizex + tem - 1) & 0xf]; ! 589: ! 590: leftx = cg2_ropwordaddr(fb, 0, tem, by); ! 591: tem = md->md_linebytes; ! 592: if (--sizey >= 0) ! 593: if (w) { ! 594: w++; ! 595: do { ! 596: register short i = w; ! 597: ma = ma_homey; ! 598: bx = leftx; ! 599: if (prime) ! 600: ropregs->mrc_source1 = *ma++; ! 601: while (i--) ! 602: *bx++ = *ma++; ! 603: (char *) ma_homey += tem; ! 604: (char *) leftx += linebytes; ! 605: } while (--sizey != -1); ! 606: } ! 607: else { ! 608: bx = leftx; ! 609: ma = ma_homey; ! 610: if (prime) { ! 611: ma++; ! 612: do { ! 613: ma--; ! 614: ropregs->mrc_source1 = *ma++; ! 615: *bx = *ma; ! 616: (char *) ma += tem; ! 617: (char *) bx += linebytes; ! 618: } while (--sizey != -1); ! 619: } ! 620: else ! 621: do { ! 622: *bx = *ma; ! 623: (char *) ma += tem; ! 624: (char *) bx += linebytes; ! 625: } while (--sizey != -1); ! 626: } ! 627: } ! 628: ! 629: return (errors); ! 630: } ! 631: ! 632: #endif sun
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.