Return to comm.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / lib / j

Annotation of researchv9/jerq/src/lib/j/comm.c, revision 1.1.1.1

1.1       root        1: #include <jerq.h>
                      2: #include <jerqio.h>
                      3: #define _SYSTAG                0375
                      4: #define _SYSINIT       0374
                      5: #define _SYSSYNC       0373
                      6: 
                      7: typedef union {
                      8:        short s;
                      9:        char c[2];
                     10: } schar;
                     11: 
                     12: typedef union {
                     13:        long l;
                     14:        char c[4];
                     15: } lchar;
                     16: 
                     17: #ifndef MUX
                     18: sendnchars(n,s)
                     19: register n;
                     20: register char *s;
                     21: {
                     22:        if (n > 0)
                     23:        do{
                     24:                sendchar(*s++);
                     25: }
                     26:        while (--n > 0);
                     27: }
                     28: #endif
                     29: #define JXBUFSIZ 512
                     30: static char cmdbuf[JXBUFSIZ];  /* command information only */
                     31: static char *cmdptr=cmdbuf;    /* command information only */
                     32: jflush()
                     33: {
                     34:        sendnchars((int)(cmdptr-cmdbuf),cmdbuf);
                     35:        cmdptr = cmdbuf;
                     36: }
                     37: 
                     38: jputchar(c)
                     39: char c;
                     40: {
                     41:        *cmdptr++ = c;
                     42:        if (cmdptr > &(cmdbuf[JXBUFSIZ - 2]))
                     43:                jflush();
                     44: }
                     45: 
                     46: jputnchars(n,p)
                     47: register n;
                     48: register char *p;
                     49: {
                     50:        do {
                     51:                *cmdptr++ = *p++;
                     52:                if (cmdptr > &(cmdbuf[JXBUFSIZ - 2]))
                     53:                        jflush();
                     54:        } while (--n > 0);
                     55: }
                     56: 
                     57: jputshort(s)
                     58: short s;
                     59: {
                     60:        jputnchars(2,&s);       /* a feeble improvement */
                     61: }
                     62: 
                     63: jputlong(l)
                     64: lchar l;
                     65: {
                     66:        jputnchars(4,l.c);      /* but an improvement */
                     67: }
                     68: 
                     69: jputbuf(p,n)
                     70: register char *p;
                     71: register short n;
                     72: {
                     73:        jputshort(n);
                     74:        jflush();
                     75:        sendnchars(n,p);        /* not always feeble */
                     76: }
                     77: 
                     78: jputstr(s)
                     79: register char *s;
                     80: {
                     81:        register char c;
                     82:        do {
                     83:                jputchar(c = *s++);
                     84:        } while (c != '\0');
                     85: }
                     86: 
                     87: #ifdef MUX
                     88: #undef jgetchar
                     89: jgetchar()
                     90: {
                     91:        register c;
                     92:        while ((c = rcvchar()) == -1)
                     93:                wait(RCV);
                     94:        return(c);
                     95: }
                     96: #endif
                     97: 
                     98: short
                     99: jgetshort()
                    100: {
                    101:        schar s;
                    102:        register char *p;
                    103:        p = s.c;
                    104:        *p++ = jgetchar();
                    105:        *p++ = jgetchar();
                    106:        return(s.s);
                    107: }
                    108: 
                    109: long
                    110: jgetlong()
                    111: {
                    112:        lchar l;
                    113:        register char *p;
                    114:        p = l.c;
                    115:        *p++ = jgetchar();
                    116:        *p++ = jgetchar();
                    117:        *p++ = jgetchar();
                    118:        *p++ = jgetchar();
                    119:        return(l.l);
                    120: }
                    121: 
                    122: jgetbuf(p,n)
                    123: register char *p;
                    124: register short n;
                    125: {
                    126:        register short i;
                    127:        jputshort(n);
                    128:        jflush();
                    129:        n = jgetshort();
                    130:        for (i = 0; i < n; i++)
                    131:                *p++ = jgetchar();
                    132:        return(n);
                    133: }
                    134: 
                    135: jgetstr(s)
                    136: register char *s;
                    137: {
                    138:        while (*s++ = jgetchar());
                    139: }
                    140: 
                    141: static int synced;
                    142: 
                    143: tag(c)
                    144: char c;
                    145: {
                    146:        if (synced == 0) {
                    147:                sync();
                    148:                synced = 1;
                    149:        }
                    150:        jputchar(_SYSTAG);
                    151:        jputchar(c);
                    152: }
                    153: 
                    154: sync()
                    155: {
                    156:        jputchar(_SYSTAG);
                    157:        jputchar(_SYSSYNC);
                    158:        jflush();
                    159:        while (jgetchar() != _SYSSYNC)
                    160:                ;
                    161: }

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