Return to fasttext.c CVS log

Up to [Atari MiNT] / MiNT / src

Annotation of MiNT/src/fasttext.c, revision 1.1

1.1     ! root        1: #include "mint.h"
        !             2: 
        !             3: #include "fasttext.h"
        !             4: 
        !             5: 
        !             6: 
        !             7: #ifdef FASTTEXT
        !             8: 
        !             9: 
        !            10: 
        !            11: #ifdef __GNUC__
        !            12: 
        !            13: #define INLINE inline
        !            14: 
        !            15: #define ITYPE long     /* gcc's optimizer likes 32 bit integers */
        !            16: 
        !            17: #else
        !            18: 
        !            19: #define INLINE
        !            20: 
        !            21: #define ITYPE int
        !            22: 
        !            23: #endif
        !            24: 
        !            25: 
        !            26: 
        !            27: #define CONDEV (2)
        !            28: 
        !            29: 
        !            30: 
        !            31: static SCREEN *current;
        !            32: 
        !            33: 
        !            34: 
        !            35: static void paint P_((SCREEN *, int, char *)),
        !            36: 
        !            37:         paint8c P_((SCREEN *, int, char *)),
        !            38: 
        !            39:         paint16m P_((SCREEN *, int, char *));
        !            40: 
        !            41: 
        !            42: 
        !            43: INLINE static void curs_off P_((SCREEN *)), curs_on P_((SCREEN *));
        !            44: 
        !            45: INLINE static void flash P_((SCREEN *));
        !            46: 
        !            47: static void normal_putch P_((SCREEN *, int));
        !            48: 
        !            49: static void escy_putch P_((SCREEN *, int));
        !            50: 
        !            51: 
        !            52: 
        !            53: static char *chartab[256];
        !            54: 
        !            55: 
        !            56: 
        !            57: static long scrnsize;
        !            58: 
        !            59: 
        !            60: 
        !            61: short hardscroll;
        !            62: 
        !            63: static char *hardbase, *oldbase;
        !            64: 
        !            65: 
        !            66: 
        !            67: typedef void (*Vfunc) P_((SCREEN *, int));
        !            68: 
        !            69: 
        !            70: 
        !            71: #define base *((char **)0x44eL)
        !            72: 
        !            73: #define escy1 *((short *)0x4acL)
        !            74: 
        !            75: 
        !            76: 
        !            77: static Vfunc state;
        !            78: 
        !            79: 
        !            80: 
        !            81: static short hardline;
        !            82: 
        !            83: static void (*vpaint) P_((SCREEN *, int, char *));
        !            84: 
        !            85: 
        !            86: 
        !            87: void init P_((void));
        !            88: 
        !            89: void hardware_scroll P_((SCREEN *));
        !            90: 
        !            91: INLINE static char *PLACE P_((SCREEN *, int, int));
        !            92: 
        !            93: INLINE static void gotoxy P_((SCREEN *, int, int));
        !            94: 
        !            95: INLINE static void clrline P_((SCREEN *, int));
        !            96: 
        !            97: INLINE static void clear P_((SCREEN *));
        !            98: 
        !            99: INLINE static void clrchar P_((SCREEN *, int, int));
        !           100: 
        !           101: INLINE static void clrfrom P_((SCREEN *, int, int, int, int));
        !           102: 
        !           103: INLINE static void delete_line P_((SCREEN *, int));
        !           104: 
        !           105: INLINE static void insert_line P_((SCREEN *, int));
        !           106: 
        !           107: static void setbgcol P_((SCREEN *, int));
        !           108: 
        !           109: static void setfgcol P_((SCREEN *, int));
        !           110: 
        !           111: static void putesc P_((SCREEN *, int));
        !           112: 
        !           113: static void escy1_putch P_((SCREEN *, int));
        !           114: 
        !           115: INLINE static void put_ch P_((SCREEN *, int));
        !           116: 
        !           117: 
        !           118: 
        !           119: /* routines for flashing the cursor for screen v */
        !           120: 
        !           121: /* flash(v): invert the character currently under the cursor */
        !           122: 
        !           123: 
        !           124: 
        !           125: INLINE static void
        !           126: 
        !           127: flash(v)
        !           128: 
        !           129:        SCREEN *v;
        !           130: 
        !           131: {
        !           132: 
        !           133:        char *place, d;
        !           134: 
        !           135:        ITYPE i, j, vplanes;
        !           136: 
        !           137: 
        !           138: 
        !           139:        vplanes = v->planes + v->planes;
        !           140: 
        !           141:        place = v->cursaddr;
        !           142: 
        !           143: 
        !           144: 
        !           145:        for (j = v->cheight; j > 0; --j) {
        !           146: 
        !           147:                d = (*place) ^ 0xff;
        !           148: 
        !           149:                for (i = 0; i < vplanes; i+=2)
        !           150: 
        !           151:                        place[i] = d;
        !           152: 
        !           153: 
        !           154: 
        !           155:                place += v->planesiz;
        !           156: 
        !           157:        }
        !           158: 
        !           159: }
        !           160: 
        !           161: 
        !           162: 
        !           163: /* make sure the cursor is off */
        !           164: 
        !           165: 
        !           166: 
        !           167: INLINE
        !           168: 
        !           169: static void
        !           170: 
        !           171: curs_off(v)
        !           172: 
        !           173:        SCREEN *v;
        !           174: 
        !           175: {
        !           176: 
        !           177:        if (v->flags & CURS_ON) {
        !           178: 
        !           179:                if (v->flags & CURS_FSTATE) {
        !           180: 
        !           181:                        flash(v);
        !           182: 
        !           183:                        v->flags &= ~CURS_FSTATE;
        !           184: 
        !           185:                }
        !           186: 
        !           187:        }
        !           188: 
        !           189: }
        !           190: 
        !           191: 
        !           192: 
        !           193: /* OK, show the cursor again (if appropriate) */
        !           194: 
        !           195: 
        !           196: 
        !           197: INLINE static void
        !           198: 
        !           199: curs_on(v)
        !           200: 
        !           201:        SCREEN *v;
        !           202: 
        !           203: {
        !           204: 
        !           205:        if (v->hidecnt) return;
        !           206: 
        !           207: 
        !           208: 
        !           209:        if (v->flags & CURS_ON) {
        !           210: 
        !           211:        /* if the cursor is flashing, we cheat a little and leave it off
        !           212: 
        !           213:         * to be turned on again (if necessary) by the VBL routine
        !           214: 
        !           215:         */
        !           216: 
        !           217:                if (v->flags & CURS_FLASH) {
        !           218: 
        !           219:                        v->curstimer = 2;
        !           220: 
        !           221:                        return;
        !           222: 
        !           223:                }
        !           224: 
        !           225:                if (!(v->flags & CURS_FSTATE)) {
        !           226: 
        !           227:                        v->flags |= CURS_FSTATE;
        !           228: 
        !           229:                        flash(v);
        !           230: 
        !           231:                }
        !           232: 
        !           233:        }
        !           234: 
        !           235: }
        !           236: 
        !           237: 
        !           238: 
        !           239: void
        !           240: 
        !           241: init()
        !           242: 
        !           243: {
        !           244: 
        !           245:        SCREEN *v;
        !           246: 
        !           247:        int i, j;
        !           248: 
        !           249:        char *data, *foo;
        !           250: 
        !           251:        static char chardata[256*16];
        !           252: 
        !           253: 
        !           254: 
        !           255:        foo = lineA0();
        !           256: 
        !           257:        v = (SCREEN *)(foo - 346);
        !           258: 
        !           259:        
        !           260: 
        !           261:        /* Ehem... The screen might be bigger than 32767 bytes.
        !           262: 
        !           263:           Let's do some casting... 
        !           264: 
        !           265:           Erling
        !           266: 
        !           267:        */
        !           268: 
        !           269:        scrnsize = (v->maxy+1)*(long)v->linelen;
        !           270: 
        !           271:        if (hardscroll > 0) {
        !           272: 
        !           273:                if (!hardbase)
        !           274: 
        !           275:                    hardbase = (char *)(((long)kcore(SCNSIZE(v)+256L)+255L)
        !           276: 
        !           277:                                           & 0xffffff00L);
        !           278: 
        !           279: 
        !           280: 
        !           281:                if (hardbase == 0) {
        !           282: 
        !           283:                        ALERT("Insufficient memory for hardware scrolling!");
        !           284: 
        !           285:                } else {
        !           286: 
        !           287:                        quickmove(hardbase, base, scrnsize);
        !           288: 
        !           289:                        v->cursaddr = v->cursaddr + (hardbase - base);
        !           290: 
        !           291:                        oldbase = base;
        !           292: 
        !           293:                        base = hardbase;
        !           294: 
        !           295:                        Setscreen(hardbase, hardbase, -1);
        !           296: 
        !           297:                }
        !           298: 
        !           299:        }
        !           300: 
        !           301:        hardline = 0;
        !           302: 
        !           303:        if (v->cheight == 8 && v->planes == 2) {
        !           304: 
        !           305:                foo = &chardata[0];
        !           306: 
        !           307:                vpaint = paint8c;
        !           308: 
        !           309:                for (i = 0; i < 256; i++) {
        !           310: 
        !           311:                        chartab[i] = foo;
        !           312: 
        !           313:                        data = v->fontdata + i;
        !           314: 
        !           315:                        for (j = 0; j < 8; j++) {
        !           316: 
        !           317:                                *foo++ = *data;
        !           318: 
        !           319:                                data += v->form_width;
        !           320: 
        !           321:                        }
        !           322: 
        !           323:                }
        !           324: 
        !           325:        } else if (v->cheight == 16 && v->planes == 1) {
        !           326: 
        !           327:                foo = &chardata[0];
        !           328: 
        !           329:                vpaint = paint16m;
        !           330: 
        !           331:                for (i = 0; i < 256; i++) {
        !           332: 
        !           333:                        chartab[i] = foo;
        !           334: 
        !           335:                        data = v->fontdata + i;
        !           336: 
        !           337:                        for (j = 0; j < 16; j++) {
        !           338: 
        !           339:                                *foo++ = *data;
        !           340: 
        !           341:                                data += v->form_width;
        !           342: 
        !           343:                        }
        !           344: 
        !           345:                }
        !           346: 
        !           347:        }
        !           348: 
        !           349:        else
        !           350: 
        !           351:                vpaint = paint;
        !           352: 
        !           353: 
        !           354: 
        !           355:        if (v->hidecnt == 0) {
        !           356: 
        !           357:        /*
        !           358: 
        !           359:         * make sure the cursor is set up correctly and turned on
        !           360: 
        !           361:         */
        !           362: 
        !           363:                (void)Cursconf(0,0);    /* turn cursor off */
        !           364: 
        !           365: 
        !           366: 
        !           367:                v->flags &= ~(CURS_FLASH|CURS_FSTATE);
        !           368: 
        !           369: 
        !           370: 
        !           371:        /* now turn the cursor on the way we like it */
        !           372: 
        !           373:                v->hidecnt = 0;
        !           374: 
        !           375:                curs_on(v);
        !           376: 
        !           377:        } else {
        !           378: 
        !           379:                (void)Cursconf(0,0);
        !           380: 
        !           381:                v->flags &= ~CURS_ON;
        !           382: 
        !           383:                v->hidecnt = 1;
        !           384: 
        !           385:        }
        !           386: 
        !           387: 
        !           388: 
        !           389:        current = v;
        !           390: 
        !           391:        state = normal_putch;
        !           392: 
        !           393: }
        !           394: 
        !           395: 
        !           396: 
        !           397: /*
        !           398: 
        !           399:  * PLACE(v, x, y): the address corresponding to the upper left hand corner of
        !           400: 
        !           401:  * the character at position (x,y) on screen v
        !           402: 
        !           403:  */
        !           404: 
        !           405: INLINE static
        !           406: 
        !           407: char *PLACE(v, x, y)
        !           408: 
        !           409:        SCREEN *v;
        !           410: 
        !           411:        int x, y;
        !           412: 
        !           413: {
        !           414: 
        !           415:        char *place;
        !           416: 
        !           417:        int i, j;
        !           418: 
        !           419: 
        !           420: 
        !           421:        place = base + x;
        !           422: 
        !           423:        if (y == v->maxy)
        !           424: 
        !           425:                place += scrnsize - v->linelen;
        !           426: 
        !           427:        else if (y) /* Yo, the screen might be bigger than 32767 bytes...
        !           428: 
        !           429:                       Do a cast to long.       Erling. */
        !           430: 
        !           431:                place += (long)y * v->linelen;
        !           432: 
        !           433: 
        !           434: 
        !           435:        if ((j = v->planes) > 1) {
        !           436: 
        !           437:                i = (x & 0xfffe);
        !           438: 
        !           439:                while (--j > 0)
        !           440: 
        !           441:                        place += i;
        !           442: 
        !           443:        }
        !           444: 
        !           445:        return place;
        !           446: 
        !           447: }
        !           448: 
        !           449: 
        !           450: 
        !           451: /*
        !           452: 
        !           453:  * paint(v, c, place): put character 'c' at position 'place' on screen
        !           454: 
        !           455:  * v. It is assumed that x, y are proper coordinates!
        !           456: 
        !           457:  * Specialized versions (paint8c and paint16m) of this routine follow;
        !           458: 
        !           459:  * they assume 8 line high characters, medium res. and 16 line/mono,
        !           460: 
        !           461:  * respectively.
        !           462: 
        !           463:  */
        !           464: 
        !           465: 
        !           466: 
        !           467: static void
        !           468: 
        !           469: paint(v, c, place)
        !           470: 
        !           471:        SCREEN *v;
        !           472: 
        !           473:        int c;
        !           474: 
        !           475:        char *place;
        !           476: 
        !           477: {
        !           478: 
        !           479:        char *data, d, doinverse;
        !           480: 
        !           481:        ITYPE j, planecount;
        !           482: 
        !           483:        int vplanes;
        !           484: 
        !           485:        long vform_width, vplanesiz;
        !           486: 
        !           487: 
        !           488: 
        !           489:        vplanes = v->planes;
        !           490: 
        !           491: 
        !           492: 
        !           493:        data = v->fontdata + c;
        !           494: 
        !           495:        doinverse = (v->flags & FINVERSE) ? 0xff : 0;
        !           496: 
        !           497:        vform_width = v->form_width;
        !           498: 
        !           499:        vplanesiz = v->planesiz;
        !           500: 
        !           501: 
        !           502: 
        !           503:        for (j = v->cheight; j > 0; --j) {
        !           504: 
        !           505:                d = *data ^ doinverse;
        !           506: 
        !           507:                *place = d;
        !           508: 
        !           509:                if (vplanes > 1) {
        !           510: 
        !           511: /* This should work for an arbitrary number of planes. Erling */
        !           512: 
        !           513:                  for(planecount=1;planecount<vplanes;planecount++) 
        !           514: 
        !           515:                    place[(planecount<<1)]=d;
        !           516: 
        !           517: #if 0
        !           518: 
        !           519:                    {
        !           520: 
        !           521:                        place[2] = d;
        !           522: 
        !           523:                        if (vplanes > 2) {
        !           524: 
        !           525:                                place[4] = place[6] = d;
        !           526: 
        !           527:                        }
        !           528: 
        !           529:                    }
        !           530: 
        !           531: #endif
        !           532: 
        !           533:                }
        !           534: 
        !           535: 
        !           536: 
        !           537:                place += vplanesiz;
        !           538: 
        !           539:                data += vform_width;
        !           540: 
        !           541:        }
        !           542: 
        !           543: 
        !           544: 
        !           545: }
        !           546: 
        !           547: 
        !           548: 
        !           549: static void
        !           550: 
        !           551: paint8c(v, c, place)
        !           552: 
        !           553:        SCREEN *v;
        !           554: 
        !           555:        int c;
        !           556: 
        !           557:        char *place;
        !           558: 
        !           559: {
        !           560: 
        !           561:        char *data;
        !           562: 
        !           563:        char d, doinverse;
        !           564: 
        !           565:        long vplanesiz;
        !           566: 
        !           567: 
        !           568: 
        !           569:        data = chartab[c];
        !           570: 
        !           571: 
        !           572: 
        !           573:        doinverse = (v->flags & FINVERSE) ? 0xff : 0;
        !           574: 
        !           575:        vplanesiz = v->planesiz;
        !           576: 
        !           577: 
        !           578: 
        !           579:        if (!doinverse) {
        !           580: 
        !           581:                /* line 1 */
        !           582: 
        !           583:                d = *data++;
        !           584: 
        !           585:                *place = d;
        !           586: 
        !           587:                place[2] = d;
        !           588: 
        !           589:                place += vplanesiz;
        !           590: 
        !           591: 
        !           592: 
        !           593:                /* line 2 */
        !           594: 
        !           595:                d = *data++;
        !           596: 
        !           597:                *place = d;
        !           598: 
        !           599:                place[2] = d;
        !           600: 
        !           601:                place += vplanesiz;
        !           602: 
        !           603: 
        !           604: 
        !           605:                /* line 3 */
        !           606: 
        !           607:                d = *data++;
        !           608: 
        !           609:                *place = d;
        !           610: 
        !           611:                place[2] = d;
        !           612: 
        !           613:                place += vplanesiz;
        !           614: 
        !           615: 
        !           616: 
        !           617:                /* line 4 */
        !           618: 
        !           619:                d = *data++;
        !           620: 
        !           621:                *place = d;
        !           622: 
        !           623:                place[2] = d;
        !           624: 
        !           625:                place += vplanesiz;
        !           626: 
        !           627: 
        !           628: 
        !           629:                /* line 5 */
        !           630: 
        !           631:                d = *data++;
        !           632: 
        !           633:                *place = d;
        !           634: 
        !           635:                place[2] = d;
        !           636: 
        !           637:                place += vplanesiz;
        !           638: 
        !           639: 
        !           640: 
        !           641:                /* line 6 */
        !           642: 
        !           643:                d = *data++;
        !           644: 
        !           645:                *place = d;
        !           646: 
        !           647:                place[2] = d;
        !           648: 
        !           649:                place += vplanesiz;
        !           650: 
        !           651: 
        !           652: 
        !           653:                /* line 7 */
        !           654: 
        !           655:                d = *data++;
        !           656: 
        !           657:                *place = d;
        !           658: 
        !           659:                place[2] = d;
        !           660: 
        !           661:                place += vplanesiz;
        !           662: 
        !           663: 
        !           664: 
        !           665:                /* line 8 */
        !           666: 
        !           667:                d = *data++;
        !           668: 
        !           669:                *place = d;
        !           670: 
        !           671:                place[2] = d;
        !           672: 
        !           673:                place += vplanesiz;
        !           674: 
        !           675:        } else {
        !           676: 
        !           677:                /* line 1 */
        !           678: 
        !           679:                d = *data++ ^ doinverse;
        !           680: 
        !           681:                *place = d;
        !           682: 
        !           683:                place[2] = d;
        !           684: 
        !           685:                place += vplanesiz;
        !           686: 
        !           687: 
        !           688: 
        !           689:                /* line 2 */
        !           690: 
        !           691:                d = *data++ ^ doinverse;
        !           692: 
        !           693:                *place = d;
        !           694: 
        !           695:                place[2] = d;
        !           696: 
        !           697:                place += vplanesiz;
        !           698: 
        !           699: 
        !           700: 
        !           701:                /* line 3 */
        !           702: 
        !           703:                d = *data++ ^ doinverse;
        !           704: 
        !           705:                *place = d;
        !           706: 
        !           707:                place[2] = d;
        !           708: 
        !           709:                place += vplanesiz;
        !           710: 
        !           711: 
        !           712: 
        !           713:                /* line 4 */
        !           714: 
        !           715:                d = *data++ ^ doinverse;
        !           716: 
        !           717:                *place = d;
        !           718: 
        !           719:                place[2] = d;
        !           720: 
        !           721:                place += vplanesiz;
        !           722: 
        !           723: 
        !           724: 
        !           725:                /* line 5 */
        !           726: 
        !           727:                d = *data++ ^ doinverse;
        !           728: 
        !           729:                *place = d;
        !           730: 
        !           731:                place[2] = d;
        !           732: 
        !           733:                place += vplanesiz;
        !           734: 
        !           735: 
        !           736: 
        !           737:                /* line 6 */
        !           738: 
        !           739:                d = *data++ ^ doinverse;
        !           740: 
        !           741:                *place = d;
        !           742: 
        !           743:                place[2] = d;
        !           744: 
        !           745:                place += vplanesiz;
        !           746: 
        !           747: 
        !           748: 
        !           749:                /* line 7 */
        !           750: 
        !           751:                d = *data++ ^ doinverse;
        !           752: 
        !           753:                *place = d;
        !           754: 
        !           755:                place[2] = d;
        !           756: 
        !           757:                place += vplanesiz;
        !           758: 
        !           759: 
        !           760: 
        !           761:                /* line 8 */
        !           762: 
        !           763:                d = *data++ ^ doinverse;
        !           764: 
        !           765:                *place = d;
        !           766: 
        !           767:                place[2] = d;
        !           768: 
        !           769:                place += vplanesiz;
        !           770: 
        !           771:        }
        !           772: 
        !           773: }
        !           774: 
        !           775: 
        !           776: 
        !           777: static void
        !           778: 
        !           779: paint16m(v, c, place)
        !           780: 
        !           781:        SCREEN *v;
        !           782: 
        !           783:        int c;
        !           784: 
        !           785:        char *place;
        !           786: 
        !           787: {
        !           788: 
        !           789:        char *data;
        !           790: 
        !           791:        char d, doinverse;
        !           792: 
        !           793:        long vplanesiz;
        !           794: 
        !           795: 
        !           796: 
        !           797:        data = chartab[c];
        !           798: 
        !           799:        doinverse = (v->flags & FINVERSE) ? 0xff : 0;
        !           800: 
        !           801:        vplanesiz = v->planesiz;
        !           802: 
        !           803: 
        !           804: 
        !           805:        if (!doinverse) {
        !           806: 
        !           807:                /* line 1 */
        !           808: 
        !           809:                d = *data++;
        !           810: 
        !           811:                *place = d;
        !           812: 
        !           813:                place += vplanesiz;
        !           814: 
        !           815: 
        !           816: 
        !           817:                /* line 2 */
        !           818: 
        !           819:                d = *data++;
        !           820: 
        !           821:                *place = d;
        !           822: 
        !           823:                place += vplanesiz;
        !           824: 
        !           825: 
        !           826: 
        !           827:                /* line 3 */
        !           828: 
        !           829:                d = *data++;
        !           830: 
        !           831:                *place = d;
        !           832: 
        !           833:                place += vplanesiz;
        !           834: 
        !           835: 
        !           836: 
        !           837:                /* line 4 */
        !           838: 
        !           839:                d = *data++;
        !           840: 
        !           841:                *place = d;
        !           842: 
        !           843:                place += vplanesiz;
        !           844: 
        !           845: 
        !           846: 
        !           847:                /* line 5 */
        !           848: 
        !           849:                d = *data++;
        !           850: 
        !           851:                *place = d;
        !           852: 
        !           853:                place += vplanesiz;
        !           854: 
        !           855: 
        !           856: 
        !           857:                /* line 6 */
        !           858: 
        !           859:                d = *data++;
        !           860: 
        !           861:                *place = d;
        !           862: 
        !           863:                place += vplanesiz;
        !           864: 
        !           865: 
        !           866: 
        !           867:                /* line 7 */
        !           868: 
        !           869:                d = *data++;
        !           870: 
        !           871:                *place = d;
        !           872: 
        !           873:                place += vplanesiz;
        !           874: 
        !           875: 
        !           876: 
        !           877:                /* line 8 */
        !           878: 
        !           879:                d = *data++;
        !           880: 
        !           881:                *place = d;
        !           882: 
        !           883:                place += vplanesiz;
        !           884: 
        !           885: 
        !           886: 
        !           887:                /* line 9 */
        !           888: 
        !           889:                d = *data++;
        !           890: 
        !           891:                *place = d;
        !           892: 
        !           893:                place += vplanesiz;
        !           894: 
        !           895: 
        !           896: 
        !           897:                /* line 10 */
        !           898: 
        !           899:                d = *data++;
        !           900: 
        !           901:                *place = d;
        !           902: 
        !           903:                place += vplanesiz;
        !           904: 
        !           905: 
        !           906: 
        !           907:                /* line 11 */
        !           908: 
        !           909:                d = *data++;
        !           910: 
        !           911:                *place = d;
        !           912: 
        !           913:                place += vplanesiz;
        !           914: 
        !           915: 
        !           916: 
        !           917:                /* line 12 */
        !           918: 
        !           919:                d = *data++;
        !           920: 
        !           921:                *place = d;
        !           922: 
        !           923:                place += vplanesiz;
        !           924: 
        !           925: 
        !           926: 
        !           927:                /* line 13 */
        !           928: 
        !           929:                d = *data++;
        !           930: 
        !           931:                *place = d;
        !           932: 
        !           933:                place += vplanesiz;
        !           934: 
        !           935: 
        !           936: 
        !           937:                /* line 14 */
        !           938: 
        !           939:                d = *data++;
        !           940: 
        !           941:                *place = d;
        !           942: 
        !           943:                place += vplanesiz;
        !           944: 
        !           945: 
        !           946: 
        !           947:                /* line 15 */
        !           948: 
        !           949:                d = *data++;
        !           950: 
        !           951:                *place = d;
        !           952: 
        !           953:                place += vplanesiz;
        !           954: 
        !           955: 
        !           956: 
        !           957:                /* line 16 */
        !           958: 
        !           959:                d = *data++;
        !           960: 
        !           961:                *place = d;
        !           962: 
        !           963:                place += vplanesiz;
        !           964: 
        !           965:        } else {
        !           966: 
        !           967:                /* line 1 */
        !           968: 
        !           969:                d = *data++ ^ doinverse;
        !           970: 
        !           971:                *place = d;
        !           972: 
        !           973:                place += vplanesiz;
        !           974: 
        !           975: 
        !           976: 
        !           977:                /* line 2 */
        !           978: 
        !           979:                d = *data++ ^ doinverse;
        !           980: 
        !           981:                *place = d;
        !           982: 
        !           983:                place += vplanesiz;
        !           984: 
        !           985: 
        !           986: 
        !           987:                /* line 3 */
        !           988: 
        !           989:                d = *data++ ^ doinverse;
        !           990: 
        !           991:                *place = d;
        !           992: 
        !           993:                place += vplanesiz;
        !           994: 
        !           995: 
        !           996: 
        !           997:                /* line 4 */
        !           998: 
        !           999:                d = *data++ ^ doinverse;
        !          1000: 
        !          1001:                *place = d;
        !          1002: 
        !          1003:                place += vplanesiz;
        !          1004: 
        !          1005: 
        !          1006: 
        !          1007:                /* line 5 */
        !          1008: 
        !          1009:                d = *data++ ^ doinverse;
        !          1010: 
        !          1011:                *place = d;
        !          1012: 
        !          1013:                place += vplanesiz;
        !          1014: 
        !          1015: 
        !          1016: 
        !          1017:                /* line 6 */
        !          1018: 
        !          1019:                d = *data++ ^ doinverse;
        !          1020: 
        !          1021:                *place = d;
        !          1022: 
        !          1023:                place += vplanesiz;
        !          1024: 
        !          1025: 
        !          1026: 
        !          1027:                /* line 7 */
        !          1028: 
        !          1029:                d = *data++ ^ doinverse;
        !          1030: 
        !          1031:                *place = d;
        !          1032: 
        !          1033:                place += vplanesiz;
        !          1034: 
        !          1035: 
        !          1036: 
        !          1037:                /* line 8 */
        !          1038: 
        !          1039:                d = *data++ ^ doinverse;
        !          1040: 
        !          1041:                *place = d;
        !          1042: 
        !          1043:                place += vplanesiz;
        !          1044: 
        !          1045: 
        !          1046: 
        !          1047:                /* line 9 */
        !          1048: 
        !          1049:                d = *data++ ^ doinverse;
        !          1050: 
        !          1051:                *place = d;
        !          1052: 
        !          1053:                place += vplanesiz;
        !          1054: 
        !          1055: 
        !          1056: 
        !          1057:                /* line 10 */
        !          1058: 
        !          1059:                d = *data++ ^ doinverse;
        !          1060: 
        !          1061:                *place = d;
        !          1062: 
        !          1063:                place += vplanesiz;
        !          1064: 
        !          1065: 
        !          1066: 
        !          1067:                /* line 11 */
        !          1068: 
        !          1069:                d = *data++ ^ doinverse;
        !          1070: 
        !          1071:                *place = d;
        !          1072: 
        !          1073:                place += vplanesiz;
        !          1074: 
        !          1075: 
        !          1076: 
        !          1077:                /* line 12 */
        !          1078: 
        !          1079:                d = *data++ ^ doinverse;
        !          1080: 
        !          1081:                *place = d;
        !          1082: 
        !          1083:                place += vplanesiz;
        !          1084: 
        !          1085: 
        !          1086: 
        !          1087:                /* line 13 */
        !          1088: 
        !          1089:                d = *data++ ^ doinverse;
        !          1090: 
        !          1091:                *place = d;
        !          1092: 
        !          1093:                place += vplanesiz;
        !          1094: 
        !          1095: 
        !          1096: 
        !          1097:                /* line 14 */
        !          1098: 
        !          1099:                d = *data++ ^ doinverse;
        !          1100: 
        !          1101:                *place = d;
        !          1102: 
        !          1103:                place += vplanesiz;
        !          1104: 
        !          1105: 
        !          1106: 
        !          1107:                /* line 15 */
        !          1108: 
        !          1109:                d = *data++ ^ doinverse;
        !          1110: 
        !          1111:                *place = d;
        !          1112: 
        !          1113:                place += vplanesiz;
        !          1114: 
        !          1115: 
        !          1116: 
        !          1117:                /* line 16 */
        !          1118: 
        !          1119:                d = *data++ ^ doinverse;
        !          1120: 
        !          1121:                *place = d;
        !          1122: 
        !          1123:                place += vplanesiz;
        !          1124: 
        !          1125:        }
        !          1126: 
        !          1127: }
        !          1128: 
        !          1129: 
        !          1130: 
        !          1131: /*
        !          1132: 
        !          1133:  * gotoxy (v, x, y): move current cursor address of screen v to (x, y)
        !          1134: 
        !          1135:  * makes sure that (x, y) will be legal
        !          1136: 
        !          1137:  */
        !          1138: 
        !          1139: 
        !          1140: 
        !          1141: INLINE static void
        !          1142: 
        !          1143: gotoxy(v, x, y)
        !          1144: 
        !          1145:        SCREEN *v;
        !          1146: 
        !          1147:        int x, y;
        !          1148: 
        !          1149: {
        !          1150: 
        !          1151:        if (x > v->maxx) x = v->maxx;
        !          1152: 
        !          1153:        else if (x < 0) x = 0;
        !          1154: 
        !          1155:        if (y > v->maxy) y = v->maxy;
        !          1156: 
        !          1157:        else if (y < 0) y = 0;
        !          1158: 
        !          1159:        curs_off(v);
        !          1160: 
        !          1161: 
        !          1162: 
        !          1163:        v->cx = x;
        !          1164: 
        !          1165:        v->cy = y;
        !          1166: 
        !          1167:        v->cursaddr = PLACE(v, x, y);
        !          1168: 
        !          1169: }
        !          1170: 
        !          1171: 
        !          1172: 
        !          1173: /*
        !          1174: 
        !          1175:  * clrline(v, r): clear line r of screen v
        !          1176: 
        !          1177:  */
        !          1178: 
        !          1179: 
        !          1180: 
        !          1181: INLINE static void
        !          1182: 
        !          1183: clrline(v, r)
        !          1184: 
        !          1185:        SCREEN *v;
        !          1186: 
        !          1187:        int r;
        !          1188: 
        !          1189: {
        !          1190: 
        !          1191:        long *dst;
        !          1192: 
        !          1193:        long nbytes;
        !          1194: 
        !          1195: 
        !          1196: 
        !          1197:        nbytes = v->linelen;
        !          1198: 
        !          1199:        /* Hey, again the screen might be bigger than 32767 bytes.
        !          1200: 
        !          1201:           Do another cast... */
        !          1202: 
        !          1203:        dst = (long *)(base + ((long)r * v->linelen));
        !          1204: 
        !          1205:        zero((char *)dst, nbytes);
        !          1206: 
        !          1207: }
        !          1208: 
        !          1209:        
        !          1210: 
        !          1211: /*
        !          1212: 
        !          1213:  * clear(v): clear the whole screen v
        !          1214: 
        !          1215:  */
        !          1216: 
        !          1217: 
        !          1218: 
        !          1219: INLINE static void
        !          1220: 
        !          1221: clear(v)
        !          1222: 
        !          1223:        SCREEN *v;
        !          1224: 
        !          1225: {
        !          1226: 
        !          1227:        zero(base, scrnsize);
        !          1228: 
        !          1229: }
        !          1230: 
        !          1231: 
        !          1232: 
        !          1233: /*
        !          1234: 
        !          1235:  * clrchar(v, x, y): clear the (x,y) position on screen v
        !          1236: 
        !          1237:  */
        !          1238: 
        !          1239: 
        !          1240: 
        !          1241: INLINE static void
        !          1242: 
        !          1243: clrchar(v, x, y)
        !          1244: 
        !          1245:        SCREEN *v;
        !          1246: 
        !          1247:        int x, y;
        !          1248: 
        !          1249: {
        !          1250: 
        !          1251:        int i, j, vplanes;
        !          1252: 
        !          1253:        char *place;
        !          1254: 
        !          1255: 
        !          1256: 
        !          1257:        vplanes = v->planes + v->planes;
        !          1258: 
        !          1259: 
        !          1260: 
        !          1261:        place = PLACE(v, x, y);
        !          1262: 
        !          1263: 
        !          1264: 
        !          1265:        for (j = v->cheight; j > 0; --j) {
        !          1266: 
        !          1267:                for (i = 0; i < vplanes; i+=2)
        !          1268: 
        !          1269:                        place[i] = 0;
        !          1270: 
        !          1271:                place += v->planesiz;
        !          1272: 
        !          1273:        }
        !          1274: 
        !          1275: }
        !          1276: 
        !          1277: 
        !          1278: 
        !          1279: /*
        !          1280: 
        !          1281:  * clrfrom(v, x1, y1, x2, y2): clear screen v from position (x1,y1) to
        !          1282: 
        !          1283:  * position (x2, y2) inclusive. It is assumed that y2 >= y1.
        !          1284: 
        !          1285:  */
        !          1286: 
        !          1287: 
        !          1288: 
        !          1289: INLINE static void
        !          1290: 
        !          1291: clrfrom(v, x1, y1, x2, y2)
        !          1292: 
        !          1293:        SCREEN *v;
        !          1294: 
        !          1295:        int x1,y1,x2,y2;
        !          1296: 
        !          1297: {
        !          1298: 
        !          1299:        int i;
        !          1300: 
        !          1301: 
        !          1302: 
        !          1303:        for (i = x1; i <= v->maxx; i++)
        !          1304: 
        !          1305:                clrchar(v, i, y1);
        !          1306: 
        !          1307:        if (y2 > y1) {
        !          1308: 
        !          1309:                for (i = 0; i <= x2; i++)
        !          1310: 
        !          1311:                        clrchar(v, i, y2);
        !          1312: 
        !          1313:                for (i = y1+1; i < y2; i++)
        !          1314: 
        !          1315:                        clrline(v, i);
        !          1316: 
        !          1317:        }
        !          1318: 
        !          1319: }
        !          1320: 
        !          1321: 
        !          1322: 
        !          1323: /*
        !          1324: 
        !          1325:  * scroll a screen in hardware; if we still have hardware scrolling lines left,
        !          1326: 
        !          1327:  * just move the physical screen base, otherwise copy the screen back to the
        !          1328: 
        !          1329:  * hardware base and start over
        !          1330: 
        !          1331:  */
        !          1332: 
        !          1333: void
        !          1334: 
        !          1335: hardware_scroll(v)
        !          1336: 
        !          1337:        SCREEN *v;
        !          1338: 
        !          1339: {
        !          1340: 
        !          1341: 
        !          1342: 
        !          1343:        ++hardline;
        !          1344: 
        !          1345:        if (hardline < hardscroll) { /* just move the screen */
        !          1346: 
        !          1347:                base += v->linelen;
        !          1348: 
        !          1349:                v->cursaddr = PLACE(v, v->cx, v->cy);
        !          1350: 
        !          1351:                Setscreen(base, base, -1);
        !          1352: 
        !          1353:        }
        !          1354: 
        !          1355:        else {
        !          1356: 
        !          1357:                hardline = 0;
        !          1358: 
        !          1359:                quickmove(hardbase, base + v->linelen, scrnsize - v->linelen);
        !          1360: 
        !          1361:                base = hardbase;
        !          1362: 
        !          1363:                v->cursaddr = PLACE(v, v->cx, v->cy);
        !          1364: 
        !          1365:                Setscreen(hardbase, hardbase, -1);
        !          1366: 
        !          1367:        }
        !          1368: 
        !          1369: }
        !          1370: 
        !          1371: 
        !          1372: 
        !          1373: /*
        !          1374: 
        !          1375:  * delete_line(v, r): delete line r of screen v. The screen below this
        !          1376: 
        !          1377:  * line is scrolled up, and the bottom line is cleared.
        !          1378: 
        !          1379:  */
        !          1380: 
        !          1381: 
        !          1382: 
        !          1383: #define scroll(v) delete_line(v, 0)
        !          1384: 
        !          1385: 
        !          1386: 
        !          1387: INLINE static void
        !          1388: 
        !          1389: delete_line(v, r)
        !          1390: 
        !          1391:        SCREEN *v;
        !          1392: 
        !          1393:        int r;
        !          1394: 
        !          1395: {
        !          1396: 
        !          1397:        long *src, *dst, nbytes;
        !          1398: 
        !          1399: 
        !          1400: 
        !          1401:        if (r == 0) {
        !          1402: 
        !          1403:                if (hardbase) {
        !          1404: 
        !          1405:                        hardware_scroll(v);
        !          1406: 
        !          1407:                        clrline(v, v->maxy);
        !          1408: 
        !          1409:                        return;
        !          1410: 
        !          1411:                }
        !          1412: 
        !          1413:                nbytes = scrnsize - v->linelen;
        !          1414: 
        !          1415:        }
        !          1416: 
        !          1417:        else
        !          1418: 
        !          1419:                nbytes = (long)v->linelen * (v->maxy - r);
        !          1420: 
        !          1421: 
        !          1422: 
        !          1423:        /* Sheeze, how many times do we really have to cast... 
        !          1424: 
        !          1425:           Erling.      
        !          1426: 
        !          1427:        */
        !          1428: 
        !          1429: 
        !          1430: 
        !          1431:        dst = (long *)(base + ((long)r * v->linelen));
        !          1432: 
        !          1433:        src = (long *)( ((long)dst) + v->linelen);
        !          1434: 
        !          1435: 
        !          1436: 
        !          1437:        quickmove(dst, src, nbytes);
        !          1438: 
        !          1439: 
        !          1440: 
        !          1441: /* clear the last line */
        !          1442: 
        !          1443:        clrline(v, v->maxy);
        !          1444: 
        !          1445: }
        !          1446: 
        !          1447: 
        !          1448: 
        !          1449: /*
        !          1450: 
        !          1451:  * insert_line(v, r): scroll all of the screen starting at line r down,
        !          1452: 
        !          1453:  * and then clear line r.
        !          1454: 
        !          1455:  */
        !          1456: 
        !          1457: 
        !          1458: 
        !          1459: INLINE static void
        !          1460: 
        !          1461: insert_line(v, r)
        !          1462: 
        !          1463:        SCREEN *v;
        !          1464: 
        !          1465:        int r;
        !          1466: 
        !          1467: {
        !          1468: 
        !          1469:        long *src, *dst;
        !          1470: 
        !          1471:        int i, limit;
        !          1472: 
        !          1473: 
        !          1474: 
        !          1475:        limit = v->maxy;
        !          1476: 
        !          1477:        for (i = limit-1; i >= r ; --i) {
        !          1478: 
        !          1479:        /* move line i to line i+1 */
        !          1480: 
        !          1481:        /* AND do some casting to support big screens.
        !          1482: 
        !          1483:           Erling
        !          1484: 
        !          1485:        */
        !          1486: 
        !          1487:                src = (long *)(base + ((long)i * v->linelen));
        !          1488: 
        !          1489:                dst = (long *)(base + ((i+1)*(long)v->linelen));
        !          1490: 
        !          1491:                quickmove(dst, src, v->linelen);
        !          1492: 
        !          1493:        }
        !          1494: 
        !          1495: 
        !          1496: 
        !          1497: /* clear line r */
        !          1498: 
        !          1499:        clrline(v, r);
        !          1500: 
        !          1501: }
        !          1502: 
        !          1503: 
        !          1504: 
        !          1505: /*
        !          1506: 
        !          1507:  * special states for handling ESC b x and ESC c x. Note that for now,
        !          1508: 
        !          1509:  * color is ignored.
        !          1510: 
        !          1511:  */
        !          1512: 
        !          1513: 
        !          1514: 
        !          1515: static void
        !          1516: 
        !          1517: setbgcol(v, c)
        !          1518: 
        !          1519:        SCREEN *v;
        !          1520: 
        !          1521:        int c;
        !          1522: 
        !          1523: {
        !          1524: 
        !          1525:        v->bgcol = c & ((1 << v->planes)-1);
        !          1526: 
        !          1527:        state = normal_putch;
        !          1528: 
        !          1529: }
        !          1530: 
        !          1531: 
        !          1532: 
        !          1533: static void
        !          1534: 
        !          1535: setfgcol(v, c)
        !          1536: 
        !          1537:        SCREEN *v;
        !          1538: 
        !          1539:        int c;
        !          1540: 
        !          1541: {
        !          1542: 
        !          1543:        v->fgcol = c & ((1 << v->planes)-1);
        !          1544: 
        !          1545:        state = normal_putch;
        !          1546: 
        !          1547: }
        !          1548: 
        !          1549: 
        !          1550: 
        !          1551: /*
        !          1552: 
        !          1553:  * putesc(v, c): handle the control sequence ESC c
        !          1554: 
        !          1555:  */
        !          1556: 
        !          1557: 
        !          1558: 
        !          1559: static void
        !          1560: 
        !          1561: putesc(v, c)
        !          1562: 
        !          1563:        SCREEN *v;
        !          1564: 
        !          1565:        int c;
        !          1566: 
        !          1567: {
        !          1568: 
        !          1569:        int cx, cy;
        !          1570: 
        !          1571: 
        !          1572: 
        !          1573:        cx = v->cx; cy = v->cy;
        !          1574: 
        !          1575: 
        !          1576: 
        !          1577:        switch (c) {
        !          1578: 
        !          1579:        case 'A':               /* cursor up */
        !          1580: 
        !          1581:                gotoxy(v, cx, cy-1);
        !          1582: 
        !          1583:                break;
        !          1584: 
        !          1585:        case 'B':               /* cursor down */
        !          1586: 
        !          1587:                gotoxy(v, cx, cy+1);
        !          1588: 
        !          1589:                break;
        !          1590: 
        !          1591:        case 'C':               /* cursor right */
        !          1592: 
        !          1593:                gotoxy(v, cx+1, cy);
        !          1594: 
        !          1595:                break;
        !          1596: 
        !          1597:        case 'D':               /* cursor left */
        !          1598: 
        !          1599:                gotoxy(v, cx-1, cy);
        !          1600: 
        !          1601:                break;
        !          1602: 
        !          1603:        case 'E':               /* clear home */
        !          1604: 
        !          1605:                curs_off(v);
        !          1606: 
        !          1607:                clear(v);
        !          1608: 
        !          1609:                /* fall through... */
        !          1610: 
        !          1611:        case 'H':               /* cursor home */
        !          1612: 
        !          1613:                gotoxy(v, 0, 0);
        !          1614: 
        !          1615:                break;
        !          1616: 
        !          1617:        case 'I':               /* cursor up, insert line */
        !          1618: 
        !          1619:                if (cy == 0) {
        !          1620: 
        !          1621:                        curs_off(v);
        !          1622: 
        !          1623:                        insert_line(v, 0);
        !          1624: 
        !          1625:                }
        !          1626: 
        !          1627:                else
        !          1628: 
        !          1629:                        gotoxy(v, cx, cy-1);
        !          1630: 
        !          1631:                break;
        !          1632: 
        !          1633:        case 'J':               /* clear below cursor */
        !          1634: 
        !          1635:                curs_off(v);
        !          1636: 
        !          1637:                clrfrom(v, cx, cy, v->maxx, v->maxy);
        !          1638: 
        !          1639:                break;
        !          1640: 
        !          1641:        case 'K':               /* clear remainder of line */
        !          1642: 
        !          1643:                curs_off(v);
        !          1644: 
        !          1645:                clrfrom(v, cx, cy, v->maxx, cy);
        !          1646: 
        !          1647:                break;
        !          1648: 
        !          1649:        case 'L':               /* insert a line */
        !          1650: 
        !          1651:                gotoxy(v, 0, cy);
        !          1652: 
        !          1653:                insert_line(v, cy);
        !          1654: 
        !          1655:                break;
        !          1656: 
        !          1657:        case 'M':               /* delete line */
        !          1658: 
        !          1659:                gotoxy(v, 0, cy);
        !          1660: 
        !          1661:                delete_line(v, cy);
        !          1662: 
        !          1663:                break;
        !          1664: 
        !          1665:        case 'Y':
        !          1666: 
        !          1667:                state = escy_putch;
        !          1668: 
        !          1669:                return;         /* YES, this should be 'return' */
        !          1670: 
        !          1671: 
        !          1672: 
        !          1673:        case 'b':
        !          1674: 
        !          1675:                state = setfgcol;
        !          1676: 
        !          1677:                return;
        !          1678: 
        !          1679:        case 'c':
        !          1680: 
        !          1681:                state = setbgcol;
        !          1682: 
        !          1683:                return;
        !          1684: 
        !          1685:        case 'd':               /* clear to cursor position */
        !          1686: 
        !          1687:                curs_off(v);
        !          1688: 
        !          1689:                clrfrom(v, 0, 0, cx, cy);
        !          1690: 
        !          1691:                break;
        !          1692: 
        !          1693:        case 'e':               /* enable cursor */
        !          1694: 
        !          1695:                curs_off(v);
        !          1696: 
        !          1697:                v->flags |= CURS_ON;
        !          1698: 
        !          1699:                v->hidecnt = 1; /* so --v->hidecnt shows the cursor */
        !          1700: 
        !          1701:                break;
        !          1702: 
        !          1703:        case 'f':               /* cursor off */
        !          1704: 
        !          1705:                curs_off(v);
        !          1706: 
        !          1707:                v->hidecnt++;
        !          1708: 
        !          1709:                v->flags &= ~CURS_ON;
        !          1710: 
        !          1711:                break;
        !          1712: 
        !          1713:        case 'j':               /* save cursor position */
        !          1714: 
        !          1715:                v->savex = v->cx;
        !          1716: 
        !          1717:                v->savey = v->cy;
        !          1718: 
        !          1719:                break;
        !          1720: 
        !          1721:        case 'k':               /* restore saved position */
        !          1722: 
        !          1723:                gotoxy(v, v->savex, v->savey);
        !          1724: 
        !          1725:                break;
        !          1726: 
        !          1727:        case 'l':               /* clear line */
        !          1728: 
        !          1729:                gotoxy(v, 0, cy);
        !          1730: 
        !          1731:                clrline(v, cy);
        !          1732: 
        !          1733:                break;
        !          1734: 
        !          1735:        case 'o':               /* clear from start of line to cursor */
        !          1736: 
        !          1737:                curs_off(v);
        !          1738: 
        !          1739:                clrfrom(v, 0, cy, cx, cy);
        !          1740: 
        !          1741:                break;
        !          1742: 
        !          1743:        case 'p':               /* reverse video on */
        !          1744: 
        !          1745:                v->flags |= FINVERSE;
        !          1746: 
        !          1747:                break;
        !          1748: 
        !          1749:        case 'q':               /* reverse video off */
        !          1750: 
        !          1751:                v->flags &= ~FINVERSE;
        !          1752: 
        !          1753:                break;
        !          1754: 
        !          1755:        case 'v':               /* wrap on */
        !          1756: 
        !          1757:                v->flags |= FWRAP;
        !          1758: 
        !          1759:                break;
        !          1760: 
        !          1761:        case 'w':
        !          1762: 
        !          1763:                v->flags &= ~FWRAP;
        !          1764: 
        !          1765:                break;
        !          1766: 
        !          1767:        }
        !          1768: 
        !          1769:        state = normal_putch;
        !          1770: 
        !          1771: }
        !          1772: 
        !          1773: 
        !          1774: 
        !          1775: /*
        !          1776: 
        !          1777:  * escy1_putch(v, c): for when an ESC Y + char has been seen
        !          1778: 
        !          1779:  */
        !          1780: 
        !          1781: static void
        !          1782: 
        !          1783: escy1_putch(v, c)
        !          1784: 
        !          1785:        SCREEN *v;
        !          1786: 
        !          1787:        int c;
        !          1788: 
        !          1789: {
        !          1790: 
        !          1791:        gotoxy(v, c - ' ', escy1 - ' ');
        !          1792: 
        !          1793:        state = normal_putch;
        !          1794: 
        !          1795: }
        !          1796: 
        !          1797: 
        !          1798: 
        !          1799: /*
        !          1800: 
        !          1801:  * escy_putch(v, c): for when an ESC Y has been seen
        !          1802: 
        !          1803:  */
        !          1804: 
        !          1805: static void
        !          1806: 
        !          1807: escy_putch(v, c)
        !          1808: 
        !          1809:        SCREEN *v;
        !          1810: 
        !          1811:        int c;
        !          1812: 
        !          1813: {
        !          1814: 
        !          1815:        escy1 = c;
        !          1816: 
        !          1817:        state = escy1_putch;
        !          1818: 
        !          1819: }
        !          1820: 
        !          1821: 
        !          1822: 
        !          1823: /*
        !          1824: 
        !          1825:  * normal_putch(v, c): put character 'c' on screen 'v'. This is the default
        !          1826: 
        !          1827:  * for when no escape, etc. is active
        !          1828: 
        !          1829:  */
        !          1830: 
        !          1831: 
        !          1832: 
        !          1833: static void
        !          1834: 
        !          1835: normal_putch(v, c)
        !          1836: 
        !          1837:        SCREEN *v;
        !          1838: 
        !          1839:        int c;
        !          1840: 
        !          1841: {
        !          1842: 
        !          1843: /* control characters */
        !          1844: 
        !          1845:        if (c < ' ') {
        !          1846: 
        !          1847:                switch (c) {
        !          1848: 
        !          1849:                case '\r':
        !          1850: 
        !          1851:                        gotoxy(v, 0, v->cy);
        !          1852: 
        !          1853:                        return;
        !          1854: 
        !          1855:                case '\n':
        !          1856: 
        !          1857:                        if (v->cy == v->maxy) {
        !          1858: 
        !          1859:                                curs_off(v);
        !          1860: 
        !          1861:                                scroll(v);
        !          1862: 
        !          1863:                        }
        !          1864: 
        !          1865:                        else
        !          1866: 
        !          1867:                                gotoxy(v, v->cx, v->cy+1);
        !          1868: 
        !          1869:                        return;
        !          1870: 
        !          1871:                case '\b':
        !          1872: 
        !          1873:                        gotoxy(v, v->cx-1, v->cy);
        !          1874: 
        !          1875:                        return;
        !          1876: 
        !          1877:                case '\007':            /* BELL */
        !          1878: 
        !          1879:                        (void)bconout(CONDEV, 7);
        !          1880: 
        !          1881:                        return;
        !          1882: 
        !          1883:                case '\033':            /* ESC */
        !          1884: 
        !          1885:                        state = putesc;
        !          1886: 
        !          1887:                        return;
        !          1888: 
        !          1889:                case '\t':
        !          1890: 
        !          1891:                        gotoxy(v, (v->cx + 8) & ~7, v->cy);
        !          1892: 
        !          1893:                        return;
        !          1894: 
        !          1895:                default:
        !          1896: 
        !          1897:                        return;
        !          1898: 
        !          1899:                }
        !          1900: 
        !          1901:        }
        !          1902: 
        !          1903: 
        !          1904: 
        !          1905:        (*vpaint)(v, c, v->cursaddr);
        !          1906: 
        !          1907:        v->flags &= ~CURS_FSTATE;       /* we just erased the cursor */
        !          1908: 
        !          1909:        v->cx++;
        !          1910: 
        !          1911:        if (v->cx > v->maxx) {
        !          1912: 
        !          1913:                if (v->flags & FWRAP) {
        !          1914: 
        !          1915:                        v->cx = 0;
        !          1916: 
        !          1917:                        normal_putch(v, '\n');
        !          1918: 
        !          1919:                        v->cursaddr = PLACE(v, v->cx, v->cy);
        !          1920: 
        !          1921:                } else {
        !          1922: 
        !          1923:                        v->cx = v->maxx;
        !          1924: 
        !          1925:                }
        !          1926: 
        !          1927:        } else {
        !          1928: 
        !          1929: #if 0
        !          1930: 
        !          1931:                v->cursaddr = PLACE(v, v->cx, v->cy);
        !          1932: 
        !          1933: #else
        !          1934: 
        !          1935:                v->cursaddr++;
        !          1936: 
        !          1937:                if ( (v->cx & 1) == 0 && v->planes > 1) { /* new word */
        !          1938: 
        !          1939:                        short skipwords = v->planes - 1;
        !          1940: 
        !          1941:                        v->cursaddr += skipwords+skipwords;
        !          1942: 
        !          1943:                }
        !          1944: 
        !          1945: #endif
        !          1946: 
        !          1947:        }
        !          1948: 
        !          1949: }
        !          1950: 
        !          1951: 
        !          1952: 
        !          1953: INLINE static void
        !          1954: 
        !          1955: put_ch(v, c)
        !          1956: 
        !          1957:        SCREEN *v;
        !          1958: 
        !          1959:        int c;
        !          1960: 
        !          1961: {
        !          1962: 
        !          1963:        (*state)(v, c & 0x00ff);
        !          1964: 
        !          1965: }
        !          1966: 
        !          1967: 
        !          1968: 
        !          1969: static long screen_open        P_((FILEPTR *f));
        !          1970: 
        !          1971: static long screen_read        P_((FILEPTR *f, char *buf, long nbytes));
        !          1972: 
        !          1973: static long screen_write P_((FILEPTR *f, const char *buf, long nbytes));
        !          1974: 
        !          1975: static long screen_lseek P_((FILEPTR *f, long where, int whence));
        !          1976: 
        !          1977: static long screen_ioctl P_((FILEPTR *f, int mode, void *buf));
        !          1978: 
        !          1979: static long screen_close P_((FILEPTR *f, int pid));
        !          1980: 
        !          1981: static long screen_select P_((FILEPTR *f, long p, int mode));
        !          1982: 
        !          1983: static void screen_unselect P_((FILEPTR *f, long p, int mode));
        !          1984: 
        !          1985: 
        !          1986: 
        !          1987: extern long    null_datime     P_((FILEPTR *f, short *time, int rwflag));
        !          1988: 
        !          1989: 
        !          1990: 
        !          1991: DEVDRV screen_device = {
        !          1992: 
        !          1993:        screen_open, screen_write, screen_read, screen_lseek, screen_ioctl,
        !          1994: 
        !          1995:        null_datime, screen_close, screen_select, screen_unselect
        !          1996: 
        !          1997: };
        !          1998: 
        !          1999: 
        !          2000: 
        !          2001: static long
        !          2002: 
        !          2003: screen_open(f)
        !          2004: 
        !          2005:        FILEPTR *f;
        !          2006: 
        !          2007: {
        !          2008: 
        !          2009: 
        !          2010: 
        !          2011:        if (!current) {
        !          2012: 
        !          2013:                init();
        !          2014: 
        !          2015:        } else
        !          2016: 
        !          2017:                return EACCDN;          /* screen in use */
        !          2018: 
        !          2019: 
        !          2020: 
        !          2021:        f->flags |= O_TTY;
        !          2022: 
        !          2023:        return 0;
        !          2024: 
        !          2025: }
        !          2026: 
        !          2027: 
        !          2028: 
        !          2029: static long
        !          2030: 
        !          2031: screen_close(f, pid)
        !          2032: 
        !          2033:        FILEPTR *f;
        !          2034: 
        !          2035:        int pid;
        !          2036: 
        !          2037: {
        !          2038: 
        !          2039:        if (f->links <= 0) {
        !          2040: 
        !          2041:                if (hardbase) {
        !          2042: 
        !          2043:                        quickmove(oldbase, base, scrnsize);
        !          2044: 
        !          2045:                        base = oldbase;
        !          2046: 
        !          2047:                        Setscreen(oldbase, oldbase, -1);
        !          2048: 
        !          2049:                }
        !          2050: 
        !          2051:                current = 0;
        !          2052: 
        !          2053:        }
        !          2054: 
        !          2055:        return 0;
        !          2056: 
        !          2057: }
        !          2058: 
        !          2059: 
        !          2060: 
        !          2061: static long
        !          2062: 
        !          2063: screen_write(f, buf, bytes)
        !          2064: 
        !          2065:        FILEPTR *f; const char *buf; long bytes;
        !          2066: 
        !          2067: {
        !          2068: 
        !          2069:        SCREEN *v = current;
        !          2070: 
        !          2071:        long *r;
        !          2072: 
        !          2073:        long ret = 0;
        !          2074: 
        !          2075:        int c;
        !          2076: 
        !          2077: 
        !          2078: 
        !          2079:        (void)checkkeys();
        !          2080: 
        !          2081:        v->hidecnt++;
        !          2082: 
        !          2083:        v->flags |= CURS_UPD;           /* for TOS 1.0 */
        !          2084: 
        !          2085:        r = (long *)buf;
        !          2086: 
        !          2087:        while (bytes > 0) {
        !          2088: 
        !          2089:                c = *r++;
        !          2090: 
        !          2091:                put_ch(v, c);
        !          2092: 
        !          2093:                bytes -= 4; ret+= 4;
        !          2094: 
        !          2095:        }
        !          2096: 
        !          2097:        --v->hidecnt;
        !          2098: 
        !          2099:        v->flags &= ~CURS_UPD;
        !          2100: 
        !          2101:        curs_on(v);
        !          2102: 
        !          2103:        return ret;
        !          2104: 
        !          2105: }
        !          2106: 
        !          2107: 
        !          2108: 
        !          2109: static long
        !          2110: 
        !          2111: screen_read(f, buf, bytes)
        !          2112: 
        !          2113:        FILEPTR *f; char *buf; long bytes;
        !          2114: 
        !          2115: {
        !          2116: 
        !          2117:        long *r, ret = 0;
        !          2118: 
        !          2119: 
        !          2120: 
        !          2121:        r = (long *)buf;
        !          2122: 
        !          2123: 
        !          2124: 
        !          2125:        while (bytes > 0) {
        !          2126: 
        !          2127:                if ( (f->flags & O_NDELAY) && !bconstat(CONDEV) )
        !          2128: 
        !          2129:                        break;
        !          2130: 
        !          2131:                *r++ = bconin(CONDEV) & 0x7fffffff;
        !          2132: 
        !          2133:                bytes -= 4; ret += 4;
        !          2134: 
        !          2135:        }
        !          2136: 
        !          2137:        return ret;
        !          2138: 
        !          2139: }
        !          2140: 
        !          2141: 
        !          2142: 
        !          2143: static long
        !          2144: 
        !          2145: screen_lseek(f, where, whence)
        !          2146: 
        !          2147:        FILEPTR *f;
        !          2148: 
        !          2149:        long where;
        !          2150: 
        !          2151:        int whence;
        !          2152: 
        !          2153: {
        !          2154: 
        !          2155: /* terminals always are at position 0 */
        !          2156: 
        !          2157:        return 0;
        !          2158: 
        !          2159: }
        !          2160: 
        !          2161: 
        !          2162: 
        !          2163: static long
        !          2164: 
        !          2165: screen_ioctl(f, mode, buf)
        !          2166: 
        !          2167:        FILEPTR *f; int mode; void *buf;
        !          2168: 
        !          2169: {
        !          2170: 
        !          2171:        long *r = (long *)buf;
        !          2172: 
        !          2173:        struct winsize *w;
        !          2174: 
        !          2175: 
        !          2176: 
        !          2177:        if (mode == FIONREAD) {
        !          2178: 
        !          2179:                if (bconstat(CONDEV))
        !          2180: 
        !          2181:                        *r = 1;
        !          2182: 
        !          2183:                else
        !          2184: 
        !          2185:                        *r = 0;
        !          2186: 
        !          2187:        }
        !          2188: 
        !          2189:        else if (mode == FIONWRITE) {
        !          2190: 
        !          2191:                        *r = 1;
        !          2192: 
        !          2193:        }
        !          2194: 
        !          2195:        else if (mode == TIOCFLUSH) {
        !          2196: 
        !          2197: /* BUG: this should flush the input/output buffers */
        !          2198: 
        !          2199:                return 0;
        !          2200: 
        !          2201:        }
        !          2202: 
        !          2203:        else if (mode == TIOCGWINSZ) {
        !          2204: 
        !          2205:                w = (struct winsize *)buf;
        !          2206: 
        !          2207:                w->ws_row = current->maxy+1;
        !          2208: 
        !          2209:                w->ws_col = current->maxx+1;
        !          2210: 
        !          2211:        }
        !          2212: 
        !          2213:        else
        !          2214: 
        !          2215:                return tty_ioctl(f, mode, buf);
        !          2216: 
        !          2217: 
        !          2218: 
        !          2219:        return 0;
        !          2220: 
        !          2221: }
        !          2222: 
        !          2223: 
        !          2224: 
        !          2225: static long
        !          2226: 
        !          2227: screen_select(f, p, mode)
        !          2228: 
        !          2229:        FILEPTR *f; long p; int mode;
        !          2230: 
        !          2231: {
        !          2232: 
        !          2233:        struct tty *tty = (struct tty *)f->devinfo;
        !          2234: 
        !          2235:        int dev = CONDEV;
        !          2236: 
        !          2237: 
        !          2238: 
        !          2239:        if (mode == O_RDONLY) {
        !          2240: 
        !          2241:                if (bconstat(dev)) {
        !          2242: 
        !          2243:                        return 1;
        !          2244: 
        !          2245:                }
        !          2246: 
        !          2247:                if (tty) {
        !          2248: 
        !          2249:                /* avoid collisions with other processes */
        !          2250: 
        !          2251:                        if (!tty->rsel)
        !          2252: 
        !          2253:                                tty->rsel = p;
        !          2254: 
        !          2255:                }
        !          2256: 
        !          2257:                return 0;
        !          2258: 
        !          2259:        } else if (mode == O_WRONLY) {
        !          2260: 
        !          2261:                return 1;
        !          2262: 
        !          2263:        }
        !          2264: 
        !          2265:        /* default -- we don't know this mode, return 0 */
        !          2266: 
        !          2267:        return 0;
        !          2268: 
        !          2269: }
        !          2270: 
        !          2271: 
        !          2272: 
        !          2273: static void
        !          2274: 
        !          2275: screen_unselect(f, p, mode)
        !          2276: 
        !          2277:        FILEPTR *f;
        !          2278: 
        !          2279:        long p;
        !          2280: 
        !          2281:        int mode;
        !          2282: 
        !          2283: {
        !          2284: 
        !          2285:        struct tty *tty = (struct tty *)f->devinfo;
        !          2286: 
        !          2287: 
        !          2288: 
        !          2289:        if (tty) {
        !          2290: 
        !          2291:                if (mode == O_RDONLY && tty->rsel == p)
        !          2292: 
        !          2293:                        tty->rsel = 0;
        !          2294: 
        !          2295:                else if (mode == O_WRONLY && tty->wsel == p)
        !          2296: 
        !          2297:                        tty->wsel = 0;
        !          2298: 
        !          2299:        }
        !          2300: 
        !          2301: }
        !          2302: 
        !          2303: 
        !          2304: 
        !          2305: #endif /* FASTTEXT */
        !          2306: 

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