← Back to branch summary

~ubuntu-branches/ubuntu/karmic/scilab/karmic

« back to all changes in this revision

Viewing changes to routines/f2c/src/gram.in

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2002-03-21 16:57:43 UTC
  • Revision ID: james.westby@ubuntu.com-20020321165743-e9mv12c1tb1plztg
Tags: upstream-2.6
Import upstream version 2.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
routines/f2c/src/gram.in
 
1
%token SEOS 1
 
2
%token SCOMMENT 2
 
3
%token SLABEL 3
 
4
%token SUNKNOWN 4
 
5
%token SHOLLERITH 5
 
6
%token SICON 6
 
7
%token SRCON 7
 
8
%token SDCON 8
 
9
%token SBITCON 9
 
10
%token SOCTCON 10
 
11
%token SHEXCON 11
 
12
%token STRUE 12
 
13
%token SFALSE 13
 
14
%token SNAME 14
 
15
%token SNAMEEQ 15
 
16
%token SFIELD 16
 
17
%token SSCALE 17
 
18
%token SINCLUDE 18
 
19
%token SLET 19
 
20
%token SASSIGN 20
 
21
%token SAUTOMATIC 21
 
22
%token SBACKSPACE 22
 
23
%token SBLOCK 23
 
24
%token SCALL 24
 
25
%token SCHARACTER 25
 
26
%token SCLOSE 26
 
27
%token SCOMMON 27
 
28
%token SCOMPLEX 28
 
29
%token SCONTINUE 29
 
30
%token SDATA 30
 
31
%token SDCOMPLEX 31
 
32
%token SDIMENSION 32
 
33
%token SDO 33
 
34
%token SDOUBLE 34
 
35
%token SELSE 35
 
36
%token SELSEIF 36
 
37
%token SEND 37
 
38
%token SENDFILE 38
 
39
%token SENDIF 39
 
40
%token SENTRY 40
 
41
%token SEQUIV 41
 
42
%token SEXTERNAL 42
 
43
%token SFORMAT 43
 
44
%token SFUNCTION 44
 
45
%token SGOTO 45
 
46
%token SASGOTO 46
 
47
%token SCOMPGOTO 47
 
48
%token SARITHIF 48
 
49
%token SLOGIF 49
 
50
%token SIMPLICIT 50
 
51
%token SINQUIRE 51
 
52
%token SINTEGER 52
 
53
%token SINTRINSIC 53
 
54
%token SLOGICAL 54
 
55
%token SNAMELIST 55
 
56
%token SOPEN 56
 
57
%token SPARAM 57
 
58
%token SPAUSE 58
 
59
%token SPRINT 59
 
60
%token SPROGRAM 60
 
61
%token SPUNCH 61
 
62
%token SREAD 62
 
63
%token SREAL 63
 
64
%token SRETURN 64
 
65
%token SREWIND 65
 
66
%token SSAVE 66
 
67
%token SSTATIC 67
 
68
%token SSTOP 68
 
69
%token SSUBROUTINE 69
 
70
%token STHEN 70
 
71
%token STO 71
 
72
%token SUNDEFINED 72
 
73
%token SWRITE 73
 
74
%token SLPAR 74
 
75
%token SRPAR 75
 
76
%token SEQUALS 76
 
77
%token SCOLON 77
 
78
%token SCOMMA 78
 
79
%token SCURRENCY 79
 
80
%token SPLUS 80
 
81
%token SMINUS 81
 
82
%token SSTAR 82
 
83
%token SSLASH 83
 
84
%token SPOWER 84
 
85
%token SCONCAT 85
 
86
%token SAND 86
 
87
%token SOR 87
 
88
%token SNEQV 88
 
89
%token SEQV 89
 
90
%token SNOT 90
 
91
%token SEQ 91
 
92
%token SLT 92
 
93
%token SGT 93
 
94
%token SLE 94
 
95
%token SGE 95
 
96
%token SNE 96
 
97
%token SENDDO 97
 
98
%token SWHILE 98
 
99
%token SSLASHD 99
 
100
%token SBYTE 100
 
101
/****************************************************************
 
102
Copyright 1990, 1993 by AT&T Bell Laboratories, Bellcore.
 
103
 
 
104
Permission to use, copy, modify, and distribute this software
 
105
and its documentation for any purpose and without fee is hereby
 
106
granted, provided that the above copyright notice appear in all
 
107
copies and that both that the copyright notice and this
 
108
permission notice and warranty disclaimer appear in supporting
 
109
documentation, and that the names of AT&T Bell Laboratories or
 
110
Bellcore or any of their entities not be used in advertising or
 
111
publicity pertaining to distribution of the software without
 
112
specific, written prior permission.
 
113
 
 
114
AT&T and Bellcore disclaim all warranties with regard to this
 
115
software, including all implied warranties of merchantability
 
116
and fitness.  In no event shall AT&T or Bellcore be liable for
 
117
any special, indirect or consequential damages or any damages
 
118
whatsoever resulting from loss of use, data or profits, whether
 
119
in an action of contract, negligence or other tortious action,
 
120
arising out of or in connection with the use or performance of
 
121
this software.
 
122
****************************************************************/
 
123
 
 
124
%{
 
125
#include "defs.h"
 
126
#include "p1defs.h"
 
127
 
 
128
static int nstars;                      /* Number of labels in an
 
129
                                           alternate return CALL */
 
130
static int datagripe;
 
131
static int ndim;
 
132
static int vartype;
 
133
int new_dcl;
 
134
static ftnint varleng;
 
135
static struct Dims dims[MAXDIM+1];
 
136
extern struct Labelblock **labarray;    /* Labels in an alternate
 
137
                                                   return CALL */
 
138
extern int maxlablist;
 
139
 
 
140
/* The next two variables are used to verify that each statement might be reached
 
141
   during runtime.   lastwasbranch   is tested only in the defintion of the
 
142
   stat:   nonterminal. */
 
143
 
 
144
int lastwasbranch = NO;
 
145
static int thiswasbranch = NO;
 
146
extern ftnint yystno;
 
147
extern flag intonly;
 
148
static chainp datastack;
 
149
extern long laststfcn, thisstno;
 
150
extern int can_include; /* for netlib */
 
151
extern struct Primblock *primchk Argdcl((expptr));
 
152
 
 
153
#define ESNULL (Extsym *)0
 
154
#define NPNULL (Namep)0
 
155
#define LBNULL (struct Listblock *)0
 
156
 
 
157
 static void
 
158
pop_datastack(Void) {
 
159
        chainp d0 = datastack;
 
160
        if (d0->datap)
 
161
                curdtp = (chainp)d0->datap;
 
162
        datastack = d0->nextp;
 
163
        d0->nextp = 0;
 
164
        frchain(&d0);
 
165
        }
 
166
 
 
167
%}
 
168
 
 
169
/* Specify precedences and associativities. */
 
170
 
 
171
%union  {
 
172
        int ival;
 
173
        ftnint lval;
 
174
        char *charpval;
 
175
        chainp chval;
 
176
        tagptr tagval;
 
177
        expptr expval;
 
178
        struct Labelblock *labval;
 
179
        struct Nameblock *namval;
 
180
        struct Eqvchain *eqvval;
 
181
        Extsym *extval;
 
182
        }
 
183
 
 
184
%left SCOMMA
 
185
%nonassoc SCOLON
 
186
%right SEQUALS
 
187
%left SEQV SNEQV
 
188
%left SOR
 
189
%left SAND
 
190
%left SNOT
 
191
%nonassoc SLT SGT SLE SGE SEQ SNE
 
192
%left SCONCAT
 
193
%left SPLUS SMINUS
 
194
%left SSTAR SSLASH
 
195
%right SPOWER
 
196
 
 
197
%start program
 
198
%type <labval> thislabel label assignlabel
 
199
%type <tagval> other inelt
 
200
%type <ival> type typespec typename dcl letter addop relop stop nameeq
 
201
%type <lval> lengspec
 
202
%type <charpval> filename
 
203
%type <chval> datavar datavarlist namelistlist funarglist funargs
 
204
%type <chval> dospec dospecw
 
205
%type <chval> callarglist arglist args exprlist inlist outlist out2 substring
 
206
%type <namval> name arg call var
 
207
%type <expval> lhs expr uexpr opt_expr fexpr unpar_fexpr
 
208
%type <expval> ubound simple value callarg complex_const simple_const bit_const
 
209
%type <extval> common comblock entryname progname
 
210
%type <eqvval> equivlist
 
211
 
 
212
%%
 
213
 
 
214
program:
 
215
        | program stat SEOS
 
216
        ;
 
217
 
 
218
stat:     thislabel  entry
 
219
                {
 
220
/* stat:   is the nonterminal for Fortran statements */
 
221
 
 
222
                  lastwasbranch = NO; }
 
223
        | thislabel  spec
 
224
        | thislabel  exec
 
225
                { /* forbid further statement function definitions... */
 
226
                  if (parstate == INDATA && laststfcn != thisstno)
 
227
                        parstate = INEXEC;
 
228
                  thisstno++;
 
229
                  if($1 && ($1->labelno==dorange))
 
230
                        enddo($1->labelno);
 
231
                  if(lastwasbranch && thislabel==NULL)
 
232
                        warn("statement cannot be reached");
 
233
                  lastwasbranch = thiswasbranch;
 
234
                  thiswasbranch = NO;
 
235
                  if($1)
 
236
                        {
 
237
                        if($1->labtype == LABFORMAT)
 
238
                                err("label already that of a format");
 
239
                        else
 
240
                                $1->labtype = LABEXEC;
 
241
                        }
 
242
                  freetemps();
 
243
                }
 
244
        | thislabel SINCLUDE filename
 
245
                { if (can_include)
 
246
                        doinclude( $3 );
 
247
                  else {
 
248
                        fprintf(diagfile, "Cannot open file %s\n", $3);
 
249
                        done(1);
 
250
                        }
 
251
                }
 
252
        | thislabel  SEND  end_spec
 
253
                { if ($1)
 
254
                        lastwasbranch = NO;
 
255
                  endproc(); /* lastwasbranch = NO; -- set in endproc() */
 
256
                }
 
257
        | thislabel SUNKNOWN
 
258
                { unclassifiable();
 
259
 
 
260
/* flline flushes the current line, ignoring the rest of the text there */
 
261
 
 
262
                  flline(); }
 
263
        | error
 
264
                { flline();  needkwd = NO;  inioctl = NO;
 
265
                  yyerrok; yyclearin; }
 
266
        ;
 
267
 
 
268
thislabel:  SLABEL
 
269
                {
 
270
                if(yystno != 0)
 
271
                        {
 
272
                        $$ = thislabel =  mklabel(yystno);
 
273
                        if( ! headerdone ) {
 
274
                                if (procclass == CLUNKNOWN)
 
275
                                        procclass = CLMAIN;
 
276
                                puthead(CNULL, procclass);
 
277
                                }
 
278
                        if(thislabel->labdefined)
 
279
                                execerr("label %s already defined",
 
280
                                        convic(thislabel->stateno) );
 
281
                        else    {
 
282
                                if(thislabel->blklevel!=0 && thislabel->blklevel<blklevel
 
283
                                    && thislabel->labtype!=LABFORMAT)
 
284
                                        warn1("there is a branch to label %s from outside block",
 
285
                                              convic( (ftnint) (thislabel->stateno) ) );
 
286
                                thislabel->blklevel = blklevel;
 
287
                                thislabel->labdefined = YES;
 
288
                                if(thislabel->labtype != LABFORMAT)
 
289
                                        p1_label((long)(thislabel - labeltab));
 
290
                                }
 
291
                        }
 
292
                else    $$ = thislabel = NULL;
 
293
                }
 
294
        ;
 
295
 
 
296
entry:    SPROGRAM new_proc progname
 
297
                   {startproc($3, CLMAIN); }
 
298
        | SPROGRAM new_proc progname progarglist
 
299
                   {    warn("ignoring arguments to main program");
 
300
                        /* hashclear(); */
 
301
                        startproc($3, CLMAIN); }
 
302
        | SBLOCK new_proc progname
 
303
                { if($3) NO66("named BLOCKDATA");
 
304
                  startproc($3, CLBLOCK); }
 
305
        | SSUBROUTINE new_proc entryname arglist
 
306
                { entrypt(CLPROC, TYSUBR, (ftnint) 0,  $3, $4); }
 
307
        | SFUNCTION new_proc entryname arglist
 
308
                { entrypt(CLPROC, TYUNKNOWN, (ftnint) 0, $3, $4); }
 
309
        | type SFUNCTION new_proc entryname arglist
 
310
                { entrypt(CLPROC, $1, varleng, $4, $5); }
 
311
        | SENTRY entryname arglist
 
312
                 { if(parstate==OUTSIDE || procclass==CLMAIN
 
313
                        || procclass==CLBLOCK)
 
314
                                execerr("misplaced entry statement", CNULL);
 
315
                  entrypt(CLENTRY, 0, (ftnint) 0, $2, $3);
 
316
                }
 
317
        ;
 
318
 
 
319
new_proc:
 
320
                { newproc(); }
 
321
        ;
 
322
 
 
323
entryname:  name
 
324
                { $$ = newentry($1, 1); }
 
325
        ;
 
326
 
 
327
name:     SNAME
 
328
                { $$ = mkname(token); }
 
329
        ;
 
330
 
 
331
progname:               { $$ = NULL; }
 
332
        | entryname
 
333
        ;
 
334
 
 
335
progarglist:
 
336
          SLPAR SRPAR
 
337
        | SLPAR progargs SRPAR
 
338
        ;
 
339
 
 
340
progargs: progarg
 
341
        | progargs SCOMMA progarg
 
342
        ;
 
343
 
 
344
progarg:  SNAME
 
345
        | SNAME SEQUALS SNAME
 
346
        ;
 
347
 
 
348
arglist:
 
349
                { $$ = 0; }
 
350
        | SLPAR SRPAR
 
351
                { NO66(" () argument list");
 
352
                  $$ = 0; }
 
353
        | SLPAR args SRPAR
 
354
                {$$ = $2; }
 
355
        ;
 
356
 
 
357
args:     arg
 
358
                { $$ = ($1 ? mkchain((char *)$1,CHNULL) : CHNULL ); }
 
359
        | args SCOMMA arg
 
360
                { if($3) $1 = $$ = mkchain((char *)$3, $1); }
 
361
        ;
 
362
 
 
363
arg:      name
 
364
                { if($1->vstg!=STGUNKNOWN && $1->vstg!=STGARG)
 
365
                        dclerr("name declared as argument after use", $1);
 
366
                  $1->vstg = STGARG;
 
367
                }
 
368
        | SSTAR
 
369
                { NO66("altenate return argument");
 
370
 
 
371
/* substars   means that '*'ed formal parameters should be replaced.
 
372
   This is used to specify alternate return labels; in theory, only
 
373
   parameter slots which have '*' should accept the statement labels.
 
374
   This compiler chooses to ignore the '*'s in the formal declaration, and
 
375
   always return the proper value anyway.
 
376
 
 
377
   This variable is only referred to in   proc.c   */
 
378
 
 
379
                  $$ = 0;  substars = YES; }
 
380
        ;
 
381
 
 
382
 
 
383
 
 
384
filename:   SHOLLERITH
 
385
                {
 
386
                char *s;
 
387
                s = copyn(toklen+1, token);
 
388
                s[toklen] = '\0';
 
389
                $$ = s;
 
390
                }
 
391
        ;
 
392
spec:     dcl
 
393
        | common
 
394
        | external
 
395
        | intrinsic
 
396
        | equivalence
 
397
        | data
 
398
        | implicit
 
399
        | namelist
 
400
        | SSAVE
 
401
                { NO66("SAVE statement");
 
402
                  saveall = YES; }
 
403
        | SSAVE savelist
 
404
                { NO66("SAVE statement"); }
 
405
        | SFORMAT
 
406
                { fmtstmt(thislabel); setfmt(thislabel); }
 
407
        | SPARAM in_dcl SLPAR paramlist SRPAR
 
408
                { NO66("PARAMETER statement"); }
 
409
        ;
 
410
 
 
411
dcl:      type opt_comma name in_dcl new_dcl dims lengspec
 
412
                { settype($3, $1, $7);
 
413
                  if(ndim>0) setbound($3,ndim,dims);
 
414
                }
 
415
        | dcl SCOMMA name dims lengspec
 
416
                { settype($3, $1, $5);
 
417
                  if(ndim>0) setbound($3,ndim,dims);
 
418
                }
 
419
        | dcl SSLASHD datainit vallist SSLASHD
 
420
                { if (new_dcl == 2) {
 
421
                        err("attempt to give DATA in type-declaration");
 
422
                        new_dcl = 1;
 
423
                        }
 
424
                }
 
425
        ;
 
426
 
 
427
new_dcl:        { new_dcl = 2; } ;
 
428
 
 
429
type:     typespec lengspec
 
430
                { varleng = $2; }
 
431
        ;
 
432
 
 
433
typespec:  typename
 
434
                { varleng = ($1<0 || ONEOF($1,M(TYLOGICAL)|M(TYLONG))
 
435
                                ? 0 : typesize[$1]);
 
436
                  vartype = $1; }
 
437
        ;
 
438
 
 
439
typename:    SINTEGER   { $$ = TYLONG; }
 
440
        | SREAL         { $$ = tyreal; }
 
441
        | SCOMPLEX      { ++complex_seen; $$ = tycomplex; }
 
442
        | SDOUBLE       { $$ = TYDREAL; }
 
443
        | SDCOMPLEX     { ++dcomplex_seen; NOEXT("DOUBLE COMPLEX statement"); $$ = TYDCOMPLEX; }
 
444
        | SLOGICAL      { $$ = TYLOGICAL; }
 
445
        | SCHARACTER    { NO66("CHARACTER statement"); $$ = TYCHAR; }
 
446
        | SUNDEFINED    { $$ = TYUNKNOWN; }
 
447
        | SDIMENSION    { $$ = TYUNKNOWN; }
 
448
        | SAUTOMATIC    { NOEXT("AUTOMATIC statement"); $$ = - STGAUTO; }
 
449
        | SSTATIC       { NOEXT("STATIC statement"); $$ = - STGBSS; }
 
450
        | SBYTE         { $$ = TYINT1; }
 
451
        ;
 
452
 
 
453
lengspec:
 
454
                { $$ = varleng; }
 
455
        | SSTAR intonlyon expr intonlyoff
 
456
                {
 
457
                expptr p;
 
458
                p = $3;
 
459
                NO66("length specification *n");
 
460
                if( ! ISICON(p) || p->constblock.Const.ci <= 0 )
 
461
                        {
 
462
                        $$ = 0;
 
463
                        dclerr("length must be a positive integer constant",
 
464
                                NPNULL);
 
465
                        }
 
466
                else {
 
467
                        if (vartype == TYCHAR)
 
468
                                $$ = p->constblock.Const.ci;
 
469
                        else switch((int)p->constblock.Const.ci) {
 
470
                                case 1: $$ = 1; break;
 
471
                                case 2: $$ = typesize[TYSHORT]; break;
 
472
                                case 4: $$ = typesize[TYLONG];  break;
 
473
                                case 8: $$ = typesize[TYDREAL]; break;
 
474
                                case 16: $$ = typesize[TYDCOMPLEX]; break;
 
475
                                default:
 
476
                                        dclerr("invalid length",NPNULL);
 
477
                                        $$ = varleng;
 
478
                                }
 
479
                        }
 
480
                }
 
481
        | SSTAR intonlyon SLPAR SSTAR SRPAR intonlyoff
 
482
                { NO66("length specification *(*)"); $$ = -1; }
 
483
        ;
 
484
 
 
485
common:   SCOMMON in_dcl var
 
486
                { incomm( $$ = comblock("") , $3 ); }
 
487
        | SCOMMON in_dcl comblock var
 
488
                { $$ = $3;  incomm($3, $4); }
 
489
        | common opt_comma comblock opt_comma var
 
490
                { $$ = $3;  incomm($3, $5); }
 
491
        | common SCOMMA var
 
492
                { incomm($1, $3); }
 
493
        ;
 
494
 
 
495
comblock:  SCONCAT
 
496
                { $$ = comblock(""); }
 
497
        | SSLASH SNAME SSLASH
 
498
                { $$ = comblock(token); }
 
499
        ;
 
500
 
 
501
external: SEXTERNAL in_dcl name
 
502
                { setext($3); }
 
503
        | external SCOMMA name
 
504
                { setext($3); }
 
505
        ;
 
506
 
 
507
intrinsic:  SINTRINSIC in_dcl name
 
508
                { NO66("INTRINSIC statement"); setintr($3); }
 
509
        | intrinsic SCOMMA name
 
510
                { setintr($3); }
 
511
        ;
 
512
 
 
513
equivalence:  SEQUIV in_dcl equivset
 
514
        | equivalence SCOMMA equivset
 
515
        ;
 
516
 
 
517
equivset:  SLPAR equivlist SRPAR
 
518
                {
 
519
                struct Equivblock *p;
 
520
                if(nequiv >= maxequiv)
 
521
                        many("equivalences", 'q', maxequiv);
 
522
                p  =  & eqvclass[nequiv++];
 
523
                p->eqvinit = NO;
 
524
                p->eqvbottom = 0;
 
525
                p->eqvtop = 0;
 
526
                p->equivs = $2;
 
527
                }
 
528
        ;
 
529
 
 
530
equivlist:  lhs
 
531
                { $$=ALLOC(Eqvchain);
 
532
                  $$->eqvitem.eqvlhs = primchk($1);
 
533
                }
 
534
        | equivlist SCOMMA lhs
 
535
                { $$=ALLOC(Eqvchain);
 
536
                  $$->eqvitem.eqvlhs = primchk($3);
 
537
                  $$->eqvnextp = $1;
 
538
                }
 
539
        ;
 
540
 
 
541
data:     SDATA in_data datalist
 
542
        | data opt_comma datalist
 
543
        ;
 
544
 
 
545
in_data:
 
546
                { if(parstate == OUTSIDE)
 
547
                        {
 
548
                        newproc();
 
549
                        startproc(ESNULL, CLMAIN);
 
550
                        }
 
551
                  if(parstate < INDATA)
 
552
                        {
 
553
                        enddcl();
 
554
                        parstate = INDATA;
 
555
                        datagripe = 1;
 
556
                        }
 
557
                }
 
558
        ;
 
559
 
 
560
datalist:  datainit datavarlist SSLASH datapop vallist SSLASH
 
561
                { ftnint junk;
 
562
                  if(nextdata(&junk) != NULL)
 
563
                        err("too few initializers");
 
564
                  frdata($2);
 
565
                  frrpl();
 
566
                }
 
567
        ;
 
568
 
 
569
datainit: /* nothing */ { frchain(&datastack); curdtp = 0; } ;
 
570
 
 
571
datapop: /* nothing */ { pop_datastack(); } ;
 
572
 
 
573
vallist:  { toomanyinit = NO; }  val
 
574
        | vallist SCOMMA val
 
575
        ;
 
576
 
 
577
val:      value
 
578
                { dataval(ENULL, $1); }
 
579
        | simple SSTAR value
 
580
                { dataval($1, $3); }
 
581
        ;
 
582
 
 
583
value:    simple
 
584
        | addop simple
 
585
                { if( $1==OPMINUS && ISCONST($2) )
 
586
                        consnegop((Constp)$2);
 
587
                  $$ = $2;
 
588
                }
 
589
        | complex_const
 
590
        ;
 
591
 
 
592
savelist: saveitem
 
593
        | savelist SCOMMA saveitem
 
594
        ;
 
595
 
 
596
saveitem: name
 
597
                { int k;
 
598
                  $1->vsave = YES;
 
599
                  k = $1->vstg;
 
600
                if( ! ONEOF(k, M(STGUNKNOWN)|M(STGBSS)|M(STGINIT)) )
 
601
                        dclerr("can only save static variables", $1);
 
602
                }
 
603
        | comblock
 
604
        ;
 
605
 
 
606
paramlist:  paramitem
 
607
        | paramlist SCOMMA paramitem
 
608
        ;
 
609
 
 
610
paramitem:  name SEQUALS expr
 
611
                { if($1->vclass == CLUNKNOWN)
 
612
                        make_param((struct Paramblock *)$1, $3);
 
613
                  else dclerr("cannot make into parameter", $1);
 
614
                }
 
615
        ;
 
616
 
 
617
var:      name dims
 
618
                { if(ndim>0) setbound($1, ndim, dims); }
 
619
        ;
 
620
 
 
621
datavar:          lhs
 
622
                { Namep np;
 
623
                  struct Primblock *pp = (struct Primblock *)$1;
 
624
                  int tt = $1->tag;
 
625
                  if (tt != TPRIM) {
 
626
                        if (tt == TCONST)
 
627
                                err("parameter in data statement");
 
628
                        else
 
629
                                erri("tag %d in data statement",tt);
 
630
                        $$ = 0;
 
631
                        err_lineno = lineno;
 
632
                        break;
 
633
                        }
 
634
                  np = pp -> namep;
 
635
                  vardcl(np);
 
636
                  if ((pp->fcharp || pp->lcharp)
 
637
                   && (np->vtype != TYCHAR || np->vdim))
 
638
                        sserr(np);
 
639
                  if(np->vstg == STGCOMMON)
 
640
                        extsymtab[np->vardesc.varno].extinit = YES;
 
641
                  else if(np->vstg==STGEQUIV)
 
642
                        eqvclass[np->vardesc.varno].eqvinit = YES;
 
643
                  else if(np->vstg!=STGINIT && np->vstg!=STGBSS) {
 
644
                        errstr(np->vstg == STGARG
 
645
                                ? "Dummy argument \"%.60s\" in data statement."
 
646
                                : "Cannot give data to \"%.75s\"",
 
647
                                np->fvarname);
 
648
                        $$ = 0;
 
649
                        err_lineno = lineno;
 
650
                        break;
 
651
                        }
 
652
                  $$ = mkchain((char *)$1, CHNULL);
 
653
                }
 
654
        | SLPAR datavarlist SCOMMA dospec SRPAR
 
655
                { chainp p; struct Impldoblock *q;
 
656
                pop_datastack();
 
657
                q = ALLOC(Impldoblock);
 
658
                q->tag = TIMPLDO;
 
659
                (q->varnp = (Namep) ($4->datap))->vimpldovar = 1;
 
660
                p = $4->nextp;
 
661
                if(p)  { q->implb = (expptr)(p->datap); p = p->nextp; }
 
662
                if(p)  { q->impub = (expptr)(p->datap); p = p->nextp; }
 
663
                if(p)  { q->impstep = (expptr)(p->datap); }
 
664
                frchain( & ($4) );
 
665
                $$ = mkchain((char *)q, CHNULL);
 
666
                q->datalist = hookup($2, $$);
 
667
                }
 
668
        ;
 
669
 
 
670
datavarlist: datavar
 
671
                { if (!datastack)
 
672
                        curdtp = 0;
 
673
                  datastack = mkchain((char *)curdtp, datastack);
 
674
                  curdtp = $1; curdtelt = 0;
 
675
                  }
 
676
        | datavarlist SCOMMA datavar
 
677
                { $$ = hookup($1, $3); }
 
678
        ;
 
679
 
 
680
dims:
 
681
                { ndim = 0; }
 
682
        | SLPAR dimlist SRPAR
 
683
        ;
 
684
 
 
685
dimlist:   { ndim = 0; }   dim
 
686
        | dimlist SCOMMA dim
 
687
        ;
 
688
 
 
689
dim:      ubound
 
690
                {
 
691
                  if(ndim == maxdim)
 
692
                        err("too many dimensions");
 
693
                  else if(ndim < maxdim)
 
694
                        { dims[ndim].lb = 0;
 
695
                          dims[ndim].ub = $1;
 
696
                        }
 
697
                  ++ndim;
 
698
                }
 
699
        | expr SCOLON ubound
 
700
                {
 
701
                  if(ndim == maxdim)
 
702
                        err("too many dimensions");
 
703
                  else if(ndim < maxdim)
 
704
                        { dims[ndim].lb = $1;
 
705
                          dims[ndim].ub = $3;
 
706
                        }
 
707
                  ++ndim;
 
708
                }
 
709
        ;
 
710
 
 
711
ubound:   SSTAR
 
712
                { $$ = 0; }
 
713
        | expr
 
714
        ;
 
715
 
 
716
labellist: label
 
717
                { nstars = 1; labarray[0] = $1; }
 
718
        | labellist SCOMMA label
 
719
                { if(nstars < maxlablist)  labarray[nstars++] = $3; }
 
720
        ;
 
721
 
 
722
label:    SICON
 
723
                { $$ = execlab( convci(toklen, token) ); }
 
724
        ;
 
725
 
 
726
implicit:  SIMPLICIT in_dcl implist
 
727
                { NO66("IMPLICIT statement"); }
 
728
        | implicit SCOMMA implist
 
729
        ;
 
730
 
 
731
implist:  imptype SLPAR letgroups SRPAR
 
732
        | imptype
 
733
                { if (vartype != TYUNKNOWN)
 
734
                        dclerr("-- expected letter range",NPNULL);
 
735
                  setimpl(vartype, varleng, 'a', 'z'); }
 
736
        ;
 
737
 
 
738
imptype:   { needkwd = 1; } type
 
739
                /* { vartype = $2; } */
 
740
        ;
 
741
 
 
742
letgroups: letgroup
 
743
        | letgroups SCOMMA letgroup
 
744
        ;
 
745
 
 
746
letgroup:  letter
 
747
                { setimpl(vartype, varleng, $1, $1); }
 
748
        | letter SMINUS letter
 
749
                { setimpl(vartype, varleng, $1, $3); }
 
750
        ;
 
751
 
 
752
letter:  SNAME
 
753
                { if(toklen!=1 || token[0]<'a' || token[0]>'z')
 
754
                        {
 
755
                        dclerr("implicit item must be single letter", NPNULL);
 
756
                        $$ = 0;
 
757
                        }
 
758
                  else $$ = token[0];
 
759
                }
 
760
        ;
 
761
 
 
762
namelist:       SNAMELIST
 
763
        | namelist namelistentry
 
764
        ;
 
765
 
 
766
namelistentry:  SSLASH name SSLASH namelistlist
 
767
                {
 
768
                if($2->vclass == CLUNKNOWN)
 
769
                        {
 
770
                        $2->vclass = CLNAMELIST;
 
771
                        $2->vtype = TYINT;
 
772
                        $2->vstg = STGBSS;
 
773
                        $2->varxptr.namelist = $4;
 
774
                        $2->vardesc.varno = ++lastvarno;
 
775
                        }
 
776
                else dclerr("cannot be a namelist name", $2);
 
777
                }
 
778
        ;
 
779
 
 
780
namelistlist:  name
 
781
                { $$ = mkchain((char *)$1, CHNULL); }
 
782
        | namelistlist SCOMMA name
 
783
                { $$ = hookup($1, mkchain((char *)$3, CHNULL)); }
 
784
        ;
 
785
 
 
786
in_dcl:
 
787
                { switch(parstate)
 
788
                        {
 
789
                        case OUTSIDE:   newproc();
 
790
                                        startproc(ESNULL, CLMAIN);
 
791
                        case INSIDE:    parstate = INDCL;
 
792
                        case INDCL:     break;
 
793
 
 
794
                        case INDATA:
 
795
                                if (datagripe) {
 
796
                                        errstr(
 
797
                                "Statement order error: declaration after DATA",
 
798
                                                CNULL);
 
799
                                        datagripe = 0;
 
800
                                        }
 
801
                                break;
 
802
 
 
803
                        default:
 
804
                                dclerr("declaration among executables", NPNULL);
 
805
                        }
 
806
                }
 
807
        ;
 
808
funarglist:
 
809
                { $$ = 0; }
 
810
        | funargs
 
811
                { $$ = revchain($1); }
 
812
        ;
 
813
 
 
814
funargs:  expr
 
815
                { $$ = mkchain((char *)$1, CHNULL); }
 
816
        | funargs SCOMMA expr
 
817
                { $$ = mkchain((char *)$3, $1); }
 
818
        ;
 
819
 
 
820
 
 
821
expr:     uexpr
 
822
        | SLPAR expr SRPAR      { $$ = $2; if ($$->tag == TPRIM)
 
823
                                        $$->primblock.parenused = 1; }
 
824
        | complex_const
 
825
        ;
 
826
 
 
827
uexpr:    lhs
 
828
        | simple_const
 
829
        | expr addop expr   %prec SPLUS
 
830
                { $$ = mkexpr($2, $1, $3); }
 
831
        | expr SSTAR expr
 
832
                { $$ = mkexpr(OPSTAR, $1, $3); }
 
833
        | expr SSLASH expr
 
834
                { $$ = mkexpr(OPSLASH, $1, $3); }
 
835
        | expr SPOWER expr
 
836
                { $$ = mkexpr(OPPOWER, $1, $3); }
 
837
        | addop expr  %prec SSTAR
 
838
                { if($1 == OPMINUS)
 
839
                        $$ = mkexpr(OPNEG, $2, ENULL);
 
840
                  else  $$ = $2;
 
841
                }
 
842
        | expr relop expr  %prec SEQ
 
843
                { $$ = mkexpr($2, $1, $3); }
 
844
        | expr SEQV expr
 
845
                { NO66(".EQV. operator");
 
846
                  $$ = mkexpr(OPEQV, $1,$3); }
 
847
        | expr SNEQV expr
 
848
                { NO66(".NEQV. operator");
 
849
                  $$ = mkexpr(OPNEQV, $1, $3); }
 
850
        | expr SOR expr
 
851
                { $$ = mkexpr(OPOR, $1, $3); }
 
852
        | expr SAND expr
 
853
                { $$ = mkexpr(OPAND, $1, $3); }
 
854
        | SNOT expr
 
855
                { $$ = mkexpr(OPNOT, $2, ENULL); }
 
856
        | expr SCONCAT expr
 
857
                { NO66("concatenation operator //");
 
858
                  $$ = mkexpr(OPCONCAT, $1, $3); }
 
859
        ;
 
860
 
 
861
addop:    SPLUS         { $$ = OPPLUS; }
 
862
        | SMINUS        { $$ = OPMINUS; }
 
863
        ;
 
864
 
 
865
relop:    SEQ   { $$ = OPEQ; }
 
866
        | SGT   { $$ = OPGT; }
 
867
        | SLT   { $$ = OPLT; }
 
868
        | SGE   { $$ = OPGE; }
 
869
        | SLE   { $$ = OPLE; }
 
870
        | SNE   { $$ = OPNE; }
 
871
        ;
 
872
 
 
873
lhs:     name
 
874
                { $$ = mkprim($1, LBNULL, CHNULL); }
 
875
        | name substring
 
876
                { NO66("substring operator :");
 
877
                  $$ = mkprim($1, LBNULL, $2); }
 
878
        | name SLPAR funarglist SRPAR
 
879
                { $$ = mkprim($1, mklist($3), CHNULL); }
 
880
        | name SLPAR funarglist SRPAR substring
 
881
                { NO66("substring operator :");
 
882
                  $$ = mkprim($1, mklist($3), $5); }
 
883
        ;
 
884
 
 
885
substring:  SLPAR opt_expr SCOLON opt_expr SRPAR
 
886
                { $$ = mkchain((char *)$2, mkchain((char *)$4,CHNULL)); }
 
887
        ;
 
888
 
 
889
opt_expr:
 
890
                { $$ = 0; }
 
891
        | expr
 
892
        ;
 
893
 
 
894
simple:   name
 
895
                { if($1->vclass == CLPARAM)
 
896
                        $$ = (expptr) cpexpr(
 
897
                                ( (struct Paramblock *) ($1) ) -> paramval);
 
898
                }
 
899
        | simple_const
 
900
        ;
 
901
 
 
902
simple_const:   STRUE   { $$ = mklogcon(1); }
 
903
        | SFALSE        { $$ = mklogcon(0); }
 
904
        | SHOLLERITH  { $$ = mkstrcon(toklen, token); }
 
905
        | SICON = { $$ = mkintcon( convci(toklen, token) ); }
 
906
        | SRCON = { $$ = mkrealcon(tyreal, token); }
 
907
        | SDCON = { $$ = mkrealcon(TYDREAL, token); }
 
908
        | bit_const
 
909
        ;
 
910
 
 
911
complex_const:  SLPAR uexpr SCOMMA uexpr SRPAR
 
912
                { $$ = mkcxcon($2,$4); }
 
913
        ;
 
914
 
 
915
bit_const:  SHEXCON
 
916
                { NOEXT("hex constant");
 
917
                  $$ = mkbitcon(4, toklen, token); }
 
918
        | SOCTCON
 
919
                { NOEXT("octal constant");
 
920
                  $$ = mkbitcon(3, toklen, token); }
 
921
        | SBITCON
 
922
                { NOEXT("binary constant");
 
923
                  $$ = mkbitcon(1, toklen, token); }
 
924
        ;
 
925
 
 
926
fexpr:    unpar_fexpr
 
927
        | SLPAR fexpr SRPAR
 
928
                { $$ = $2; }
 
929
        ;
 
930
 
 
931
unpar_fexpr:      lhs
 
932
        | simple_const
 
933
        | fexpr addop fexpr   %prec SPLUS
 
934
                { $$ = mkexpr($2, $1, $3); }
 
935
        | fexpr SSTAR fexpr
 
936
                { $$ = mkexpr(OPSTAR, $1, $3); }
 
937
        | fexpr SSLASH fexpr
 
938
                { $$ = mkexpr(OPSLASH, $1, $3); }
 
939
        | fexpr SPOWER fexpr
 
940
                { $$ = mkexpr(OPPOWER, $1, $3); }
 
941
        | addop fexpr  %prec SSTAR
 
942
                { if($1 == OPMINUS)
 
943
                        $$ = mkexpr(OPNEG, $2, ENULL);
 
944
                  else  $$ = $2;
 
945
                }
 
946
        | fexpr SCONCAT fexpr
 
947
                { NO66("concatenation operator //");
 
948
                  $$ = mkexpr(OPCONCAT, $1, $3); }
 
949
        ;
 
950
exec:     iffable
 
951
        | SDO end_spec intonlyon label intonlyoff opt_comma dospecw
 
952
                {
 
953
                if($4->labdefined)
 
954
                        execerr("no backward DO loops", CNULL);
 
955
                $4->blklevel = blklevel+1;
 
956
                exdo($4->labelno, NPNULL, $7);
 
957
                }
 
958
        | SDO end_spec opt_comma dospecw
 
959
                {
 
960
                exdo((int)(ctls - ctlstack - 2), NPNULL, $4);
 
961
                NOEXT("DO without label");
 
962
                }
 
963
        | SENDDO
 
964
                { exenddo(NPNULL); }
 
965
        | logif iffable
 
966
                { exendif();  thiswasbranch = NO; }
 
967
        | logif STHEN
 
968
        | SELSEIF end_spec SLPAR expr SRPAR STHEN
 
969
                { exelif($4); lastwasbranch = NO; }
 
970
        | SELSE end_spec
 
971
                { exelse(); lastwasbranch = NO; }
 
972
        | SENDIF end_spec
 
973
                { exendif(); lastwasbranch = NO; }
 
974
        ;
 
975
 
 
976
logif:    SLOGIF end_spec SLPAR expr SRPAR
 
977
                { exif($4); }
 
978
        ;
 
979
 
 
980
dospec:   name SEQUALS exprlist
 
981
                { $$ = mkchain((char *)$1, $3); }
 
982
        ;
 
983
 
 
984
dospecw:  dospec
 
985
        | SWHILE SLPAR expr SRPAR
 
986
                { $$ = mkchain(CNULL, (chainp)$3); }
 
987
        ;
 
988
 
 
989
iffable:  let lhs SEQUALS expr
 
990
                { exequals((struct Primblock *)$2, $4); }
 
991
        | SASSIGN end_spec assignlabel STO name
 
992
                { exassign($5, $3); }
 
993
        | SCONTINUE end_spec
 
994
        | goto
 
995
        | io
 
996
                { inioctl = NO; }
 
997
        | SARITHIF end_spec SLPAR expr SRPAR label SCOMMA label SCOMMA label
 
998
                { exarif($4, $6, $8, $10);  thiswasbranch = YES; }
 
999
        | call
 
1000
                { excall($1, LBNULL, 0, labarray); }
 
1001
        | call SLPAR SRPAR
 
1002
                { excall($1, LBNULL, 0, labarray); }
 
1003
        | call SLPAR callarglist SRPAR
 
1004
                { if(nstars < maxlablist)
 
1005
                        excall($1, mklist(revchain($3)), nstars, labarray);
 
1006
                  else
 
1007
                        many("alternate returns", 'l', maxlablist);
 
1008
                }
 
1009
        | SRETURN end_spec opt_expr
 
1010
                { exreturn($3);  thiswasbranch = YES; }
 
1011
        | stop end_spec opt_expr
 
1012
                { exstop($1, $3);  thiswasbranch = $1; }
 
1013
        ;
 
1014
 
 
1015
assignlabel:   SICON
 
1016
                { $$ = mklabel( convci(toklen, token) ); }
 
1017
        ;
 
1018
 
 
1019
let:      SLET
 
1020
                { if(parstate == OUTSIDE)
 
1021
                        {
 
1022
                        newproc();
 
1023
                        startproc(ESNULL, CLMAIN);
 
1024
                        }
 
1025
                }
 
1026
        ;
 
1027
 
 
1028
goto:     SGOTO end_spec label
 
1029
                { exgoto($3);  thiswasbranch = YES; }
 
1030
        | SASGOTO end_spec name
 
1031
                { exasgoto($3);  thiswasbranch = YES; }
 
1032
        | SASGOTO end_spec name opt_comma SLPAR labellist SRPAR
 
1033
                { exasgoto($3);  thiswasbranch = YES; }
 
1034
        | SCOMPGOTO end_spec SLPAR labellist SRPAR opt_comma expr
 
1035
                { if(nstars < maxlablist)
 
1036
                        putcmgo(putx(fixtype($7)), nstars, labarray);
 
1037
                  else
 
1038
                        many("labels in computed GOTO list", 'l', maxlablist);
 
1039
                }
 
1040
        ;
 
1041
 
 
1042
opt_comma:
 
1043
        | SCOMMA
 
1044
        ;
 
1045
 
 
1046
call:     SCALL end_spec name
 
1047
                { nstars = 0; $$ = $3; }
 
1048
        ;
 
1049
 
 
1050
callarglist:  callarg
 
1051
                { $$ = $1 ? mkchain((char *)$1,CHNULL) : CHNULL; }
 
1052
        | callarglist SCOMMA callarg
 
1053
                { $$ = $3 ? mkchain((char *)$3, $1) : $1; }
 
1054
        ;
 
1055
 
 
1056
callarg:  expr
 
1057
        | SSTAR label
 
1058
                { if(nstars < maxlablist) labarray[nstars++] = $2; $$ = 0; }
 
1059
        ;
 
1060
 
 
1061
stop:     SPAUSE
 
1062
                { $$ = 0; }
 
1063
        | SSTOP
 
1064
                { $$ = 2; }
 
1065
        ;
 
1066
 
 
1067
exprlist:  expr
 
1068
                { $$ = mkchain((char *)$1, CHNULL); }
 
1069
        | exprlist SCOMMA expr
 
1070
                { $$ = hookup($1, mkchain((char *)$3,CHNULL) ); }
 
1071
        ;
 
1072
 
 
1073
end_spec:
 
1074
                { if(parstate == OUTSIDE)
 
1075
                        {
 
1076
                        newproc();
 
1077
                        startproc(ESNULL, CLMAIN);
 
1078
                        }
 
1079
 
 
1080
/* This next statement depends on the ordering of the state table encoding */
 
1081
 
 
1082
                  if(parstate < INDATA) enddcl();
 
1083
                }
 
1084
        ;
 
1085
 
 
1086
intonlyon:
 
1087
                { intonly = YES; }
 
1088
        ;
 
1089
 
 
1090
intonlyoff:
 
1091
                { intonly = NO; }
 
1092
        ;
 
1093
  /*  Input/Output Statements */
 
1094
 
 
1095
io:       io1
 
1096
                { endio(); }
 
1097
        ;
 
1098
 
 
1099
io1:      iofmove ioctl
 
1100
        | iofmove unpar_fexpr
 
1101
                { ioclause(IOSUNIT, $2); endioctl(); }
 
1102
        | iofmove SSTAR
 
1103
                { ioclause(IOSUNIT, ENULL); endioctl(); }
 
1104
        | iofmove SPOWER
 
1105
                { ioclause(IOSUNIT, IOSTDERR); endioctl(); }
 
1106
        | iofctl ioctl
 
1107
        | read ioctl
 
1108
                { doio(CHNULL); }
 
1109
        | read infmt
 
1110
                { doio(CHNULL); }
 
1111
        | read ioctl inlist
 
1112
                { doio(revchain($3)); }
 
1113
        | read infmt SCOMMA inlist
 
1114
                { doio(revchain($4)); }
 
1115
        | read ioctl SCOMMA inlist
 
1116
                { doio(revchain($4)); }
 
1117
        | write ioctl
 
1118
                { doio(CHNULL); }
 
1119
        | write ioctl outlist
 
1120
                { doio(revchain($3)); }
 
1121
        | print
 
1122
                { doio(CHNULL); }
 
1123
        | print SCOMMA outlist
 
1124
                { doio(revchain($3)); }
 
1125
        ;
 
1126
 
 
1127
iofmove:   fmkwd end_spec in_ioctl
 
1128
        ;
 
1129
 
 
1130
fmkwd:    SBACKSPACE
 
1131
                { iostmt = IOBACKSPACE; }
 
1132
        | SREWIND
 
1133
                { iostmt = IOREWIND; }
 
1134
        | SENDFILE
 
1135
                { iostmt = IOENDFILE; }
 
1136
        ;
 
1137
 
 
1138
iofctl:  ctlkwd end_spec in_ioctl
 
1139
        ;
 
1140
 
 
1141
ctlkwd:   SINQUIRE
 
1142
                { iostmt = IOINQUIRE; }
 
1143
        | SOPEN
 
1144
                { iostmt = IOOPEN; }
 
1145
        | SCLOSE
 
1146
                { iostmt = IOCLOSE; }
 
1147
        ;
 
1148
 
 
1149
infmt:    unpar_fexpr
 
1150
                {
 
1151
                ioclause(IOSUNIT, ENULL);
 
1152
                ioclause(IOSFMT, $1);
 
1153
                endioctl();
 
1154
                }
 
1155
        | SSTAR
 
1156
                {
 
1157
                ioclause(IOSUNIT, ENULL);
 
1158
                ioclause(IOSFMT, ENULL);
 
1159
                endioctl();
 
1160
                }
 
1161
        ;
 
1162
 
 
1163
ioctl:    SLPAR fexpr SRPAR
 
1164
                {
 
1165
                  ioclause(IOSUNIT, $2);
 
1166
                  endioctl();
 
1167
                }
 
1168
        | SLPAR ctllist SRPAR
 
1169
                { endioctl(); }
 
1170
        ;
 
1171
 
 
1172
ctllist:  ioclause
 
1173
        | ctllist SCOMMA ioclause
 
1174
        ;
 
1175
 
 
1176
ioclause:  fexpr
 
1177
                { ioclause(IOSPOSITIONAL, $1); }
 
1178
        | SSTAR
 
1179
                { ioclause(IOSPOSITIONAL, ENULL); }
 
1180
        | SPOWER
 
1181
                { ioclause(IOSPOSITIONAL, IOSTDERR); }
 
1182
        | nameeq expr
 
1183
                { ioclause($1, $2); }
 
1184
        | nameeq SSTAR
 
1185
                { ioclause($1, ENULL); }
 
1186
        | nameeq SPOWER
 
1187
                { ioclause($1, IOSTDERR); }
 
1188
        ;
 
1189
 
 
1190
nameeq:  SNAMEEQ
 
1191
                { $$ = iocname(); }
 
1192
        ;
 
1193
 
 
1194
read:     SREAD end_spec in_ioctl
 
1195
                { iostmt = IOREAD; }
 
1196
        ;
 
1197
 
 
1198
write:    SWRITE end_spec in_ioctl
 
1199
                { iostmt = IOWRITE; }
 
1200
        ;
 
1201
 
 
1202
print:    SPRINT end_spec fexpr in_ioctl
 
1203
                {
 
1204
                iostmt = IOWRITE;
 
1205
                ioclause(IOSUNIT, ENULL);
 
1206
                ioclause(IOSFMT, $3);
 
1207
                endioctl();
 
1208
                }
 
1209
        | SPRINT end_spec SSTAR in_ioctl
 
1210
                {
 
1211
                iostmt = IOWRITE;
 
1212
                ioclause(IOSUNIT, ENULL);
 
1213
                ioclause(IOSFMT, ENULL);
 
1214
                endioctl();
 
1215
                }
 
1216
        ;
 
1217
 
 
1218
inlist:   inelt
 
1219
                { $$ = mkchain((char *)$1, CHNULL); }
 
1220
        | inlist SCOMMA inelt
 
1221
                { $$ = mkchain((char *)$3, $1); }
 
1222
        ;
 
1223
 
 
1224
inelt:    lhs
 
1225
                { $$ = (tagptr) $1; }
 
1226
        | SLPAR inlist SCOMMA dospec SRPAR
 
1227
                { $$ = (tagptr) mkiodo($4,revchain($2)); }
 
1228
        ;
 
1229
 
 
1230
outlist:  uexpr
 
1231
                { $$ = mkchain((char *)$1, CHNULL); }
 
1232
        | other
 
1233
                { $$ = mkchain((char *)$1, CHNULL); }
 
1234
        | out2
 
1235
        ;
 
1236
 
 
1237
out2:     uexpr SCOMMA uexpr
 
1238
                { $$ = mkchain((char *)$3, mkchain((char *)$1, CHNULL) ); }
 
1239
        | uexpr SCOMMA other
 
1240
                { $$ = mkchain((char *)$3, mkchain((char *)$1, CHNULL) ); }
 
1241
        | other SCOMMA uexpr
 
1242
                { $$ = mkchain((char *)$3, mkchain((char *)$1, CHNULL) ); }
 
1243
        | other SCOMMA other
 
1244
                { $$ = mkchain((char *)$3, mkchain((char *)$1, CHNULL) ); }
 
1245
        | out2  SCOMMA uexpr
 
1246
                { $$ = mkchain((char *)$3, $1); }
 
1247
        | out2  SCOMMA other
 
1248
                { $$ = mkchain((char *)$3, $1); }
 
1249
        ;
 
1250
 
 
1251
other:    complex_const
 
1252
                { $$ = (tagptr) $1; }
 
1253
        | SLPAR expr SRPAR
 
1254
                { $$ = (tagptr) $2; }
 
1255
        | SLPAR uexpr SCOMMA dospec SRPAR
 
1256
                { $$ = (tagptr) mkiodo($4, mkchain((char *)$2, CHNULL) ); }
 
1257
        | SLPAR other SCOMMA dospec SRPAR
 
1258
                { $$ = (tagptr) mkiodo($4, mkchain((char *)$2, CHNULL) ); }
 
1259
        | SLPAR out2  SCOMMA dospec SRPAR
 
1260
                { $$ = (tagptr) mkiodo($4, revchain($2)); }
 
1261
        ;
 
1262
 
 
1263
in_ioctl:
 
1264
                { startioctl(); }
 
1265
        ;