Return to io.c CVS log

Up to [Research Unix] / researchv10no / libj

Annotation of researchv10no/libj/io.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <sgtty.h>
        !             3: #include "/usr/jerq/include/jioctl.h"
        !             4: #include "jerq.h"
        !             5: #include "io.h"
        !             6: #include "balloc.h"
        !             7: #include "commands.h"
        !             8: 
        !             9: extern int lookUpFont();
        !            10: extern Font *fntab[];
        !            11: extern Font *loadFont();
        !            12: 
        !            13: Rectangle Jrect, Drect;
        !            14: int Jin, Jout;
        !            15: 
        !            16: #define mouseQsize 20
        !            17: Mouse mouseQ[mouseQsize];
        !            18: int Qnum = 0;
        !            19: int lookMouse = 0; nextMouse = 0;
        !            20: 
        !            21: struct sgttyb ttyisave, ttyosave, ttymodes;
        !            22: 
        !            23: int jinit()
        !            24: {      
        !            25:        if (system("32ld /usr/jerq/lib/term.m")) {
        !            26:                fprintf(stderr,"main: can't boot terminal program\n");
        !            27:                return(0);
        !            28:        }
        !            29:        Jin = open("/dev/tty",0);
        !            30:        Jout = open("/dev/tty",1);
        !            31:        if (Jin<0 | Jout <0) {
        !            32:                fprintf(stderr,"couldn't open /dev/tty\n");
        !            33:                return(0);
        !            34:        }
        !            35:        ioctl(Jin, TIOCGETP, &ttymodes);
        !            36:        ttyisave = ttymodes;
        !            37:        ttymodes.sg_flags |= RAW;
        !            38:        ttymodes.sg_flags &= ~ECHO;
        !            39:        ioctl(Jin, TIOCSETP, &ttymodes);
        !            40: 
        !            41:        ioctl(Jout, TIOCGETP, &ttymodes);
        !            42:        ttyosave = ttymodes;
        !            43:        ttymodes.sg_flags |= RAW;
        !            44:        ttymodes.sg_flags &= ~ECHO;
        !            45:        ioctl(Jout, TIOCSETP, &ttymodes);
        !            46: 
        !            47:        Jrect.origin.x = Jrect.origin.y = 0;
        !            48:        Jrect.corner.x = XMAX; Jrect.corner.y = YMAX;
        !            49:        Drect.origin.x = recInt();
        !            50:        Drect.origin.y = recInt();
        !            51:        Drect.corner.x = recInt();
        !            52:        Drect.corner.y = recInt();
        !            53:        BMT[0].rect = Drect;
        !            54: 
        !            55:        fntab[0] = loadFont("/usr/jerq/font/defont");
        !            56:        return(1);
        !            57: }
        !            58: 
        !            59: #define BUFsize 32
        !            60: char obuf[BUFsize], ibuf[BUFsize];
        !            61: int pobuf = 0, pibuf = 0, pinum = 0;
        !            62: 
        !            63: void flush()
        !            64: {
        !            65:        if (pobuf>0) write(Jout,obuf,pobuf);
        !            66:        pobuf = 0;
        !            67: }
        !            68:        
        !            69: put(c) char c;
        !            70: {
        !            71:        if (pobuf == BUFsize) flush();
        !            72:        obuf[pobuf++] = c;
        !            73: }
        !            74: 
        !            75: char get()
        !            76: {
        !            77:        if (pibuf==pinum) {
        !            78:                pinum = read(Jin,ibuf,BUFsize);
        !            79:                pibuf = 0;
        !            80:        }
        !            81:        return ibuf[pibuf++];
        !            82: }
        !            83:        
        !            84: void sendChar(c) char c;
        !            85: {
        !            86:        put(c);
        !            87: }
        !            88: 
        !            89: void sendInt(n) int n;
        !            90: {
        !            91:        if (n<0) {
        !            92:                put('-');
        !            93:                n = -n;
        !            94:        }
        !            95:        for ( ; n != 0; n >>= 4) put((n&15)+'A');
        !            96:        put(' ');
        !            97: }
        !            98: 
        !            99: 
        !           100: void sendPoint(p) Point p;
        !           101: {
        !           102:        sendInt(p.x);
        !           103:        sendInt(p.y);
        !           104: }
        !           105: 
        !           106: void sendRectangle(r) Rectangle r;
        !           107: {
        !           108:        sendInt(r.origin.x);
        !           109:        sendInt(r.origin.y);
        !           110:        sendInt(r.corner.x);
        !           111:        sendInt(r.corner.y);
        !           112: }
        !           113: 
        !           114: void sendToBitmap(b) Bitmap *b;
        !           115: {
        !           116:        if (b<BMT || b>BMT+BMTsize || b->jname<0) 
        !           117:                fprintf(stderr,"inappropriate bitmap\n");
        !           118:        else sendInt(b->jname);
        !           119: }
        !           120: 
        !           121: void sendToFont(f) Font *f;
        !           122: {
        !           123:        sendInt(lookUpFont(f));
        !           124: }
        !           125: 
        !           126: 
        !           127: #define TXTsize 20
        !           128: Texture *txp[TXTsize];
        !           129: Texture txtab[TXTsize];
        !           130: 
        !           131: void sendTexture(i,t) int i; Texture *t;
        !           132: {      int j;
        !           133:        sendInt(i);
        !           134:        txp[i] = t;
        !           135:        txtab[i] = *t;
        !           136:        for (j=0; j<16; j++) sendInt(t->bits[j]);
        !           137: }
        !           138: #define TNULL (Texture *)NULL
        !           139:                
        !           140: void sendToTexture(t) Texture *t;
        !           141: {      int i, j;
        !           142:        if (t==TNULL) {
        !           143:                sendInt(-1);
        !           144:                sendInt(-1);
        !           145:        }
        !           146:        else {
        !           147:                for (i=0; i<TXTsize && txp[i]!=TNULL && txp[i]!=t; i++) ;
        !           148:                if (i>=TXTsize) {
        !           149:                        fprintf(stderr,"out of space in TXTAB\n");
        !           150:                        exit();
        !           151:                }
        !           152:                else if (txp[i]==TNULL) sendTexture(i,t);
        !           153:                else {
        !           154:                        for (j=0; j<16 && t->bits[j]==txp[i]->bits[j]; j++) ;
        !           155:                        if (j==16) {
        !           156:                                sendInt(-1);
        !           157:                                sendInt(i);
        !           158:                        }
        !           159:                        else sendTexture(i,t);
        !           160:                }
        !           161:        }
        !           162: }
        !           163: 
        !           164: void sendToChar(str) char *str;
        !           165: {      int i = 0;
        !           166:        do { put(str[i]); } while (str[i++] != 0); 
        !           167: }
        !           168: 
        !           169: void sendToToChar(cpp) char **cpp;
        !           170: {
        !           171:        sendToChar(*cpp);
        !           172: }
        !           173: 
        !           174: void sendUnsignedInt(n) unsigned int n;
        !           175: {
        !           176:        for ( ; n != 0; n >>= 4) put((n&15)+'A');
        !           177:        put(' ');
        !           178: }
        !           179: 
        !           180: Point recPoint()
        !           181: {      Point p;
        !           182:        p.x = recInt();
        !           183:        p.y = recInt();
        !           184:        return(p);
        !           185: }
        !           186: 
        !           187: Rectangle recRectangle()
        !           188: {      Rectangle r;
        !           189:        r.origin.x = recInt();
        !           190:        r.origin.y = recInt();
        !           191:        r.corner.x = recInt();
        !           192:        r.corner.y = recInt();
        !           193:        return(r);
        !           194: }
        !           195: 
        !           196: int recChar()
        !           197: {      int c;
        !           198:        return get();
        !           199: }
        !           200: 
        !           201: int recInt()
        !           202: {      char c; 
        !           203:        register n, i;
        !           204:        int sign = 1;
        !           205:        
        !           206:        if ((c = get()) == '-') {
        !           207:                sign = -1;
        !           208:                c = get();
        !           209:        }
        !           210:        for (n=0, i=0; (c >= 'A' && c <= 'P'); c = get(), i+=4) 
        !           211:                n += (c - 'A')<<i;
        !           212:        return (n * sign);
        !           213: }
        !           214: 
        !           215: Texture *recToTexture()
        !           216: {      int t;
        !           217:        t = recInt();
        !           218:        return(&txtab[t]);
        !           219: }
        !           220: 
        !           221: void readMouse()
        !           222: {      int i, j;
        !           223:        sendCommand(CCGETMOUSE);
        !           224:        flush();
        !           225:        Qnum = recInt();
        !           226:        for (j=0; j<Qnum; j++) {
        !           227:                for (mouseQ[j].xy.x=0, i=0; i<4*3; i+=4) 
        !           228:                        mouseQ[j].xy.x |= (get() << i);
        !           229:                for (mouseQ[j].xy.y=0, i=0; i<4*3; i+=4) 
        !           230:                        mouseQ[j].xy.y |= (get() << i);
        !           231:                mouseQ[j].buttons = get();
        !           232:        }
        !           233:        get(); /* dump the carriage return */
        !           234: 
        !           235: }
        !           236: 
        !           237: clearMouseQ()
        !           238: {
        !           239:        Qnum = 0;
        !           240: }
        !           241: 
        !           242: Point mousexy()
        !           243: {
        !           244:        if (nextMouse >= Qnum) {
        !           245:                readMouse();
        !           246:                lookMouse = nextMouse = 0;
        !           247:        }
        !           248:        lookMouse  = 0;
        !           249:        return(mouseQ[nextMouse++].xy);
        !           250: }
        !           251: 
        !           252: int mousebuttons()
        !           253: {      
        !           254:        if (lookMouse) nextMouse++;
        !           255:        if (nextMouse >= Qnum) {
        !           256:                readMouse();
        !           257:                lookMouse = nextMouse = 0;
        !           258:        }
        !           259:        lookMouse = 1;
        !           260:        return(mouseQ[nextMouse].buttons);
        !           261: }
        !           262: 
        !           263: int kbdbuf[50];
        !           264: int kbdp = 0;
        !           265: int kbdn = 0;
        !           266: 
        !           267: int kbdchar()
        !           268: {      int c;
        !           269:        if (kbdp >= kbdn) {
        !           270:                sendCommand(CCKBDCHAR);
        !           271:                flush();
        !           272:                kbdn = kbdp = 0;
        !           273:                while ((c = recInt()) != -1) kbdbuf[kbdn++] = c;
        !           274:        }
        !           275:        return((kbdn == 0)? -1 : kbdbuf[kbdp++]);       
        !           276: }
        !           277:                
        !           278: void jexit()
        !           279: {      struct sgttyb buf;
        !           280:        sendCommand(CCEXIT);
        !           281:        flush();
        !           282:        ioctl(Jin, TIOCSETP, &ttyisave);
        !           283:        ttyosave.sg_flags &= ~RAW;
        !           284:        ttyosave.sg_flags |= ECHO;
        !           285:        ioctl(Jout, TIOCSETP, &ttyosave);
        !           286:        ioctl(Jout, JTERM, &ttyosave);
        !           287:        close(Jin);
        !           288:        close(Jout);
        !           289:        exit();
        !           290: }
        !           291:        

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