![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to y.tab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / oworm / oscsi|
Return to y.tab.c CVS log | Up to [Research Unix] / researchv10dc / cmd / oworm / oscsi |
1.1 root 1:
2: # line 4 "gram.y"
3:
4: #include "scsi.h"
5:
6:
7: # line 16 "gram.y"
8: typedef union {
9: char *str;
10: long num;
11: } YYSTYPE;
12: # define DISK 257
13: # define ID 258
14: # define RELEASE 259
15: # define HELP 260
16: # define SET 261
17: # define EJECT 262
18: # define INQUIRY 263
19: # define READ 264
20: # define CAPACITY 265
21: # define SENSE 266
22: # define NUMBER 267
23: # define EXT 268
24: # define SIDEA 269
25: # define SIDEB 270
26: # define ALL 271
27: # define RESET 272
28: # define SLEEP 273
29: # define START 274
30: # define STOP 275
31: # define STATUS 276
32: # define ECHO 277
33: # define ERROR 278
34: # define MEDIA 279
35: # define WORM 280
36: # define WRITE 281
37: # define DIAGNOSTIC 282
38: # define STRING 283
39: # define COPY 284
40: #define yyclearin yychar = -1
41: #define yyerrok yyerrflag = 0
42: extern int yychar;
43: extern short yyerrflag;
44: #ifndef YYMAXDEPTH
45: #define YYMAXDEPTH 150
46: #endif
47: YYSTYPE yylval, yyval;
48: # define YYERRCODE 256
49:
50: # line 89 "gram.y"
51:
52:
53: yywrap()
54: {
55: return(1);
56: }
57:
58: yyerror(s1, s2)
59: char *s1, *s2;
60: {
61: fprint(2, s1, s2);
62: fprint(2, "\n");
63: }
64: short yyexca[] ={
65: -1, 1,
66: 0, -1,
67: -2, 6,
68: };
69: # define YYNPROD 40
70: # define YYLAST 257
71: short yyact[]={
72:
73: 6, 9, 72, 8, 64, 65, 10, 13, 3, 15,
74: 23, 12, 39, 37, 63, 14, 16, 17, 19, 18,
75: 7, 26, 11, 20, 21, 5, 36, 4, 74, 73,
76: 26, 68, 67, 66, 53, 61, 60, 59, 57, 54,
77: 49, 41, 32, 30, 25, 31, 29, 47, 52, 27,
78: 28, 2, 1, 0, 33, 34, 35, 0, 38, 24,
79: 40, 0, 42, 43, 44, 45, 46, 0, 0, 0,
80: 0, 0, 0, 0, 50, 51, 0, 70, 0, 0,
81: 0, 55, 56, 0, 58, 0, 0, 0, 0, 0,
82: 0, 0, 0, 0, 0, 0, 48, 0, 0, 0,
83: 62, 0, 0, 0, 0, 0, 69, 0, 71, 0,
84: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
85: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
86: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
87: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
88: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
89: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
90: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
91: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
92: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
93: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
94: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
95: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
96: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
97: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
98: 0, 0, 0, 0, 0, 0, 22 };
99: short yypact[]={
100:
101: -1000,-257, 0,-237,-237,-237,-216,-225,-1000,-237,
102: -237,-237,-253,-246,-1000,-237,-226,-237,-237,-237,
103: -237,-237, 37,-1000,-1000,-1000,-1000,-227,-1000,-237,
104: -237,-233,-1000,-1000,-1000,-228,-237,-237,-229,-237,
105: -1000,-1000,-1000,-1000,-1000,-230,-231,-1000,-1000,-232,
106: -1000,-233,-265,-1000,-234,-235,-1000,-1000,-1000,-1000,
107: -236,-237,-265,-237,-1000,-1000,-281,-238,-1000,-239,
108: -1000,-1000,-1000,-1000,-1000 };
109: short yypgo[]={
110:
111: 0, 52, 44, 14, 48, 51 };
112: short yyr1[]={
113:
114: 0, 1, 1, 1, 1, 1, 5, 5, 5, 5,
115: 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
116: 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
117: 5, 5, 5, 5, 5, 5, 2, 4, 3, 3 };
118: short yyr2[]={
119:
120: 0, 0, 4, 3, 3, 4, 0, 2, 6, 2,
121: 3, 5, 3, 5, 2, 1, 2, 1, 2, 4,
122: 5, 5, 3, 3, 1, 2, 3, 2, 2, 2,
123: 1, 2, 2, 3, 3, 4, 1, 1, 1, 1 };
124: short yychk[]={
125:
126: -1000, -1, -5, 265, 284, 282, 257, 277, 260, 258,
127: 263, 279, 268, 264, 272, 266, 273, 274, 276, 275,
128: 280, 281, 256, 10, 59, -2, 267, -2, -2, 262,
129: 259, 261, 267, -2, -2, -2, 279, 266, -2, 258,
130: -2, 267, -2, -2, -2, -2, -2, 10, 59, 267,
131: -2, -2, -4, 267, 267, -2, -2, 267, -2, 267,
132: 267, 267, -4, -3, 269, 270, 267, 267, 267, -2,
133: -3, -2, 283, 267, 267 };
134: short yydef[]={
135:
136: 1, -2, 0, 0, 0, 0, 0, 0, 15, 0,
137: 17, 0, 0, 0, 24, 0, 0, 0, 30, 0,
138: 0, 0, 0, 3, 4, 7, 36, 0, 9, 0,
139: 0, 0, 14, 16, 18, 0, 0, 0, 0, 0,
140: 25, 27, 28, 29, 31, 32, 0, 2, 5, 0,
141: 10, 12, 0, 37, 0, 0, 26, 22, 23, 33,
142: 34, 0, 0, 0, 38, 39, 19, 0, 35, 0,
143: 11, 13, 20, 21, 8 };
144: # ifdef YYDEBUG
145: # include "y.debug"
146: # endif
147:
148: # define YYFLAG -1000
149: # define YYERROR goto yyerrlab
150: # define YYACCEPT return(0)
151: # define YYABORT return(1)
152:
153: /* parser for yacc output */
154:
155: #ifdef YYDEBUG
156: int yydebug = 0; /* 1 for debugging */
157: #endif
158: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
159: int yychar = -1; /* current input token number */
160: int yynerrs = 0; /* number of errors */
161: short yyerrflag = 0; /* error recovery flag */
162:
163: yyparse()
164: { short yys[YYMAXDEPTH];
165: int yyj, yym;
166: register YYSTYPE *yypvt;
167: register int yystate, yyn;
168: register short *yyps;
169: register YYSTYPE *yypv;
170: register short *yyxi;
171:
172: yystate = 0;
173: yychar = -1;
174: yynerrs = 0;
175: yyerrflag = 0;
176: yyps= &yys[-1];
177: yypv= &yyv[-1];
178:
179: yystack: /* put a state and value onto the stack */
180: #ifdef YYDEBUG
181: if(yydebug >= 3)
182: if(yychar < 0 || yytoknames[yychar] == 0)
183: printf("char %d in %s", yychar, yystates[yystate]);
184: else
185: printf("%s in %s", yytoknames[yychar], yystates[yystate]);
186: #endif
187: if( ++yyps >= &yys[YYMAXDEPTH] ) {
188: yyerror( "yacc stack overflow" );
189: return(1);
190: }
191: *yyps = yystate;
192: ++yypv;
193: *yypv = yyval;
194: yynewstate:
195: yyn = yypact[yystate];
196: if(yyn <= YYFLAG) goto yydefault; /* simple state */
197: if(yychar<0) {
198: yychar = yylex();
199: #ifdef YYDEBUG
200: if(yydebug >= 2) {
201: if(yychar <= 0)
202: printf("lex EOF\n");
203: else if(yytoknames[yychar])
204: printf("lex %s\n", yytoknames[yychar]);
205: else
206: printf("lex (%c)\n", yychar);
207: }
208: #endif
209: if(yychar < 0)
210: yychar = 0;
211: }
212: if((yyn += yychar) < 0 || yyn >= YYLAST)
213: goto yydefault;
214: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
215: yychar = -1;
216: yyval = yylval;
217: yystate = yyn;
218: if( yyerrflag > 0 ) --yyerrflag;
219: goto yystack;
220: }
221: yydefault:
222: /* default state action */
223: if( (yyn=yydef[yystate]) == -2 ) {
224: if(yychar < 0) {
225: yychar = yylex();
226: #ifdef YYDEBUG
227: if(yydebug >= 2)
228: if(yychar < 0)
229: printf("lex EOF\n");
230: else
231: printf("lex %s\n", yytoknames[yychar]);
232: #endif
233: if(yychar < 0)
234: yychar = 0;
235: }
236: /* look through exception table */
237: for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate);
238: yyxi += 2 ) ; /* VOID */
239: while( *(yyxi+=2) >= 0 ){
240: if( *yyxi == yychar ) break;
241: }
242: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
243: }
244: if( yyn == 0 ){ /* error */
245: /* error ... attempt to resume parsing */
246: switch( yyerrflag ){
247: case 0: /* brand new error */
248: #ifdef YYDEBUG
249: yyerror("syntax error\n%s", yystates[yystate]);
250: if(yytoknames[yychar])
251: yyerror("saw %s\n", yytoknames[yychar]);
252: else if(yychar >= ' ' && yychar < '\177')
253: yyerror("saw `%c'\n", yychar);
254: else if(yychar == 0)
255: yyerror("saw EOF\n");
256: else
257: yyerror("saw char 0%o\n", yychar);
258: #else
259: yyerror( "syntax error" );
260: #endif
261: yyerrlab:
262: ++yynerrs;
263: case 1:
264: case 2: /* incompletely recovered error ... try again */
265: yyerrflag = 3;
266: /* find a state where "error" is a legal shift action */
267: while ( yyps >= yys ) {
268: yyn = yypact[*yyps] + YYERRCODE;
269: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
270: yystate = yyact[yyn]; /* simulate a shift of "error" */
271: goto yystack;
272: }
273: yyn = yypact[*yyps];
274: /* the current yyps has no shift onn "error", pop stack */
275: #ifdef YYDEBUG
276: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
277: #endif
278: --yyps;
279: --yypv;
280: }
281: /* there is no state on the stack with an error shift ... abort */
282: yyabort:
283: return(1);
284: case 3: /* no shift yet; clobber input char */
285: #ifdef YYDEBUG
286: if( yydebug ) {
287: printf("error recovery discards ");
288: if(yytoknames[yychar])
289: printf("%s\n", yytoknames[yychar]);
290: else if(yychar >= ' ' && yychar < '\177')
291: printf("`%c'\n", yychar);
292: else if(yychar == 0)
293: printf("EOF\n");
294: else
295: printf("char 0%o\n", yychar);
296: }
297: #endif
298: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
299: yychar = -1;
300: goto yynewstate; /* try again in the same state */
301: }
302: }
303: /* reduction by production yyn */
304: #ifdef YYDEBUG
305: if(yydebug) { char *s;
306: printf("reduce %d in:\n\t", yyn);
307: for(s = yystates[yystate]; *s; s++) {
308: putchar(*s);
309: if(*s == '\n' && *(s+1))
310: putchar('\t');
311: }
312: }
313: #endif
314: yyps -= yyr2[yyn];
315: yypvt = yypv;
316: yypv -= yyr2[yyn];
317: yyval = yypv[1];
318: yym=yyn;
319: /* consult goto table to find next state */
320: yyn = yyr1[yyn];
321: yyj = yypgo[yyn] + *yyps + 1;
322: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
323: switch(yym){
324:
325: case 7:
326: # line 34 "gram.y"
327: { s_capacity(yypvt[-0].num, (long *)0, (long *)0); } break;
328: case 8:
329: # line 35 "gram.y"
330: {/*:COPY sdrive sstart nblocks ddrive dstart:: */
331: s_copy(yypvt[-4].num, yypvt[-3].num, yypvt[-2].num, yypvt[-1].num, yypvt[-0].num);
332: } break;
333: case 9:
334: # line 38 "gram.y"
335: { s_drdiag(yypvt[-0].num); } break;
336: case 10:
337: # line 39 "gram.y"
338: { s_diskeject(yypvt[-0].num); } break;
339: case 11:
340: # line 40 "gram.y"
341: { s_diskrelease(yypvt[-1].num, yypvt[-0].num, yypvt[-2].num, 1); } break;
342: case 12:
343: # line 41 "gram.y"
344: { s_diskrelease(-1, A, yypvt[-0].num, 1); } break;
345: case 13:
346: # line 42 "gram.y"
347: { s_diskset(yypvt[-2].num, yypvt[-1].num, yypvt[-0].num, 1); } break;
348: case 14:
349: # line 43 "gram.y"
350: { print(">> %d <<\n", yypvt[-0].num); } break;
351: case 15:
352: # line 44 "gram.y"
353: { help(); } break;
354: case 16:
355: # line 45 "gram.y"
356: { scsiid(yypvt[-0].num); } break;
357: case 17:
358: # line 46 "gram.y"
359: {
360: int i;
361: for(i = 0; i<8; i++)
362: s_inquiry(scsi_id, i);
363: } break;
364: case 18:
365: # line 51 "gram.y"
366: { s_inquiry(scsi_id, yypvt[-0].num); } break;
367: case 19:
368: # line 52 "gram.y"
369: { s_media(yypvt[-2].num, yypvt[-1].num, yypvt[-0].num, 0); } break;
370: case 20:
371: # line 53 "gram.y"
372: { s_mediaf(yypvt[-3].num, yypvt[-2].num, yypvt[-1].num, yypvt[-0].str); } break;
373: case 21:
374: # line 54 "gram.y"
375: { s_media(yypvt[-2].num, yypvt[-1].num, yypvt[-0].num, 1); } break;
376: case 22:
377: # line 55 "gram.y"
378: {
379: struct scsi_o output;
380: s_read(yypvt[-1].num, yypvt[-0].num, 1, &output);
381: scsiodump(output.data, 1024);
382: } break;
383: case 23:
384: # line 60 "gram.y"
385: {
386: struct scsi_o output;
387: s_read(yypvt[-0].num, 1, 1, &output);
388: print("id='%s'\n", &output.data[42]);
389: } break;
390: case 24:
391: # line 65 "gram.y"
392: { s_reset(); } break;
393: case 25:
394: # line 66 "gram.y"
395: { s_sense(yypvt[-0].num, 0); } break;
396: case 26:
397: # line 67 "gram.y"
398: { s_sense(yypvt[-0].num, 1); } break;
399: case 27:
400: # line 68 "gram.y"
401: { sleep(yypvt[-0].num); } break;
402: case 28:
403: # line 69 "gram.y"
404: { s_start(yypvt[-0].num); } break;
405: case 29:
406: # line 70 "gram.y"
407: { s_status(yypvt[-0].num, (struct scsi_o *)0); } break;
408: case 30:
409: # line 71 "gram.y"
410: { s_status(0, (struct scsi_o *)0); } break;
411: case 31:
412: # line 72 "gram.y"
413: { s_stop(yypvt[-0].num); } break;
414: case 32:
415: # line 73 "gram.y"
416: { s_worm(yypvt[-0].num, 1); } break;
417: case 33:
418: # line 74 "gram.y"
419: { s_worm(yypvt[-1].num, yypvt[-0].num); } break;
420: case 34:
421: # line 75 "gram.y"
422: { s_write(yypvt[-1].num, yypvt[-0].num, 1); } break;
423: case 35:
424: # line 76 "gram.y"
425: { s_write(yypvt[-2].num, yypvt[-1].num, yypvt[-0].num); } break;
426: case 38:
427: # line 85 "gram.y"
428: { yyval.num = 0; } break;
429: case 39:
430: # line 86 "gram.y"
431: { yyval.num = 1; } break;
432: }
433: goto yystack; /* stack new state and value */
434: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.