Debian Codegraph @

yaccsrc.y

raw ◀ ▶
1 Debian patch touch this file
1 %{
2
3 #ifndef lint
4 static char *RCSid = "$Id: yaccsrc.y,v 1.44 2019/04/06 10:11:51 mark Exp $";
5 #endif
6
7 /*
8 * The Regina Rexx Interpreter
9 * Copyright (C) 1992-1994 Anders Christensen <[email protected]>
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Library General Public License for more details.
20 *
21 * You should have received a copy of the GNU Library General Public
22 * License along with this library; if not, write to the Free
23 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "rexx.h"
27 #include <time.h>
28
29 #if defined(HAVE_MALLOC_H)
30 # include <malloc.h>
31 #endif
32
33 #if defined(HAVE_ALLOCA_H)
34 # include <alloca.h>
35 #endif
36
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <string.h>
40 #include <assert.h>
41
42 #if defined(_MSC_VER) || defined(MAC)
43 # define __STDC__ 1 /* Hack to allow const since it is not defined */
44 #endif
45
46 #define YYSTYPE nodeptr
47
48 /* locals, they are protected by regina_parser (see lexsrc.l) */
49 static int tmplno, /* lineno of current instruction */
50 tmpchr, /* character position of current instruction */
51 level, /* nested do/if/select depth */
52 start_parendepth; /* see below at parendepth */
53
54 /*
55 * parendepth regulates the action which happens detecting a comma or an
56 * empty expression. A negative values indicates an error; both a comma
57 * and an empty expression raise an error.
58 * We regulate the enumeration of arguments with this semantical flag.
59 * Look at "call subroutine args" and "function args". Function itself
60 * contains a parentheses pair, so starting with a depth of just allows
61 * the enumeration. subroutine starts with either 0 or 1. The latter one
62 * is allowed for the support request of "call subroutine(a,b,c)" which
63 * isn't allowed by ANSI but can be enabled for backward compatibility.
64 */
65 static int parendepth;
66
67 static nodeptr current, with = NULL;
68
•69 static char *mynullptr = NULL; /* for C++ compilation */
70
71 typedef enum { IS_UNKNOWN,
72 IS_A_NUMBER,
73 IS_NO_NUMBER,
74 IS_SIM_SYMBOL,
75 IS_COMP_SYMBOL } node_type;
76
77 typedef enum { REDUCE_CALL,
78 REDUCE_EXPR,
79 REDUCE_RIGHT,
80 REDUCE_SUBEXPR } reduce_mode;
81
82 static node_type gettypeof( nodeptr thisptr ) ;
83 static void checkconst( nodeptr thisptr ) ;
84 static nodeptr reduce_expr_list( nodeptr thisptr, reduce_mode mode );
85 static void transform( nodeptr thisptr ) ;
86 static nodeptr create_head( const char *name ) ;
87 static nodeptr makenode( int type, int numb, ... ) ;
88 static void checkdosyntax( cnodeptr thisptr ) ;
89 void newlabel( const tsd_t *TSD, internal_parser_type *ipt, nodeptr thisptr ) ;
90 static nodeptr optgluelast( nodeptr p1, nodeptr p2 );
91 static void move_labels( nodeptr front, nodeptr end, int level );
92
93 #define IS_EXPRLIST(x) ( ( (x) != NULL ) \
94 && ( ( (x)->type == X_CEXPRLIST ) \
95 || ( (x)->type == X_EXPRLIST ) ) )
96
97 #define IS_FUNCTION(x) ( ( (x) != NULL ) \
98 && ( ( (x)->type == X_EX_FUNC ) \
99 || ( (x)->type == X_IN_FUNC ) ) )
100
101 #define AUTO_REDUCE(x,y) { if ( parendepth == 1 ) \
102 { \
103 x = reduce_expr_list( x, REDUCE_EXPR ); \
104 /* detect "call s (a,b)<op>" and */ \
105 /* "call s ()<op>" */ \
106 if ( IS_EXPRLIST( x ) ) \
107 { \
108 if ( (y) != NULL ) \
109 exiterror( ERR_INVALID_EXPRESSION, 1, y ); \
110 else if ( (x)->p[0] == NULL ) \
111 exiterror( ERR_UNEXPECTED_PARAN, 0 ); \
112 else \
113 exiterror( ERR_UNEXPECTED_PARAN, 1 ); \
114 } \
115 } \
116 }
117 %}
118
119 %token ADDRESS ARG CALL DO TO BY FOR WHILE UNTIL EXIT IF THEN ELSE
120 %token ITERATE INTERPRET LEAVE NOP NUMERIC PARSE EXTERNAL SOURCE VAR
121 %token VALUE WITH PROCEDURE EXPOSE PULL PUSH QUEUE SAY RETURN SELECT
122 %token WHEN DROP OTHERWISE SIGNAL ON OFF SYNTAX HALT NOVALUE
123 %token TRACE END UPPER ASSIGNMENTVARIABLE STATSEP FOREVER DIGITS FORM
124 %token FUZZ SCIENTIFIC ENGINEERING NOT CONCATENATE MODULUS GTE GT LTE
125 %token LT DIFFERENT EQUALEQUAL NOTEQUALEQUAL OFFSET SPACE EXP XOR
126 %token PLACEHOLDER NOTREADY CONSYMBOL SIMSYMBOL EXFUNCNAME INFUNCNAME
127 %token LABEL DOVARIABLE HEXSTRING STRING VERSION LINEIN WHATEVER NAME
128 %token FAILURE BINSTRING OPTIONS ENVIRONMENT LOSTDIGITS
129 %token GTGT LTLT NOTGTGT NOTLTLT GTGTE LTLTE
130 %token INPUT OUTPUT ERROR NORMAL APPEND REPLACE STREAM STEM LIFO FIFO NOEOL
131 %token LOWER CASELESS
132 %token PLUSASSIGNMENTVARIABLE MINUSASSIGNMENTVARIABLE MULTASSIGNMENTVARIABLE DIVASSIGNMENTVARIABLE MODULUSASSIGNMENTVARIABLE INTDIVASSIGNMENTVARIABLE ORASSIGNMENTVARIABLE XORASSIGNMENTVARIABLE ANDASSIGNMENTVARIABLE CONCATASSIGNMENTVARIABLE
133
134 %start start
135
136 %left '|' XOR
137 %left '&'
138 %left '=' DIFFERENT GTE GT LT LTE EQUALEQUAL NOTEQUALEQUAL GTGT LTLT NOTGTGT NOTLTLT GTGTE LTLTE
139 %left CONCATENATE SPACE CCAT
140 %left '+' '-'
141 %left '*' '/' '%' MODULUS
142 %left EXP
143 %left UMINUS UPLUS NOT /*UPLUS and UMINUS are locally used to assign precedence*/
144
145 %nonassoc THEN
146 %nonassoc ELSE
147
148 %right STATSEP
149
150 %{
151 #ifdef NDEBUG
152 # define YYDEBUG 0
153 #else
154 # define YYDEBUG 1
155 #endif
156 %}
157
158 %%
159
160 start : { level = 0;
161 if ( get_options_flag( parser_data.TSD->currlevel, EXT_CALLS_AS_FUNCS )
162 && !get_options_flag( parser_data.TSD->currlevel, EXT_STRICT_ANSI ) )
163 start_parendepth = 1;
164 else
165 start_parendepth = 0;
166 parendepth = 0; }
167 prog
168 ;
169
170 prog : nlncl stats { $$ = optgluelast( $1, $2 );
171 $$->o.last = NULL;
172 EndProg( $$ ) ; }
173 | nlncl { $$ = $1;
174 if ( $$ != NULL )
175 $$->o.last = NULL;
176 EndProg( $$ ); }
177 ;
178
179 stats : stats ystatement { /* fixes bug 579711 */
180 $$ = optgluelast( $1, $2 ); }
181 | ystatement { $$ = $1; }
182 ;
183
184 xstats : xstats statement { /* fixes bug 579711 */
185 $$ = optgluelast( $1, $2 ); }
186 | statement gruff { $$ = $1; }
187 ;
188
189 ystatement : statement { $$ = $1 ; }
190 | lonely_end { exiterror( ERR_UNMATCHED_END, 1 ); }
191 ;
192
193 lonely_end : gruff end ncl /* ncl's label's out of matter, this
194 * rule leads to an error.
195 */
196 ;
197
198 nxstats : xstats { $$ = $1; }
199 | gruff { $$ = NULL; }
200 ;
201
202 ncl : ncl STATSEP optLabels { $$ = optgluelast( $1, $3 ); }
203 | STATSEP optLabels { $$ = $2; }
204 ;
205
206 nlncl : optLabels ncl { $$ = optgluelast( $1, $2 ); }
207 | optLabels { $$ = $1; }
208 ;
209
210 optLabels : optLabels label_stat { $$ = optgluelast( $1, $2 ); }
211 | { $$ = NULL; }
212 ;
213
214 statement : mttstatement
215 | ex_when_stat
216 ;
217
218 gruff : { tmpchr=parser_data.tstart;
219 tmplno=parser_data.tline; }
220 ;
221
222 mttstatement : gruff mtstatement { $$=$2; }
223 ;
224
225 mtstatement : nclstatement ncl { $$ = optgluelast( $1, $2 ); }
226 | if_stat
227 | unexp_then
228 | unexp_else
229 ;
230
231 nclstatement : address_stat
232 | expr_stat
233 | arg_stat
234 | call_stat
235 | do_stat
236 | drop_stat
237 | exit_stat
238 | ipret_stat
239 | iterate_stat
240 | leave_stat
241 | nop_stat
242 | numeric_stat
243 | options_stat
244 | parse_stat
245 | proc_stat
246 | pull_stat
247 | push_stat
248 | queue_stat
249 | return_stat
250 | say_stat
251 | select_stat
252 | signal_stat
253 | trace_stat
254 | upper_stat
255 | plusassignment
256 | minusassignment
257 | multassignment
258 | divassignment
259 | intdivassignment
260 | modulusassignment
261 | xorassignment
262 | orassignment
263 | andassignment
264 | concatassignment
265 | assignment
266 ;
267
268 call : CALL { $$ = makenode(X_CALL,0) ;
269 $$->lineno = parser_data.tline ;
270 $$->charnr = parser_data.tstart ; }
271 ;
272 do : DO { $$ = makenode(X_DO,0) ;
273 $$->lineno = parser_data.tline ;
274 $$->charnr = parser_data.tstart ;
275 level++; }
276 ;
277 exit : EXIT { $$ = makenode(X_EXIT,0) ;
278 $$->lineno = parser_data.tline ;
279 $$->charnr = parser_data.tstart ; }
280 ;
281 if : IF { $$ = makenode(X_IF,0) ;
282 $$->lineno = parser_data.tline ;
283 $$->charnr = parser_data.tstart ;
284 level++; }
285 ;
286 iterate : ITERATE { $$ = makenode(X_ITERATE,0) ;
287 $$->lineno = parser_data.tline ;
288 $$->charnr = parser_data.tstart ; }
289 ;
290 leave : LEAVE { $$ = makenode(X_LEAVE,0) ;
291 $$->lineno = parser_data.tline ;
292 $$->charnr = parser_data.tstart ; }
293 ;
294 say : SAY { $$ = makenode(X_SAY,0) ;
295 $$->lineno = parser_data.tline ;
296 $$->charnr = parser_data.tstart ; }
297 ;
298 return : RETURN { $$ = makenode(X_RETURN,0) ;
299 $$->lineno = parser_data.tline ;
300 $$->charnr = parser_data.tstart ; }
301 ;
302 address : ADDRESS { $$ = makenode(X_ADDR_N,0) ;
303 $$->lineno = parser_data.tline ;
304 $$->charnr = parser_data.tstart ; }
305 ;
306 arg : ARG { $$ = makenode(X_PARSE_ARG,0) ;
307 $$->lineno = parser_data.tline ;
308 $$->charnr = parser_data.tstart ; }
309 ;
310 drop : DROP { $$ = makenode(X_DROP,0) ;
311 $$->lineno = parser_data.tline ;
312 $$->charnr = parser_data.tstart ; }
313 ;
314 interpret : INTERPRET { $$ = makenode(X_IPRET,0) ;
315 $$->lineno = parser_data.tline ;
316 $$->charnr = parser_data.tstart ; }
317 ;
318 label : LABEL { $$ = makenode(X_LABEL,0) ;
319 $$->lineno = parser_data.tline ;
320 $$->charnr = parser_data.tstart ; }
321 ;
322 nop : NOP { $$ = makenode(X_NULL,0) ;
323 $$->lineno = parser_data.tline ;
324 $$->charnr = parser_data.tstart ; }
325 ;
326 numeric : NUMERIC { $$ = makenode(0,0) ;
327 $$->lineno = parser_data.tline ;
328 $$->charnr = parser_data.tstart ; }
329 ;
330 options : OPTIONS { $$ = makenode(X_OPTIONS,0) ;
331 $$->lineno = parser_data.tline ;
332 $$->charnr = parser_data.tstart ; }
333 ;
334 parse : PARSE { $$ = makenode(0,0) ;
335 $$->lineno = parser_data.tline ;
336 $$->charnr = parser_data.tstart ; }
337 ;
338 proc : PROCEDURE { $$ = makenode(X_PROC,0) ;
339 $$->lineno = parser_data.tline ;
340 $$->charnr = parser_data.tstart ; }
341 ;
342 pull : PULL { $$ = makenode(X_PULL,0) ;
343 $$->lineno = parser_data.tline ;
344 $$->charnr = parser_data.tstart ; }
345 ;
346 push : PUSH { $$ = makenode(X_PUSH,0) ;
347 $$->lineno = parser_data.tline ;
348 $$->charnr = parser_data.tstart ; }
349 ;
350 queue : QUEUE { $$ = makenode(X_QUEUE,0) ;
351 $$->lineno = parser_data.tline ;
352 $$->charnr = parser_data.tstart ; }
353 ;
354 select : SELECT { $$ = makenode(X_SELECT,0) ;
355 $$->lineno = parser_data.tline ;
356 $$->charnr = parser_data.tstart ;
357 level++; }
358 ;
359 signal : SIGNAL { $$ = makenode(X_SIG_LAB,0) ;
360 $$->lineno = parser_data.tline ;
361 $$->charnr = parser_data.tstart ; }
362 ;
363 when : WHEN { $$ = makenode(X_WHEN,0) ;
364 $$->lineno = parser_data.tline ;
365 $$->charnr = parser_data.tstart ; }
366 ;
367 otherwise : OTHERWISE { $$ = makenode(X_OTHERWISE,0) ;
368 $$->lineno = parser_data.tline ;
369 $$->charnr = parser_data.tstart ; }
370 ;
371 trace : TRACE { $$ = makenode(X_TRACE,0) ;
372 $$->lineno = parser_data.tline ;
373 $$->charnr = parser_data.tstart ; }
374 ;
375 upper : UPPER { $$ = makenode(X_UPPER_VAR,0) ;
376 $$->lineno = parser_data.tline ;
377 $$->charnr = parser_data.tstart ; }
378 ;
379 address_stat : address { $$ = current = $1 ; }
380 address_stat2
381 ;
382
383 address_stat2: VALUE expr naddr_with { current->type = X_ADDR_V ;
384 current->p[0] = $2 ;
385 current->p[1] = $3 ; }
386 | addr_with { exiterror( ERR_STRING_EXPECTED, 1, __reginatext ) ;}
387 | { current->type = X_ADDR_S ; }
388 | error { exiterror( ERR_STRING_EXPECTED, 1, __reginatext ) ;}
389 naddr_with
390 | nvir nexpr naddr_with { current->name = (streng *)$1 ;
391 current->type = X_ADDR_N ;
392 current->p[0] = $2 ;
393 current->p[1] = $3 ; }
394 | '(' expr ')' nspace naddr_with { current->type = X_ADDR_V ;
395 current->p[0] = $2 ;
396 current->p[1] = $5 ;
397 current->u.nonansi = 1 ; }
398 ;
399
400 arg_stat : arg templs { $$ = makenode( X_PARSE, 2, $1, $2 );
401 $$->u.parseflags = PARSE_UPPER;
402 $$->lineno = $1->lineno;
403 $$->charnr = $1->charnr; }
404 ;
405
406 call_stat : call call_name { parendepth = start_parendepth; }
407 call_args { $$ = $1;
408 $$->p[0] = $4;
409 $$->name = (streng *) $2;
410 parendepth = 0; }
411 | call string { parendepth = start_parendepth; }
412 call_args { $$ = $1;
413 $$->type = X_EX_FUNC;
414 $$->p[0] = $4;
415 $$->name = (streng *) $2;
416 parendepth = 0; }
417 | call on error { exiterror( ERR_INV_SUBKEYWORD, 1, "ERROR FAILURE HALT NOTREADY", __reginatext ) ;}
418 | call off error { exiterror( ERR_INV_SUBKEYWORD, 2, "ERROR FAILURE HALT NOTREADY", __reginatext ) ;}
419 | call on c_action error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
420 | call on c_action namespec error { exiterror( ERR_STRING_EXPECTED, 3, __reginatext ) ;}
421 | call on c_action namespec
422 { $$ = $1 ;
423 $$->type = X_CALL_SET ;
424 $$->p[0] = $2 ;
425 $$->name = (streng *)$4 ;
426 $$->p[1] = $3 ; }
427 | call on c_action { $$ = $1 ;
428 $$->type = X_CALL_SET ;
429 $$->p[0] = $2 ;
430 $$->name = NULL ;
431 $$->p[1] = $3 ; }
432 | call off c_action error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
433 | call off c_action { $$ = $1 ;
434 $$->type = X_CALL_SET ;
435 $$->p[0] = $2 ;
436 $$->p[1] = $3 ; }
437 ;
438
439 call_name : asymbol { $$ = $1; }
440 | error { exiterror( ERR_STRING_EXPECTED, 2, __reginatext );}
441 ;
442
443 call_args : exprs {
444 /*
445 * "call_args" accepted probably with
446 * surrounding parentheses. Strip them.
447 */
448 $$ = reduce_expr_list( $1,
449 REDUCE_CALL );
450 }
451 | exprs ')' { exiterror(ERR_UNEXPECTED_PARAN, 2); }
452 ;
453
454 expr_stat : expr { $$ = makenode(X_COMMAND,0) ;
455 $$->charnr = tmpchr ;
456 $$->lineno = tmplno;
457 $$->p[0] = $1 ; }
458 ;
459
460 end_stat : END { $$ = makenode(X_END,0) ;
461 $$->lineno = parser_data.tline ;
462 $$->charnr = parser_data.tstart ;
463 level--; }
464 ;
465
466 end : end_stat simsymb { $$ = $1 ;
467 $$->name = (streng*)($2) ; }
468 | end_stat { $$ = $1 ; }
469 | end_stat simsymb error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
470 ;
471
472 do_stat : do repetitor conditional ncl nxstats end
473 { $$ = $1;
474 $$->p[0] = $2;
475 $$->p[1] = $3;
476 $$->p[2] = optgluelast( $4, $5 );
477 if ( $$->p[2] )
478 $$->p[2]->o.last = NULL;
479 $$->p[3] = $6;
480 if (($$->p[0]==NULL || $$->p[0]->name==NULL)
481 && $$->p[3]->name)
482 exiterror( ERR_UNMATCHED_END, 0 );
483 if (($$->p[0])&&($$->p[0]->name)&&
484 ($$->p[3]->name)&&
485 (($$->p[3]->name->len != $$->p[0]->name->len)||
486 (strncmp($$->p[3]->name->value,
487 $$->p[0]->name->value,
488 $$->p[0]->name->len))))
489 exiterror( ERR_UNMATCHED_END, 0 );
490 }
491 ;
492
493 repetitor : dovar '=' expr nspace tobyfor tobyfor tobyfor
494 { $$ =makenode(X_REP,4,$3,$5,$6,$7) ;
495 $$->name = (streng *)$1 ;
496 checkdosyntax($$) ; }
497 | dovar '=' expr nspace tobyfor tobyfor
498 { $$ =makenode(X_REP,3,$3,$5,$6) ;
499 $$->name = (streng *)$1 ;
500 checkdosyntax($$) ; }
501 | dovar '=' expr nspace tobyfor
502 { $$ = makenode(X_REP,2,$3,$5) ;
503 $$->name = (streng *)$1 ;
504 checkdosyntax($$) ; }
505 | dovar '=' expr nspace { $$ = makenode(X_REP,1,$3) ;
506 $$->name = (streng *)$1 ;
507 checkdosyntax($$) ; }
508 | FOREVER nspace { $$ = makenode(X_REP_FOREVER,0) ; }
509 | FOREVER error { exiterror( ERR_INV_SUBKEYWORD, 16, "WHILE UNTIL", __reginatext ) ; }
510 | expr nspace { $1 = makenode(X_DO_EXPR,1,$1) ;
511 $$ = makenode(X_REP,2,NULL,$1) ; }
512 | { $$ = NULL ; }
513 ;
514
515 nvir : CONSYMBOL { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
516 | SIMSYMBOL { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
517 | STRING { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
518 ;
519
520 naddr_with : { SymbolDetect |= SD_ADDRWITH ;
521 $$ = with = makenode(X_ADDR_WITH,0) ;
522 $$->lineno = parser_data.tline ;
523 $$->charnr = parser_data.tstart ; }
524 addr_with { with = NULL ;
525 SymbolDetect &= ~SD_ADDRWITH ; }
526 | { $$ = NULL ; }
527 ;
528
529 addr_with : WITH connection { $$ = $2; }
530 | WITH connection error { exiterror( ERR_INV_SUBKEYWORD, 5, __reginatext ) ; }
531 | WITH nspace { exiterror( ERR_INV_SUBKEYWORD, 5, __reginatext ) ; }
532 ;
533
534 connection : inputstmts
535 | outputstmts
536 | errorstmts
537 | error { exiterror( ERR_INV_SUBKEYWORD, 5, __reginatext ) ; }
538 ;
539
540 inputstmts : inputstmt
541 adeo
542 ;
543
544 outputstmts : outputstmt
545 adei
546 ;
547
548 errorstmts : errorstmt
549 adio
550 ;
551
552 adeo : outputstmt nspace
553 | outputstmt errorstmt nspace
554 | errorstmt nspace
555 | errorstmt outputstmt nspace
556 | nspace
557 ;
558
559 adei : inputstmt nspace
560 | inputstmt errorstmt nspace
561 | errorstmt nspace
562 | errorstmt inputstmt nspace
563 | nspace
564 ;
565
566 adio : inputstmt nspace
567 | inputstmt outputstmt nspace
568 | outputstmt nspace
569 | outputstmt inputstmt nspace
570 | nspace
571 ;
572
573 inputstmt : nspace INPUT nspace resourcei { with->p[0] = $4; }
574 | nspace INPUT error { exiterror( ERR_INV_SUBKEYWORD, 6, __reginatext ) ; }
575 ;
576
577 outputstmt : nspace OUTPUT nspace resourceo { with->p[1] = $4; }
578 | nspace OUTPUT error { exiterror( ERR_INV_SUBKEYWORD, 7, __reginatext ) ; }
579 ;
580
581 errorstmt : nspace ERROR nspace resourceo { with->p[2] = $4; }
582 | nspace ERROR error { exiterror( ERR_INV_SUBKEYWORD, 14, __reginatext ) ; }
583 ;
584
585 resourcei : resources { $$ = $1 ; }
586 | NOEOL resources { $$ = $2 ;
587 $$->u.of.noeol = 1 ; }
588 | NOEOL error { exiterror( ERR_INV_SUBKEYWORD, 8, __reginatext ) ; }
589 | NORMAL { $$ = makenode(X_ADDR_WITH, 0) ;
590 $$->lineno = parser_data.tline ;
591 $$->charnr = parser_data.tstart ; }
592 ;
593
594 resourceo : resources { $$ = $1 ; }
595 | APPEND resources { $$ = $2 ;
596 $$->u.of.append = 1 ; }
597 | APPEND error { exiterror( ERR_INV_SUBKEYWORD, 8, __reginatext ) ; }
598 | REPLACE resources { $$ = $2 ; }
599 | REPLACE error { exiterror( ERR_INV_SUBKEYWORD, 9, __reginatext ) ; }
600 | NORMAL { $$ = makenode(X_ADDR_WITH, 0) ;
601 $$->lineno = parser_data.tline ;
602 $$->charnr = parser_data.tstart ; }
603 ;
604
605 resources : STREAM nnvir { /* ANSI extension: nsimsymb is
606 * used by the standard, but I think
607 * there are no reasons why using
608 * it here as a must. FGC
609 */
610 $$ = $2 ;
611 $$->u.of.awt = awtSTREAM;
612 SymbolDetect |= SD_ADDRWITH ; }
613 | STREAM error { exiterror( ERR_INVALID_OPTION, 1, __reginatext ) ; }
614 | STEM nsimsymb {
615 streng *tmp = $2->name;
616 char *p;
617
618 /*
619 * expect a single dot as the last character
620 */
621 p = (char *)memchr( tmp->value, '.', tmp->len );
622 if ( p != tmp->value + tmp->len - 1 )
623 exiterror( ERR_INVALID_OPTION, 3, __reginatext );
624 $$ = $2 ;
625 $$->u.of.awt = awtSTEM ;
626 SymbolDetect |= SD_ADDRWITH ; }
627 | STEM error { exiterror( ERR_INVALID_OPTION, 2, __reginatext ) ; }
628 | LIFO nnvir {
629 $$ = $2 ;
630 $$->u.of.awt = awtLIFO ;
631 SymbolDetect |= SD_ADDRWITH ; }
632 | LIFO error { exiterror( ERR_INVALID_OPTION, 100, __reginatext ) ; }
633 | FIFO nnvir {
634 $$ = $2 ;
635 $$->u.of.awt = awtFIFO ;
636 SymbolDetect |= SD_ADDRWITH ; }
637 | FIFO error { exiterror( ERR_INVALID_OPTION, 101, __reginatext ) ; }
638 ;
639
640 nsimsymb : { SymbolDetect &= ~SD_ADDRWITH ; }
641 nspace addrSim { $$ = $3 ; }
642 ;
643
644 nnvir : { SymbolDetect &= ~SD_ADDRWITH ; }
645 nspace addrAll { $$ = $3 ; }
646 ;
647
648 nspace : SPACE
649 |
650 ;
651
652 addrAll : addrSim { $$ = $1 ; }
653 | addrString { $$ = $1 ; }
654 ;
655
656 addrSim : xsimsymb { $$ = makenode(X_ADDR_WITH, 0) ;
657 $$->name = (streng *) $1 ;
658 $$->lineno = parser_data.tline ;
659 $$->charnr = parser_data.tstart ;
660 $$->u.of.ant = antSIMSYMBOL;
661 }
662 ;
663
664 addrString : string { $$ = makenode(X_ADDR_WITH, 0) ;
665 $$->name = (streng *) $1 ;
666 $$->lineno = parser_data.tline ;
667 $$->charnr = parser_data.tstart ;
668 $$->u.of.ant = antSTRING;
669 }
670 ;
671
672 dovar : DOVARIABLE { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
673 ;
674
675 tobyfor : TO expr nspace { $$ = makenode(X_DO_TO,1,$2) ; }
676 | FOR expr nspace { $$ = makenode(X_DO_FOR,1,$2) ; }
677 | BY expr nspace { $$ = makenode(X_DO_BY,1,$2) ; }
678 ;
679
680 conditional : WHILE expr nspace { $$ = makenode(X_WHILE,1,$2) ; }
681 | UNTIL expr nspace { $$ = makenode(X_UNTIL,1,$2) ; }
682 | { $$ = NULL ; }
683 ;
684
685 drop_stat : drop anyvars error { exiterror( ERR_SYMBOL_EXPECTED, 1, __reginatext ) ;}
686 | drop anyvars { $$ = $1 ;
687 $$->p[0] = $2 ; }
688 ;
689
690 upper_stat : upper anyvars error { exiterror( ERR_SYMBOL_EXPECTED, 1, __reginatext ) ;}
691 | upper anyvars { $$ = $1 ;
692 $$->p[0] = $2 ; }
693 ;
694
695 exit_stat : exit nexpr { $$ = $1 ;
696 $$->p[0] = $2 ; }
697 ;
698
699 if_stat : if expr nlncl THEN nlncl ystatement
700 { move_labels( $1, $6, level - 1 );
701 $$ = $1;
702 $$->p[0] = optgluelast( $2, $3 );
703 $$->p[0]->o.last = NULL;
704 $$->p[1] = optgluelast( $5, $6 );
705 $$->p[1]->o.last = NULL;
706 level--; }
707 | if expr nlncl THEN nlncl ystatement ELSE nlncl ystatement
708 { move_labels( $1, $9, level - 1 );
709 $$ = $1;
710 $$->p[0] = optgluelast( $2, $3 );
711 $$->p[0]->o.last = NULL;
712 $$->p[1] = optgluelast( $5, $6 );
713 $$->p[1]->o.last = NULL;
714 $$->p[2] = optgluelast( $8, $9 );
715 $$->p[2]->o.last = NULL;
716 level--; }
717 | if expr nlncl THEN nlncl ystatement ELSE nlncl error
718 { exiterror( ERR_INCOMPLETE_STRUCT, 4 ) ;}
719 | if expr nlncl THEN nlncl error
720 { exiterror( ERR_INCOMPLETE_STRUCT, 3 ) ;}
721 | if ncl { exiterror( ERR_INCOMPLETE_STRUCT, 0 ) ;}
722 | if expr nlncl error { exiterror( ERR_THEN_EXPECTED, 1, parser_data.if_linenr, __reginatext ) ; }
723 ;
724
725 unexp_then : gruff THEN { exiterror( ERR_THEN_UNEXPECTED, 1 ) ; }
726 ;
727
728 unexp_else : gruff ELSE { exiterror( ERR_THEN_UNEXPECTED, 2 ) ; }
729 ;
730
731 ipret_stat : interpret expr { $$ = $1 ;
732 $$->p[0] = $2 ; }
733 ;
734
735
736 iterate_stat : iterate simsymb { $$ = $1 ;
737 $$->name = (streng *) $2 ; }
738 | iterate simsymb error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
739 | iterate { $$ = $1 ; }
740 ;
741
742 label_stat : labelname { $$ = $1 ;
743 $$->u.trace_only =
744 (level == 0) ? 0 : 1;
745 newlabel( (const tsd_t *)parser_data.TSD,
746 &parser_data,
747 $1 ) ; }
748 ;
749
750 labelname : label { $$ = $1 ;
751 $$->name = Str_cre_TSD(parser_data.TSD,retvalue) ; }
752 ;
753
754 leave_stat : leave simsymb { $$ = $1 ;
755 $$->name = (streng *) $2 ; }
756 | leave simsymb error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
757 | leave { $$ = $1 ; }
758 ;
759
760 nop_stat : nop { $$ = $1 ; }
761 | nop error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
762 ;
763
764 numeric_stat : numeric DIGITS expr { $$ = $1 ;
765 $$->type = X_NUM_D ;
766 $$->p[0] = $3 ; }
767 | numeric DIGITS { $$ = $1; $$->type = X_NUM_DDEF ; }
768 | numeric FORM form_expr error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
769 | numeric FORM form_expr { $$ = $1 ;
770 $$->type = X_NUM_F ;
771 $$->p[0] = $3 ; }
772 | numeric FORM { /* NOTE! This clashes ANSI! */
773 $$ = $1 ; $$->type=X_NUM_FRMDEF ;}
774 | numeric FORM VALUE expr { $$ = $1 ; $$->type=X_NUM_V ;
775 $$->p[0] = $4 ; }
776 | numeric FORM error { exiterror( ERR_INV_SUBKEYWORD, 11, "ENGINEERING SCIENTIFIC", __reginatext ) ;}
777 | numeric FUZZ { $$ = $1; $$->type = X_NUM_FDEF ;}
778 | numeric FUZZ expr { $$ = $1 ;
779 $$->type = X_NUM_FUZZ ;
780 $$->p[0] = $3 ; }
781 | numeric error { exiterror( ERR_INV_SUBKEYWORD, 15, "DIGITS FORM FUZZ", __reginatext ) ;}
782 ;
783
784 form_expr : SCIENTIFIC { $$ = makenode(X_NUM_SCI,0) ; }
785 | ENGINEERING { $$ = makenode(X_NUM_ENG,0) ; }
786 ;
787
788 options_stat : options nexpr { ($$=$1)->p[0]=$2 ; }
789 ;
790
791 parse_stat : parse parse_flags parse_param templs
792 { $$ = $1 ;
793 $$->type = X_PARSE ;
794 $$->u.parseflags = (int) $2 ;
795 $$->p[0] = $3 ;
796 $$->p[1] = $4 ; }
797 | parse parse_param templs
798 { $$ = $1 ;
799 $$->type = X_PARSE ;
800 $$->u.parseflags = 0;
801 $$->p[0] = $2 ;
802 $$->p[1] = $3 ; }
803 | parse parse_flags error { exiterror( ERR_INV_SUBKEYWORD, 12, "ARG EXTERNAL LINEIN PULL SOURCE VAR VALUE VERSION", __reginatext ) ;}
804 | parse error { exiterror( ERR_INV_SUBKEYWORD, 12, "ARG CASELESS EXTERNAL LINEIN LOWER PULL SOURCE UPPER VAR VALUE VERSION", __reginatext ) ;}
805 ;
806
807 parse_flags : UPPER { $$ = (nodeptr) (PARSE_UPPER |
808 PARSE_NORMAL); }
809 | UPPER CASELESS { $$ = (nodeptr) (PARSE_UPPER |
810 PARSE_CASELESS); }
811 | CASELESS UPPER { $$ = (nodeptr) (PARSE_UPPER |
812 PARSE_CASELESS); }
813 | LOWER { $$ = (nodeptr) (PARSE_LOWER |
814 PARSE_NORMAL); }
815 | LOWER CASELESS { $$ = (nodeptr) (PARSE_LOWER |
816 PARSE_CASELESS); }
817 | CASELESS LOWER { $$ = (nodeptr) (PARSE_LOWER |
818 PARSE_CASELESS); }
819 | CASELESS { $$ = (nodeptr) (PARSE_NORMAL |
820 PARSE_CASELESS); }
821 ;
822
823 templs : templs ',' template { /* fixes bugs like bug 579711 */
824 $$ = optgluelast( $1, $3 ); }
825 | template { $$ = $1 ; }
826 ;
827
828 parse_param : ARG { $$ = makenode(X_PARSE_ARG,0) ; }
829 | LINEIN { $$ = makenode(X_PARSE_EXT,0) ; }
830 | EXTERNAL { $$ = makenode(X_PARSE_EXT,0) ; }
831 | VERSION { $$ = makenode(X_PARSE_VER,0) ; }
832 | PULL { $$ = makenode(X_PARSE_PULL,0) ; }
833 | SOURCE { $$ = makenode(X_PARSE_SRC,0) ; }
834 | VAR simsymb { $$ = makenode(X_PARSE_VAR,0) ;
835 $$->name = (streng *) $2 ; }
836 | VALUE nexpr WITH { $$ = makenode(X_PARSE_VAL,1,$2) ; }
837 | VALUE error { exiterror( ERR_INVALID_TEMPLATE, 3 ) ;}
838 ;
839
840 proc_stat : proc { $$ = $1 ; }
841 | proc error { exiterror( ERR_INV_SUBKEYWORD, 17, __reginatext ) ;}
842 | proc EXPOSE error { exiterror( ERR_SYMBOL_EXPECTED, 1, __reginatext ) ;}
843 | proc EXPOSE anyvars error { exiterror( ERR_SYMBOL_EXPECTED, 1, __reginatext ) ;}
844 | proc EXPOSE anyvars { $$ = $1 ;
845 $$->p[0] = $3 ; }
846 ;
847
848 pull_stat : pull template { $$ = $1 ;
849 $$->p[0] = $2 ; }
850 ;
851
852 push_stat : push nexpr { $$ = $1 ;
853 $$->p[0] = $2 ; }
854 ;
855
856 queue_stat : queue nexpr { $$ = $1 ;
857 $$->p[0] = $2 ; }
858 ;
859
860 say_stat : say nexpr { $$ = $1 ;
861 $$->p[0] = $2 ; }
862 ;
863
864 return_stat : return nexpr { $$ = $1 ;
865 $$->p[0] = $2 ; }
866 ;
867
868 sel_end : END simsymb { exiterror( ERR_UNMATCHED_END, 0 ) ;}
869 | END simsymb error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
870 | END { level--; }
871 ;
872
873 select_stat : select ncl when_stats otherwise_stat sel_end
874 { $$ = $1;
875 $$->p[0] = optgluelast( $2, $3 );
876 $$->p[0]->o.last = NULL;
877 $$->p[1] = $4; }
878 | select ncl END error { exiterror( ERR_WHEN_EXPECTED, 1, parser_data.select_linenr, __reginatext ) ;}
879 | select ncl otherwise error
880 { exiterror( ERR_WHEN_EXPECTED, 2, parser_data.select_linenr, __reginatext ) ;}
881 | select error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
882 | select ncl THEN { exiterror( ERR_THEN_UNEXPECTED, 0 ) ;}
883 | select ncl when_stats otherwise error
884 { exiterror( ERR_INCOMPLETE_STRUCT, 0 ) ;}
885 ;
886
887 when_stats : when_stats when_stat { $$ = optgluelast( $1, $2 ); }
888 | when_stat { $$ = $1 ; }
889 | error { exiterror( ERR_WHEN_EXPECTED, 2, parser_data.select_linenr, __reginatext ) ;}
890 ;
891
892 when_stat : when expr nlncl THEN nlncl statement
893 { $$ = $1; /* fixes bugs like bug 579711 */
894 $$->p[0] = optgluelast( $2, $3 );
895 $$->p[0]->o.last = NULL;
896 $$->p[1] = optgluelast( $5, $6 );
897 $$->p[1]->o.last = NULL; }
898 | when expr nlncl THEN nlncl statement THEN
899 { exiterror( ERR_THEN_UNEXPECTED, 0 ) ;}
900 | when expr { exiterror( ERR_THEN_EXPECTED, 2, parser_data.select_linenr, __reginatext ) ; }
901 | when error { exiterror( ERR_INVALID_EXPRESSION, 0 ) ;}
902 ;
903
904 /*
905 when_or_other: when
906 | otherwise
907 ;
908 ex_when_stat : gruff when_or_other { exiterror( ERR_WHEN_UNEXPECTED, 1 ); }
909 ;
910 */
911 ex_when_stat : gruff when { exiterror( ERR_WHEN_UNEXPECTED, 1 ); }
912 | gruff otherwise { exiterror( ERR_WHEN_UNEXPECTED, 2 ); }
913 ;
914
915 otherwise_stat : otherwise nlncl nxstats { $$ = $1;
916 $$->p[0] = optgluelast( $2, $3 );
917 if ( $$->p[0] )
918 $$->p[0]->o.last = NULL; }
919 | { $$ = makenode(X_NO_OTHERWISE,0) ;
920 $$->lineno = parser_data.tline ;
921 $$->charnr = parser_data.tstart ; }
922 ;
923
924
925 signal_stat : signal VALUE expr { $$ = $1 ;
926 $$->type = X_SIG_VAL ;
927 $$->p[0] = $3 ; }
928 | signal signal_name error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
929 | signal signal_name { $$ = $1 ;
930 $$->name = (streng *)$2 ; }
931 | signal on error { exiterror( ERR_INV_SUBKEYWORD, 3, "ERROR FAILURE HALT NOTREADY NOVALUE SYNTAX LOSTDIGITS", __reginatext ) ;}
932 | signal off error { exiterror( ERR_INV_SUBKEYWORD, 4, "ERROR FAILURE HALT NOTREADY NOVALUE SYNTAX LOSTDIGITS", __reginatext ) ;}
933 | signal on s_action error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
934 | signal on s_action namespec error { exiterror( ERR_STRING_EXPECTED, 3, __reginatext ) ;}
935 | signal on s_action namespec
936 { $$ = $1 ;
937 $$->type = X_SIG_SET ;
938 $$->p[0] = $2 ;
939 $$->name = (streng *)$4 ;
940 $$->p[1] = $3 ; }
941 | signal on s_action { $$ = $1 ;
942 $$->type = X_SIG_SET ;
943 $$->p[0] = $2 ;
944 $$->p[1] = $3 ; }
945 | signal off s_action error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
946 | signal off s_action { $$ = $1 ;
947 $$->type = X_SIG_SET ;
948 $$->p[0] = $2 ;
949 $$->p[1] = $3 ; }
950 ;
951
952 signal_name : asymbol { $$ = $1; }
953 | STRING { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
954 | error { exiterror( ERR_STRING_EXPECTED, 4, __reginatext );}
955 ;
956
957 namespec : NAME SIMSYMBOL { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue);}
958 | NAME STRING { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
959 | NAME error { exiterror( ERR_STRING_EXPECTED, 3, __reginatext ) ;}
960 ;
961
962 asymbol : CONSYMBOL { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
963 | SIMSYMBOL { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
964 ;
965
966 on : ON { $$ = makenode(X_ON,0) ; }
967 ;
968
969 off : OFF { $$ = makenode(X_OFF,0) ; }
970 ;
971
972 c_action : ERROR { $$ = makenode(X_S_ERROR,0) ; }
973 | HALT { $$ = makenode(X_S_HALT,0) ; }
974 | NOTREADY { $$ = makenode(X_S_NOTREADY,0) ; }
975 | FAILURE { $$ = makenode(X_S_FAILURE,0) ; }
976 ;
977
978 s_action : c_action { $$ = $1 ; }
979 | NOVALUE { $$ = makenode(X_S_NOVALUE,0) ; }
980 | SYNTAX { $$ = makenode(X_S_SYNTAX,0) ; }
981 | LOSTDIGITS { $$ = makenode(X_S_LOSTDIGITS,0) ; }
982 ;
983
984 trace_stat : trace VALUE expr { $$ = $1 ;
985 $$->p[0] = $3 ; }
986 | trace nexpr { $$ = $1 ;
987 $$->p[0] = $2 ; }
988 | trace whatever error { exiterror( ERR_EXTRA_DATA, 1, __reginatext ) ;}
989 | trace whatever { $$ = $1 ;
990 $$->name = (streng *) $2 ; }
991 ;
992
993 whatever : WHATEVER { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
994 ;
995
996
997 assignment : ass_part nexpr { $$ = $1 ;
998 $$->p[1] = $2 ;
999 /*
1000 * An assignment is a numerical
1001 * assignment if and only if we have
1002 * to do a numerical operation, which
1003 * is equivalent to the existence of
1004 * one more argument to $2.
1005 * This fixes bug 720166.
1006 */
1007 if ($2 &&
1008 $2->p[0] &&
1009 gettypeof($2) == IS_A_NUMBER)
1010 $$->type = X_NASSIGN ; }
1011 ;
1012
1013 ass_part : ASSIGNMENTVARIABLE { $$ = makenode(X_ASSIGN,0) ;
1014 $$->charnr = parser_data.tstart ;
1015 $$->lineno = parser_data.tline ;
1016 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1017 ;
1018
1019 plusassignment : plus_ass_part nexpr { $$ = $1 ;
1020 $$->p[1] = $2 ;
1021 }
1022 ;
1023
1024 plus_ass_part : PLUSASSIGNMENTVARIABLE { $$ = makenode(X_PLUSASSIGN,0) ;
1025 $$->charnr = parser_data.tstart ;
1026 $$->lineno = parser_data.tline ;
1027 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1028 ;
1029
1030 minusassignment : minus_ass_part nexpr { $$ = $1 ;
1031 $$->p[1] = $2 ;
1032 }
1033 ;
1034
1035 minus_ass_part : MINUSASSIGNMENTVARIABLE { $$ = makenode(X_MINUSASSIGN,0) ;
1036 $$->charnr = parser_data.tstart ;
1037 $$->lineno = parser_data.tline ;
1038 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1039 ;
1040
1041 multassignment : mult_ass_part nexpr { $$ = $1 ;
1042 $$->p[1] = $2 ;
1043 }
1044 ;
1045
1046 mult_ass_part : MULTASSIGNMENTVARIABLE { $$ = makenode(X_MULTASSIGN,0) ;
1047 $$->charnr = parser_data.tstart ;
1048 $$->lineno = parser_data.tline ;
1049 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1050 ;
1051
1052 divassignment : div_ass_part nexpr { $$ = $1 ;
1053 $$->p[1] = $2 ;
1054 }
1055 ;
1056
1057 div_ass_part : DIVASSIGNMENTVARIABLE { $$ = makenode(X_DIVASSIGN,0) ;
1058 $$->charnr = parser_data.tstart ;
1059 $$->lineno = parser_data.tline ;
1060 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1061 ;
1062
1063 intdivassignment : intdiv_ass_part nexpr { $$ = $1 ;
1064 $$->p[1] = $2 ;
1065 }
1066 ;
1067
1068 intdiv_ass_part : INTDIVASSIGNMENTVARIABLE { $$ = makenode(X_INTDIVASSIGN,0) ;
1069 $$->charnr = parser_data.tstart ;
1070 $$->lineno = parser_data.tline ;
1071 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1072 ;
1073
1074 modulusassignment : modulus_ass_part nexpr { $$ = $1 ;
1075 $$->p[1] = $2 ;
1076 }
1077 ;
1078
1079 modulus_ass_part : MODULUSASSIGNMENTVARIABLE { $$ = makenode(X_MODULUSASSIGN,0) ;
1080 $$->charnr = parser_data.tstart ;
1081 $$->lineno = parser_data.tline ;
1082 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1083 ;
1084
1085 andassignment : and_ass_part nexpr { $$ = $1 ;
1086 $$->p[1] = $2 ;
1087 }
1088 ;
1089
1090 and_ass_part : ANDASSIGNMENTVARIABLE { $$ = makenode(X_ANDASSIGN,0) ;
1091 $$->charnr = parser_data.tstart ;
1092 $$->lineno = parser_data.tline ;
1093 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1094 ;
1095
1096 xorassignment : xor_ass_part nexpr { $$ = $1 ;
1097 $$->p[1] = $2 ;
1098 }
1099 ;
1100
1101 xor_ass_part : XORASSIGNMENTVARIABLE { $$ = makenode(X_XORASSIGN,0) ;
1102 $$->charnr = parser_data.tstart ;
1103 $$->lineno = parser_data.tline ;
1104 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1105 ;
1106
1107 orassignment : or_ass_part nexpr { $$ = $1 ;
1108 $$->p[1] = $2 ;
1109 }
1110 ;
1111
1112 or_ass_part : ORASSIGNMENTVARIABLE { $$ = makenode(X_ORASSIGN,0) ;
1113 $$->charnr = parser_data.tstart ;
1114 $$->lineno = parser_data.tline ;
1115 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1116 ;
1117
1118 concatassignment : concat_ass_part nexpr { $$ = $1 ;
1119 $$->p[1] = $2 ;
1120 }
1121 ;
1122
1123 concat_ass_part : CONCATASSIGNMENTVARIABLE { $$ = makenode(X_CONCATASSIGN,0) ;
1124 $$->charnr = parser_data.tstart ;
1125 $$->lineno = parser_data.tline ;
1126 $$->p[0] = (nodeptr)create_head( (const char *)retvalue ); }
1127 ;
1128
1129
1130 expr : '(' { /* We have to accept exprs here even
1131 * if we just want to accept
1132 * '(' expr ')' only. We do this
1133 * because we appect
1134 * "call '(' exprs ')'" too.
1135 * This kann happen only if the
1136 * related control flag parendepth is
1137 * set. But since the parentheses are
1138 * voided just for the outer ones, we
1139 * can reduce the allowness level.
1140 * We don't have to set it back,
1141 * because the outer parentheses
1142 * either is THE one we look for or
1143 * none. This allows a faster error
1144 * detection and that's a good goal.*/
1145 parendepth--; }
1146 exprs_sub { parendepth++;
1147 if ( parendepth == 1 )
1148 {
1149 /* exprs on as-is basis */
1150 $$ = $3;
1151 }
1152 else
1153 {
1154 /* Must already be a plain expr.
1155 * The nexpr part of exprs detects
1156 * mistakes. */
1157 $$ = reduce_expr_list( $3,
1158 REDUCE_EXPR );
1159 if ( $$ == $3 )
1160 exiterror( ERR_INTERPRETER_FAILURE, 1, __FILE__, __LINE__, "Reduction of `exprs' not happened." );
1161 }
1162 }
1163 | expr '+' { parendepth--; }
1164 expr { parendepth++; AUTO_REDUCE( $1, "+" );
1165 $$ = makenode( X_PLUSS, 2, $1, $4 ); }
1166 | expr '-' { parendepth--; }
1167 expr { parendepth++; AUTO_REDUCE( $1, "-" );
1168 $$ = makenode( X_MINUS, 2, $1, $4 ); }
1169 | expr '*' { parendepth--; }
1170 expr { parendepth++; AUTO_REDUCE( $1, "*" );
1171 $$ = makenode( X_MULT, 2, $1, $4 ); }
1172 | '*' { exiterror( ERR_INVALID_EXPRESSION, 1, "*" ); }
1173 | expr '/' { parendepth--; }
1174 expr { parendepth++; AUTO_REDUCE( $1, "/" );
1175 $$ = makenode( X_DEVIDE, 2, $1, $4 ); }
1176 | '/' { exiterror( ERR_INVALID_EXPRESSION, 1, "/" ); }
1177 | expr MODULUS { parendepth--; }
1178 expr { parendepth++; AUTO_REDUCE( $1, "//" );
1179 $$ = makenode( X_MODULUS, 2, $1, $4 ); }
1180 | MODULUS { exiterror( ERR_INVALID_EXPRESSION, 1, "//" ); }
1181 | expr '%' { parendepth--; }
1182 expr { parendepth++; AUTO_REDUCE( $1, "%" );
1183 $$ = makenode( X_INTDIV, 2, $1, $4 ); }
1184 | '%' { exiterror( ERR_INVALID_EXPRESSION, 1, "%" ); }
1185 | expr '|' { parendepth--; }
1186 expr { parendepth++; AUTO_REDUCE( $1, "|" );
1187 $$ = makenode( X_LOG_OR, 2, $1, $4 ); }
1188 | '|' { exiterror( ERR_INVALID_EXPRESSION, 1, "|" ); }
1189 | expr '&' { parendepth--; }
1190 expr { parendepth++; AUTO_REDUCE( $1, "&" );
1191 $$ = makenode( X_LOG_AND, 2, $1, $4 ); }
1192 | '&' { exiterror( ERR_INVALID_EXPRESSION, 1, "&" ); }
1193 | expr XOR { parendepth--; }
1194 expr { parendepth++; AUTO_REDUCE( $1, "&&" );
1195 $$ = makenode( X_LOG_XOR, 2, $1, $4 ); }
1196 | XOR { exiterror( ERR_INVALID_EXPRESSION, 1, "&&" ); }
1197 | expr EXP { parendepth--; }
1198 expr { parendepth++; AUTO_REDUCE( $1, "**" );
1199 $$ = makenode( X_EXP, 2, $1, $4 ); }
1200 | EXP { exiterror( ERR_INVALID_EXPRESSION, 1, "**" ); }
1201 | expr SPACE { parendepth--; }
1202 expr { parendepth++; AUTO_REDUCE( $1, " " );
1203 $$ = makenode( X_SPACE, 2, $1, $4 ); }
1204 | SPACE { exiterror( ERR_INVALID_EXPRESSION, 1, " " ); }
1205 | expr CONCATENATE { parendepth--; }
1206 expr { parendepth++; AUTO_REDUCE( $1, "||" );
1207 $$ = makenode( X_CONCAT, 2, $1, $4 ); }
1208 | CONCATENATE { exiterror( ERR_INVALID_EXPRESSION, 1, "||" ); }
1209 | NOT expr { AUTO_REDUCE( $2, "\\" );
1210 $$ = makenode( X_LOG_NOT, 1, $2 ); }
1211 | NOT { exiterror( ERR_INVALID_EXPRESSION, 1, "\\" ); }
1212 | expr '=' { parendepth--; }
1213 expr { parendepth++; AUTO_REDUCE( $1, "=" );
1214 $$ = makenode( X_EQUAL, 2, $1, $4 );
1215 transform( $$ ); }
1216 | '=' { exiterror( ERR_INVALID_EXPRESSION, 1, "=" ); }
1217 | expr GTE { parendepth--; }
1218 expr { parendepth++; AUTO_REDUCE( $1, ">=" );
1219 $$ = makenode( X_GTE, 2, $1, $4 );
1220 transform( $$ ) ; }
1221 | GTE { exiterror( ERR_INVALID_EXPRESSION, 1, ">=" ); }
1222 | expr LTE { parendepth--; }
1223 expr { parendepth++; AUTO_REDUCE( $1, "<=" );
1224 $$ = makenode( X_LTE, 2, $1, $4 );
1225 transform( $$ ) ; }
1226 | LTE { exiterror( ERR_INVALID_EXPRESSION, 1, "<=" ); }
1227 | expr GT { parendepth--; }
1228 expr { parendepth++; AUTO_REDUCE( $1, ">" );
1229 $$ = makenode( X_GT, 2, $1, $4 );
1230 transform( $$ ) ; }
1231 | GT { exiterror( ERR_INVALID_EXPRESSION, 1, ">" ); }
1232 | expr LT { parendepth--; }
1233 expr { parendepth++; AUTO_REDUCE( $1, "<" );
1234 $$ = makenode( X_LT, 2, $1, $4 );
1235 transform( $$ ) ; }
1236 | LT { exiterror( ERR_INVALID_EXPRESSION, 1, "<" ); }
1237 | expr DIFFERENT { parendepth--; }
1238 expr { parendepth++; AUTO_REDUCE( $1, "\\=" );
1239 $$ = makenode( X_DIFF, 2, $1, $4 );
1240 transform( $$ ) ; }
1241 | DIFFERENT { exiterror( ERR_INVALID_EXPRESSION, 1, "\\=" ); }
1242 | expr EQUALEQUAL { parendepth--; }
1243 expr { parendepth++; AUTO_REDUCE( $1, "==" );
1244 $$ = makenode( X_S_EQUAL, 2, $1, $4 ); }
1245 | EQUALEQUAL { exiterror( ERR_INVALID_EXPRESSION, 1, "==" ); }
1246 | expr NOTEQUALEQUAL { parendepth--; }
1247 expr { parendepth++; AUTO_REDUCE( $1, "\\==" );
1248 $$ = makenode( X_S_DIFF, 2, $1, $4 ); }
1249 | NOTEQUALEQUAL { exiterror( ERR_INVALID_EXPRESSION, 1, "\\==" ); }
1250 | expr GTGT { parendepth--; }
1251 expr { parendepth++; AUTO_REDUCE( $1, ">>" );
1252 $$ = makenode( X_S_GT, 2, $1, $4 ); }
1253 | GTGT { exiterror( ERR_INVALID_EXPRESSION, 1, ">>" ); }
1254 | expr LTLT { parendepth--; }
1255 expr { parendepth++; AUTO_REDUCE( $1, "<<" );
1256 $$ = makenode( X_S_LT, 2, $1, $4 ); }
1257 | LTLT { exiterror( ERR_INVALID_EXPRESSION, 1, "<<" ); }
1258 | expr NOTGTGT { parendepth--; }
1259 expr { parendepth++; AUTO_REDUCE( $1, "\\>>" );
1260 $$ = makenode( X_S_NGT, 2, $1, $4 ); }
1261 | NOTGTGT { exiterror( ERR_INVALID_EXPRESSION, 1, "\\>>" ); }
1262 | expr NOTLTLT { parendepth--; }
1263 expr { parendepth++; AUTO_REDUCE( $1, "\\<<" );
1264 $$ = makenode( X_S_NLT, 2, $1, $4 ); }
1265 | NOTLTLT { exiterror( ERR_INVALID_EXPRESSION, 1, "\\<<" ); }
1266 | expr GTGTE { parendepth--; }
1267 expr { parendepth++; AUTO_REDUCE( $1, ">>=" );
1268 $$ = makenode( X_S_GTE, 2, $1, $4 ); }
1269 | GTGTE { exiterror( ERR_INVALID_EXPRESSION, 1, ">>=" ); }
1270 | expr LTLTE { parendepth--; }
1271 expr { parendepth++; AUTO_REDUCE( $1, "<<=" );
1272 $$ = makenode( X_S_LTE, 2, $1, $4 ); }
1273 | LTLTE { exiterror( ERR_INVALID_EXPRESSION, 1, "<<=" ); }
1274 | symbtree { $$ = $1 ; }
1275 | CONSYMBOL { $$ = makenode( X_STRING, 0 );
1276 $$->name = Str_cre_TSD(parser_data.TSD,retvalue) ; }
1277 | HEXSTRING { $$ = makenode( X_STRING, 0 );
1278 $$->name = Str_make_TSD(parser_data.TSD,retlength) ;
1279 memcpy($$->name->value,retvalue,
1280 $$->name->len=retlength); }
1281 | BINSTRING { $$ = makenode( X_STRING, 0 );
1282 $$->name = Str_make_TSD(parser_data.TSD,retlength) ;
1283 memcpy($$->name->value,retvalue,
1284 $$->name->len=retlength); }
1285 | STRING { $$ = makenode( X_STRING, 0 );
1286 $$->name = Str_cre_TSD(parser_data.TSD,retvalue) ; }
1287 | function { $$ = $1 ; }
•1288 | '+' expr %prec UPLUS { AUTO_REDUCE( $2, mynullptr );
1289 $$ = makenode( X_U_PLUSS, 1, $2 ); }
•1290 | '-' expr %prec UMINUS { AUTO_REDUCE( $2, mynullptr );
1291 $$ = makenode( X_U_MINUS, 1, $2 ); }
1292 | '+' error { exiterror( ERR_INVALID_EXPRESSION, 1, __reginatext ); } /* fixes bug 1107760 */
1293 | '-' error { exiterror( ERR_INVALID_EXPRESSION, 1, __reginatext ); } /* fixes bug 1107760 */
1294 ;
1295
1296 exprs_sub : exprs ')' { $$ = $1; }
1297 | exprs error { exiterror( ERR_UNMATCHED_PARAN, 0 ); }
1298 | STATSEP { exiterror( ERR_UNMATCHED_PARAN, 0 ); }
1299 ;
1300
1301 symbtree : SIMSYMBOL { $$ = (nodeptr)create_head( (const char *)retvalue ) ; }
1302 ;
1303
1304
1305 function : extfunc func_args { $$ = makenode(X_EX_FUNC,1,$2) ;
1306 $$->name = (streng *)$1 ; }
1307 | intfunc func_args { $$ = makenode(X_IN_FUNC,1,$2) ;
1308 $$->name = (streng *)$1 ; }
1309 ;
1310
1311 func_args : { /* ugly fake preservs parendepth */
1312 $$ = (YYSTYPE) parendepth;
1313 parendepth = 0; }
1314 exprs_sub { parendepth = (int) $$;
1315 $$ = $2; }
1316 ;
1317
1318 intfunc : INFUNCNAME { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
1319 ;
1320
1321 extfunc : EXFUNCNAME { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
1322 ;
1323
1324 template : pv solid template { $$ =makenode(X_TPL_SOLID,3,$1,$2,$3);}
1325 | pv { $$ =makenode(X_TPL_SOLID,1,$1) ; }
1326 | error { exiterror( ERR_INVALID_TEMPLATE, 1, __reginatext ) ;}
1327 ;
1328
1329 solid : '-' offset { $$ = makenode(X_NEG_OFFS,0) ;
1330 $$->name = (streng *) $2 ; }
1331 | '+' offset { $$ = makenode(X_POS_OFFS,0) ;
1332 $$->name = (streng *) $2 ; }
1333 | offset { $$ = makenode(X_ABS_OFFS,0) ;
1334 $$->name = (streng *) $1 ; }
1335 | '=' offset { $$ = makenode(X_ABS_OFFS,0) ;
1336 $$->name = (streng *) $2 ; }
1337 | '(' symbtree ')' { $$ = makenode(X_TPL_VAR,0) ;
1338 $$->p[0] = $2 ; }
1339 | '-' '(' symbtree ')' { $$ = makenode(X_NEG_OFFS,0) ;
1340 $$->p[0] = $3 ; }
1341 | '+' '(' symbtree ')' { $$ = makenode(X_POS_OFFS,0) ;
1342 $$->p[0] = $3 ; }
1343 | '=' '(' symbtree ')' { $$ = makenode(X_ABS_OFFS,0) ;
1344 $$->p[0] = $3 ; }
1345 | string { $$ = makenode(X_TPL_MVE,0) ;
1346 $$->name = (streng *) $1 ; }
1347 ;
1348
1349 offset : OFFSET { $$ = (nodeptr)Str_cre_TSD(parser_data.TSD,retvalue) ; }
1350 | CONSYMBOL { streng *sptr = Str_cre_TSD(parser_data.TSD,retvalue) ;
1351 if (myisnumber(parser_data.TSD, sptr))
1352 {
1353 exiterror( ERR_INVALID_INTEGER, 4, sptr->value ) ;
1354 }
1355 else
1356 exiterror( ERR_INVALID_TEMPLATE, 0 ) ;}
1357 ;
1358
1359 string : STRING { $$ = (nodeptr) Str_cre_TSD(parser_data.TSD,retvalue) ; }
1360 | HEXSTRING { streng *sptr = Str_make_TSD(parser_data.TSD,retlength) ;
1361 memcpy(sptr->value,retvalue,
1362 sptr->len=retlength) ;
1363 $$ = (nodeptr) sptr ; }
1364 | BINSTRING { streng *sptr = Str_make_TSD(parser_data.TSD,retlength) ;
1365 memcpy(sptr->value,retvalue,
1366 sptr->len=retlength) ;
1367 $$ = (nodeptr) sptr ; }
1368 ;
1369
1370 pv : PLACEHOLDER pv { $$ = makenode(X_TPL_POINT,1,$2) ; }
1371 | symbtree pv { $$ = makenode(X_TPL_SYMBOL,2,$2,$1) ; }
1372 | { $$ = NULL ; }
1373 ;
1374
1375 /*
1376 * exprs isn't for enumerating arguments
1377 * only, it has to detect missing closing
1378 * parentheses and other stuff.
1379 * parendepth regulates the behaviour.
1380 * Getting negative indicates an error.
1381 */
1382 exprs : nexpr ',' { /* detect
1383 * "x = ( a,. b )",
1384 * "x = ( ,. b )",
1385 * "x = a,. b",
1386 * "x = ,. b",
1387 * "x = f( ( x,. b ) )",
1388 * "x = f( ( ,. b ) )" */
1389 if ( parendepth < 0 )
1390 exiterror( ERR_UNEXPECTED_PARAN, 1 );
1391
1392 /* With call being the extended kind
1393 * of CALL we may have:
1394 * "x = f( (a),. b )",
1395 * "x = f( a,. b )",
1396 * "x = f( ,. b )",
1397 * "CALL s (a),. b",
1398 * "CALL s a,. b",
1399 * "CALL s ,. b",
1400 * "call s (a),. b",
1401 * "call s a,. b",
1402 * "call s ,. b",
1403 * "call s( (a),. b )",
1404 * "call s( a,. b )",
1405 * "call s( ,. b )",
1406 * "call s (a,a),. b",
1407 * "call s (a),. b",
1408 * "call s (),. b"
1409 *
1410 * detect "(a),." and transform it
1411 * to "a,." */
1412 $1 = reduce_expr_list( $1,
1413 REDUCE_EXPR );
1414
1415 /* detect "call s (a,b),. b" and
1416 * "call s (),. b", but every list on
1417 * the left side of "," is wrong, so
1418 * complain about every exprlist. */
1419 if ( IS_EXPRLIST( $1 ) )
1420 exiterror( ERR_UNEXPECTED_PARAN, 1 );
1421
1422 $1 = reduce_expr_list( $1,
1423 REDUCE_SUBEXPR );
1424 }
1425 exprs { /*
1426 * Fixes bug 961301.
1427 */
1428 nodeptr curr;
1429
1430 assert( IS_EXPRLIST( $4 ) );
1431
1432 /* detect ",()." */
1433 if ( IS_EXPRLIST( $4->p[0] )
1434 && ( $4->p[1] == NULL )
1435 && ( $4->p[0]->p[0] == NULL ) )
1436 exiterror( ERR_UNEXPECTED_PARAN, 0 );
1437
1438 /* detect ",(a,b)." */
1439 if ( IS_EXPRLIST( $4->p[0] )
1440 && ( $4->p[1] == NULL )
1441 && IS_EXPRLIST( $4->p[0]->p[1] ) )
1442 exiterror( ERR_UNEXPECTED_PARAN, 1 );
1443
1444 /* detect ",(a)." and transform it
1445 * to ",a." */
1446 $4 = reduce_expr_list( $4,
1447 REDUCE_RIGHT );
1448 assert( IS_EXPRLIST( $4 ) );
1449
1450 /* Detect something like
1451 * "call s (a,b)+1" */
1452 curr = $4->p[0];
1453 if ( ( curr != NULL )
1454 && !IS_EXPRLIST( curr )
1455 && !IS_FUNCTION( curr )
1456 && ( IS_EXPRLIST( curr->p[0] )
1457 || IS_EXPRLIST( curr->p[1] ) ) )
1458 exiterror( ERR_INVALID_EXPRESSION, 0 );
1459
1460 $$ = makenode( X_EXPRLIST, 2, $1, $4 );
1461 checkconst( $$ ); }
1462 | nexpr { /* detect
1463 * "x = ()."
1464 * "x = f(().)"
1465 * "call s (().)"
1466 * "CALL s ()." */
1467 if ( ( parendepth < 0 ) && ( $1 == NULL ) )
1468 exiterror( ERR_UNEXPECTED_PARAN, 0 );
1469
1470 /* With call being the extended kind
1471 * of CALL we may have:
1472 * "x = ( a. )",
1473 * "x = f( . )",
1474 * "x = f( ., )",
1475 * "x = f( a. )",
1476 * "x = f( a., )",
1477 * "x = f( a, . )",
1478 * "x = f( a, b. )",
1479 * "CALL s .",
1480 * "CALL s .,",
1481 * "CALL s a.,",
1482 * "CALL s a, .",
1483 * "CALL s a, b.",
1484 * "call s .",
1485 * "call s .,",
1486 * "call s a.,",
1487 * "call s a, .",
1488 * "call s a, b.",
1489 * "call s (a.)",
1490 * "call s (a)+1, .",
1491 * "call s (a), .",
1492 * "call s (a), a.",
1493 * "call s (a), (a).",
1494 * "call s ( ., )",
1495 * "call s ( a., )",
1496 * "call s ( a, . )",
1497 * "call s ( a, b. )" */
1498
1499 $1 = reduce_expr_list( $1,
1500 REDUCE_SUBEXPR );
1501 $$ = makenode( X_EXPRLIST, 1, $1 );
1502 checkconst( $$ );
1503 }
1504 ;
1505
1506 nexpr : expr { $$ = $1 ; }
1507 | { $$ = NULL ; }
1508 ;
1509
1510 anyvars : xsimsymb anyvars { $$ = makenode(X_SIM_SYMBOL,1,$2) ;
1511 $$->name = (streng *) $1 ; }
1512 | xsimsymb { $$ = makenode(X_SIM_SYMBOL,0) ;
1513 $$->name = (streng *) $1 ; }
1514 | '(' xsimsymb ')' anyvars { $$ = makenode(X_IND_SYMBOL,1,$4) ;
1515 $$->name = (streng *) $2 ; }
1516 | '(' xsimsymb ')' { $$ = makenode(X_IND_SYMBOL,0) ;
1517 $$->name = (streng *) $2 ; }
1518 ;
1519
1520 xsimsymb : SIMSYMBOL { $$ = (treenode *) Str_cre_TSD(parser_data.TSD,retvalue);}
1521 ;
1522
1523 simsymb : SIMSYMBOL { $$ = (treenode *) Str_cre_TSD(parser_data.TSD,retvalue);}
1524 | error { exiterror( ERR_SYMBOL_EXPECTED, 1, __reginatext ) ;}
1525 ;
1526
1527 %%
1528
1529 static nodeptr makenode( int type, int numb, ... )
1530 {
1531 nodeptr thisleave ;
1532 va_list argptr ;
1533 int i ;
1534
1535 assert(numb <= (int) (sizeof(thisleave->p)/sizeof(thisleave->p[0])));
1536 #ifdef REXXDEBUG
1537 printf("makenode: making new node, type: %d\n",type) ;
1538 #endif /* REXXDEBUG */
1539
1540 thisleave = FreshNode( ) ;
1541 /* thisleave is initialized to zero except for nodeindex */
1542 va_start( argptr, numb ) ;
1543 thisleave->type = type ;
1544 thisleave->lineno = -1 ;
1545 thisleave->charnr = -1 ;
1546 for (i=0;i<numb;i++)
1547 thisleave->p[i]=va_arg(argptr, nodeptr) ;
1548
1549 va_end( argptr ) ;
1550
1551 return( thisleave ) ;
1552 }
1553
1554 static char *getdokeyword( int type )
1555 {
1556 char *ptr;
1557 switch( type )
1558 {
1559 case X_DO_TO: ptr="TO";break;
1560 case X_DO_BY: ptr="BY";break;
1561 case X_DO_FOR: ptr="FOR";break;
1562 default: ptr="";break;
1563 }
1564 return ptr;
1565 }
1566
1567 static void checkdosyntax( cnodeptr thisptr )
1568 {
1569 if ((thisptr->p[1]!=NULL)&&(thisptr->p[2]!=NULL))
1570 {
1571 if ((thisptr->p[1]->type)==(thisptr->p[2]->type))
1572 {
1573 exiterror( ERR_INVALID_DO_SYNTAX, 1, getdokeyword(thisptr->p[1]->type) ) ;
1574 }
1575 }
1576 if ((thisptr->p[2]!=NULL)&&(thisptr->p[3]!=NULL))
1577 {
1578 if ((thisptr->p[2]->type)==(thisptr->p[3]->type))
1579 {
1580 exiterror( ERR_INVALID_DO_SYNTAX, 1, getdokeyword(thisptr->p[2]->type) ) ;
1581 }
1582 }
1583 if ((thisptr->p[1]!=NULL)&&(thisptr->p[3]!=NULL))
1584 {
1585 if ((thisptr->p[1]->type)==(thisptr->p[3]->type))
1586 {
1587 exiterror( ERR_INVALID_DO_SYNTAX, 1, getdokeyword(thisptr->p[1]->type) ) ;
1588 }
1589 }
1590 return ;
1591 }
1592
1593
1594 void newlabel( const tsd_t *TSD, internal_parser_type *ipt, nodeptr thisptr )
1595 {
1596 labelboxptr newptr ;
1597
1598 assert( thisptr ) ;
1599
1600 newptr = (labelboxptr)MallocTSD(sizeof(labelbox)) ;
1601
1602 newptr->next = NULL ;
1603 newptr->entry = thisptr ;
1604 if (ipt->first_label == NULL)
1605 {
1606 ipt->first_label = newptr ;
1607 ipt->last_label = newptr ; /* must be NULL, too */
1608 }
1609 else
1610 {
1611 ipt->last_label->next = newptr ;
1612 ipt->last_label = newptr ;
1613 }
1614 ipt->numlabels++;
1615 }
1616
1617 static nodeptr create_tail( const char *name )
1618 {
1619 const char *cptr ;
1620 nodeptr node ;
1621 int constant ;
1622 streng *tname ;
1623 tsd_t *TSD = parser_data.TSD;
1624
1625 if (!*name)
1626 {
1627 node = makenode( X_CTAIL_SYMBOL, 0 ) ;
1628 node->name = Str_make_TSD( parser_data.TSD, 0) ;
1629 return node ;
1630 }
1631
1632 cptr = name ;
1633 constant = rx_isdigit(*cptr) || *cptr=='.' || (!*cptr) ;
1634 node = makenode( (constant) ? X_CTAIL_SYMBOL : X_VTAIL_SYMBOL, 0 ) ;
1635
1636 for (;*cptr && *cptr!='.'; cptr++) ;
1637 node->name = Str_ncre_TSD( parser_data.TSD, name, cptr-name ) ;
1638
1639 if (*cptr)
1640 {
1641 node->p[0] = create_tail( ++cptr ) ;
1642 if (constant && node->p[0]->type==X_CTAIL_SYMBOL)
1643 {
1644 streng *first, *second ;
1645 nodeptr tptr ;
1646
1647 first = node->name ;
1648 second = node->p[0]->name ;
1649 node->name = NULL;
1650 node->p[0]->name = NULL;
1651 tname = Str_makeTSD( first->len + second->len + 1) ;
1652 memcpy( tname->value, first->value, first->len ) ;
1653 tname->value[first->len] = '.' ;
1654 memcpy( tname->value+first->len+1, second->value, second->len) ;
1655 tname->len = first->len + second->len + 1 ;
1656
1657 Free_stringTSD( first ) ;
1658 Free_stringTSD( second ) ;
1659 node->name = tname ;
1660 tptr = node->p[0] ;
1661 node->p[0] = tptr->p[0] ;
1662 RejectNode(tptr);
1663 }
1664 }
1665
1666 return node ;
1667 }
1668
1669 static nodeptr create_head( const char *name )
1670 {
1671 const char *cptr ;
1672 nodeptr node ;
1673
1674 /* Bypass reserved variables */
1675 cptr = ( *name ) ? ( name + 1 ) : name;
1676 for (; *cptr && *cptr!='.'; cptr++) ;
1677 node = makenode( X_SIM_SYMBOL, 0 ) ;
1678 node->name = Str_ncre_TSD( parser_data.TSD, name, cptr-name+(*cptr=='.')) ;
1679
1680 if (*cptr)
1681 {
1682 if (*(++cptr))
1683 node->p[0] = create_tail( cptr ) ;
1684 else
1685 node->p[0] = NULL ;
1686
1687 node->type = (node->p[0]) ? X_HEAD_SYMBOL : X_STEM_SYMBOL ;
1688 }
1689
1690 return node ;
1691 }
1692
1693
1694 static node_type gettypeof( nodeptr thisptr )
1695 {
1696 tsd_t *TSD = parser_data.TSD;
1697
1698 switch(thisptr->type)
1699 {
1700 case X_PLUSS:
1701 case X_MINUS:
1702 case X_MULT:
1703 case X_U_PLUSS:
1704 case X_U_MINUS:
1705 case X_DEVIDE:
1706 case X_INTDIV:
1707 case X_MODULUS:
1708 case X_EQUAL:
1709 case X_DIFF:
1710 case X_GTE:
1711 case X_GT:
1712 case X_LTE:
1713 case X_LT:
1714 case X_SEQUAL:
1715 case X_SDIFF:
1716 case X_SGTE:
1717 case X_SGT:
1718 case X_SLTE:
1719 case X_SLT:
1720 case X_NEQUAL:
1721 case X_NDIFF:
1722 case X_NGTE:
1723 case X_NGT:
1724 case X_NLTE:
1725 case X_NLT:
1726 return IS_A_NUMBER ;
1727
1728
1729 case X_SIM_SYMBOL:
1730 return IS_SIM_SYMBOL ;
1731
1732 case X_HEAD_SYMBOL:
1733 return IS_COMP_SYMBOL ;
1734
1735 case X_STRING:
1736 case X_CON_SYMBOL:
1737 {
1738 if (thisptr->u.number)
1739 {
1740 fprintf( stderr, "Found an internal spot of investigation of the Regina interpreter.\n"
1741 "Please inform Mark Hessling or Florian Grosse-Coosmann about the\n"
1742 "circumstances and this script.\n"
1743 "\n"
1744 "Many thanks!\n"
1745 "email addresses:\n"
1746 "[email protected]\n"
1747 "[email protected]\n");
1748 /* FIXME: When does this happen?
1749 * It doesn't happen if no feedback is send until end of 2005.
1750 */
1751 return IS_A_NUMBER ;
1752 }
1753
1754 if ( ( thisptr->u.number = is_a_descr( TSD, thisptr->name ) ) != NULL )
1755 return IS_A_NUMBER;
1756 return IS_NO_NUMBER;
1757 }
1758 }
1759 return IS_UNKNOWN ;
1760 }
1761
1762
1763
1764 static void transform( nodeptr thisptr )
1765 {
1766 int type ;
1767 node_type left,rght;
1768
1769 left = gettypeof( thisptr->p[0] ) ;
1770 rght = gettypeof( thisptr->p[1] ) ;
1771 type = thisptr->type ;
1772
1773 if ( ( left == IS_A_NUMBER ) && ( rght == IS_A_NUMBER ) )
1774 {
1775 if (type==X_EQUAL)
1776 thisptr->type = X_NEQUAL ;
1777 else if (type==X_DIFF)
1778 thisptr->type = X_NDIFF ;
1779 else if (type==X_GTE)
1780 thisptr->type = X_NGTE ;
1781 else if (type==X_GT)
1782 thisptr->type = X_NGT ;
1783 else if (type==X_LTE)
1784 thisptr->type = X_NLTE ;
1785 else if (type==X_LT)
1786 thisptr->type = X_NLT ;
1787 }
1788 else if ( ( left == IS_NO_NUMBER ) || ( rght == IS_NO_NUMBER ) )
1789 {
1790 if (type==X_EQUAL)
1791 thisptr->type = X_SEQUAL ;
1792 else if (type==X_DIFF)
1793 thisptr->type = X_SDIFF ;
1794 else if (type==X_GTE)
1795 thisptr->type = X_SGTE ;
1796 else if (type==X_GT)
1797 thisptr->type = X_SGT ;
1798 else if (type==X_LTE)
1799 thisptr->type = X_SLTE ;
1800 else if (type==X_LT)
1801 thisptr->type = X_SLT ;
1802 }
1803 else
1804 {
1805 type = thisptr->p[0]->type ;
1806 if ( ( left == IS_A_NUMBER )
1807 && ( ( type == X_STRING ) || ( type == X_CON_SYMBOL ) ) )
1808 thisptr->u.flags.lnum = 1 ;
1809 else if ( left == IS_SIM_SYMBOL )
1810 thisptr->u.flags.lsvar = 1 ;
1811 else if ( left == IS_COMP_SYMBOL )
1812 thisptr->u.flags.lcvar = 1 ;
1813
1814 type = thisptr->p[1]->type ;
1815 if ( ( rght == IS_A_NUMBER )
1816 && ( ( type == X_STRING ) || ( type == X_CON_SYMBOL ) ) )
1817 thisptr->u.flags.rnum = 1 ;
1818 else if ( rght == IS_SIM_SYMBOL )
1819 thisptr->u.flags.rsvar = 1 ;
1820 else if ( rght == IS_COMP_SYMBOL )
1821 thisptr->u.flags.rcvar = 1 ;
1822 }
1823 }
1824
1825
1826 static int is_const( cnodeptr thisptr )
1827 {
1828 if (!thisptr)
1829 return 1 ;
1830
1831 switch (thisptr->type)
1832 {
1833 case X_STRING:
1834 case X_CON_SYMBOL:
1835 return 1 ;
1836
1837 #if 0
1838 Pre-evaluation is not allowed. DIGITS and FUZZ may change within loops
1839 and the resulting value may or may not be the same. Concatenation with
1840 or without spaces is the sole allowed operation.
1841
1842 NEVER ENABLE THIS AGAIN WITHOUT SOLVING THIS PROBLEMS!
1843
1844 case X_U_PLUSS:
1845 case X_U_MINUS:
1846 return is_const( thisptr->p[0] ) ;
1847
1848 case X_PLUSS:
1849 case X_MINUS:
1850 case X_MULT:
1851 /* case X_DEVIDE: Bug 20000807-41821 */
1852 case X_INTDIV:
1853 case X_MODULUS:
1854 case X_EQUAL:
1855 case X_DIFF:
1856 case X_GTE:
1857 case X_GT:
1858 case X_LTE:
1859 case X_LT:
1860 case X_SEQUAL:
1861 case X_SDIFF:
1862 case X_SGTE:
1863 case X_SGT:
1864 case X_SLTE:
1865 case X_SLT:
1866 case X_NEQUAL:
1867 case X_NDIFF:
1868 case X_NGTE:
1869 case X_NGT:
1870 case X_NLTE:
1871 case X_NLT:
1872 #endif
1873
1874 case X_SPACE:
1875 case X_CONCAT:
1876 return is_const( thisptr->p[0] ) && is_const( thisptr->p[1] ) ;
1877 }
1878 return 0 ;
1879 }
1880
1881
1882 static void checkconst( nodeptr thisptr )
1883 {
1884 tsd_t *TSD = parser_data.TSD;
1885
1886 assert( thisptr->type == X_EXPRLIST ) ;
1887 if (is_const(thisptr->p[0]))
1888 {
1889 if (thisptr->p[0])
1890 thisptr->u.strng = evaluate( TSD, thisptr->p[0], NULL ) ;
1891 else
1892 thisptr->u.strng = NULL ;
1893
1894 thisptr->type = X_CEXPRLIST ;
1895 }
1896 }
1897
1898 /*
1899 * reduce_expr_list will be invoked if the reduction of a list expression for
1900 * "call" arguments or a plain "(expr)" is needed. The reduction of the
1901 * outer parentheses of the extended CALL syntax is done with
1902 * mode==REDUCE_CALL, the reduction of a simple "(expr)" is done with
1903 * mode==REDUCE_EXPR. REDUCE_RIGHT is a synonym for REDUCE_CALL currently and
1904 * is intended to be used for reducing the right side of an expression list.
1905 *
1906 * REDUCE_SUBEXPR detect "call s (a)+1," and "call s 1+(a)," and reduces it.
1907 * Furthermore it detects "call s ()+1", "call s 1+()", "call s 1+(a,b)",
1908 * "call s (a,b)+1" and raises an error in this case.
1909 */
1910 static nodeptr reduce_expr_list( nodeptr thisptr, reduce_mode mode )
1911 {
1912 nodeptr h, retval = thisptr;
1913
1914 if ( !thisptr )
1915 return retval;
1916
1917 if ( mode == REDUCE_SUBEXPR )
1918 {
1919 if ( ( parendepth == 1 ) && !IS_FUNCTION( thisptr ) && !IS_EXPRLIST( thisptr ) )
1920 {
1921 if ( IS_EXPRLIST( thisptr->p[0] ) )
1922 {
1923 h = thisptr->p[0];
1924 if ( ( h->p[0] == NULL ) || ( h->p[1] != NULL ) )
1925 exiterror( ERR_INVALID_EXPRESSION, 0 );
1926 thisptr->p[0] = h->p[0];
1927 RejectNode( h );
1928 }
1929 if ( IS_EXPRLIST( thisptr->p[1] ) )
1930 {
1931 h = thisptr->p[1];
1932 if ( ( h->p[0] == NULL ) || ( h->p[1] != NULL ) )
1933 exiterror( ERR_INVALID_EXPRESSION, 0 );
1934 thisptr->p[1] = h->p[0];
1935 RejectNode( h );
1936 }
1937 }
1938 return retval;
1939 }
1940
1941 if ( !IS_EXPRLIST( thisptr ) )
1942 return retval;
1943
1944 if ( ( mode == REDUCE_CALL ) || ( mode == REDUCE_RIGHT ) )
1945 {
1946 if ( IS_EXPRLIST( thisptr->p[0] ) && ( thisptr->p[1] == NULL ) )
1947 {
1948 retval = thisptr->p[0];
1949 RejectNode( thisptr );
1950 }
1951 }
1952 else
1953 {
1954 /*
1955 * mode == REDUCE_EXPR
1956 */
1957 if ( ( thisptr->p[0] != NULL ) && ( thisptr->p[1] == NULL ) )
1958 {
1959 if ( !IS_EXPRLIST( thisptr->p[0] ) )
1960 {
1961 retval = thisptr->p[0];
1962 RejectNode( thisptr );
1963 }
1964 }
1965 }
1966 return retval;
1967 }
1968
1969 /*
1970 * optgluelast connect p2 as the ->next element to p1. Every element may be
1971 * NULL.
1972 * If both are non-NULL, the connection is performed using the o.last elements.
1973 * Just the o.last element of p1 remains non-NULL.
1974 *
1975 * Returns: NULL if p1 and p2 are NULL.
1976 * The non-NULL element if one argumet is NULL.
1977 * p1 otherwise.
1978 */
1979 static nodeptr optgluelast( nodeptr p1, nodeptr p2 )
1980 {
1981 nodeptr p2last;
1982
1983 if ( p1 == NULL )
1984 return p2;
1985 if ( p2 == NULL )
1986 return p1;
1987
1988 /*
1989 * This is performed very often, so keep the code fast.
1990 *
1991 * p2last is the "o.last"-element of p2 or just p2 if p2 has no next
1992 * elements. We set p1's o.last further down, but we have to ensure that
1993 * p2->o.last is NULL first. Therefore every element in the ->next chain
1994 * of p1 will have NULL as its o.last field.
1995 */
1996 if ( ( p2last = p2->o.last ) == NULL )
1997 p2last = p2;
1998 else
1999 p2->o.last = NULL;
2000
2001 if ( p1->o.last == NULL )
2002 p1->next = p2;
2003 else
2004 p1->o.last->next = p2;
2005 p1->o.last = p2last;
2006
2007 return p1;
2008 }
2009
2010 /*
2011 * justlabels returns 1, if n consists of a sequence of labels. The return
2012 * value is 0 otherwise.
2013 */
2014 static int justlabels( nodeptr n )
2015 {
2016 while ( n != NULL )
2017 {
2018 if ( n->type != X_LABEL )
2019 return 0;
2020 n = n->next;
2021 }
2022
2023 return 1;
2024 }
2025
2026 /*
2027 * move_labels move the labels from the end of "end" to the end of "front".
2028 * The labels are marked "read_only" if level is nonnull, the read-only flag
2029 * is removed if level is 0.
2030 * NOTE: At least one element of the "end" chain must contain a non-label
2031 * element.
2032 */
2033 static void move_labels( nodeptr front, nodeptr end, int level )
2034 {
2035 nodeptr oend = end;
2036 nodeptr labels;
2037
2038 assert( front != NULL );
2039 assert( !justlabels( end ) );
2040
2041 while ( !justlabels( end->next ) )
2042 end = end->next;
2043
2044 if ( ( labels = end->next ) == NULL )
2045 return;
2046
2047 /*
2048 * extract the labels.
2049 */
2050 labels->o.last = oend->o.last;
2051 end->next = NULL;
2052 if ( end == oend )
2053 oend->o.last = NULL;
2054 else
2055 oend->o.last = end;
2056
2057 if ( labels->next == NULL )
2058 labels->o.last = NULL;
2059
2060 /*
2061 * add the labels to the end of front and then re-mark the labels.
2062 */
2063 optgluelast( front, labels );
2064 while ( labels ) {
2065 labels->u.trace_only = ( level == 0 ) ? 0 : 1;
2066 labels = labels->next;
2067 }
2068 }