![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ibic.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / qsnap|
Return to ibic.c CVS log | Up to [Research Unix] / researchv10dc / cmd / qsnap |
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.