Return to ibic.c CVS log

Up to [Research Unix] / researchv10no / cmd / qsnap

Annotation of researchv10no/cmd/qsnap/ibic.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: 
        !             3: /*
        !             4:  * This software is provided solely for use with
        !             5:  * the National Instruments GPIB series interfaces.
        !             6:  *
        !             7:  * Copyright 1980, 1983 National Instruments
        !             8:  *
        !             9:  * Jeffrey Kodosky
        !            10:  * REV D:  10/09/83
        !            11:  */
        !            12: 
        !            13: extern int ibup(), gpib(), slp(), echo();
        !            14: extern int errno;
        !            15: 
        !            16: #define EINTR  4
        !            17: #define        NTYPES  (sizeof fctn / sizeof fctn[0])
        !            18: 
        !            19: char *fns[]= { "ibup", "gpib", "sleep", "echo" };
        !            20: 
        !            21: int (*fctn[])()= { ibup, gpib, slp, echo };
        !            22: 
        !            23: int maxcode[]= { 10, 16, 0 };
        !            24: 
        !            25: struct argdef {
        !            26:        char *name, *args, *ans; };
        !            27: 
        !            28: struct argdef echoargs[]= {
        !            29:        {"str", "S", "B"},
        !            30: };
        !            31: 
        !            32: struct argdef slpargs[]= {
        !            33:        {"sec", "I", "B"},
        !            34: };
        !            35: 
        !            36: struct argdef ibupargs[]= {
        !            37:        {"write", "ISL", "I" },
        !            38:        {"read", "IBN", "IB" },
        !            39:        {"clear", "I", "I" },
        !            40:        {"trigger", "I", "I" },
        !            41:        {"remote", "I", "I" },
        !            42:        {"local", "I", "I" },
        !            43:        {"poll", "I", "O" },
        !            44:        {"configure", "III", "I" },
        !            45:        {"passcontrol", "I", "I" },
        !            46:        {"define", "IIIIIII", "I" },
        !            47:        {"finish", "", "I" }  };
        !            48: 
        !            49: struct argdef gpibargs[]= {
        !            50:        {"command", "SL", "I" },
        !            51:        {"write", "SIL", "I" },
        !            52:        {"read", "BNII", "IB" },
        !            53:        {"transfer", "", "I" },
        !            54:        {"clear", "", "I" },
        !            55:        {"remote", "", "I" },
        !            56:        {"local", "", "I" },
        !            57:        {"parallelpoll", "", "O" },
        !            58:        {"passcontrol", "", "I" },
        !            59:        {"setstatus", "I", "I" },
        !            60:        {"monitor", "I", "I" },
        !            61:        {"readcommand", "", "O" },
        !            62:        {"setparameters", "I", "I" },
        !            63:        {"testsrq", "I", "I" },
        !            64:        {"finish", "", "I" },
        !            65:        {"status", "BN", "IT" },
        !            66:        {"spbyte", "I", "I" }   };
        !            67: 
        !            68: struct argdef *fnargs[]= { ibupargs, gpibargs, slpargs, echoargs };
        !            69: 
        !            70: #define SIGSRQ 2
        !            71: #define MAXLIN 256
        !            72: #define MAXBUF 2048
        !            73: #define MAXINT 0100000
        !            74: 
        !            75: char lbuf[MAXBUF], ansbuf[MAXBUF], *cp;
        !            76: int strleng, fn;
        !            77: int argc;
        !            78: int argv[9];
        !            79: int code;
        !            80: 
        !            81: main(){ int n, srqint();
        !            82:        char *atp, c, *getstr();
        !            83: 
        !            84:        signal(SIGSRQ,srqint);
        !            85: loop:  while((n=getline())>=0){
        !            86:                if(n==0) continue;
        !            87:                cp= lbuf;
        !            88:                skpspc();
        !            89:                if(*cp == 0) continue;
        !            90:                if((fn=getfn())<0) continue;
        !            91:                if((code=getcode(fn))<0) continue;
        !            92:                for(argc=0, atp=fnargs[fn][code].args; c= *atp++; )
        !            93:                        switch(c){
        !            94:                                case 'N':
        !            95:                                        if((n=getint(0))==MAXINT) goto loop;
        !            96:                                        if(n>MAXBUF) n= MAXBUF;
        !            97:                                        argv[argc++]= n;
        !            98:                                        break;
        !            99:                                case 'I':
        !           100:                                        if((argv[argc++]= getint(0))==MAXINT)
        !           101:                                                goto loop;
        !           102:                                        break;
        !           103:                                case 'S':
        !           104:                                        if((argv[argc++]= (int)getstr())==0)
        !           105:                                                goto loop;
        !           106:                                        break;
        !           107:                                case 'L':
        !           108:                                        n = getint(1);
        !           109:                                        if(n == MAXINT) n = strleng;
        !           110:                                        argv[argc++]= n;
        !           111:                                        break;
        !           112:                                case 'B':
        !           113:                                        argv[argc++]= (int)ansbuf;
        !           114:                                        break;
        !           115:                                }
        !           116:                n= (*fctn[fn])(code,argv[0],argv[1],argv[2],argv[3],argv[4],argv[5]);
        !           117:                for(atp= fnargs[fn][code].ans; c= *atp++; )
        !           118:                        switch(c){
        !           119:                                case 'I': if(n<0) iberr(n, "IBIC");
        !           120:                                          else putd(n);
        !           121:                                          putchar(' '); break;
        !           122:                                case 'O': if(n<0) putd(n);
        !           123:                                          else puto(n);
        !           124:                                          putchar(' '); break;
        !           125:                                case 'B': put(ansbuf,n); putchar(' '); break;
        !           126:                                case 'T': putt(ansbuf,n);putchar(' '); break;
        !           127:                                }
        !           128:                putchar('\n');
        !           129:        }       }
        !           130: 
        !           131: srqint(){
        !           132:        puts("SRQ interrupt\n");
        !           133:        signal(SIGSRQ,srqint); }
        !           134: 
        !           135: echo(n, a)
        !           136:        char *a;
        !           137: {
        !           138:        return(strlen(ansbuf));
        !           139: }
        !           140: 
        !           141: slp(n, a)
        !           142: {
        !           143:        printf("sleeping %d secs\n", a); fflush(stdout);
        !           144:        sleep(a);
        !           145:        return(0);
        !           146: }
        !           147: 
        !           148: getfn(){ int fn;char *s, **a;
        !           149:        skpspc();
        !           150:        for(fn=0, a=fns; fn<NTYPES; fn++, a++)
        !           151:                if(match(cp,*a)) break;
        !           152:        if(fn>=NTYPES){ putl("unrecognized function"); return -1; }
        !           153:        skpnspc();
        !           154:        return fn; }
        !           155: 
        !           156: getcode(fn){ int f; struct argdef *a;
        !           157:        skpspc();
        !           158:        if(*cp>='0' && *cp<='9') f= atoi(cp);
        !           159:        else for(f=0, a=fnargs[fn]; f<=maxcode[fn]; a++, f++)
        !           160:                if(match(cp,a->name)) break;
        !           161:        if(f<0 || f>maxcode[fn]){ putl("illegal code"); return -1; }
        !           162:        skpnspc();
        !           163:        return f; }
        !           164: 
        !           165: getint(opt){ register int i;
        !           166:        skpspc();
        !           167:        if(*cp>='0' && *cp<='9' || *cp=='-'){
        !           168:                i= atoi(cp);
        !           169:                skpnspc();
        !           170:                return i; }
        !           171:        if(!opt)putl("illegal integer argument");
        !           172:        return MAXINT; }
        !           173: 
        !           174: char *getstr(){ char *s;
        !           175:        skpspc();
        !           176:        if(*cp++=='"'){
        !           177:                for(strleng=0, s=ansbuf; *cp && *cp!='"'; strleng++)
        !           178:                        *s++= cscan();
        !           179:                skpnspc();
        !           180:                return ansbuf; }
        !           181:        putl("illegal string argument");
        !           182:        return 0; }
        !           183: 
        !           184: skpspc()
        !           185: {
        !           186:        while(*cp)
        !           187:        {
        !           188:                if(*cp == '#')
        !           189:                        while(*++cp);
        !           190:                else if(*cp > ' ') break;
        !           191:                else cp++;
        !           192:        }
        !           193: }
        !           194: 
        !           195: skpnspc()
        !           196: {
        !           197:        while(*cp>' ') cp++;
        !           198: }
        !           199: 
        !           200: putl(s) char *s;{
        !           201:        puts(s); putchar('\n'); }
        !           202: 
        !           203: puts(s) char *s;{
        !           204:        while(*s) putchar(*s++); }
        !           205: 
        !           206: put(s,i) char *s;{
        !           207:        register int c;
        !           208:        while(i-->0)
        !           209:                if((c= *s++&0377)>=' ' && c<0177)
        !           210:                        putchar(c);
        !           211:                else {  putchar('\\');
        !           212:                        switch(c){
        !           213:                                case '\r': putchar('r'); break;
        !           214:                                case '\n': putchar('n'); break;
        !           215:                                case '\t': putchar('t'); break;
        !           216:                                case '\b': putchar('b'); break;
        !           217:                                case '\014': putchar('p'); break;
        !           218:                                default: putchar(((c>>6)&7) +'0');
        !           219:                                        putchar(((c>>3)&7) +'0');
        !           220:                                        putchar((c&7) +'0');
        !           221:                                        break;
        !           222:        }               }       }
        !           223: 
        !           224: putd(n){
        !           225:        if(n<0){ putchar('-'); n= -n; }
        !           226:        putu(n); }
        !           227: 
        !           228: putu(u) unsigned u;{
        !           229:        if(u>=10) putu(u/10);
        !           230:        putchar(u%10 + '0'); }
        !           231: 
        !           232: puto(o){
        !           233:        if(o&0177770) puto((o>>3)&017777);
        !           234:        putchar((o&7) +'0'); }
        !           235: 
        !           236: putt(buf,ct) char *buf;{ register int i;
        !           237:        if(ct<=0) return;
        !           238:        i= 0;
        !           239:        while(ct--){
        !           240:                if((i%8)==0) putchar('\n');
        !           241:                puto(buf[i++] & 0377);
        !           242:                putchar(' ');
        !           243:        }       }
        !           244: 
        !           245: atoi(s) char *s;{ int sign, base, n;
        !           246:        sign= 0;
        !           247:        base= 10;
        !           248:        if(*s=='-'){ sign++; s++; }
        !           249:        else if(*s=='0'){ base= 8; s++; }
        !           250:        for(n=0; *s>='0' && *s<='9'; ) n= n*base + *s++ - '0';
        !           251:        return sign? -n:n; }
        !           252: 
        !           253: getline(){ char *s;
        !           254:        putchar(':');
        !           255:        for(s=lbuf; (*s=getchar())!='\n'; )
        !           256:                if(*s<=0)
        !           257:                        if(errno==EINTR) errno= 0;
        !           258:                        else return s>lbuf? s-lbuf: -1;
        !           259:                else s++;
        !           260:        *s= 0;
        !           261:        return s-lbuf; }
        !           262: 
        !           263: match(st,s) char *st, *s;{ register char *t;
        !           264:        for(t=st; *t==*s || *t==(*s&~040); t++)
        !           265:                if(*s++==0) return 1;
        !           266:        if(t>st && *t<=' ') return 1;
        !           267:        return 0; }
        !           268: 
        !           269: cscan(){ register int n, i;
        !           270:        if(*cp!='\\') return *cp++;
        !           271:        cp++;
        !           272:        if(*cp>='0' && *cp<='7'){
        !           273:                for(i=3, n=0; i-->0 && *cp>='0' && *cp<='7'; )
        !           274:                        n= (n<<3) + *cp++ -'0';
        !           275:                return n; }
        !           276:        switch(*cp){
        !           277:                case 0: return 0;
        !           278:                case 'n': cp++; return '\n';
        !           279:                case 't': cp++; return '\t';
        !           280:                case 'r': cp++; return '\r';
        !           281:                case 'b': cp++; return '\b';
        !           282:                case 'p': cp++; return '\014';
        !           283:                default: return *cp++;
        !           284:        }       }

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