Return to gram.y CVS log

Up to [Research Unix] / researchv10dc / cmd / oworm / scsi

Annotation of researchv10dc/cmd/oworm/scsi/gram.y, revision 1.1.1.1

1.1       root        1: %start         input
                      2: 
                      3: %{
                      4: 
                      5: #include       "scsi.h"
                      6: 
                      7: %}
                      8: 
                      9: %token         DISK ID RELEASE HELP SET EJECT INQUIRY READ CAPACITY SENSE
                     10: %token         NUMBER EXT SIDEA SIDEB ALL RESET SLEEP START STOP STATUS
                     11: %token         ECHO ERROR MEDIA WORM WRITE DIAGNOSTIC STRING COPY CONFIG
                     12: %token         TEST INTERNAL ALTERNATE
                     13: 
                     14: %type <str>    STRING
                     15: %type <num>    NUMBER drive side shelf optdrive
                     16: 
                     17: %union {
                     18:        char *str;
                     19:        int num;        /* 32 bits */
                     20: }
                     21: 
                     22: %%
                     23: 
                     24: input  :       /* nothing */
                     25:        |       input line error '\n'
                     26:        |       input line '\n'
                     27:        |       input line ';'
                     28:        |       input line error ';'
                     29:        ;
                     30: 
                     31:        /*
                     32:                help can be done explicitly by :help info::
                     33:        */
                     34: line   :               /* nothing */
                     35:        |       ALTERNATE optdrive  { s_alternate($2); }
                     36:        |       CAPACITY optdrive   { s_capacity($2, (long *)0, (long *)0); }
                     37:        |       CONFIG { s_config(); }
                     38:        |       COPY drive NUMBER NUMBER drive NUMBER {/*:COPY sdrive sstart nblocks ddrive dstart:: */
                     39:                        s_copy($2, $3, $4, $5, $6);
                     40:                }
                     41:        |       DISK EJECT drive  { s_diskeject($3); }
                     42:        |       DISK ID drive  { s_diskid($3); }
                     43:        |       DISK RELEASE drive shelf side  { s_diskrelease($4, $5, $3, 1); }
                     44:        |       DISK RELEASE drive  { s_diskrelease(-1, A, $3, 1); }
                     45:        |       DISK SET shelf side drive  { s_diskset($3, $4, $5, 1); }
                     46:        |       ECHO NUMBER  { print(">> %d <<\n", $2); }
                     47:        |       HELP  { help(); }
                     48:        |       ID drive  { scsiid($2); }
                     49:        |       INQUIRY {
                     50:                        int i;
                     51:                        for(i = 0; i<8; i++)
                     52:                                s_inquiry(scsi_id, i);
                     53:                }
                     54:        |       INQUIRY drive  { s_inquiry(scsi_id, $2); }
                     55:        |       INTERNAL { s_internal(-1, 0); }
                     56:        |       INTERNAL NUMBER optdrive  { s_internal($2, $3); }
                     57:        |       MEDIA drive NUMBER NUMBER  { s_media($2, $3, $4, 0); }
                     58:        |       MEDIA drive NUMBER NUMBER STRING  { s_mediaf($2, $3, $4, $5); } /*:MEDIA drive start nblocks \"filename\"::*/
                     59:        |       EXT MEDIA drive NUMBER NUMBER  { s_media($3, $4, $5, 1); }
                     60:        |       READ drive NUMBER  {
                     61:                        struct scsi_o output;
                     62:                        s_read($2, $3, 1, &output);
                     63:                        scsiodump(output.data, 1024);
                     64:                }
                     65:        |       READ ID drive  {
                     66:                        char name[256];
                     67: ;
                     68:                        s_readid($3, name);
                     69:                        print("id='%s'\n", name);
                     70:                }
                     71:        |       RESET  { s_reset(); }
                     72:        |       SENSE drive { s_sense($2, 0); }
                     73:        |       EXT SENSE drive { s_sense($3, 1); }
                     74:        |       SLEEP NUMBER  { sleep($2); }
                     75:        |       START drive { s_start($2); }
                     76:        |       STATUS drive { s_status($2, (struct scsi_o *)0); }
                     77:        |       STATUS { s_status(0, (struct scsi_o *)0); }
                     78:        |       STOP drive  { s_stop($2); }
                     79:        |       TEST drive { s_testunit(scsi_id, $2); }
                     80:        |       WORM drive { s_worm($2, 1); }
                     81:        |       WORM drive NUMBER { s_worm($2, $3); } /*:WORM drive start:: */
                     82:        |       WRITE drive NUMBER { s_write($2, $3, 1); }
                     83:        |       WRITE drive NUMBER NUMBER { s_write($2, $3, $4); } /*:WRITE drive start n:: */
                     84:        ;
                     85: 
                     86: drive  :       NUMBER
                     87:        ;
                     88: 
                     89: optdrive:      NUMBER
                     90:        |       { $$ = 0; }
                     91:        ;
                     92: 
                     93: shelf  :       NUMBER
                     94:        ;
                     95: 
                     96: side   :       SIDEA  { $$ = 0; }
                     97:        |       SIDEB   { $$ = 1; }
                     98:        ;
                     99: 
                    100: %%
                    101: 
                    102: yywrap()
                    103: {
                    104:        return(1);
                    105: }
                    106: 
                    107: yyerror(s1, s2)
                    108:        char *s1, *s2;
                    109: {
                    110:        fprint(2, s1, s2);
                    111:        fprint(2, "\n");
                    112: }

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