GNU Octave  3.8.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
oct-parse.cc
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 2.7.12-4996. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
6 
7  This program is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /* As a special exception, you may create a larger work that contains
21  part or all of the Bison parser skeleton and distribute that work
22  under terms of your choice, so long as that work isn't itself a
23  parser generator using the skeleton or a modified version thereof
24  as a parser skeleton. Alternatively, if you modify or redistribute
25  the parser skeleton itself, you may (at your option) remove this
26  special exception, which will cause the skeleton and the resulting
27  Bison output files to be licensed under the GNU General Public
28  License without this special exception.
29 
30  This special exception was added by the Free Software Foundation in
31  version 2.2 of Bison. */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34  simplifying the original so-called "semantic" parser. */
35 
36 /* All symbols defined below should begin with yy or YY, to avoid
37  infringing on user name space. This should be done even for local
38  variables, as they might otherwise be expanded by user macros.
39  There are some unavoidable exceptions within include files to
40  define necessary library symbols; they are noted "INFRINGES ON
41  USER NAME SPACE" below. */
42 
43 /* Identify Bison output. */
44 #define YYBISON 1
45 
46 /* Bison version. */
47 #define YYBISON_VERSION "2.7.12-4996"
48 
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers. */
53 #define YYPURE 1
54 
55 /* Push parsers. */
56 #define YYPUSH 1
57 
58 /* Pull parsers. */
59 #define YYPULL 1
60 
61 
62 /* Substitute the variable and function names. */
63 #define yyparse octave_parse
64 #define yypush_parse octave_push_parse
65 #define yypull_parse octave_pull_parse
66 #define yypstate_new octave_pstate_new
67 #define yypstate_delete octave_pstate_delete
68 #define yypstate octave_pstate
69 #define yylex octave_lex
70 #define yyerror octave_error
71 #define yylval octave_lval
72 #define yychar octave_char
73 #define yydebug octave_debug
74 #define yynerrs octave_nerrs
75 
76 /* Copy the first part of user declarations. */
77 /* Line 371 of yacc.c */
78 #line 29 "parse-tree/oct-parse.yy"
79 
80 #define YYDEBUG 1
81 
82 #ifdef HAVE_CONFIG_H
83 #include <config.h>
84 #endif
85 
86 #include <cassert>
87 #include <cstdio>
88 #include <cstdlib>
89 
90 #include <iostream>
91 #include <map>
92 #include <sstream>
93 
94 #include "Cell.h"
95 #include "Matrix.h"
96 #include "cmd-edit.h"
97 #include "cmd-hist.h"
98 #include "file-ops.h"
99 #include "file-stat.h"
100 #include "oct-env.h"
101 #include "oct-time.h"
102 #include "quit.h"
103 
104 #include "comment-list.h"
105 #include "defaults.h"
106 #include "defun.h"
107 #include "dirfns.h"
108 #include "dynamic-ld.h"
109 #include "error.h"
110 #include "input.h"
111 #include "lex.h"
112 #include "load-path.h"
113 #include "oct-hist.h"
114 #include "oct-map.h"
115 #include "ov-fcn-handle.h"
116 #include "ov-usr-fcn.h"
117 #include "ov-null-mat.h"
118 #include "toplev.h"
119 #include "pager.h"
120 #include "parse.h"
121 #include "pt-all.h"
122 #include "pt-eval.h"
123 #include "symtab.h"
124 #include "token.h"
125 #include "unwind-prot.h"
126 #include "utils.h"
127 #include "variables.h"
128 
129 // oct-parse.h must be included after pt-all.h
130 #include <oct-parse.h>
131 
132 extern int octave_lex (YYSTYPE *, void *);
133 
134 // Global access to currently active lexer.
135 // FIXME -- to be removed after more parser+lexer refactoring.
136 octave_base_lexer *LEXER = 0;
137 
138 #if defined (GNULIB_NAMESPACE)
139 // Calls to the following functions appear in the generated output from
140 // Bison without the namespace tag. Redefine them so we will use them
141 // via the gnulib namespace.
142 #define fclose GNULIB_NAMESPACE::fclose
143 #define fprintf GNULIB_NAMESPACE::fprintf
144 #define malloc GNULIB_NAMESPACE::malloc
145 #endif
146 
147 // TRUE means we printed messages about reading startup files.
148 bool reading_startup_message_printed = false;
149 
150 // List of autoloads (function -> file mapping).
151 static std::map<std::string, std::string> autoload_map;
152 
153 // Forward declarations for some functions defined at the bottom of
154 // the file.
155 
156 static void yyerror (octave_base_parser& parser, const char *s);
157 
158 #define ABORT_PARSE \
159  do \
160  { \
161  yyerrok; \
162  if ((interactive || forced_interactive) \
163  && ! lexer.input_from_eval_string ()) \
164  YYACCEPT; \
165  else \
166  YYABORT; \
167  } \
168  while (0)
169 
170 #define lexer parser.lexer
171 #define scanner lexer.scanner
172 
173 
174 /* Line 371 of yacc.c */
175 #line 176 "parse-tree/oct-parse.cc"
176 
177 # ifndef YY_NULL
178 # if defined __cplusplus && 201103L <= __cplusplus
179 # define YY_NULL nullptr
180 # else
181 # define YY_NULL 0
182 # endif
183 # endif
184 
185 /* Enabling verbose error messages. */
186 #ifdef YYERROR_VERBOSE
187 # undef YYERROR_VERBOSE
188 # define YYERROR_VERBOSE 1
189 #else
190 # define YYERROR_VERBOSE 0
191 #endif
192 
193 /* In a future release of Bison, this section will be replaced
194  by #include "y.tab.h". */
195 #ifndef YY_OCTAVE_PARSE_TREE_OCT_PARSE_H_INCLUDED
196 # define YY_OCTAVE_PARSE_TREE_OCT_PARSE_H_INCLUDED
197 /* Enabling traces. */
198 #ifndef YYDEBUG
199 # define YYDEBUG 0
200 #endif
201 #if YYDEBUG
202 extern int octave_debug;
203 #endif
204 
205 /* Tokens. */
206 #ifndef YYTOKENTYPE
207 # define YYTOKENTYPE
208  /* Put the tokens into the symbol table, so that GDB and other debuggers
209  know about them. */
210  enum yytokentype {
211  ADD_EQ = 258,
212  SUB_EQ = 259,
213  MUL_EQ = 260,
214  DIV_EQ = 261,
215  LEFTDIV_EQ = 262,
216  POW_EQ = 263,
217  EMUL_EQ = 264,
218  EDIV_EQ = 265,
219  ELEFTDIV_EQ = 266,
220  EPOW_EQ = 267,
221  AND_EQ = 268,
222  OR_EQ = 269,
223  LSHIFT_EQ = 270,
224  RSHIFT_EQ = 271,
225  LSHIFT = 272,
226  RSHIFT = 273,
227  EXPR_AND_AND = 274,
228  EXPR_OR_OR = 275,
229  EXPR_AND = 276,
230  EXPR_OR = 277,
231  EXPR_NOT = 278,
232  EXPR_LT = 279,
233  EXPR_LE = 280,
234  EXPR_EQ = 281,
235  EXPR_NE = 282,
236  EXPR_GE = 283,
237  EXPR_GT = 284,
238  LEFTDIV = 285,
239  EMUL = 286,
240  EDIV = 287,
241  ELEFTDIV = 288,
242  EPLUS = 289,
243  EMINUS = 290,
244  HERMITIAN = 291,
245  TRANSPOSE = 292,
246  PLUS_PLUS = 293,
247  MINUS_MINUS = 294,
248  POW = 295,
249  EPOW = 296,
250  NUM = 297,
251  IMAG_NUM = 298,
252  STRUCT_ELT = 299,
253  NAME = 300,
254  END = 301,
255  DQ_STRING = 302,
256  SQ_STRING = 303,
257  FOR = 304,
258  PARFOR = 305,
259  WHILE = 306,
260  DO = 307,
261  UNTIL = 308,
262  IF = 309,
263  ELSEIF = 310,
264  ELSE = 311,
265  SWITCH = 312,
266  CASE = 313,
267  OTHERWISE = 314,
268  BREAK = 315,
269  CONTINUE = 316,
270  FUNC_RET = 317,
271  UNWIND = 318,
272  CLEANUP = 319,
273  TRY = 320,
274  CATCH = 321,
275  GLOBAL = 322,
276  PERSISTENT = 323,
277  FCN_HANDLE = 324,
278  PROPERTIES = 325,
279  METHODS = 326,
280  EVENTS = 327,
281  ENUMERATION = 328,
282  METAQUERY = 329,
283  SUPERCLASSREF = 330,
284  GET = 331,
285  SET = 332,
286  FCN = 333,
287  END_OF_INPUT = 334,
288  LEXICAL_ERROR = 335,
289  INPUT_FILE = 336,
290  CLASSDEF = 337,
291  UNARY = 338
292  };
293 #endif
294 /* Tokens. */
295 #define ADD_EQ 258
296 #define SUB_EQ 259
297 #define MUL_EQ 260
298 #define DIV_EQ 261
299 #define LEFTDIV_EQ 262
300 #define POW_EQ 263
301 #define EMUL_EQ 264
302 #define EDIV_EQ 265
303 #define ELEFTDIV_EQ 266
304 #define EPOW_EQ 267
305 #define AND_EQ 268
306 #define OR_EQ 269
307 #define LSHIFT_EQ 270
308 #define RSHIFT_EQ 271
309 #define LSHIFT 272
310 #define RSHIFT 273
311 #define EXPR_AND_AND 274
312 #define EXPR_OR_OR 275
313 #define EXPR_AND 276
314 #define EXPR_OR 277
315 #define EXPR_NOT 278
316 #define EXPR_LT 279
317 #define EXPR_LE 280
318 #define EXPR_EQ 281
319 #define EXPR_NE 282
320 #define EXPR_GE 283
321 #define EXPR_GT 284
322 #define LEFTDIV 285
323 #define EMUL 286
324 #define EDIV 287
325 #define ELEFTDIV 288
326 #define EPLUS 289
327 #define EMINUS 290
328 #define HERMITIAN 291
329 #define TRANSPOSE 292
330 #define PLUS_PLUS 293
331 #define MINUS_MINUS 294
332 #define POW 295
333 #define EPOW 296
334 #define NUM 297
335 #define IMAG_NUM 298
336 #define STRUCT_ELT 299
337 #define NAME 300
338 #define END 301
339 #define DQ_STRING 302
340 #define SQ_STRING 303
341 #define FOR 304
342 #define PARFOR 305
343 #define WHILE 306
344 #define DO 307
345 #define UNTIL 308
346 #define IF 309
347 #define ELSEIF 310
348 #define ELSE 311
349 #define SWITCH 312
350 #define CASE 313
351 #define OTHERWISE 314
352 #define BREAK 315
353 #define CONTINUE 316
354 #define FUNC_RET 317
355 #define UNWIND 318
356 #define CLEANUP 319
357 #define TRY 320
358 #define CATCH 321
359 #define GLOBAL 322
360 #define PERSISTENT 323
361 #define FCN_HANDLE 324
362 #define PROPERTIES 325
363 #define METHODS 326
364 #define EVENTS 327
365 #define ENUMERATION 328
366 #define METAQUERY 329
367 #define SUPERCLASSREF 330
368 #define GET 331
369 #define SET 332
370 #define FCN 333
371 #define END_OF_INPUT 334
372 #define LEXICAL_ERROR 335
373 #define INPUT_FILE 336
374 #define CLASSDEF 337
375 #define UNARY 338
376 
377 
378 
379 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
380 typedef union YYSTYPE
381 {
382 /* Line 387 of yacc.c */
383 #line 152 "parse-tree/oct-parse.yy"
384 
385  // The type of the basic tokens returned by the lexer.
386  token *tok_val;
387 
388  // Comment strings that we need to deal with mid-rule.
389  octave_comment_list *comment_type;
390 
391  // Types for the nonterminals we generate.
392  char sep_type;
393  tree *tree_type;
394  tree_matrix *tree_matrix_type;
395  tree_cell *tree_cell_type;
396  tree_expression *tree_expression_type;
397  tree_constant *tree_constant_type;
398  tree_fcn_handle *tree_fcn_handle_type;
399  tree_anon_fcn_handle *tree_anon_fcn_handle_type;
400  tree_identifier *tree_identifier_type;
401  tree_index_expression *tree_index_expression_type;
402  tree_colon_expression *tree_colon_expression_type;
403  tree_argument_list *tree_argument_list_type;
404  tree_parameter_list *tree_parameter_list_type;
405  tree_command *tree_command_type;
406  tree_if_command *tree_if_command_type;
407  tree_if_clause *tree_if_clause_type;
408  tree_if_command_list *tree_if_command_list_type;
409  tree_switch_command *tree_switch_command_type;
410  tree_switch_case *tree_switch_case_type;
411  tree_switch_case_list *tree_switch_case_list_type;
412  tree_decl_elt *tree_decl_elt_type;
413  tree_decl_init_list *tree_decl_init_list_type;
414  tree_decl_command *tree_decl_command_type;
415  tree_statement *tree_statement_type;
416  tree_statement_list *tree_statement_list_type;
417  octave_user_function *octave_user_function_type;
418  void *dummy_type;
419 
420 
421 /* Line 387 of yacc.c */
422 #line 423 "parse-tree/oct-parse.cc"
423 } YYSTYPE;
424 # define YYSTYPE_IS_TRIVIAL 1
425 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
426 # define YYSTYPE_IS_DECLARED 1
427 #endif
428 
429 
430 #ifndef YYPUSH_MORE_DEFINED
431 # define YYPUSH_MORE_DEFINED
432 enum { YYPUSH_MORE = 4 };
433 #endif
434 
435 typedef struct octave_pstate octave_pstate;
436 
437 #if defined __STDC__ || defined __cplusplus
438 int octave_parse (octave_base_parser& parser);
439 #else
440 int octave_parse ();
441 #endif
442 #if defined __STDC__ || defined __cplusplus
443 int octave_push_parse (octave_pstate *ps, int pushed_char, YYSTYPE const *pushed_val, octave_base_parser& parser);
444 #else
445 int octave_push_parse ();
446 #endif
447 #if defined __STDC__ || defined __cplusplus
448 int octave_pull_parse (octave_pstate *ps, octave_base_parser& parser);
449 #else
450 int octave_pull_parse ();
451 #endif
452 #if defined __STDC__ || defined __cplusplus
453 octave_pstate * octave_pstate_new (void);
454 #else
455 octave_pstate * octave_pstate_new ();
456 #endif
457 #if defined __STDC__ || defined __cplusplus
458 void octave_pstate_delete (octave_pstate *ps);
459 #else
460 void octave_pstate_delete ();
461 #endif
462 
463 #endif /* !YY_OCTAVE_PARSE_TREE_OCT_PARSE_H_INCLUDED */
464 
465 /* Copy the second part of user declarations. */
466 
467 /* Line 390 of yacc.c */
468 #line 469 "parse-tree/oct-parse.cc"
469 
470 #ifdef short
471 # undef short
472 #endif
473 
474 #ifdef YYTYPE_UINT8
475 typedef YYTYPE_UINT8 yytype_uint8;
476 #else
477 typedef unsigned char yytype_uint8;
478 #endif
479 
480 #ifdef YYTYPE_INT8
481 typedef YYTYPE_INT8 yytype_int8;
482 #elif (defined __STDC__ || defined __C99__FUNC__ \
483  || defined __cplusplus || defined _MSC_VER)
484 typedef signed char yytype_int8;
485 #else
486 typedef short int yytype_int8;
487 #endif
488 
489 #ifdef YYTYPE_UINT16
490 typedef YYTYPE_UINT16 yytype_uint16;
491 #else
492 typedef unsigned short int yytype_uint16;
493 #endif
494 
495 #ifdef YYTYPE_INT16
496 typedef YYTYPE_INT16 yytype_int16;
497 #else
498 typedef short int yytype_int16;
499 #endif
500 
501 #ifndef YYSIZE_T
502 # ifdef __SIZE_TYPE__
503 # define YYSIZE_T __SIZE_TYPE__
504 # elif defined size_t
505 # define YYSIZE_T size_t
506 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
507  || defined __cplusplus || defined _MSC_VER)
508 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
509 # define YYSIZE_T size_t
510 # else
511 # define YYSIZE_T unsigned int
512 # endif
513 #endif
514 
515 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
516 
517 #ifndef YY_
518 # if defined YYENABLE_NLS && YYENABLE_NLS
519 # if ENABLE_NLS
520 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
521 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
522 # endif
523 # endif
524 # ifndef YY_
525 # define YY_(Msgid) Msgid
526 # endif
527 #endif
528 
529 #ifndef __attribute__
530 /* This feature is available in gcc versions 2.5 and later. */
531 # if (! defined __GNUC__ || __GNUC__ < 2 \
532  || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
533 # define __attribute__(Spec) /* empty */
534 # endif
535 #endif
536 
537 /* Suppress unused-variable warnings by "using" E. */
538 #if ! defined lint || defined __GNUC__
539 # define YYUSE(E) ((void) (E))
540 #else
541 # define YYUSE(E) /* empty */
542 #endif
543 
544 
545 /* Identity function, used to suppress warnings about constant conditions. */
546 #ifndef lint
547 # define YYID(N) (N)
548 #else
549 #if (defined __STDC__ || defined __C99__FUNC__ \
550  || defined __cplusplus || defined _MSC_VER)
551 static int
552 YYID (int yyi)
553 #else
554 static int
555 YYID (yyi)
556  int yyi;
557 #endif
558 {
559  return yyi;
560 }
561 #endif
562 
563 #if ! defined yyoverflow || YYERROR_VERBOSE
564 
565 /* The parser invokes alloca or malloc; define the necessary symbols. */
566 
567 # ifdef YYSTACK_ALLOC
568  /* Pacify GCC's `empty if-body' warning. */
569 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
570 # ifndef YYSTACK_ALLOC_MAXIMUM
571  /* The OS might guarantee only one guard page at the bottom of the stack,
572  and a page size can be as small as 4096 bytes. So we cannot safely
573  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
574  to allow for a few compiler-allocated temporary stack slots. */
575 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
576 # endif
577 # else
578 # define YYSTACK_ALLOC YYMALLOC
579 # define YYSTACK_FREE YYFREE
580 # ifndef YYSTACK_ALLOC_MAXIMUM
581 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
582 # endif
583 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
584  && ! ((defined YYMALLOC || defined malloc) \
585  && (defined YYFREE || defined free)))
586 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
587 # ifndef EXIT_SUCCESS
588 # define EXIT_SUCCESS 0
589 # endif
590 # endif
591 # ifndef YYMALLOC
592 # define YYMALLOC malloc
593 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
594  || defined __cplusplus || defined _MSC_VER)
595 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
596 # endif
597 # endif
598 # ifndef YYFREE
599 # define YYFREE free
600 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
601  || defined __cplusplus || defined _MSC_VER)
602 void free (void *); /* INFRINGES ON USER NAME SPACE */
603 # endif
604 # endif
605 # endif
606 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
607 
608 
609 #if (! defined yyoverflow \
610  && (! defined __cplusplus \
611  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
612 
613 /* A type that is properly aligned for any stack member. */
614 union yyalloc
615 {
616  yytype_int16 yyss_alloc;
617  YYSTYPE yyvs_alloc;
618 };
619 
620 /* The size of the maximum gap between one aligned stack and the next. */
621 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
622 
623 /* The size of an array large to enough to hold all stacks, each with
624  N elements. */
625 # define YYSTACK_BYTES(N) \
626  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
627  + YYSTACK_GAP_MAXIMUM)
628 
629 # define YYCOPY_NEEDED 1
630 
631 /* Relocate STACK from its old location to the new one. The
632  local variables YYSIZE and YYSTACKSIZE give the old and new number of
633  elements in the stack, and YYPTR gives the new location of the
634  stack. Advance YYPTR to a properly aligned location for the next
635  stack. */
636 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
637  do \
638  { \
639  YYSIZE_T yynewbytes; \
640  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
641  Stack = &yyptr->Stack_alloc; \
642  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
643  yyptr += yynewbytes / sizeof (*yyptr); \
644  } \
645  while (YYID (0))
646 
647 #endif
648 
649 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
650 /* Copy COUNT objects from SRC to DST. The source and destination do
651  not overlap. */
652 # ifndef YYCOPY
653 # if defined __GNUC__ && 1 < __GNUC__
654 # define YYCOPY(Dst, Src, Count) \
655  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
656 # else
657 # define YYCOPY(Dst, Src, Count) \
658  do \
659  { \
660  YYSIZE_T yyi; \
661  for (yyi = 0; yyi < (Count); yyi++) \
662  (Dst)[yyi] = (Src)[yyi]; \
663  } \
664  while (YYID (0))
665 # endif
666 # endif
667 #endif /* !YYCOPY_NEEDED */
668 
669 /* YYFINAL -- State number of the termination state. */
670 #define YYFINAL 115
671 /* YYLAST -- Last index in YYTABLE. */
672 #define YYLAST 1410
673 
674 /* YYNTOKENS -- Number of terminals. */
675 #define YYNTOKENS 101
676 /* YYNNTS -- Number of nonterminals. */
677 #define YYNNTS 104
678 /* YYNRULES -- Number of rules. */
679 #define YYNRULES 275
680 /* YYNRULES -- Number of states. */
681 #define YYNSTATES 514
682 
683 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
684 #define YYUNDEFTOK 2
685 #define YYMAXUTOK 338
686 
687 #define YYTRANSLATE(YYX) \
688  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
689 
690 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
691 static const yytype_uint8 yytranslate[] =
692 {
693  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
694  93, 2, 2, 2, 2, 2, 2, 2, 2, 2,
695  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
696  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
697  90, 100, 7, 6, 98, 5, 91, 8, 2, 2,
698  2, 2, 2, 2, 2, 2, 2, 2, 4, 96,
699  2, 3, 2, 2, 99, 2, 2, 2, 2, 2,
700  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
701  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
702  2, 94, 2, 95, 2, 2, 2, 2, 2, 2,
703  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
704  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
705  2, 2, 2, 92, 2, 97, 2, 2, 2, 2,
706  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
707  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
708  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
709  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
710  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
711  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
712  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
713  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
714  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
715  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
716  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
717  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
718  2, 2, 2, 2, 2, 2, 1, 2, 9, 10,
719  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
720  21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
721  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
722  41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
723  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
724  61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
725  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
726  81, 82, 83, 84, 85, 86, 87, 88, 89
727 };
728 
729 #if YYDEBUG
730 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
731  YYRHS. */
732 static const yytype_uint16 yyprhs[] =
733 {
734  0, 0, 3, 6, 9, 11, 13, 16, 18, 22,
735  23, 25, 28, 30, 34, 36, 38, 40, 43, 45,
736  48, 50, 52, 54, 56, 58, 60, 62, 64, 68,
737  70, 74, 78, 80, 84, 85, 87, 89, 92, 95,
738  99, 102, 107, 109, 111, 113, 115, 117, 119, 121,
739  125, 127, 129, 131, 133, 135, 139, 143, 147, 149,
740  151, 154, 157, 161, 166, 170, 175, 178, 181, 185,
741  191, 194, 197, 200, 203, 206, 210, 214, 218, 222,
742  226, 230, 234, 238, 242, 246, 250, 254, 256, 259,
743  262, 266, 271, 275, 280, 284, 290, 293, 296, 299,
744  302, 305, 307, 309, 313, 315, 319, 323, 327, 331,
745  335, 339, 343, 347, 351, 355, 359, 363, 365, 369,
746  373, 377, 381, 385, 389, 393, 397, 401, 405, 409,
747  413, 417, 421, 425, 427, 429, 431, 433, 435, 437,
748  439, 441, 443, 445, 447, 450, 453, 455, 458, 459,
749  461, 466, 468, 470, 475, 477, 480, 485, 488, 496,
750  501, 508, 509, 511, 513, 516, 518, 521, 529, 534,
751  542, 549, 559, 570, 580, 593, 595, 597, 599, 609,
752  619, 625, 626, 628, 630, 634, 637, 638, 640, 642,
753  646, 648, 650, 653, 655, 659, 661, 665, 670, 673,
754  677, 683, 685, 689, 693, 696, 701, 705, 707, 709,
755  712, 714, 719, 726, 727, 731, 733, 737, 739, 744,
756  747, 748, 750, 755, 758, 764, 768, 770, 772, 774,
757  776, 780, 784, 788, 792, 795, 802, 804, 808, 810,
758  816, 819, 826, 828, 832, 835, 842, 844, 848, 850,
759  853, 860, 862, 866, 871, 872, 873, 875, 877, 879,
760  881, 884, 887, 888, 890, 891, 893, 895, 898, 900,
761  902, 904, 907, 910, 913, 914
762 };
763 
764 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
765 static const yytype_int16 yyrhs[] =
766 {
767  102, 0, -1, 103, 93, -1, 103, 85, -1, 198,
768  -1, 200, -1, 104, 200, -1, 108, -1, 104, 199,
769  108, -1, -1, 106, -1, 107, 204, -1, 108, -1,
770  107, 203, 108, -1, 135, -1, 136, -1, 109, -1,
771  111, 110, -1, 114, -1, 110, 114, -1, 51, -1,
772  81, -1, 80, -1, 53, -1, 54, -1, 48, -1,
773  49, -1, 114, -1, 94, 117, 95, -1, 120, -1,
774  117, 96, 120, -1, 92, 119, 97, -1, 120, -1,
775  119, 96, 120, -1, -1, 98, -1, 126, -1, 126,
776  98, -1, 98, 126, -1, 98, 126, 98, -1, 99,
777  75, -1, 99, 158, 196, 108, -1, 111, -1, 115,
778  -1, 121, -1, 116, -1, 118, -1, 113, -1, 112,
779  -1, 90, 135, 100, -1, 4, -1, 29, -1, 135,
780  -1, 124, -1, 125, -1, 126, 98, 124, -1, 126,
781  98, 125, -1, 126, 98, 135, -1, 91, -1, 123,
782  -1, 128, 44, -1, 128, 45, -1, 128, 90, 100,
783  -1, 128, 90, 126, 100, -1, 128, 92, 97, -1,
784  128, 92, 126, 97, -1, 128, 42, -1, 128, 43,
785  -1, 128, 127, 50, -1, 128, 127, 90, 135, 100,
786  -1, 44, 128, -1, 45, 128, -1, 29, 128, -1,
787  6, 128, -1, 5, 128, -1, 128, 46, 129, -1,
788  128, 47, 129, -1, 128, 6, 128, -1, 128, 5,
789  128, -1, 128, 7, 128, -1, 128, 8, 128, -1,
790  128, 40, 128, -1, 128, 41, 128, -1, 128, 37,
791  128, -1, 128, 38, 128, -1, 128, 36, 128, -1,
792  128, 39, 128, -1, 123, -1, 129, 44, -1, 129,
793  45, -1, 129, 90, 100, -1, 129, 90, 126, 100,
794  -1, 129, 92, 97, -1, 129, 92, 126, 97, -1,
795  129, 127, 50, -1, 129, 127, 90, 135, 100, -1,
796  44, 129, -1, 45, 129, -1, 29, 129, -1, 6,
797  129, -1, 5, 129, -1, 131, -1, 128, -1, 131,
798  4, 128, -1, 130, -1, 132, 23, 132, -1, 132,
799  24, 132, -1, 132, 30, 132, -1, 132, 31, 132,
800  -1, 132, 32, 132, -1, 132, 34, 132, -1, 132,
801  35, 132, -1, 132, 33, 132, -1, 132, 27, 132,
802  -1, 132, 28, 132, -1, 132, 25, 132, -1, 132,
803  26, 132, -1, 132, -1, 133, 3, 135, -1, 133,
804  9, 135, -1, 133, 10, 135, -1, 133, 11, 135,
805  -1, 133, 12, 135, -1, 133, 13, 135, -1, 133,
806  14, 135, -1, 133, 21, 135, -1, 133, 22, 135,
807  -1, 133, 15, 135, -1, 133, 16, 135, -1, 133,
808  17, 135, -1, 133, 18, 135, -1, 133, 19, 135,
809  -1, 133, 20, 135, -1, 132, -1, 134, -1, 122,
810  -1, 137, -1, 141, -1, 152, -1, 153, -1, 154,
811  -1, 166, -1, 164, -1, 174, -1, 73, 138, -1,
812  74, 138, -1, 140, -1, 138, 140, -1, -1, 111,
813  -1, 111, 3, 139, 135, -1, 142, -1, 147, -1,
814  60, 197, 143, 52, -1, 144, -1, 144, 146, -1,
815  135, 196, 204, 105, -1, 144, 145, -1, 61, 197,
816  204, 135, 196, 204, 105, -1, 62, 197, 204, 105,
817  -1, 63, 197, 135, 204, 148, 52, -1, -1, 151,
818  -1, 149, -1, 149, 151, -1, 150, -1, 149, 150,
819  -1, 64, 197, 204, 135, 196, 204, 105, -1, 65,
820  197, 204, 105, -1, 57, 197, 135, 196, 204, 105,
821  52, -1, 58, 197, 204, 105, 59, 135, -1, 55,
822  197, 133, 3, 135, 196, 204, 105, 52, -1, 55,
823  197, 90, 133, 3, 135, 100, 204, 105, 52, -1,
824  56, 197, 133, 3, 135, 196, 204, 105, 52, -1,
825  56, 197, 90, 133, 3, 135, 98, 135, 100, 204,
826  105, 52, -1, 66, -1, 67, -1, 68, -1, 69,
827  197, 204, 105, 70, 197, 204, 105, 52, -1, 71,
828  197, 204, 105, 72, 197, 204, 105, 52, -1, 71,
829  197, 204, 105, 52, -1, -1, 90, -1, 100, -1,
830  156, 159, 157, -1, 156, 1, -1, -1, 160, -1,
831  161, -1, 160, 98, 161, -1, 140, -1, 125, -1,
832  94, 95, -1, 111, -1, 94, 163, 95, -1, 111,
833  -1, 163, 98, 111, -1, 87, 201, 105, 85, -1,
834  155, 84, -1, 165, 197, 168, -1, 165, 197, 162,
835  3, 168, -1, 111, -1, 82, 91, 111, -1, 83,
836  91, 111, -1, 167, 169, -1, 158, 204, 105, 170,
837  -1, 204, 105, 170, -1, 52, -1, 85, -1, 88,
838  197, -1, 52, -1, 171, 175, 111, 178, -1, 173,
839  204, 180, 204, 197, 172, -1, -1, 90, 176, 100,
840  -1, 177, -1, 176, 98, 177, -1, 111, -1, 111,
841  3, 139, 135, -1, 29, 111, -1, -1, 179, -1,
842  30, 111, 91, 111, -1, 30, 111, -1, 179, 27,
843  111, 91, 111, -1, 179, 27, 111, -1, 182, -1,
844  186, -1, 189, -1, 193, -1, 180, 204, 182, -1,
845  180, 204, 186, -1, 180, 204, 189, -1, 180, 204,
846  193, -1, 76, 197, -1, 181, 175, 204, 183, 204,
847  52, -1, 184, -1, 183, 204, 184, -1, 111, -1,
848  111, 3, 139, 135, 96, -1, 77, 197, -1, 185,
849  175, 204, 187, 204, 52, -1, 166, -1, 187, 204,
850  166, -1, 78, 197, -1, 188, 175, 204, 190, 204,
851  52, -1, 191, -1, 190, 204, 191, -1, 111, -1,
852  79, 197, -1, 192, 175, 204, 194, 204, 52, -1,
853  195, -1, 194, 204, 195, -1, 111, 90, 135, 100,
854  -1, -1, -1, 86, -1, 1, -1, 98, -1, 96,
855  -1, 199, 98, -1, 199, 96, -1, -1, 199, -1,
856  -1, 202, -1, 93, -1, 202, 93, -1, 98, -1,
857  96, -1, 93, -1, 203, 98, -1, 203, 96, -1,
858  203, 93, -1, -1, 203, -1
859 };
860 
861 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
862 static const yytype_uint16 yyrline[] =
863 {
864  0, 350, 350, 355, 361, 365, 367, 371, 373, 378,
865  379, 383, 387, 389, 393, 395, 397, 409, 420, 422,
866  433, 441, 445, 449, 451, 455, 457, 459, 463, 467,
867  469, 483, 487, 489, 508, 509, 511, 513, 515, 517,
868  521, 528, 535, 537, 539, 541, 546, 548, 550, 552,
869  556, 563, 569, 571, 573, 575, 580, 585, 592, 596,
870  598, 600, 602, 611, 620, 629, 638, 640, 642, 644,
871  646, 648, 650, 652, 654, 656, 658, 660, 662, 664,
872  666, 668, 670, 672, 674, 676, 678, 682, 684, 686,
873  688, 697, 706, 715, 724, 726, 728, 730, 732, 734,
874  736, 740, 744, 746, 757, 759, 761, 763, 765, 767,
875  769, 771, 773, 775, 777, 779, 781, 785, 799, 801,
876  803, 805, 807, 809, 811, 813, 815, 817, 819, 821,
877  823, 825, 827, 831, 846, 848, 856, 858, 860, 862,
878  864, 866, 868, 870, 878, 883, 890, 892, 900, 902,
879  904, 915, 917, 925, 935, 937, 944, 950, 957, 965,
880  973, 984, 985, 987, 989, 996, 998, 1005, 1009, 1019,
881  1029, 1033, 1042, 1051, 1060, 1075, 1077, 1079, 1087, 1096,
882  1105, 1120, 1147, 1160, 1167, 1174, 1183, 1184, 1200, 1202,
883  1209, 1211, 1219, 1225, 1243, 1260, 1262, 1273, 1303, 1312,
884  1318, 1326, 1335, 1341, 1349, 1359, 1361, 1365, 1374, 1414,
885  1421, 1433, 1437, 1442, 1443, 1447, 1449, 1453, 1455, 1457,
886  1463, 1464, 1468, 1470, 1472, 1474, 1478, 1480, 1482, 1484,
887  1486, 1488, 1490, 1492, 1496, 1501, 1506, 1508, 1512, 1514,
888  1518, 1522, 1526, 1528, 1532, 1536, 1540, 1542, 1546, 1550,
889  1554, 1558, 1560, 1564, 1573, 1577, 1580, 1582, 1585, 1587,
890  1589, 1591, 1596, 1597, 1602, 1603, 1607, 1609, 1613, 1615,
891  1617, 1619, 1621, 1623, 1628, 1629
892 };
893 #endif
894 
895 #if YYDEBUG || YYERROR_VERBOSE || 0
896 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
897  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
898 static const char *const yytname[] =
899 {
900  "$end", "error", "$undefined", "'='", "':'", "'-'", "'+'", "'*'", "'/'",
901  "ADD_EQ", "SUB_EQ", "MUL_EQ", "DIV_EQ", "LEFTDIV_EQ", "POW_EQ",
902  "EMUL_EQ", "EDIV_EQ", "ELEFTDIV_EQ", "EPOW_EQ", "AND_EQ", "OR_EQ",
903  "LSHIFT_EQ", "RSHIFT_EQ", "LSHIFT", "RSHIFT", "EXPR_AND_AND",
904  "EXPR_OR_OR", "EXPR_AND", "EXPR_OR", "EXPR_NOT", "EXPR_LT", "EXPR_LE",
905  "EXPR_EQ", "EXPR_NE", "EXPR_GE", "EXPR_GT", "LEFTDIV", "EMUL", "EDIV",
906  "ELEFTDIV", "EPLUS", "EMINUS", "HERMITIAN", "TRANSPOSE", "PLUS_PLUS",
907  "MINUS_MINUS", "POW", "EPOW", "NUM", "IMAG_NUM", "STRUCT_ELT", "NAME",
908  "END", "DQ_STRING", "SQ_STRING", "FOR", "PARFOR", "WHILE", "DO", "UNTIL",
909  "IF", "ELSEIF", "ELSE", "SWITCH", "CASE", "OTHERWISE", "BREAK",
910  "CONTINUE", "FUNC_RET", "UNWIND", "CLEANUP", "TRY", "CATCH", "GLOBAL",
911  "PERSISTENT", "FCN_HANDLE", "PROPERTIES", "METHODS", "EVENTS",
912  "ENUMERATION", "METAQUERY", "SUPERCLASSREF", "GET", "SET", "FCN",
913  "END_OF_INPUT", "LEXICAL_ERROR", "INPUT_FILE", "CLASSDEF", "UNARY",
914  "'('", "'.'", "'{'", "'\\n'", "'['", "']'", "';'", "'}'", "','", "'@'",
915  "')'", "$accept", "input", "simple_list", "simple_list1", "opt_list",
916  "list", "list1", "statement", "word_list_cmd", "word_list", "identifier",
917  "superclass_identifier", "meta_identifier", "string", "constant",
918  "matrix", "matrix_rows", "cell", "cell_rows", "cell_or_matrix_row",
919  "fcn_handle", "anon_fcn_handle", "primary_expr", "magic_colon",
920  "magic_tilde", "arg_list", "indirect_ref_op", "oper_expr", "power_expr",
921  "colon_expr", "colon_expr1", "simple_expr", "assign_lhs", "assign_expr",
922  "expression", "command", "declaration", "decl1", "decl_param_init",
923  "decl2", "select_command", "if_command", "if_cmd_list", "if_cmd_list1",
924  "elseif_clause", "else_clause", "switch_command", "case_list",
925  "case_list1", "switch_case", "default_case", "loop_command",
926  "jump_command", "except_command", "push_fcn_symtab", "param_list_beg",
927  "param_list_end", "param_list", "param_list1", "param_list2",
928  "param_list_elt", "return_list", "return_list1", "file", "function_beg",
929  "function", "fcn_name", "function1", "function2", "function_end",
930  "classdef_beg", "classdef_end", "classdef1", "classdef", "opt_attr_list",
931  "attr_list", "attr", "opt_superclasses", "superclasses", "class_body",
932  "properties_beg", "properties_block", "properties_list",
933  "class_property", "methods_beg", "methods_block", "methods_list",
934  "events_beg", "events_block", "events_list", "class_event", "enum_beg",
935  "enum_block", "enum_list", "class_enum", "stmt_begin", "stash_comment",
936  "parse_error", "sep_no_nl", "opt_sep_no_nl", "opt_nl", "nl", "sep",
937  "opt_sep", YY_NULL
938 };
939 #endif
940 
941 # ifdef YYPRINT
942 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
943  token YYLEX-NUM. */
944 static const yytype_uint16 yytoknum[] =
945 {
946  0, 256, 257, 61, 58, 45, 43, 42, 47, 258,
947  259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
948  269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
949  279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
950  289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
951  299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
952  309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
953  319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
954  329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
955  40, 46, 123, 10, 91, 93, 59, 125, 44, 64,
956  41
957 };
958 # endif
959 
960 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
961 static const yytype_uint8 yyr1[] =
962 {
963  0, 101, 102, 102, 102, 103, 103, 104, 104, 105,
964  105, 106, 107, 107, 108, 108, 108, 109, 110, 110,
965  111, 112, 113, 114, 114, 115, 115, 115, 116, 117,
966  117, 118, 119, 119, 120, 120, 120, 120, 120, 120,
967  121, 122, 123, 123, 123, 123, 123, 123, 123, 123,
968  124, 125, 126, 126, 126, 126, 126, 126, 127, 128,
969  128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
970  128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
971  128, 128, 128, 128, 128, 128, 128, 129, 129, 129,
972  129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
973  129, 130, 131, 131, 132, 132, 132, 132, 132, 132,
974  132, 132, 132, 132, 132, 132, 132, 133, 134, 134,
975  134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
976  134, 134, 134, 135, 135, 135, 136, 136, 136, 136,
977  136, 136, 136, 136, 137, 137, 138, 138, 139, 140,
978  140, 141, 141, 142, 143, 143, 144, 144, 145, 146,
979  147, 148, 148, 148, 148, 149, 149, 150, 151, 152,
980  152, 152, 152, 152, 152, 153, 153, 153, 154, 154,
981  154, 155, 156, 157, 158, 158, 159, 159, 160, 160,
982  161, 161, 162, 162, 162, 163, 163, 164, 165, 166,
983  166, 167, 167, 167, 168, 169, 169, 170, 170, 171,
984  172, 173, 174, 175, 175, 176, 176, 177, 177, 177,
985  178, 178, 179, 179, 179, 179, 180, 180, 180, 180,
986  180, 180, 180, 180, 181, 182, 183, 183, 184, 184,
987  185, 186, 187, 187, 188, 189, 190, 190, 191, 192,
988  193, 194, 194, 195, 196, 197, 198, 198, 199, 199,
989  199, 199, 200, 200, 201, 201, 202, 202, 203, 203,
990  203, 203, 203, 203, 204, 204
991 };
992 
993 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
994 static const yytype_uint8 yyr2[] =
995 {
996  0, 2, 2, 2, 1, 1, 2, 1, 3, 0,
997  1, 2, 1, 3, 1, 1, 1, 2, 1, 2,
998  1, 1, 1, 1, 1, 1, 1, 1, 3, 1,
999  3, 3, 1, 3, 0, 1, 1, 2, 2, 3,
1000  2, 4, 1, 1, 1, 1, 1, 1, 1, 3,
1001  1, 1, 1, 1, 1, 3, 3, 3, 1, 1,
1002  2, 2, 3, 4, 3, 4, 2, 2, 3, 5,
1003  2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
1004  3, 3, 3, 3, 3, 3, 3, 1, 2, 2,
1005  3, 4, 3, 4, 3, 5, 2, 2, 2, 2,
1006  2, 1, 1, 3, 1, 3, 3, 3, 3, 3,
1007  3, 3, 3, 3, 3, 3, 3, 1, 3, 3,
1008  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1009  3, 3, 3, 1, 1, 1, 1, 1, 1, 1,
1010  1, 1, 1, 1, 2, 2, 1, 2, 0, 1,
1011  4, 1, 1, 4, 1, 2, 4, 2, 7, 4,
1012  6, 0, 1, 1, 2, 1, 2, 7, 4, 7,
1013  6, 9, 10, 9, 12, 1, 1, 1, 9, 9,
1014  5, 0, 1, 1, 3, 2, 0, 1, 1, 3,
1015  1, 1, 2, 1, 3, 1, 3, 4, 2, 3,
1016  5, 1, 3, 3, 2, 4, 3, 1, 1, 2,
1017  1, 4, 6, 0, 3, 1, 3, 1, 4, 2,
1018  0, 1, 4, 2, 5, 3, 1, 1, 1, 1,
1019  3, 3, 3, 3, 2, 6, 1, 3, 1, 5,
1020  2, 6, 1, 3, 2, 6, 1, 3, 1, 2,
1021  6, 1, 3, 4, 0, 0, 1, 1, 1, 1,
1022  2, 2, 0, 1, 0, 1, 1, 2, 1, 1,
1023  1, 2, 2, 2, 0, 1
1024 };
1025 
1026 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1027  Performed when YYTABLE doesn't specify something else to do. Zero
1028  means the default is an error. */
1029 static const yytype_uint16 yydefact[] =
1030 {
1031  0, 257, 0, 0, 0, 0, 0, 25, 26, 20,
1032  23, 24, 255, 255, 255, 255, 255, 255, 175, 176,
1033  177, 255, 255, 0, 0, 22, 21, 256, 264, 255,
1034  0, 34, 34, 259, 258, 0, 0, 0, 262, 7,
1035  16, 42, 48, 47, 27, 43, 45, 46, 44, 135,
1036  59, 102, 104, 101, 133, 0, 134, 14, 15, 136,
1037  137, 151, 152, 138, 139, 140, 0, 142, 255, 141,
1038  213, 274, 143, 4, 263, 5, 0, 42, 74, 73,
1039  72, 70, 71, 0, 0, 0, 274, 0, 0, 274,
1040  274, 149, 144, 146, 145, 266, 9, 265, 209, 0,
1041  50, 51, 35, 0, 32, 53, 54, 36, 52, 0,
1042  29, 40, 182, 0, 254, 1, 3, 2, 263, 6,
1043  17, 18, 0, 0, 0, 0, 0, 0, 0, 0,
1044  0, 0, 66, 67, 60, 61, 0, 0, 0, 58,
1045  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1046  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1047  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1048  198, 0, 0, 0, 270, 269, 268, 275, 0, 261,
1049  260, 0, 117, 0, 0, 0, 254, 9, 254, 0,
1050  154, 274, 9, 9, 148, 147, 0, 10, 274, 12,
1051  267, 49, 38, 34, 31, 37, 28, 34, 185, 51,
1052  191, 190, 0, 187, 188, 181, 8, 19, 78, 77,
1053  79, 80, 85, 83, 84, 86, 81, 82, 0, 0,
1054  0, 0, 0, 87, 75, 76, 62, 0, 64, 0,
1055  68, 0, 103, 105, 106, 115, 116, 113, 114, 107,
1056  108, 109, 112, 110, 111, 118, 119, 120, 121, 122,
1057  123, 124, 127, 128, 129, 130, 131, 132, 125, 126,
1058  0, 0, 0, 201, 0, 274, 199, 0, 217, 0,
1059  215, 220, 273, 272, 271, 255, 255, 255, 255, 274,
1060  213, 226, 213, 227, 213, 228, 213, 229, 0, 0,
1061  0, 0, 274, 0, 274, 153, 255, 255, 157, 155,
1062  161, 0, 0, 0, 197, 275, 11, 39, 33, 55,
1063  56, 57, 30, 183, 184, 0, 41, 100, 99, 98,
1064  96, 97, 88, 89, 0, 0, 0, 0, 63, 65,
1065  0, 0, 0, 192, 195, 0, 0, 274, 204, 9,
1066  219, 148, 0, 214, 0, 211, 221, 234, 240, 244,
1067  249, 255, 274, 274, 274, 274, 0, 254, 0, 254,
1068  9, 0, 9, 274, 274, 255, 255, 0, 163, 165,
1069  162, 255, 180, 255, 150, 13, 189, 90, 0, 92,
1070  0, 94, 0, 69, 202, 203, 194, 0, 201, 200,
1071  9, 0, 0, 216, 223, 0, 230, 231, 232, 233,
1072  0, 0, 181, 0, 0, 0, 274, 118, 274, 0,
1073  170, 156, 0, 9, 274, 274, 160, 166, 164, 274,
1074  274, 91, 93, 0, 196, 0, 207, 208, 206, 218,
1075  0, 225, 210, 212, 238, 274, 236, 242, 274, 248,
1076  274, 246, 0, 274, 251, 274, 9, 0, 9, 169,
1077  254, 159, 0, 9, 9, 9, 95, 205, 222, 0,
1078  148, 0, 181, 0, 0, 0, 9, 0, 0, 0,
1079  274, 254, 168, 0, 0, 224, 0, 235, 237, 241,
1080  243, 245, 247, 0, 250, 252, 0, 171, 274, 173,
1081  9, 274, 178, 179, 0, 253, 172, 9, 158, 9,
1082  239, 0, 167, 174
1083 };
1084 
1085 /* YYDEFGOTO[NTERM-NUM]. */
1086 static const yytype_int16 yydefgoto[] =
1087 {
1088  -1, 36, 37, 38, 196, 197, 198, 199, 40, 120,
1089  77, 42, 43, 44, 45, 46, 109, 47, 103, 104,
1090  48, 49, 50, 105, 106, 107, 141, 51, 234, 52,
1091  53, 54, 55, 56, 57, 58, 59, 92, 313, 93,
1092  60, 61, 189, 190, 308, 309, 62, 377, 378, 379,
1093  380, 63, 64, 65, 66, 113, 324, 114, 212, 213,
1094  214, 274, 345, 67, 68, 69, 275, 276, 348, 438,
1095  70, 443, 71, 72, 173, 279, 280, 355, 356, 289,
1096  290, 291, 445, 446, 292, 293, 448, 294, 295, 450,
1097  451, 296, 297, 453, 454, 215, 83, 73, 74, 75,
1098  96, 97, 177, 178
1099 };
1100 
1101 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1102  STATE-NUM. */
1103 #define YYPACT_NINF -400
1104 static const yytype_int16 yypact[] =
1105 {
1106  547, -400, 1093, 1093, 1093, 1093, 1093, -400, -400, -400,
1107  -400, -400, -400, -400, -400, -400, -400, -400, -400, -400,
1108  -400, -400, -400, -15, -15, -400, -400, -400, -36, -400,
1109  1110, 686, 686, -400, -400, -31, 67, -45, 16, -400,
1110  -400, -8, -400, -400, -400, -400, -400, -400, -400, -400,
1111  -400, 1264, -400, 68, 1309, 1348, -400, -400, -400, -400,
1112  -400, -400, -400, -400, -400, -400, 22, -400, -400, -400,
1113  38, 28, -400, -400, 79, -400, 7, -400, 19, 19,
1114  19, 19, 19, 1127, 1183, 1110, 28, 1110, 1110, 28,
1115  28, 83, -15, -400, -15, -400, 981, 64, -400, 74,
1116  -400, 1093, 816, -44, -400, -400, -400, 88, -400, 2,
1117  -400, -400, -400, 20, -400, -400, -400, -400, 925, -400,
1118  -8, -400, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
1119  1093, 1093, -400, -400, -400, -400, 1200, 1200, 618, -400,
1120  720, -13, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
1121  1093, 1093, 1093, 1093, 1093, 1110, 1110, 1110, 1110, 1110,
1122  1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110, 1110,
1123  -400, 5, -4, -15, -400, -400, -400, 72, 112, -400,
1124  -400, 1110, 231, 164, 1110, 178, -400, 981, -400, 146,
1125  61, 28, 981, 981, -400, -400, 129, -400, 28, -400,
1126  -400, -400, 119, 686, -400, 816, -400, 686, -400, -400,
1127  -400, -400, 121, 126, -400, 1037, -400, -400, 245, 245,
1128  19, 19, 19, 19, 19, 19, 245, 245, 1200, 1200,
1129  1200, 1200, 1200, -400, -12, -12, -400, 96, -400, 55,
1130  -400, 1110, 1264, -400, -400, 299, 279, 332, 199, 155,
1131  155, 155, 155, 155, 155, -400, -400, -400, -400, -400,
1132  -400, -400, -400, -400, -400, -400, -400, -400, -400, -400,
1133  151, 157, -37, 243, 247, 37, -400, -15, 268, 97,
1134  -400, 250, -400, -400, -400, -400, -400, -400, -400, 28,
1135  38, -400, 38, -400, 38, -400, 38, -400, 1368, 1110,
1136  1388, 1110, 28, 216, 28, -400, -400, -400, -400, -400,
1137  173, 223, -2, 1110, -400, 869, -400, 816, -400, -400,
1138  -400, -400, -400, -400, -400, 9, -400, -12, -12, -12,
1139  -12, -12, -400, -400, 652, 754, -7, 816, -400, -400,
1140  186, -15, -15, -400, -400, 71, 34, 28, -400, 981,
1141  -400, -400, -4, -400, -15, -400, 267, -400, -400, -400,
1142  -400, 112, 28, 28, 28, 28, 1110, -400, 1110, -400,
1143  981, 1110, 981, 28, 28, -400, -400, 244, 173, -400,
1144  -400, -400, -400, -400, -400, -400, -400, -400, 120, -400,
1145  143, -400, 1110, -400, -400, -400, -400, -15, -400, -400,
1146  981, -1, 1110, -400, 204, -15, -400, -400, -400, -400,
1147  253, -15, -400, -15, -15, 208, 28, 219, 28, 266,
1148  -400, -400, 1110, 981, 28, 28, -400, -400, -400, 28,
1149  28, -400, -400, 221, -400, -1, -400, -400, -400, -400,
1150  -15, 233, -400, -400, 325, 28, -400, -400, 28, -400,
1151  28, -400, 248, 28, -400, 28, 981, 1110, 981, -400,
1152  -400, -400, 1110, 981, 981, 981, -400, -400, -400, -15,
1153  -400, 193, 287, 218, 1110, 227, 981, 288, 251, 295,
1154  28, -400, -400, 296, 298, -400, 1110, -400, -400, -400,
1155  -400, -400, -400, 259, -400, -400, 301, -400, 28, -400,
1156  981, 28, -400, -400, 264, -400, -400, 981, -400, 981,
1157  -400, 316, -400, -400
1158 };
1159 
1160 /* YYPGOTO[NTERM-NUM]. */
1161 static const yytype_int16 yypgoto[] =
1162 {
1163  -400, -400, -400, -400, 81, -400, -400, 1, -400, -400,
1164  0, -400, -400, -30, -400, -400, -400, -400, -400, -27,
1165  -400, -400, -68, -183, -98, -99, -180, 14, -128, -400,
1166  -400, 740, -76, -400, 44, -400, -400, 345, -345, -82,
1167  -400, -400, -400, -400, -400, -400, -400, -400, -400, -3,
1168  4, -400, -400, -400, -400, -400, -400, 101, -400, -400,
1169  52, -400, -400, -400, -400, -399, -400, 39, -400, -55,
1170  -400, -400, -400, -400, -201, -400, 31, -400, -400, -400,
1171  -400, 23, -400, -85, -400, 26, -400, -400, 29, -400,
1172  -81, -400, 30, -400, -80, -184, 13, -400, 355, 360,
1173  -400, -400, 201, 69
1174 };
1175 
1176 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1177  positive, shift that token. If negative, reduce the rule which
1178  number is the opposite. If YYTABLE_NINF, syntax error. */
1179 #define YYTABLE_NINF -263
1180 static const yytype_int16 yytable[] =
1181 {
1182  41, 39, 302, 202, 304, 110, 402, 183, 185, 235,
1183  195, 121, 195, 447, 9, 210, 78, 79, 80, 81,
1184  82, 208, 319, 91, 91, 277, 84, 85, 86, 87,
1185  88, 211, 332, 333, 89, 90, 9, 240, 209, 237,
1186  116, 239, 98, 391, 111, 10, 11, 9, 117, 209,
1187  382, 436, 203, 204, 336, 336, 9, 95, 343, 112,
1188  9, 132, 133, 134, 135, 136, 137, 115, 233, 233,
1189  383, 9, 142, 490, 99, 108, 108, 241, 334, 139,
1190  335, 171, 111, 392, 437, 9, 194, 270, 271, 362,
1191  217, 363, 91, 364, 91, 365, 41, 206, 207, 272,
1192  327, 328, 329, 330, 331, 298, 170, 320, 300, 138,
1193  139, 140, 33, 91, 34, 80, 270, 271, 41, 216,
1194  -186, 174, 306, 307, 175, 486, 176, 112, 172, 186,
1195  174, 188, 191, 175, 319, 176, 218, 219, 220, 221,
1196  222, 223, 224, 225, 226, 227, 108, 336, 336, 336,
1197  336, 336, 339, 337, 319, 187, 242, 200, 192, 193,
1198  233, 233, 233, 233, 233, 282, 396, 299, 283, 397,
1199  284, 273, 278, 281, 201, 179, 318, 180, 143, 144,
1200  322, 301, 108, 416, 108, 418, 205, 41, 285, 286,
1201  287, 288, 41, 41, 337, 352, 338, 353, 305, 255,
1202  256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1203  266, 267, 268, 269, 314, 41, 326, 317, 337, 320,
1204  431, 323, 143, 144, 325, 99, 147, 210, 99, 149,
1205  150, 151, 152, 153, 154, 388, 390, 375, 376, 320,
1206  432, 337, 341, 211, 9, 487, -193, 108, 342, 321,
1207  346, 108, 124, 125, 143, 144, 145, 146, 147, 148,
1208  310, 149, 150, 151, 152, 153, 154, 316, 303, 9,
1209  491, 351, 344, 311, 312, 371, 480, 350, 9, 494,
1210  354, 126, 127, 128, 129, 340, 393, 132, 133, 134,
1211  135, 136, 137, 381, 405, 440, 426, 501, 357, 358,
1212  359, 360, 143, 144, 145, 442, 147, 148, 455, 149,
1213  150, 151, 152, 153, 154, 41, 385, 457, 459, 373,
1214  374, 466, 143, 144, 469, 91, 147, 148, 470, 149,
1215  150, 151, 152, 153, 154, 138, 139, 140, 474, 489,
1216  497, 394, 395, 367, 349, 369, 398, 499, 502, 41,
1217  503, 498, 278, 506, 404, 143, 144, 384, 361, 505,
1218  510, 321, 149, 150, 151, 152, 153, 154, 513, 94,
1219  41, 370, 41, 372, 410, 427, 347, 386, 108, 108,
1220  467, 321, 428, 403, 406, 399, 488, 407, 424, 425,
1221  408, 409, 492, 118, 429, 495, 430, 434, 119, 315,
1222  41, 0, 0, 0, 0, 441, 0, 0, 0, 0,
1223  415, 444, 417, 449, 452, 420, 400, 0, 0, 0,
1224  0, 0, 0, 41, 0, 0, 0, 0, 0, 0,
1225  401, 411, 412, 413, 414, 0, 433, 0, 0, 0,
1226  468, 0, 422, 423, 0, 0, 439, 0, 0, 0,
1227  0, 419, 0, 421, 0, 0, 41, 0, 41, 0,
1228  0, 0, 0, 41, 41, 41, 460, 0, 0, 485,
1229  0, 444, 0, 449, 0, 452, 41, 0, 0, 0,
1230  0, 435, 0, 0, 0, 456, 0, 458, 0, 0,
1231  0, 0, 0, 462, 463, 0, 0, 0, 464, 465,
1232  41, 478, 0, 0, 461, 0, 481, 41, 0, 41,
1233  0, 0, 0, 0, 471, 0, 0, 472, 493, 473,
1234  0, 0, 475, 0, 476, 0, 0, 0, 0, 0,
1235  504, 0, 0, 0, 0, 0, 0, 477, 0, 479,
1236  0, 0, 0, 0, 482, 483, 484, 0, 1, 500,
1237  0, 0, 2, 3, 0, 0, 0, 496, 0, 0,
1238  0, 0, 0, 0, 0, 0, 0, 507, 0, 0,
1239  509, 0, 0, 0, 0, 0, 4, 0, 0, 0,
1240  0, 508, 0, 0, 0, 0, 0, 0, 511, 0,
1241  512, 5, 6, 0, 0, 7, 8, 0, 9, 0,
1242  10, 11, 12, 13, 14, 15, 0, 16, 0, 0,
1243  17, 0, 0, 18, 19, 20, 21, 0, 22, 0,
1244  23, 24, 100, 2, 3, 0, 0, 25, 26, 0,
1245  0, -181, -262, 27, 28, 29, 0, 30, 0, 31,
1246  -262, 32, 0, 33, 0, 34, 35, 101, 0, 0,
1247  0, 0, 0, 0, 0, 0, 100, 2, 3, 0,
1248  0, 0, 5, 6, 0, 0, 7, 8, 0, 9,
1249  0, 10, 11, 0, 0, 0, 0, 0, 0, 0,
1250  0, 101, 0, 0, 0, 0, 0, 0, 0, 0,
1251  100, 2, 3, 0, 0, 0, 5, 6, 25, 26,
1252  7, 8, 0, 9, 0, 10, 11, 0, 30, 0,
1253  31, 0, 32, 0, 0, 101, 0, 35, 236, 0,
1254  0, 0, 0, 0, 100, 2, 3, 0, 0, 0,
1255  5, 6, 25, 26, 7, 8, 0, 9, 0, 10,
1256  11, 0, 30, 0, 31, 0, 32, 0, 0, 101,
1257  0, 35, 387, 0, 0, 0, 0, 0, 100, 2,
1258  3, 0, 0, 0, 5, 6, 25, 26, 7, 8,
1259  0, 9, 0, 10, 11, 0, 30, 0, 31, 0,
1260  32, 0, 0, 101, 102, 35, 0, 0, 0, 0,
1261  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
1262  25, 26, 7, 8, 0, 9, 0, 10, 11, 0,
1263  30, 0, 31, 0, 32, 0, 0, 238, 0, 35,
1264  100, 2, 3, 182, 182, 0, 0, 0, 0, 0,
1265  0, 0, 0, 0, 25, 26, 0, 0, 0, 0,
1266  0, 0, 0, 0, 30, 101, 31, 0, 32, 0,
1267  0, 389, 0, 35, 0, 0, 0, 0, 0, 0,
1268  5, 6, 0, 0, 7, 8, 0, 9, 0, 10,
1269  11, 0, 0, 0, 2, 3, 0, 0, 0, 0,
1270  0, 0, 0, 243, 244, 245, 246, 247, 248, 249,
1271  250, 251, 252, 253, 254, 0, 25, 26, 4, 0,
1272  0, 0, 0, 0, 0, 0, 30, 0, 31, 0,
1273  32, 0, 0, 5, 6, 35, 0, 7, 8, 0,
1274  9, 0, 10, 11, 12, 13, 14, 15, 0, 16,
1275  2, 3, 17, 0, 0, 18, 19, 20, 21, 0,
1276  22, 0, 23, 24, 0, 0, 0, 0, 0, 25,
1277  26, 0, 0, -181, 4, 0, 28, 29, 0, 30,
1278  0, 31, 282, 32, 0, 283, 0, 284, 35, 5,
1279  6, 0, 0, 7, 8, 0, 9, 0, 10, 11,
1280  12, 13, 14, 15, 0, 16, 2, 3, 17, 0,
1281  0, 18, 19, 20, 21, 0, 22, 0, 23, 24,
1282  0, 0, 0, 0, 0, 25, 26, 0, 0, -181,
1283  4, 0, 28, 29, 0, 30, 0, 31, 0, 32,
1284  0, 179, 0, 180, 35, 5, 6, 0, 0, 7,
1285  8, 0, 9, 0, 10, 11, 12, 13, 14, 15,
1286  0, 16, 2, 3, 17, 0, 0, 18, 19, 20,
1287  21, 0, 22, 0, 23, 24, 0, 0, 0, 0,
1288  0, 25, 26, 0, 0, -181, 4, 0, 28, 29,
1289  0, 30, 0, 31, 0, 32, 0, 0, 0, 0,
1290  35, 5, 6, 0, 0, 7, 8, 0, 9, 0,
1291  10, 11, 12, 13, 14, 15, 0, 16, 2, 3,
1292  17, 0, 0, 18, 19, 20, 21, 0, 22, 0,
1293  23, 24, 0, 0, 0, 2, 3, 25, 26, 0,
1294  0, 0, 4, 0, 28, 29, 0, 30, 0, 31,
1295  0, 32, 2, 3, 0, 0, 35, 5, 6, 4,
1296  0, 7, 8, 0, 9, 0, 10, 11, 0, 0,
1297  0, 0, 0, 0, 5, 6, 4, 0, 7, 8,
1298  0, 9, 0, 10, 11, 0, 0, 0, 0, 0,
1299  0, 5, 6, 25, 26, 7, 8, 0, 9, 0,
1300  10, 11, 0, 30, 0, 31, 0, 32, 2, 3,
1301  25, 26, 76, 0, 0, 0, 0, 0, 0, 0,
1302  30, 0, 31, 0, 32, 228, 229, 25, 26, 35,
1303  0, 0, 4, 0, 0, 0, 0, 181, 0, 31,
1304  0, 32, 0, 0, 0, 0, 76, 5, 6, 230,
1305  0, 7, 8, 0, 9, 0, 10, 11, 0, 0,
1306  0, 0, 0, 0, 231, 232, 0, 0, 7, 8,
1307  0, 9, 0, 10, 11, 0, 0, 0, 0, 0,
1308  0, 0, 0, 25, 26, 0, 0, 0, 0, 122,
1309  123, 124, 125, 184, 0, 31, 0, 32, 0, 0,
1310  25, 26, 76, 0, 0, 0, 0, 0, 0, 0,
1311  30, 0, 31, 0, 32, 0, 0, 0, 0, 76,
1312  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1313  136, 137, -117, 0, 0, 0, 0, 0, -117, -117,
1314  -117, -117, -117, -117, -117, -117, -117, -117, -117, -117,
1315  -117, -117, 143, 144, 145, 146, 147, 148, 0, 149,
1316  150, 151, 152, 153, 154, 0, 0, 0, 0, 0,
1317  0, 155, 0, 0, 138, 139, 140, 156, 157, 158,
1318  159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
1319  169, 366, 0, 0, 0, 0, 0, 156, 157, 158,
1320  159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
1321  169, 368, 0, 0, 0, 0, 0, 156, 157, 158,
1322  159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
1323  169
1324 };
1325 
1326 #define yypact_value_is_default(Yystate) \
1327  (!!((Yystate) == (-400)))
1328 
1329 #define yytable_value_is_error(Yytable_value) \
1330  YYID (0)
1331 
1332 static const yytype_int16 yycheck[] =
1333 {
1334  0, 0, 186, 102, 188, 32, 351, 83, 84, 137,
1335  92, 41, 94, 412, 51, 113, 2, 3, 4, 5,
1336  6, 1, 205, 23, 24, 29, 13, 14, 15, 16,
1337  17, 113, 44, 45, 21, 22, 51, 50, 29, 138,
1338  85, 140, 29, 50, 75, 53, 54, 51, 93, 29,
1339  52, 52, 96, 97, 234, 235, 51, 93, 95, 90,
1340  51, 42, 43, 44, 45, 46, 47, 0, 136, 137,
1341  72, 51, 4, 472, 30, 31, 32, 90, 90, 91,
1342  92, 68, 75, 90, 85, 51, 3, 82, 83, 290,
1343  120, 292, 92, 294, 94, 296, 96, 95, 96, 94,
1344  228, 229, 230, 231, 232, 181, 84, 205, 184, 90,
1345  91, 92, 96, 113, 98, 101, 82, 83, 118, 118,
1346  100, 93, 61, 62, 96, 470, 98, 90, 90, 85,
1347  93, 87, 88, 96, 317, 98, 122, 123, 124, 125,
1348  126, 127, 128, 129, 130, 131, 102, 327, 328, 329,
1349  330, 331, 97, 98, 337, 86, 142, 93, 89, 90,
1350  228, 229, 230, 231, 232, 93, 95, 3, 96, 98,
1351  98, 171, 172, 173, 100, 96, 203, 98, 23, 24,
1352  207, 3, 138, 367, 140, 369, 98, 187, 76, 77,
1353  78, 79, 192, 193, 98, 98, 100, 100, 52, 155,
1354  156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1355  166, 167, 168, 169, 85, 215, 215, 98, 98, 317,
1356  100, 100, 23, 24, 98, 181, 27, 325, 184, 30,
1357  31, 32, 33, 34, 35, 334, 335, 64, 65, 337,
1358  97, 98, 91, 325, 51, 52, 3, 203, 91, 205,
1359  3, 207, 7, 8, 23, 24, 25, 26, 27, 28,
1360  191, 30, 31, 32, 33, 34, 35, 198, 187, 51,
1361  52, 3, 272, 192, 193, 59, 460, 277, 51, 52,
1362  30, 36, 37, 38, 39, 241, 100, 42, 43, 44,
1363  45, 46, 47, 70, 27, 91, 52, 481, 285, 286,
1364  287, 288, 23, 24, 25, 52, 27, 28, 100, 30,
1365  31, 32, 33, 34, 35, 315, 315, 98, 52, 306,
1366  307, 100, 23, 24, 91, 325, 27, 28, 3, 30,
1367  31, 32, 33, 34, 35, 90, 91, 92, 90, 52,
1368  52, 341, 342, 299, 275, 301, 346, 52, 52, 349,
1369  52, 100, 352, 52, 354, 23, 24, 313, 289, 100,
1370  96, 317, 30, 31, 32, 33, 34, 35, 52, 24,
1371  370, 302, 372, 304, 361, 378, 275, 325, 334, 335,
1372  435, 337, 378, 352, 361, 346, 471, 361, 375, 376,
1373  361, 361, 473, 38, 381, 475, 383, 397, 38, 198,
1374  400, -1, -1, -1, -1, 405, -1, -1, -1, -1,
1375  366, 411, 368, 413, 414, 371, 347, -1, -1, -1,
1376  -1, -1, -1, 423, -1, -1, -1, -1, -1, -1,
1377  349, 362, 363, 364, 365, -1, 392, -1, -1, -1,
1378  440, -1, 373, 374, -1, -1, 402, -1, -1, -1,
1379  -1, 370, -1, 372, -1, -1, 456, -1, 458, -1,
1380  -1, -1, -1, 463, 464, 465, 422, -1, -1, 469,
1381  -1, 471, -1, 473, -1, 475, 476, -1, -1, -1,
1382  -1, 400, -1, -1, -1, 416, -1, 418, -1, -1,
1383  -1, -1, -1, 424, 425, -1, -1, -1, 429, 430,
1384  500, 457, -1, -1, 423, -1, 462, 507, -1, 509,
1385  -1, -1, -1, -1, 445, -1, -1, 448, 474, 450,
1386  -1, -1, 453, -1, 455, -1, -1, -1, -1, -1,
1387  486, -1, -1, -1, -1, -1, -1, 456, -1, 458,
1388  -1, -1, -1, -1, 463, 464, 465, -1, 1, 480,
1389  -1, -1, 5, 6, -1, -1, -1, 476, -1, -1,
1390  -1, -1, -1, -1, -1, -1, -1, 498, -1, -1,
1391  501, -1, -1, -1, -1, -1, 29, -1, -1, -1,
1392  -1, 500, -1, -1, -1, -1, -1, -1, 507, -1,
1393  509, 44, 45, -1, -1, 48, 49, -1, 51, -1,
1394  53, 54, 55, 56, 57, 58, -1, 60, -1, -1,
1395  63, -1, -1, 66, 67, 68, 69, -1, 71, -1,
1396  73, 74, 4, 5, 6, -1, -1, 80, 81, -1,
1397  -1, 84, 85, 86, 87, 88, -1, 90, -1, 92,
1398  93, 94, -1, 96, -1, 98, 99, 29, -1, -1,
1399  -1, -1, -1, -1, -1, -1, 4, 5, 6, -1,
1400  -1, -1, 44, 45, -1, -1, 48, 49, -1, 51,
1401  -1, 53, 54, -1, -1, -1, -1, -1, -1, -1,
1402  -1, 29, -1, -1, -1, -1, -1, -1, -1, -1,
1403  4, 5, 6, -1, -1, -1, 44, 45, 80, 81,
1404  48, 49, -1, 51, -1, 53, 54, -1, 90, -1,
1405  92, -1, 94, -1, -1, 29, -1, 99, 100, -1,
1406  -1, -1, -1, -1, 4, 5, 6, -1, -1, -1,
1407  44, 45, 80, 81, 48, 49, -1, 51, -1, 53,
1408  54, -1, 90, -1, 92, -1, 94, -1, -1, 29,
1409  -1, 99, 100, -1, -1, -1, -1, -1, 4, 5,
1410  6, -1, -1, -1, 44, 45, 80, 81, 48, 49,
1411  -1, 51, -1, 53, 54, -1, 90, -1, 92, -1,
1412  94, -1, -1, 29, 98, 99, -1, -1, -1, -1,
1413  -1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
1414  80, 81, 48, 49, -1, 51, -1, 53, 54, -1,
1415  90, -1, 92, -1, 94, -1, -1, 97, -1, 99,
1416  4, 5, 6, 83, 84, -1, -1, -1, -1, -1,
1417  -1, -1, -1, -1, 80, 81, -1, -1, -1, -1,
1418  -1, -1, -1, -1, 90, 29, 92, -1, 94, -1,
1419  -1, 97, -1, 99, -1, -1, -1, -1, -1, -1,
1420  44, 45, -1, -1, 48, 49, -1, 51, -1, 53,
1421  54, -1, -1, -1, 5, 6, -1, -1, -1, -1,
1422  -1, -1, -1, 143, 144, 145, 146, 147, 148, 149,
1423  150, 151, 152, 153, 154, -1, 80, 81, 29, -1,
1424  -1, -1, -1, -1, -1, -1, 90, -1, 92, -1,
1425  94, -1, -1, 44, 45, 99, -1, 48, 49, -1,
1426  51, -1, 53, 54, 55, 56, 57, 58, -1, 60,
1427  5, 6, 63, -1, -1, 66, 67, 68, 69, -1,
1428  71, -1, 73, 74, -1, -1, -1, -1, -1, 80,
1429  81, -1, -1, 84, 29, -1, 87, 88, -1, 90,
1430  -1, 92, 93, 94, -1, 96, -1, 98, 99, 44,
1431  45, -1, -1, 48, 49, -1, 51, -1, 53, 54,
1432  55, 56, 57, 58, -1, 60, 5, 6, 63, -1,
1433  -1, 66, 67, 68, 69, -1, 71, -1, 73, 74,
1434  -1, -1, -1, -1, -1, 80, 81, -1, -1, 84,
1435  29, -1, 87, 88, -1, 90, -1, 92, -1, 94,
1436  -1, 96, -1, 98, 99, 44, 45, -1, -1, 48,
1437  49, -1, 51, -1, 53, 54, 55, 56, 57, 58,
1438  -1, 60, 5, 6, 63, -1, -1, 66, 67, 68,
1439  69, -1, 71, -1, 73, 74, -1, -1, -1, -1,
1440  -1, 80, 81, -1, -1, 84, 29, -1, 87, 88,
1441  -1, 90, -1, 92, -1, 94, -1, -1, -1, -1,
1442  99, 44, 45, -1, -1, 48, 49, -1, 51, -1,
1443  53, 54, 55, 56, 57, 58, -1, 60, 5, 6,
1444  63, -1, -1, 66, 67, 68, 69, -1, 71, -1,
1445  73, 74, -1, -1, -1, 5, 6, 80, 81, -1,
1446  -1, -1, 29, -1, 87, 88, -1, 90, -1, 92,
1447  -1, 94, 5, 6, -1, -1, 99, 44, 45, 29,
1448  -1, 48, 49, -1, 51, -1, 53, 54, -1, -1,
1449  -1, -1, -1, -1, 44, 45, 29, -1, 48, 49,
1450  -1, 51, -1, 53, 54, -1, -1, -1, -1, -1,
1451  -1, 44, 45, 80, 81, 48, 49, -1, 51, -1,
1452  53, 54, -1, 90, -1, 92, -1, 94, 5, 6,
1453  80, 81, 99, -1, -1, -1, -1, -1, -1, -1,
1454  90, -1, 92, -1, 94, 5, 6, 80, 81, 99,
1455  -1, -1, 29, -1, -1, -1, -1, 90, -1, 92,
1456  -1, 94, -1, -1, -1, -1, 99, 44, 45, 29,
1457  -1, 48, 49, -1, 51, -1, 53, 54, -1, -1,
1458  -1, -1, -1, -1, 44, 45, -1, -1, 48, 49,
1459  -1, 51, -1, 53, 54, -1, -1, -1, -1, -1,
1460  -1, -1, -1, 80, 81, -1, -1, -1, -1, 5,
1461  6, 7, 8, 90, -1, 92, -1, 94, -1, -1,
1462  80, 81, 99, -1, -1, -1, -1, -1, -1, -1,
1463  90, -1, 92, -1, 94, -1, -1, -1, -1, 99,
1464  36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1465  46, 47, 3, -1, -1, -1, -1, -1, 9, 10,
1466  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1467  21, 22, 23, 24, 25, 26, 27, 28, -1, 30,
1468  31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
1469  -1, 3, -1, -1, 90, 91, 92, 9, 10, 11,
1470  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1471  22, 3, -1, -1, -1, -1, -1, 9, 10, 11,
1472  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1473  22, 3, -1, -1, -1, -1, -1, 9, 10, 11,
1474  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1475  22
1476 };
1477 
1478 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1479  symbol of state STATE-NUM. */
1480 static const yytype_uint8 yystos[] =
1481 {
1482  0, 1, 5, 6, 29, 44, 45, 48, 49, 51,
1483  53, 54, 55, 56, 57, 58, 60, 63, 66, 67,
1484  68, 69, 71, 73, 74, 80, 81, 86, 87, 88,
1485  90, 92, 94, 96, 98, 99, 102, 103, 104, 108,
1486  109, 111, 112, 113, 114, 115, 116, 118, 121, 122,
1487  123, 128, 130, 131, 132, 133, 134, 135, 136, 137,
1488  141, 142, 147, 152, 153, 154, 155, 164, 165, 166,
1489  171, 173, 174, 198, 199, 200, 99, 111, 128, 128,
1490  128, 128, 128, 197, 197, 197, 197, 197, 197, 197,
1491  197, 111, 138, 140, 138, 93, 201, 202, 197, 135,
1492  4, 29, 98, 119, 120, 124, 125, 126, 135, 117,
1493  120, 75, 90, 156, 158, 0, 85, 93, 199, 200,
1494  110, 114, 5, 6, 7, 8, 36, 37, 38, 39,
1495  40, 41, 42, 43, 44, 45, 46, 47, 90, 91,
1496  92, 127, 4, 23, 24, 25, 26, 27, 28, 30,
1497  31, 32, 33, 34, 35, 3, 9, 10, 11, 12,
1498  13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1499  84, 197, 90, 175, 93, 96, 98, 203, 204, 96,
1500  98, 90, 132, 133, 90, 133, 135, 204, 135, 143,
1501  144, 135, 204, 204, 3, 140, 105, 106, 107, 108,
1502  93, 100, 126, 96, 97, 98, 95, 96, 1, 29,
1503  125, 140, 159, 160, 161, 196, 108, 114, 128, 128,
1504  128, 128, 128, 128, 128, 128, 128, 128, 5, 6,
1505  29, 44, 45, 123, 129, 129, 100, 126, 97, 126,
1506  50, 90, 128, 132, 132, 132, 132, 132, 132, 132,
1507  132, 132, 132, 132, 132, 135, 135, 135, 135, 135,
1508  135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
1509  82, 83, 94, 111, 162, 167, 168, 29, 111, 176,
1510  177, 111, 93, 96, 98, 76, 77, 78, 79, 180,
1511  181, 182, 185, 186, 188, 189, 192, 193, 133, 3,
1512  133, 3, 196, 105, 196, 52, 61, 62, 145, 146,
1513  204, 105, 105, 139, 85, 203, 204, 98, 120, 124,
1514  125, 135, 120, 100, 157, 98, 108, 129, 129, 129,
1515  129, 129, 44, 45, 90, 92, 127, 98, 100, 97,
1516  135, 91, 91, 95, 111, 163, 3, 158, 169, 204,
1517  111, 3, 98, 100, 30, 178, 179, 197, 197, 197,
1518  197, 204, 175, 175, 175, 175, 3, 135, 3, 135,
1519  204, 59, 204, 197, 197, 64, 65, 148, 149, 150,
1520  151, 70, 52, 72, 135, 108, 161, 100, 126, 97,
1521  126, 50, 90, 100, 111, 111, 95, 98, 111, 168,
1522  204, 105, 139, 177, 111, 27, 182, 186, 189, 193,
1523  197, 204, 204, 204, 204, 135, 196, 135, 196, 105,
1524  135, 105, 204, 204, 197, 197, 52, 150, 151, 197,
1525  197, 100, 97, 135, 111, 105, 52, 85, 170, 135,
1526  91, 111, 52, 172, 111, 183, 184, 166, 187, 111,
1527  190, 191, 111, 194, 195, 100, 204, 98, 204, 52,
1528  135, 105, 204, 204, 204, 204, 100, 170, 111, 91,
1529  3, 204, 204, 204, 90, 204, 204, 105, 135, 105,
1530  196, 135, 105, 105, 105, 111, 139, 52, 184, 52,
1531  166, 52, 191, 135, 52, 195, 105, 52, 100, 52,
1532  204, 196, 52, 52, 135, 100, 52, 204, 105, 204,
1533  96, 105, 105, 52
1534 };
1535 
1536 #define yyerrok (yyerrstatus = 0)
1537 #define yyclearin (yychar = YYEMPTY)
1538 #define YYEMPTY (-2)
1539 #define YYEOF 0
1540 
1541 #define YYACCEPT goto yyacceptlab
1542 #define YYABORT goto yyabortlab
1543 #define YYERROR goto yyerrorlab
1544 
1545 
1546 /* Like YYERROR except do call yyerror. This remains here temporarily
1547  to ease the transition to the new meaning of YYERROR, for GCC.
1548  Once GCC version 2 has supplanted version 1, this can go. However,
1549  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1550  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1551  discussed. */
1552 
1553 #define YYFAIL goto yyerrlab
1554 #if defined YYFAIL
1555  /* This is here to suppress warnings from the GCC cpp's
1556  -Wunused-macros. Normally we don't worry about that warning, but
1557  some users do, and we want to make it easy for users to remove
1558  YYFAIL uses, which will produce warnings from Bison 2.5. */
1559 #endif
1560 
1561 #define YYRECOVERING() (!!yyerrstatus)
1562 
1563 #define YYBACKUP(Token, Value) \
1564 do \
1565  if (yychar == YYEMPTY) \
1566  { \
1567  yychar = (Token); \
1568  yylval = (Value); \
1569  YYPOPSTACK (yylen); \
1570  yystate = *yyssp; \
1571  goto yybackup; \
1572  } \
1573  else \
1574  { \
1575  yyerror (parser, YY_("syntax error: cannot back up")); \
1576  YYERROR; \
1577  } \
1578 while (YYID (0))
1579 
1580 /* Error token number */
1581 #define YYTERROR 1
1582 #define YYERRCODE 256
1583 
1584 
1585 /* This macro is provided for backward compatibility. */
1586 #ifndef YY_LOCATION_PRINT
1587 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1588 #endif
1589 
1590 
1591 /* YYLEX -- calling `yylex' with the right arguments. */
1592 #ifdef YYLEX_PARAM
1593 # define YYLEX yylex (&yylval, YYLEX_PARAM)
1594 #else
1595 # define YYLEX yylex (&yylval, scanner)
1596 #endif
1597 
1598 /* Enable debugging if requested. */
1599 #if YYDEBUG
1600 
1601 # ifndef YYFPRINTF
1602 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1603 # define YYFPRINTF fprintf
1604 # endif
1605 
1606 # define YYDPRINTF(Args) \
1607 do { \
1608  if (yydebug) \
1609  YYFPRINTF Args; \
1610 } while (YYID (0))
1611 
1612 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1613 do { \
1614  if (yydebug) \
1615  { \
1616  YYFPRINTF (stderr, "%s ", Title); \
1617  yy_symbol_print (stderr, \
1618  Type, Value, parser); \
1619  YYFPRINTF (stderr, "\n"); \
1620  } \
1621 } while (YYID (0))
1622 
1623 
1624 /*--------------------------------.
1625 | Print this symbol on YYOUTPUT. |
1626 `--------------------------------*/
1627 
1628 /*ARGSUSED*/
1629 #if (defined __STDC__ || defined __C99__FUNC__ \
1630  || defined __cplusplus || defined _MSC_VER)
1631 static void
1632 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, octave_base_parser& parser)
1633 #else
1634 static void
1635 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
1636  FILE *yyoutput;
1637  int yytype;
1638  YYSTYPE const * const yyvaluep;
1639  octave_base_parser& parser;
1640 #endif
1641 {
1642  FILE *yyo = yyoutput;
1643  YYUSE (yyo);
1644  if (!yyvaluep)
1645  return;
1646  YYUSE (parser);
1647 # ifdef YYPRINT
1648  if (yytype < YYNTOKENS)
1649  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1650 # else
1651  YYUSE (yyoutput);
1652 # endif
1653  YYUSE (yytype);
1654 }
1655 
1656 
1657 /*--------------------------------.
1658 | Print this symbol on YYOUTPUT. |
1659 `--------------------------------*/
1660 
1661 #if (defined __STDC__ || defined __C99__FUNC__ \
1662  || defined __cplusplus || defined _MSC_VER)
1663 static void
1664 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, octave_base_parser& parser)
1665 #else
1666 static void
1667 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
1668  FILE *yyoutput;
1669  int yytype;
1670  YYSTYPE const * const yyvaluep;
1671  octave_base_parser& parser;
1672 #endif
1673 {
1674  if (yytype < YYNTOKENS)
1675  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1676  else
1677  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1678 
1679  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
1680  YYFPRINTF (yyoutput, ")");
1681 }
1682 
1683 /*------------------------------------------------------------------.
1684 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1685 | TOP (included). |
1686 `------------------------------------------------------------------*/
1687 
1688 #if (defined __STDC__ || defined __C99__FUNC__ \
1689  || defined __cplusplus || defined _MSC_VER)
1690 static void
1691 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1692 #else
1693 static void
1694 yy_stack_print (yybottom, yytop)
1695  yytype_int16 *yybottom;
1696  yytype_int16 *yytop;
1697 #endif
1698 {
1699  YYFPRINTF (stderr, "Stack now");
1700  for (; yybottom <= yytop; yybottom++)
1701  {
1702  int yybot = *yybottom;
1703  YYFPRINTF (stderr, " %d", yybot);
1704  }
1705  YYFPRINTF (stderr, "\n");
1706 }
1707 
1708 # define YY_STACK_PRINT(Bottom, Top) \
1709 do { \
1710  if (yydebug) \
1711  yy_stack_print ((Bottom), (Top)); \
1712 } while (YYID (0))
1713 
1714 
1715 /*------------------------------------------------.
1716 | Report that the YYRULE is going to be reduced. |
1717 `------------------------------------------------*/
1718 
1719 #if (defined __STDC__ || defined __C99__FUNC__ \
1720  || defined __cplusplus || defined _MSC_VER)
1721 static void
1722 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, octave_base_parser& parser)
1723 #else
1724 static void
1725 yy_reduce_print (yyvsp, yyrule, parser)
1726  YYSTYPE *yyvsp;
1727  int yyrule;
1728  octave_base_parser& parser;
1729 #endif
1730 {
1731  int yynrhs = yyr2[yyrule];
1732  int yyi;
1733  unsigned long int yylno = yyrline[yyrule];
1734  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1735  yyrule - 1, yylno);
1736  /* The symbols being reduced. */
1737  for (yyi = 0; yyi < yynrhs; yyi++)
1738  {
1739  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1740  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1741  &(yyvsp[(yyi + 1) - (yynrhs)])
1742  , parser);
1743  YYFPRINTF (stderr, "\n");
1744  }
1745 }
1746 
1747 # define YY_REDUCE_PRINT(Rule) \
1748 do { \
1749  if (yydebug) \
1750  yy_reduce_print (yyvsp, Rule, parser); \
1751 } while (YYID (0))
1752 
1753 /* Nonzero means print parse trace. It is left uninitialized so that
1754  multiple parsers can coexist. */
1755 int yydebug;
1756 #else /* !YYDEBUG */
1757 # define YYDPRINTF(Args)
1758 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1759 # define YY_STACK_PRINT(Bottom, Top)
1760 # define YY_REDUCE_PRINT(Rule)
1761 #endif /* !YYDEBUG */
1762 
1763 
1764 /* YYINITDEPTH -- initial size of the parser's stacks. */
1765 #ifndef YYINITDEPTH
1766 # define YYINITDEPTH 200
1767 #endif
1768 
1769 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1770  if the built-in stack extension method is used).
1771 
1772  Do not make this value too large; the results are undefined if
1773  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1774  evaluated with infinite-precision integer arithmetic. */
1775 
1776 #ifndef YYMAXDEPTH
1777 # define YYMAXDEPTH 10000
1778 #endif
1779 
1780 
1781 #if YYERROR_VERBOSE
1782 
1783 # ifndef yystrlen
1784 # if defined __GLIBC__ && defined _STRING_H
1785 # define yystrlen strlen
1786 # else
1787 /* Return the length of YYSTR. */
1788 #if (defined __STDC__ || defined __C99__FUNC__ \
1789  || defined __cplusplus || defined _MSC_VER)
1790 static YYSIZE_T
1791 yystrlen (const char *yystr)
1792 #else
1793 static YYSIZE_T
1794 yystrlen (yystr)
1795  const char *yystr;
1796 #endif
1797 {
1798  YYSIZE_T yylen;
1799  for (yylen = 0; yystr[yylen]; yylen++)
1800  continue;
1801  return yylen;
1802 }
1803 # endif
1804 # endif
1805 
1806 # ifndef yystpcpy
1807 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1808 # define yystpcpy stpcpy
1809 # else
1810 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1811  YYDEST. */
1812 #if (defined __STDC__ || defined __C99__FUNC__ \
1813  || defined __cplusplus || defined _MSC_VER)
1814 static char *
1815 yystpcpy (char *yydest, const char *yysrc)
1816 #else
1817 static char *
1818 yystpcpy (yydest, yysrc)
1819  char *yydest;
1820  const char *yysrc;
1821 #endif
1822 {
1823  char *yyd = yydest;
1824  const char *yys = yysrc;
1825 
1826  while ((*yyd++ = *yys++) != '\0')
1827  continue;
1828 
1829  return yyd - 1;
1830 }
1831 # endif
1832 # endif
1833 
1834 # ifndef yytnamerr
1835 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1836  quotes and backslashes, so that it's suitable for yyerror. The
1837  heuristic is that double-quoting is unnecessary unless the string
1838  contains an apostrophe, a comma, or backslash (other than
1839  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1840  null, do not copy; instead, return the length of what the result
1841  would have been. */
1842 static YYSIZE_T
1843 yytnamerr (char *yyres, const char *yystr)
1844 {
1845  if (*yystr == '"')
1846  {
1847  YYSIZE_T yyn = 0;
1848  char const *yyp = yystr;
1849 
1850  for (;;)
1851  switch (*++yyp)
1852  {
1853  case '\'':
1854  case ',':
1855  goto do_not_strip_quotes;
1856 
1857  case '\\':
1858  if (*++yyp != '\\')
1859  goto do_not_strip_quotes;
1860  /* Fall through. */
1861  default:
1862  if (yyres)
1863  yyres[yyn] = *yyp;
1864  yyn++;
1865  break;
1866 
1867  case '"':
1868  if (yyres)
1869  yyres[yyn] = '\0';
1870  return yyn;
1871  }
1872  do_not_strip_quotes: ;
1873  }
1874 
1875  if (! yyres)
1876  return yystrlen (yystr);
1877 
1878  return yystpcpy (yyres, yystr) - yyres;
1879 }
1880 # endif
1881 
1882 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1883  about the unexpected token YYTOKEN for the state stack whose top is
1884  YYSSP.
1885 
1886  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1887  not large enough to hold the message. In that case, also set
1888  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1889  required number of bytes is too large to store. */
1890 static int
1891 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1892  yytype_int16 *yyssp, int yytoken)
1893 {
1894  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1895  YYSIZE_T yysize = yysize0;
1896  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1897  /* Internationalized format string. */
1898  const char *yyformat = YY_NULL;
1899  /* Arguments of yyformat. */
1900  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1901  /* Number of reported tokens (one for the "unexpected", one per
1902  "expected"). */
1903  int yycount = 0;
1904 
1905  /* There are many possibilities here to consider:
1906  - Assume YYFAIL is not used. It's too flawed to consider. See
1907  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1908  for details. YYERROR is fine as it does not invoke this
1909  function.
1910  - If this state is a consistent state with a default action, then
1911  the only way this function was invoked is if the default action
1912  is an error action. In that case, don't check for expected
1913  tokens because there are none.
1914  - The only way there can be no lookahead present (in yychar) is if
1915  this state is a consistent state with a default action. Thus,
1916  detecting the absence of a lookahead is sufficient to determine
1917  that there is no unexpected or expected token to report. In that
1918  case, just report a simple "syntax error".
1919  - Don't assume there isn't a lookahead just because this state is a
1920  consistent state with a default action. There might have been a
1921  previous inconsistent state, consistent state with a non-default
1922  action, or user semantic action that manipulated yychar.
1923  - Of course, the expected token list depends on states to have
1924  correct lookahead information, and it depends on the parser not
1925  to perform extra reductions after fetching a lookahead from the
1926  scanner and before detecting a syntax error. Thus, state merging
1927  (from LALR or IELR) and default reductions corrupt the expected
1928  token list. However, the list is correct for canonical LR with
1929  one exception: it will still contain any token that will not be
1930  accepted due to an error action in a later state.
1931  */
1932  if (yytoken != YYEMPTY)
1933  {
1934  int yyn = yypact[*yyssp];
1935  yyarg[yycount++] = yytname[yytoken];
1936  if (!yypact_value_is_default (yyn))
1937  {
1938  /* Start YYX at -YYN if negative to avoid negative indexes in
1939  YYCHECK. In other words, skip the first -YYN actions for
1940  this state because they are default actions. */
1941  int yyxbegin = yyn < 0 ? -yyn : 0;
1942  /* Stay within bounds of both yycheck and yytname. */
1943  int yychecklim = YYLAST - yyn + 1;
1944  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1945  int yyx;
1946 
1947  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1948  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1949  && !yytable_value_is_error (yytable[yyx + yyn]))
1950  {
1951  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1952  {
1953  yycount = 1;
1954  yysize = yysize0;
1955  break;
1956  }
1957  yyarg[yycount++] = yytname[yyx];
1958  {
1959  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1960  if (! (yysize <= yysize1
1961  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1962  return 2;
1963  yysize = yysize1;
1964  }
1965  }
1966  }
1967  }
1968 
1969  switch (yycount)
1970  {
1971 # define YYCASE_(N, S) \
1972  case N: \
1973  yyformat = S; \
1974  break
1975  YYCASE_(0, YY_("syntax error"));
1976  YYCASE_(1, YY_("syntax error, unexpected %s"));
1977  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1978  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1979  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1980  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1981 # undef YYCASE_
1982  }
1983 
1984  {
1985  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1986  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1987  return 2;
1988  yysize = yysize1;
1989  }
1990 
1991  if (*yymsg_alloc < yysize)
1992  {
1993  *yymsg_alloc = 2 * yysize;
1994  if (! (yysize <= *yymsg_alloc
1995  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1996  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1997  return 1;
1998  }
1999 
2000  /* Avoid sprintf, as that infringes on the user's name space.
2001  Don't have undefined behavior even if the translation
2002  produced a string with the wrong number of "%s"s. */
2003  {
2004  char *yyp = *yymsg;
2005  int yyi = 0;
2006  while ((*yyp = *yyformat) != '\0')
2007  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2008  {
2009  yyp += yytnamerr (yyp, yyarg[yyi++]);
2010  yyformat += 2;
2011  }
2012  else
2013  {
2014  yyp++;
2015  yyformat++;
2016  }
2017  }
2018  return 0;
2019 }
2020 #endif /* YYERROR_VERBOSE */
2021 
2022 /*-----------------------------------------------.
2023 | Release the memory associated to this symbol. |
2024 `-----------------------------------------------*/
2025 
2026 /*ARGSUSED*/
2027 #if (defined __STDC__ || defined __C99__FUNC__ \
2028  || defined __cplusplus || defined _MSC_VER)
2029 static void
2030 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, octave_base_parser& parser)
2031 #else
2032 static void
2033 yydestruct (yymsg, yytype, yyvaluep, parser)
2034  const char *yymsg;
2035  int yytype;
2036  YYSTYPE *yyvaluep;
2037  octave_base_parser& parser;
2038 #endif
2039 {
2040  YYUSE (yyvaluep);
2041  YYUSE (parser);
2042 
2043  if (!yymsg)
2044  yymsg = "Deleting";
2045  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2046 
2047  switch (yytype)
2048  {
2049  case 3: /* '=' */
2050 /* Line 1393 of yacc.c */
2051 #line 304 "parse-tree/oct-parse.yy"
2052  { };
2053 /* Line 1393 of yacc.c */
2054 #line 2055 "parse-tree/oct-parse.cc"
2055  break;
2056  case 4: /* ':' */
2057 /* Line 1393 of yacc.c */
2058 #line 304 "parse-tree/oct-parse.yy"
2059  { };
2060 /* Line 1393 of yacc.c */
2061 #line 2062 "parse-tree/oct-parse.cc"
2062  break;
2063  case 5: /* '-' */
2064 /* Line 1393 of yacc.c */
2065 #line 304 "parse-tree/oct-parse.yy"
2066  { };
2067 /* Line 1393 of yacc.c */
2068 #line 2069 "parse-tree/oct-parse.cc"
2069  break;
2070  case 6: /* '+' */
2071 /* Line 1393 of yacc.c */
2072 #line 304 "parse-tree/oct-parse.yy"
2073  { };
2074 /* Line 1393 of yacc.c */
2075 #line 2076 "parse-tree/oct-parse.cc"
2076  break;
2077  case 7: /* '*' */
2078 /* Line 1393 of yacc.c */
2079 #line 304 "parse-tree/oct-parse.yy"
2080  { };
2081 /* Line 1393 of yacc.c */
2082 #line 2083 "parse-tree/oct-parse.cc"
2083  break;
2084  case 8: /* '/' */
2085 /* Line 1393 of yacc.c */
2086 #line 304 "parse-tree/oct-parse.yy"
2087  { };
2088 /* Line 1393 of yacc.c */
2089 #line 2090 "parse-tree/oct-parse.cc"
2090  break;
2091  case 9: /* ADD_EQ */
2092 /* Line 1393 of yacc.c */
2093 #line 304 "parse-tree/oct-parse.yy"
2094  { };
2095 /* Line 1393 of yacc.c */
2096 #line 2097 "parse-tree/oct-parse.cc"
2097  break;
2098  case 10: /* SUB_EQ */
2099 /* Line 1393 of yacc.c */
2100 #line 304 "parse-tree/oct-parse.yy"
2101  { };
2102 /* Line 1393 of yacc.c */
2103 #line 2104 "parse-tree/oct-parse.cc"
2104  break;
2105  case 11: /* MUL_EQ */
2106 /* Line 1393 of yacc.c */
2107 #line 304 "parse-tree/oct-parse.yy"
2108  { };
2109 /* Line 1393 of yacc.c */
2110 #line 2111 "parse-tree/oct-parse.cc"
2111  break;
2112  case 12: /* DIV_EQ */
2113 /* Line 1393 of yacc.c */
2114 #line 304 "parse-tree/oct-parse.yy"
2115  { };
2116 /* Line 1393 of yacc.c */
2117 #line 2118 "parse-tree/oct-parse.cc"
2118  break;
2119  case 13: /* LEFTDIV_EQ */
2120 /* Line 1393 of yacc.c */
2121 #line 304 "parse-tree/oct-parse.yy"
2122  { };
2123 /* Line 1393 of yacc.c */
2124 #line 2125 "parse-tree/oct-parse.cc"
2125  break;
2126  case 14: /* POW_EQ */
2127 /* Line 1393 of yacc.c */
2128 #line 304 "parse-tree/oct-parse.yy"
2129  { };
2130 /* Line 1393 of yacc.c */
2131 #line 2132 "parse-tree/oct-parse.cc"
2132  break;
2133  case 15: /* EMUL_EQ */
2134 /* Line 1393 of yacc.c */
2135 #line 304 "parse-tree/oct-parse.yy"
2136  { };
2137 /* Line 1393 of yacc.c */
2138 #line 2139 "parse-tree/oct-parse.cc"
2139  break;
2140  case 16: /* EDIV_EQ */
2141 /* Line 1393 of yacc.c */
2142 #line 304 "parse-tree/oct-parse.yy"
2143  { };
2144 /* Line 1393 of yacc.c */
2145 #line 2146 "parse-tree/oct-parse.cc"
2146  break;
2147  case 17: /* ELEFTDIV_EQ */
2148 /* Line 1393 of yacc.c */
2149 #line 304 "parse-tree/oct-parse.yy"
2150  { };
2151 /* Line 1393 of yacc.c */
2152 #line 2153 "parse-tree/oct-parse.cc"
2153  break;
2154  case 18: /* EPOW_EQ */
2155 /* Line 1393 of yacc.c */
2156 #line 304 "parse-tree/oct-parse.yy"
2157  { };
2158 /* Line 1393 of yacc.c */
2159 #line 2160 "parse-tree/oct-parse.cc"
2160  break;
2161  case 19: /* AND_EQ */
2162 /* Line 1393 of yacc.c */
2163 #line 304 "parse-tree/oct-parse.yy"
2164  { };
2165 /* Line 1393 of yacc.c */
2166 #line 2167 "parse-tree/oct-parse.cc"
2167  break;
2168  case 20: /* OR_EQ */
2169 /* Line 1393 of yacc.c */
2170 #line 304 "parse-tree/oct-parse.yy"
2171  { };
2172 /* Line 1393 of yacc.c */
2173 #line 2174 "parse-tree/oct-parse.cc"
2174  break;
2175  case 21: /* LSHIFT_EQ */
2176 /* Line 1393 of yacc.c */
2177 #line 304 "parse-tree/oct-parse.yy"
2178  { };
2179 /* Line 1393 of yacc.c */
2180 #line 2181 "parse-tree/oct-parse.cc"
2181  break;
2182  case 22: /* RSHIFT_EQ */
2183 /* Line 1393 of yacc.c */
2184 #line 304 "parse-tree/oct-parse.yy"
2185  { };
2186 /* Line 1393 of yacc.c */
2187 #line 2188 "parse-tree/oct-parse.cc"
2188  break;
2189  case 23: /* LSHIFT */
2190 /* Line 1393 of yacc.c */
2191 #line 304 "parse-tree/oct-parse.yy"
2192  { };
2193 /* Line 1393 of yacc.c */
2194 #line 2195 "parse-tree/oct-parse.cc"
2195  break;
2196  case 24: /* RSHIFT */
2197 /* Line 1393 of yacc.c */
2198 #line 304 "parse-tree/oct-parse.yy"
2199  { };
2200 /* Line 1393 of yacc.c */
2201 #line 2202 "parse-tree/oct-parse.cc"
2202  break;
2203  case 25: /* EXPR_AND_AND */
2204 /* Line 1393 of yacc.c */
2205 #line 304 "parse-tree/oct-parse.yy"
2206  { };
2207 /* Line 1393 of yacc.c */
2208 #line 2209 "parse-tree/oct-parse.cc"
2209  break;
2210  case 26: /* EXPR_OR_OR */
2211 /* Line 1393 of yacc.c */
2212 #line 304 "parse-tree/oct-parse.yy"
2213  { };
2214 /* Line 1393 of yacc.c */
2215 #line 2216 "parse-tree/oct-parse.cc"
2216  break;
2217  case 27: /* EXPR_AND */
2218 /* Line 1393 of yacc.c */
2219 #line 304 "parse-tree/oct-parse.yy"
2220  { };
2221 /* Line 1393 of yacc.c */
2222 #line 2223 "parse-tree/oct-parse.cc"
2223  break;
2224  case 28: /* EXPR_OR */
2225 /* Line 1393 of yacc.c */
2226 #line 304 "parse-tree/oct-parse.yy"
2227  { };
2228 /* Line 1393 of yacc.c */
2229 #line 2230 "parse-tree/oct-parse.cc"
2230  break;
2231  case 29: /* EXPR_NOT */
2232 /* Line 1393 of yacc.c */
2233 #line 304 "parse-tree/oct-parse.yy"
2234  { };
2235 /* Line 1393 of yacc.c */
2236 #line 2237 "parse-tree/oct-parse.cc"
2237  break;
2238  case 30: /* EXPR_LT */
2239 /* Line 1393 of yacc.c */
2240 #line 304 "parse-tree/oct-parse.yy"
2241  { };
2242 /* Line 1393 of yacc.c */
2243 #line 2244 "parse-tree/oct-parse.cc"
2244  break;
2245  case 31: /* EXPR_LE */
2246 /* Line 1393 of yacc.c */
2247 #line 304 "parse-tree/oct-parse.yy"
2248  { };
2249 /* Line 1393 of yacc.c */
2250 #line 2251 "parse-tree/oct-parse.cc"
2251  break;
2252  case 32: /* EXPR_EQ */
2253 /* Line 1393 of yacc.c */
2254 #line 304 "parse-tree/oct-parse.yy"
2255  { };
2256 /* Line 1393 of yacc.c */
2257 #line 2258 "parse-tree/oct-parse.cc"
2258  break;
2259  case 33: /* EXPR_NE */
2260 /* Line 1393 of yacc.c */
2261 #line 304 "parse-tree/oct-parse.yy"
2262  { };
2263 /* Line 1393 of yacc.c */
2264 #line 2265 "parse-tree/oct-parse.cc"
2265  break;
2266  case 34: /* EXPR_GE */
2267 /* Line 1393 of yacc.c */
2268 #line 304 "parse-tree/oct-parse.yy"
2269  { };
2270 /* Line 1393 of yacc.c */
2271 #line 2272 "parse-tree/oct-parse.cc"
2272  break;
2273  case 35: /* EXPR_GT */
2274 /* Line 1393 of yacc.c */
2275 #line 304 "parse-tree/oct-parse.yy"
2276  { };
2277 /* Line 1393 of yacc.c */
2278 #line 2279 "parse-tree/oct-parse.cc"
2279  break;
2280  case 36: /* LEFTDIV */
2281 /* Line 1393 of yacc.c */
2282 #line 304 "parse-tree/oct-parse.yy"
2283  { };
2284 /* Line 1393 of yacc.c */
2285 #line 2286 "parse-tree/oct-parse.cc"
2286  break;
2287  case 37: /* EMUL */
2288 /* Line 1393 of yacc.c */
2289 #line 304 "parse-tree/oct-parse.yy"
2290  { };
2291 /* Line 1393 of yacc.c */
2292 #line 2293 "parse-tree/oct-parse.cc"
2293  break;
2294  case 38: /* EDIV */
2295 /* Line 1393 of yacc.c */
2296 #line 304 "parse-tree/oct-parse.yy"
2297  { };
2298 /* Line 1393 of yacc.c */
2299 #line 2300 "parse-tree/oct-parse.cc"
2300  break;
2301  case 39: /* ELEFTDIV */
2302 /* Line 1393 of yacc.c */
2303 #line 304 "parse-tree/oct-parse.yy"
2304  { };
2305 /* Line 1393 of yacc.c */
2306 #line 2307 "parse-tree/oct-parse.cc"
2307  break;
2308  case 40: /* EPLUS */
2309 /* Line 1393 of yacc.c */
2310 #line 304 "parse-tree/oct-parse.yy"
2311  { };
2312 /* Line 1393 of yacc.c */
2313 #line 2314 "parse-tree/oct-parse.cc"
2314  break;
2315  case 41: /* EMINUS */
2316 /* Line 1393 of yacc.c */
2317 #line 304 "parse-tree/oct-parse.yy"
2318  { };
2319 /* Line 1393 of yacc.c */
2320 #line 2321 "parse-tree/oct-parse.cc"
2321  break;
2322  case 42: /* HERMITIAN */
2323 /* Line 1393 of yacc.c */
2324 #line 304 "parse-tree/oct-parse.yy"
2325  { };
2326 /* Line 1393 of yacc.c */
2327 #line 2328 "parse-tree/oct-parse.cc"
2328  break;
2329  case 43: /* TRANSPOSE */
2330 /* Line 1393 of yacc.c */
2331 #line 304 "parse-tree/oct-parse.yy"
2332  { };
2333 /* Line 1393 of yacc.c */
2334 #line 2335 "parse-tree/oct-parse.cc"
2335  break;
2336  case 44: /* PLUS_PLUS */
2337 /* Line 1393 of yacc.c */
2338 #line 304 "parse-tree/oct-parse.yy"
2339  { };
2340 /* Line 1393 of yacc.c */
2341 #line 2342 "parse-tree/oct-parse.cc"
2342  break;
2343  case 45: /* MINUS_MINUS */
2344 /* Line 1393 of yacc.c */
2345 #line 304 "parse-tree/oct-parse.yy"
2346  { };
2347 /* Line 1393 of yacc.c */
2348 #line 2349 "parse-tree/oct-parse.cc"
2349  break;
2350  case 46: /* POW */
2351 /* Line 1393 of yacc.c */
2352 #line 304 "parse-tree/oct-parse.yy"
2353  { };
2354 /* Line 1393 of yacc.c */
2355 #line 2356 "parse-tree/oct-parse.cc"
2356  break;
2357  case 47: /* EPOW */
2358 /* Line 1393 of yacc.c */
2359 #line 304 "parse-tree/oct-parse.yy"
2360  { };
2361 /* Line 1393 of yacc.c */
2362 #line 2363 "parse-tree/oct-parse.cc"
2363  break;
2364  case 48: /* NUM */
2365 /* Line 1393 of yacc.c */
2366 #line 304 "parse-tree/oct-parse.yy"
2367  { };
2368 /* Line 1393 of yacc.c */
2369 #line 2370 "parse-tree/oct-parse.cc"
2370  break;
2371  case 49: /* IMAG_NUM */
2372 /* Line 1393 of yacc.c */
2373 #line 304 "parse-tree/oct-parse.yy"
2374  { };
2375 /* Line 1393 of yacc.c */
2376 #line 2377 "parse-tree/oct-parse.cc"
2377  break;
2378  case 50: /* STRUCT_ELT */
2379 /* Line 1393 of yacc.c */
2380 #line 304 "parse-tree/oct-parse.yy"
2381  { };
2382 /* Line 1393 of yacc.c */
2383 #line 2384 "parse-tree/oct-parse.cc"
2384  break;
2385  case 51: /* NAME */
2386 /* Line 1393 of yacc.c */
2387 #line 304 "parse-tree/oct-parse.yy"
2388  { };
2389 /* Line 1393 of yacc.c */
2390 #line 2391 "parse-tree/oct-parse.cc"
2391  break;
2392  case 52: /* END */
2393 /* Line 1393 of yacc.c */
2394 #line 304 "parse-tree/oct-parse.yy"
2395  { };
2396 /* Line 1393 of yacc.c */
2397 #line 2398 "parse-tree/oct-parse.cc"
2398  break;
2399  case 53: /* DQ_STRING */
2400 /* Line 1393 of yacc.c */
2401 #line 304 "parse-tree/oct-parse.yy"
2402  { };
2403 /* Line 1393 of yacc.c */
2404 #line 2405 "parse-tree/oct-parse.cc"
2405  break;
2406  case 54: /* SQ_STRING */
2407 /* Line 1393 of yacc.c */
2408 #line 304 "parse-tree/oct-parse.yy"
2409  { };
2410 /* Line 1393 of yacc.c */
2411 #line 2412 "parse-tree/oct-parse.cc"
2412  break;
2413  case 55: /* FOR */
2414 /* Line 1393 of yacc.c */
2415 #line 304 "parse-tree/oct-parse.yy"
2416  { };
2417 /* Line 1393 of yacc.c */
2418 #line 2419 "parse-tree/oct-parse.cc"
2419  break;
2420  case 56: /* PARFOR */
2421 /* Line 1393 of yacc.c */
2422 #line 304 "parse-tree/oct-parse.yy"
2423  { };
2424 /* Line 1393 of yacc.c */
2425 #line 2426 "parse-tree/oct-parse.cc"
2426  break;
2427  case 57: /* WHILE */
2428 /* Line 1393 of yacc.c */
2429 #line 304 "parse-tree/oct-parse.yy"
2430  { };
2431 /* Line 1393 of yacc.c */
2432 #line 2433 "parse-tree/oct-parse.cc"
2433  break;
2434  case 58: /* DO */
2435 /* Line 1393 of yacc.c */
2436 #line 304 "parse-tree/oct-parse.yy"
2437  { };
2438 /* Line 1393 of yacc.c */
2439 #line 2440 "parse-tree/oct-parse.cc"
2440  break;
2441  case 59: /* UNTIL */
2442 /* Line 1393 of yacc.c */
2443 #line 304 "parse-tree/oct-parse.yy"
2444  { };
2445 /* Line 1393 of yacc.c */
2446 #line 2447 "parse-tree/oct-parse.cc"
2447  break;
2448  case 60: /* IF */
2449 /* Line 1393 of yacc.c */
2450 #line 304 "parse-tree/oct-parse.yy"
2451  { };
2452 /* Line 1393 of yacc.c */
2453 #line 2454 "parse-tree/oct-parse.cc"
2454  break;
2455  case 61: /* ELSEIF */
2456 /* Line 1393 of yacc.c */
2457 #line 304 "parse-tree/oct-parse.yy"
2458  { };
2459 /* Line 1393 of yacc.c */
2460 #line 2461 "parse-tree/oct-parse.cc"
2461  break;
2462  case 62: /* ELSE */
2463 /* Line 1393 of yacc.c */
2464 #line 304 "parse-tree/oct-parse.yy"
2465  { };
2466 /* Line 1393 of yacc.c */
2467 #line 2468 "parse-tree/oct-parse.cc"
2468  break;
2469  case 63: /* SWITCH */
2470 /* Line 1393 of yacc.c */
2471 #line 304 "parse-tree/oct-parse.yy"
2472  { };
2473 /* Line 1393 of yacc.c */
2474 #line 2475 "parse-tree/oct-parse.cc"
2475  break;
2476  case 64: /* CASE */
2477 /* Line 1393 of yacc.c */
2478 #line 304 "parse-tree/oct-parse.yy"
2479  { };
2480 /* Line 1393 of yacc.c */
2481 #line 2482 "parse-tree/oct-parse.cc"
2482  break;
2483  case 65: /* OTHERWISE */
2484 /* Line 1393 of yacc.c */
2485 #line 304 "parse-tree/oct-parse.yy"
2486  { };
2487 /* Line 1393 of yacc.c */
2488 #line 2489 "parse-tree/oct-parse.cc"
2489  break;
2490  case 66: /* BREAK */
2491 /* Line 1393 of yacc.c */
2492 #line 304 "parse-tree/oct-parse.yy"
2493  { };
2494 /* Line 1393 of yacc.c */
2495 #line 2496 "parse-tree/oct-parse.cc"
2496  break;
2497  case 67: /* CONTINUE */
2498 /* Line 1393 of yacc.c */
2499 #line 304 "parse-tree/oct-parse.yy"
2500  { };
2501 /* Line 1393 of yacc.c */
2502 #line 2503 "parse-tree/oct-parse.cc"
2503  break;
2504  case 68: /* FUNC_RET */
2505 /* Line 1393 of yacc.c */
2506 #line 304 "parse-tree/oct-parse.yy"
2507  { };
2508 /* Line 1393 of yacc.c */
2509 #line 2510 "parse-tree/oct-parse.cc"
2510  break;
2511  case 69: /* UNWIND */
2512 /* Line 1393 of yacc.c */
2513 #line 304 "parse-tree/oct-parse.yy"
2514  { };
2515 /* Line 1393 of yacc.c */
2516 #line 2517 "parse-tree/oct-parse.cc"
2517  break;
2518  case 70: /* CLEANUP */
2519 /* Line 1393 of yacc.c */
2520 #line 304 "parse-tree/oct-parse.yy"
2521  { };
2522 /* Line 1393 of yacc.c */
2523 #line 2524 "parse-tree/oct-parse.cc"
2524  break;
2525  case 71: /* TRY */
2526 /* Line 1393 of yacc.c */
2527 #line 304 "parse-tree/oct-parse.yy"
2528  { };
2529 /* Line 1393 of yacc.c */
2530 #line 2531 "parse-tree/oct-parse.cc"
2531  break;
2532  case 72: /* CATCH */
2533 /* Line 1393 of yacc.c */
2534 #line 304 "parse-tree/oct-parse.yy"
2535  { };
2536 /* Line 1393 of yacc.c */
2537 #line 2538 "parse-tree/oct-parse.cc"
2538  break;
2539  case 73: /* GLOBAL */
2540 /* Line 1393 of yacc.c */
2541 #line 304 "parse-tree/oct-parse.yy"
2542  { };
2543 /* Line 1393 of yacc.c */
2544 #line 2545 "parse-tree/oct-parse.cc"
2545  break;
2546  case 74: /* PERSISTENT */
2547 /* Line 1393 of yacc.c */
2548 #line 304 "parse-tree/oct-parse.yy"
2549  { };
2550 /* Line 1393 of yacc.c */
2551 #line 2552 "parse-tree/oct-parse.cc"
2552  break;
2553  case 75: /* FCN_HANDLE */
2554 /* Line 1393 of yacc.c */
2555 #line 304 "parse-tree/oct-parse.yy"
2556  { };
2557 /* Line 1393 of yacc.c */
2558 #line 2559 "parse-tree/oct-parse.cc"
2559  break;
2560  case 76: /* PROPERTIES */
2561 /* Line 1393 of yacc.c */
2562 #line 304 "parse-tree/oct-parse.yy"
2563  { };
2564 /* Line 1393 of yacc.c */
2565 #line 2566 "parse-tree/oct-parse.cc"
2566  break;
2567  case 77: /* METHODS */
2568 /* Line 1393 of yacc.c */
2569 #line 304 "parse-tree/oct-parse.yy"
2570  { };
2571 /* Line 1393 of yacc.c */
2572 #line 2573 "parse-tree/oct-parse.cc"
2573  break;
2574  case 78: /* EVENTS */
2575 /* Line 1393 of yacc.c */
2576 #line 304 "parse-tree/oct-parse.yy"
2577  { };
2578 /* Line 1393 of yacc.c */
2579 #line 2580 "parse-tree/oct-parse.cc"
2580  break;
2581  case 79: /* ENUMERATION */
2582 /* Line 1393 of yacc.c */
2583 #line 304 "parse-tree/oct-parse.yy"
2584  { };
2585 /* Line 1393 of yacc.c */
2586 #line 2587 "parse-tree/oct-parse.cc"
2587  break;
2588  case 80: /* METAQUERY */
2589 /* Line 1393 of yacc.c */
2590 #line 304 "parse-tree/oct-parse.yy"
2591  { };
2592 /* Line 1393 of yacc.c */
2593 #line 2594 "parse-tree/oct-parse.cc"
2594  break;
2595  case 81: /* SUPERCLASSREF */
2596 /* Line 1393 of yacc.c */
2597 #line 304 "parse-tree/oct-parse.yy"
2598  { };
2599 /* Line 1393 of yacc.c */
2600 #line 2601 "parse-tree/oct-parse.cc"
2601  break;
2602  case 82: /* GET */
2603 /* Line 1393 of yacc.c */
2604 #line 304 "parse-tree/oct-parse.yy"
2605  { };
2606 /* Line 1393 of yacc.c */
2607 #line 2608 "parse-tree/oct-parse.cc"
2608  break;
2609  case 83: /* SET */
2610 /* Line 1393 of yacc.c */
2611 #line 304 "parse-tree/oct-parse.yy"
2612  { };
2613 /* Line 1393 of yacc.c */
2614 #line 2615 "parse-tree/oct-parse.cc"
2615  break;
2616  case 84: /* FCN */
2617 /* Line 1393 of yacc.c */
2618 #line 304 "parse-tree/oct-parse.yy"
2619  { };
2620 /* Line 1393 of yacc.c */
2621 #line 2622 "parse-tree/oct-parse.cc"
2622  break;
2623  case 85: /* END_OF_INPUT */
2624 /* Line 1393 of yacc.c */
2625 #line 307 "parse-tree/oct-parse.yy"
2626  { };
2627 /* Line 1393 of yacc.c */
2628 #line 2629 "parse-tree/oct-parse.cc"
2629  break;
2630  case 86: /* LEXICAL_ERROR */
2631 /* Line 1393 of yacc.c */
2632 #line 307 "parse-tree/oct-parse.yy"
2633  { };
2634 /* Line 1393 of yacc.c */
2635 #line 2636 "parse-tree/oct-parse.cc"
2636  break;
2637  case 87: /* INPUT_FILE */
2638 /* Line 1393 of yacc.c */
2639 #line 307 "parse-tree/oct-parse.yy"
2640  { };
2641 /* Line 1393 of yacc.c */
2642 #line 2643 "parse-tree/oct-parse.cc"
2643  break;
2644  case 88: /* CLASSDEF */
2645 /* Line 1393 of yacc.c */
2646 #line 307 "parse-tree/oct-parse.yy"
2647  { };
2648 /* Line 1393 of yacc.c */
2649 #line 2650 "parse-tree/oct-parse.cc"
2650  break;
2651  case 89: /* UNARY */
2652 /* Line 1393 of yacc.c */
2653 #line 307 "parse-tree/oct-parse.yy"
2654  { };
2655 /* Line 1393 of yacc.c */
2656 #line 2657 "parse-tree/oct-parse.cc"
2657  break;
2658  case 90: /* '(' */
2659 /* Line 1393 of yacc.c */
2660 #line 307 "parse-tree/oct-parse.yy"
2661  { };
2662 /* Line 1393 of yacc.c */
2663 #line 2664 "parse-tree/oct-parse.cc"
2664  break;
2665  case 91: /* '.' */
2666 /* Line 1393 of yacc.c */
2667 #line 307 "parse-tree/oct-parse.yy"
2668  { };
2669 /* Line 1393 of yacc.c */
2670 #line 2671 "parse-tree/oct-parse.cc"
2671  break;
2672  case 92: /* '{' */
2673 /* Line 1393 of yacc.c */
2674 #line 307 "parse-tree/oct-parse.yy"
2675  { };
2676 /* Line 1393 of yacc.c */
2677 #line 2678 "parse-tree/oct-parse.cc"
2678  break;
2679  case 93: /* '\n' */
2680 /* Line 1393 of yacc.c */
2681 #line 307 "parse-tree/oct-parse.yy"
2682  { };
2683 /* Line 1393 of yacc.c */
2684 #line 2685 "parse-tree/oct-parse.cc"
2685  break;
2686  case 94: /* '[' */
2687 /* Line 1393 of yacc.c */
2688 #line 307 "parse-tree/oct-parse.yy"
2689  { };
2690 /* Line 1393 of yacc.c */
2691 #line 2692 "parse-tree/oct-parse.cc"
2692  break;
2693  case 95: /* ']' */
2694 /* Line 1393 of yacc.c */
2695 #line 307 "parse-tree/oct-parse.yy"
2696  { };
2697 /* Line 1393 of yacc.c */
2698 #line 2699 "parse-tree/oct-parse.cc"
2699  break;
2700  case 96: /* ';' */
2701 /* Line 1393 of yacc.c */
2702 #line 307 "parse-tree/oct-parse.yy"
2703  { };
2704 /* Line 1393 of yacc.c */
2705 #line 2706 "parse-tree/oct-parse.cc"
2706  break;
2707  case 97: /* '}' */
2708 /* Line 1393 of yacc.c */
2709 #line 307 "parse-tree/oct-parse.yy"
2710  { };
2711 /* Line 1393 of yacc.c */
2712 #line 2713 "parse-tree/oct-parse.cc"
2713  break;
2714  case 98: /* ',' */
2715 /* Line 1393 of yacc.c */
2716 #line 307 "parse-tree/oct-parse.yy"
2717  { };
2718 /* Line 1393 of yacc.c */
2719 #line 2720 "parse-tree/oct-parse.cc"
2720  break;
2721  case 99: /* '@' */
2722 /* Line 1393 of yacc.c */
2723 #line 307 "parse-tree/oct-parse.yy"
2724  { };
2725 /* Line 1393 of yacc.c */
2726 #line 2727 "parse-tree/oct-parse.cc"
2727  break;
2728  case 100: /* ')' */
2729 /* Line 1393 of yacc.c */
2730 #line 307 "parse-tree/oct-parse.yy"
2731  { };
2732 /* Line 1393 of yacc.c */
2733 #line 2734 "parse-tree/oct-parse.cc"
2734  break;
2735  case 102: /* input */
2736 /* Line 1393 of yacc.c */
2737 #line 309 "parse-tree/oct-parse.yy"
2738  { delete ((*yyvaluep).tree_type); };
2739 /* Line 1393 of yacc.c */
2740 #line 2741 "parse-tree/oct-parse.cc"
2741  break;
2742  case 103: /* simple_list */
2743 /* Line 1393 of yacc.c */
2744 #line 332 "parse-tree/oct-parse.yy"
2745  { delete ((*yyvaluep).tree_statement_list_type); };
2746 /* Line 1393 of yacc.c */
2747 #line 2748 "parse-tree/oct-parse.cc"
2748  break;
2749  case 104: /* simple_list1 */
2750 /* Line 1393 of yacc.c */
2751 #line 332 "parse-tree/oct-parse.yy"
2752  { delete ((*yyvaluep).tree_statement_list_type); };
2753 /* Line 1393 of yacc.c */
2754 #line 2755 "parse-tree/oct-parse.cc"
2755  break;
2756  case 105: /* opt_list */
2757 /* Line 1393 of yacc.c */
2758 #line 332 "parse-tree/oct-parse.yy"
2759  { delete ((*yyvaluep).tree_statement_list_type); };
2760 /* Line 1393 of yacc.c */
2761 #line 2762 "parse-tree/oct-parse.cc"
2762  break;
2763  case 106: /* list */
2764 /* Line 1393 of yacc.c */
2765 #line 332 "parse-tree/oct-parse.yy"
2766  { delete ((*yyvaluep).tree_statement_list_type); };
2767 /* Line 1393 of yacc.c */
2768 #line 2769 "parse-tree/oct-parse.cc"
2769  break;
2770  case 107: /* list1 */
2771 /* Line 1393 of yacc.c */
2772 #line 332 "parse-tree/oct-parse.yy"
2773  { delete ((*yyvaluep).tree_statement_list_type); };
2774 /* Line 1393 of yacc.c */
2775 #line 2776 "parse-tree/oct-parse.cc"
2776  break;
2777  case 108: /* statement */
2778 /* Line 1393 of yacc.c */
2779 #line 331 "parse-tree/oct-parse.yy"
2780  { delete ((*yyvaluep).tree_statement_type); };
2781 /* Line 1393 of yacc.c */
2782 #line 2783 "parse-tree/oct-parse.cc"
2783  break;
2784  case 109: /* word_list_cmd */
2785 /* Line 1393 of yacc.c */
2786 #line 317 "parse-tree/oct-parse.yy"
2787  { delete ((*yyvaluep).tree_index_expression_type); };
2788 /* Line 1393 of yacc.c */
2789 #line 2790 "parse-tree/oct-parse.cc"
2790  break;
2791  case 110: /* word_list */
2792 /* Line 1393 of yacc.c */
2793 #line 319 "parse-tree/oct-parse.yy"
2794  { delete ((*yyvaluep).tree_argument_list_type); };
2795 /* Line 1393 of yacc.c */
2796 #line 2797 "parse-tree/oct-parse.cc"
2797  break;
2798  case 111: /* identifier */
2799 /* Line 1393 of yacc.c */
2800 #line 316 "parse-tree/oct-parse.yy"
2801  { delete ((*yyvaluep).tree_identifier_type); };
2802 /* Line 1393 of yacc.c */
2803 #line 2804 "parse-tree/oct-parse.cc"
2804  break;
2805  case 112: /* superclass_identifier */
2806 /* Line 1393 of yacc.c */
2807 #line 316 "parse-tree/oct-parse.yy"
2808  { delete ((*yyvaluep).tree_identifier_type); };
2809 /* Line 1393 of yacc.c */
2810 #line 2811 "parse-tree/oct-parse.cc"
2811  break;
2812  case 113: /* meta_identifier */
2813 /* Line 1393 of yacc.c */
2814 #line 316 "parse-tree/oct-parse.yy"
2815  { delete ((*yyvaluep).tree_identifier_type); };
2816 /* Line 1393 of yacc.c */
2817 #line 2818 "parse-tree/oct-parse.cc"
2818  break;
2819  case 114: /* string */
2820 /* Line 1393 of yacc.c */
2821 #line 313 "parse-tree/oct-parse.yy"
2822  { delete ((*yyvaluep).tree_constant_type); };
2823 /* Line 1393 of yacc.c */
2824 #line 2825 "parse-tree/oct-parse.cc"
2825  break;
2826  case 115: /* constant */
2827 /* Line 1393 of yacc.c */
2828 #line 313 "parse-tree/oct-parse.yy"
2829  { delete ((*yyvaluep).tree_constant_type); };
2830 /* Line 1393 of yacc.c */
2831 #line 2832 "parse-tree/oct-parse.cc"
2832  break;
2833  case 116: /* matrix */
2834 /* Line 1393 of yacc.c */
2835 #line 312 "parse-tree/oct-parse.yy"
2836  { delete ((*yyvaluep).tree_expression_type); };
2837 /* Line 1393 of yacc.c */
2838 #line 2839 "parse-tree/oct-parse.cc"
2839  break;
2840  case 117: /* matrix_rows */
2841 /* Line 1393 of yacc.c */
2842 #line 310 "parse-tree/oct-parse.yy"
2843  { delete ((*yyvaluep).tree_matrix_type); };
2844 /* Line 1393 of yacc.c */
2845 #line 2846 "parse-tree/oct-parse.cc"
2846  break;
2847  case 118: /* cell */
2848 /* Line 1393 of yacc.c */
2849 #line 312 "parse-tree/oct-parse.yy"
2850  { delete ((*yyvaluep).tree_expression_type); };
2851 /* Line 1393 of yacc.c */
2852 #line 2853 "parse-tree/oct-parse.cc"
2853  break;
2854  case 119: /* cell_rows */
2855 /* Line 1393 of yacc.c */
2856 #line 311 "parse-tree/oct-parse.yy"
2857  { delete ((*yyvaluep).tree_cell_type); };
2858 /* Line 1393 of yacc.c */
2859 #line 2860 "parse-tree/oct-parse.cc"
2860  break;
2861  case 120: /* cell_or_matrix_row */
2862 /* Line 1393 of yacc.c */
2863 #line 319 "parse-tree/oct-parse.yy"
2864  { delete ((*yyvaluep).tree_argument_list_type); };
2865 /* Line 1393 of yacc.c */
2866 #line 2867 "parse-tree/oct-parse.cc"
2867  break;
2868  case 121: /* fcn_handle */
2869 /* Line 1393 of yacc.c */
2870 #line 314 "parse-tree/oct-parse.yy"
2871  { delete ((*yyvaluep).tree_fcn_handle_type); };
2872 /* Line 1393 of yacc.c */
2873 #line 2874 "parse-tree/oct-parse.cc"
2874  break;
2875  case 122: /* anon_fcn_handle */
2876 /* Line 1393 of yacc.c */
2877 #line 315 "parse-tree/oct-parse.yy"
2878  { delete ((*yyvaluep).tree_anon_fcn_handle_type); };
2879 /* Line 1393 of yacc.c */
2880 #line 2881 "parse-tree/oct-parse.cc"
2881  break;
2882  case 123: /* primary_expr */
2883 /* Line 1393 of yacc.c */
2884 #line 312 "parse-tree/oct-parse.yy"
2885  { delete ((*yyvaluep).tree_expression_type); };
2886 /* Line 1393 of yacc.c */
2887 #line 2888 "parse-tree/oct-parse.cc"
2888  break;
2889  case 124: /* magic_colon */
2890 /* Line 1393 of yacc.c */
2891 #line 313 "parse-tree/oct-parse.yy"
2892  { delete ((*yyvaluep).tree_constant_type); };
2893 /* Line 1393 of yacc.c */
2894 #line 2895 "parse-tree/oct-parse.cc"
2895  break;
2896  case 125: /* magic_tilde */
2897 /* Line 1393 of yacc.c */
2898 #line 316 "parse-tree/oct-parse.yy"
2899  { delete ((*yyvaluep).tree_identifier_type); };
2900 /* Line 1393 of yacc.c */
2901 #line 2902 "parse-tree/oct-parse.cc"
2902  break;
2903  case 126: /* arg_list */
2904 /* Line 1393 of yacc.c */
2905 #line 319 "parse-tree/oct-parse.yy"
2906  { delete ((*yyvaluep).tree_argument_list_type); };
2907 /* Line 1393 of yacc.c */
2908 #line 2909 "parse-tree/oct-parse.cc"
2909  break;
2910  case 127: /* indirect_ref_op */
2911 /* Line 1393 of yacc.c */
2912 #line 307 "parse-tree/oct-parse.yy"
2913  { };
2914 /* Line 1393 of yacc.c */
2915 #line 2916 "parse-tree/oct-parse.cc"
2916  break;
2917  case 128: /* oper_expr */
2918 /* Line 1393 of yacc.c */
2919 #line 312 "parse-tree/oct-parse.yy"
2920  { delete ((*yyvaluep).tree_expression_type); };
2921 /* Line 1393 of yacc.c */
2922 #line 2923 "parse-tree/oct-parse.cc"
2923  break;
2924  case 129: /* power_expr */
2925 /* Line 1393 of yacc.c */
2926 #line 312 "parse-tree/oct-parse.yy"
2927  { delete ((*yyvaluep).tree_expression_type); };
2928 /* Line 1393 of yacc.c */
2929 #line 2930 "parse-tree/oct-parse.cc"
2930  break;
2931  case 130: /* colon_expr */
2932 /* Line 1393 of yacc.c */
2933 #line 312 "parse-tree/oct-parse.yy"
2934  { delete ((*yyvaluep).tree_expression_type); };
2935 /* Line 1393 of yacc.c */
2936 #line 2937 "parse-tree/oct-parse.cc"
2937  break;
2938  case 131: /* colon_expr1 */
2939 /* Line 1393 of yacc.c */
2940 #line 318 "parse-tree/oct-parse.yy"
2941  { delete ((*yyvaluep).tree_colon_expression_type); };
2942 /* Line 1393 of yacc.c */
2943 #line 2944 "parse-tree/oct-parse.cc"
2944  break;
2945  case 132: /* simple_expr */
2946 /* Line 1393 of yacc.c */
2947 #line 312 "parse-tree/oct-parse.yy"
2948  { delete ((*yyvaluep).tree_expression_type); };
2949 /* Line 1393 of yacc.c */
2950 #line 2951 "parse-tree/oct-parse.cc"
2951  break;
2952  case 133: /* assign_lhs */
2953 /* Line 1393 of yacc.c */
2954 #line 319 "parse-tree/oct-parse.yy"
2955  { delete ((*yyvaluep).tree_argument_list_type); };
2956 /* Line 1393 of yacc.c */
2957 #line 2958 "parse-tree/oct-parse.cc"
2958  break;
2959  case 134: /* assign_expr */
2960 /* Line 1393 of yacc.c */
2961 #line 312 "parse-tree/oct-parse.yy"
2962  { delete ((*yyvaluep).tree_expression_type); };
2963 /* Line 1393 of yacc.c */
2964 #line 2965 "parse-tree/oct-parse.cc"
2965  break;
2966  case 135: /* expression */
2967 /* Line 1393 of yacc.c */
2968 #line 312 "parse-tree/oct-parse.yy"
2969  { delete ((*yyvaluep).tree_expression_type); };
2970 /* Line 1393 of yacc.c */
2971 #line 2972 "parse-tree/oct-parse.cc"
2972  break;
2973  case 136: /* command */
2974 /* Line 1393 of yacc.c */
2975 #line 321 "parse-tree/oct-parse.yy"
2976  { delete ((*yyvaluep).tree_command_type); };
2977 /* Line 1393 of yacc.c */
2978 #line 2979 "parse-tree/oct-parse.cc"
2979  break;
2980  case 137: /* declaration */
2981 /* Line 1393 of yacc.c */
2982 #line 330 "parse-tree/oct-parse.yy"
2983  { delete ((*yyvaluep).tree_decl_command_type); };
2984 /* Line 1393 of yacc.c */
2985 #line 2986 "parse-tree/oct-parse.cc"
2986  break;
2987  case 138: /* decl1 */
2988 /* Line 1393 of yacc.c */
2989 #line 329 "parse-tree/oct-parse.yy"
2990  { delete ((*yyvaluep).tree_decl_init_list_type); };
2991 /* Line 1393 of yacc.c */
2992 #line 2993 "parse-tree/oct-parse.cc"
2993  break;
2994  case 139: /* decl_param_init */
2995 /* Line 1393 of yacc.c */
2996 #line 307 "parse-tree/oct-parse.yy"
2997  { };
2998 /* Line 1393 of yacc.c */
2999 #line 3000 "parse-tree/oct-parse.cc"
3000  break;
3001  case 140: /* decl2 */
3002 /* Line 1393 of yacc.c */
3003 #line 328 "parse-tree/oct-parse.yy"
3004  { delete ((*yyvaluep).tree_decl_elt_type); };
3005 /* Line 1393 of yacc.c */
3006 #line 3007 "parse-tree/oct-parse.cc"
3007  break;
3008  case 141: /* select_command */
3009 /* Line 1393 of yacc.c */
3010 #line 321 "parse-tree/oct-parse.yy"
3011  { delete ((*yyvaluep).tree_command_type); };
3012 /* Line 1393 of yacc.c */
3013 #line 3014 "parse-tree/oct-parse.cc"
3014  break;
3015  case 142: /* if_command */
3016 /* Line 1393 of yacc.c */
3017 #line 322 "parse-tree/oct-parse.yy"
3018  { delete ((*yyvaluep).tree_if_command_type); };
3019 /* Line 1393 of yacc.c */
3020 #line 3021 "parse-tree/oct-parse.cc"
3021  break;
3022  case 143: /* if_cmd_list */
3023 /* Line 1393 of yacc.c */
3024 #line 324 "parse-tree/oct-parse.yy"
3025  { delete ((*yyvaluep).tree_if_command_list_type); };
3026 /* Line 1393 of yacc.c */
3027 #line 3028 "parse-tree/oct-parse.cc"
3028  break;
3029  case 144: /* if_cmd_list1 */
3030 /* Line 1393 of yacc.c */
3031 #line 324 "parse-tree/oct-parse.yy"
3032  { delete ((*yyvaluep).tree_if_command_list_type); };
3033 /* Line 1393 of yacc.c */
3034 #line 3035 "parse-tree/oct-parse.cc"
3035  break;
3036  case 145: /* elseif_clause */
3037 /* Line 1393 of yacc.c */
3038 #line 323 "parse-tree/oct-parse.yy"
3039  { delete ((*yyvaluep).tree_if_clause_type); };
3040 /* Line 1393 of yacc.c */
3041 #line 3042 "parse-tree/oct-parse.cc"
3042  break;
3043  case 146: /* else_clause */
3044 /* Line 1393 of yacc.c */
3045 #line 323 "parse-tree/oct-parse.yy"
3046  { delete ((*yyvaluep).tree_if_clause_type); };
3047 /* Line 1393 of yacc.c */
3048 #line 3049 "parse-tree/oct-parse.cc"
3049  break;
3050  case 147: /* switch_command */
3051 /* Line 1393 of yacc.c */
3052 #line 325 "parse-tree/oct-parse.yy"
3053  { delete ((*yyvaluep).tree_switch_command_type); };
3054 /* Line 1393 of yacc.c */
3055 #line 3056 "parse-tree/oct-parse.cc"
3056  break;
3057  case 148: /* case_list */
3058 /* Line 1393 of yacc.c */
3059 #line 327 "parse-tree/oct-parse.yy"
3060  { delete ((*yyvaluep).tree_switch_case_list_type); };
3061 /* Line 1393 of yacc.c */
3062 #line 3063 "parse-tree/oct-parse.cc"
3063  break;
3064  case 149: /* case_list1 */
3065 /* Line 1393 of yacc.c */
3066 #line 327 "parse-tree/oct-parse.yy"
3067  { delete ((*yyvaluep).tree_switch_case_list_type); };
3068 /* Line 1393 of yacc.c */
3069 #line 3070 "parse-tree/oct-parse.cc"
3070  break;
3071  case 150: /* switch_case */
3072 /* Line 1393 of yacc.c */
3073 #line 326 "parse-tree/oct-parse.yy"
3074  { delete ((*yyvaluep).tree_switch_case_type); };
3075 /* Line 1393 of yacc.c */
3076 #line 3077 "parse-tree/oct-parse.cc"
3077  break;
3078  case 151: /* default_case */
3079 /* Line 1393 of yacc.c */
3080 #line 326 "parse-tree/oct-parse.yy"
3081  { delete ((*yyvaluep).tree_switch_case_type); };
3082 /* Line 1393 of yacc.c */
3083 #line 3084 "parse-tree/oct-parse.cc"
3084  break;
3085  case 152: /* loop_command */
3086 /* Line 1393 of yacc.c */
3087 #line 321 "parse-tree/oct-parse.yy"
3088  { delete ((*yyvaluep).tree_command_type); };
3089 /* Line 1393 of yacc.c */
3090 #line 3091 "parse-tree/oct-parse.cc"
3091  break;
3092  case 153: /* jump_command */
3093 /* Line 1393 of yacc.c */
3094 #line 321 "parse-tree/oct-parse.yy"
3095  { delete ((*yyvaluep).tree_command_type); };
3096 /* Line 1393 of yacc.c */
3097 #line 3098 "parse-tree/oct-parse.cc"
3098  break;
3099  case 154: /* except_command */
3100 /* Line 1393 of yacc.c */
3101 #line 321 "parse-tree/oct-parse.yy"
3102  { delete ((*yyvaluep).tree_command_type); };
3103 /* Line 1393 of yacc.c */
3104 #line 3105 "parse-tree/oct-parse.cc"
3105  break;
3106  case 155: /* push_fcn_symtab */
3107 /* Line 1393 of yacc.c */
3108 #line 307 "parse-tree/oct-parse.yy"
3109  { };
3110 /* Line 1393 of yacc.c */
3111 #line 3112 "parse-tree/oct-parse.cc"
3112  break;
3113  case 156: /* param_list_beg */
3114 /* Line 1393 of yacc.c */
3115 #line 307 "parse-tree/oct-parse.yy"
3116  { };
3117 /* Line 1393 of yacc.c */
3118 #line 3119 "parse-tree/oct-parse.cc"
3119  break;
3120  case 157: /* param_list_end */
3121 /* Line 1393 of yacc.c */
3122 #line 307 "parse-tree/oct-parse.yy"
3123  { };
3124 /* Line 1393 of yacc.c */
3125 #line 3126 "parse-tree/oct-parse.cc"
3126  break;
3127  case 158: /* param_list */
3128 /* Line 1393 of yacc.c */
3129 #line 320 "parse-tree/oct-parse.yy"
3130  { delete ((*yyvaluep).tree_parameter_list_type); };
3131 /* Line 1393 of yacc.c */
3132 #line 3133 "parse-tree/oct-parse.cc"
3133  break;
3134  case 159: /* param_list1 */
3135 /* Line 1393 of yacc.c */
3136 #line 320 "parse-tree/oct-parse.yy"
3137  { delete ((*yyvaluep).tree_parameter_list_type); };
3138 /* Line 1393 of yacc.c */
3139 #line 3140 "parse-tree/oct-parse.cc"
3140  break;
3141  case 160: /* param_list2 */
3142 /* Line 1393 of yacc.c */
3143 #line 320 "parse-tree/oct-parse.yy"
3144  { delete ((*yyvaluep).tree_parameter_list_type); };
3145 /* Line 1393 of yacc.c */
3146 #line 3147 "parse-tree/oct-parse.cc"
3147  break;
3148  case 161: /* param_list_elt */
3149 /* Line 1393 of yacc.c */
3150 #line 328 "parse-tree/oct-parse.yy"
3151  { delete ((*yyvaluep).tree_decl_elt_type); };
3152 /* Line 1393 of yacc.c */
3153 #line 3154 "parse-tree/oct-parse.cc"
3154  break;
3155  case 162: /* return_list */
3156 /* Line 1393 of yacc.c */
3157 #line 320 "parse-tree/oct-parse.yy"
3158  { delete ((*yyvaluep).tree_parameter_list_type); };
3159 /* Line 1393 of yacc.c */
3160 #line 3161 "parse-tree/oct-parse.cc"
3161  break;
3162  case 163: /* return_list1 */
3163 /* Line 1393 of yacc.c */
3164 #line 320 "parse-tree/oct-parse.yy"
3165  { delete ((*yyvaluep).tree_parameter_list_type); };
3166 /* Line 1393 of yacc.c */
3167 #line 3168 "parse-tree/oct-parse.cc"
3168  break;
3169  case 164: /* file */
3170 /* Line 1393 of yacc.c */
3171 #line 321 "parse-tree/oct-parse.yy"
3172  { delete ((*yyvaluep).tree_command_type); };
3173 /* Line 1393 of yacc.c */
3174 #line 3175 "parse-tree/oct-parse.cc"
3175  break;
3176  case 165: /* function_beg */
3177 /* Line 1393 of yacc.c */
3178 #line 304 "parse-tree/oct-parse.yy"
3179  { };
3180 /* Line 1393 of yacc.c */
3181 #line 3182 "parse-tree/oct-parse.cc"
3182  break;
3183  case 166: /* function */
3184 /* Line 1393 of yacc.c */
3185 #line 321 "parse-tree/oct-parse.yy"
3186  { delete ((*yyvaluep).tree_command_type); };
3187 /* Line 1393 of yacc.c */
3188 #line 3189 "parse-tree/oct-parse.cc"
3189  break;
3190  case 167: /* fcn_name */
3191 /* Line 1393 of yacc.c */
3192 #line 316 "parse-tree/oct-parse.yy"
3193  { delete ((*yyvaluep).tree_identifier_type); };
3194 /* Line 1393 of yacc.c */
3195 #line 3196 "parse-tree/oct-parse.cc"
3196  break;
3197  case 168: /* function1 */
3198 /* Line 1393 of yacc.c */
3199 #line 333 "parse-tree/oct-parse.yy"
3200  { delete ((*yyvaluep).octave_user_function_type); };
3201 /* Line 1393 of yacc.c */
3202 #line 3203 "parse-tree/oct-parse.cc"
3203  break;
3204  case 169: /* function2 */
3205 /* Line 1393 of yacc.c */
3206 #line 333 "parse-tree/oct-parse.yy"
3207  { delete ((*yyvaluep).octave_user_function_type); };
3208 /* Line 1393 of yacc.c */
3209 #line 3210 "parse-tree/oct-parse.cc"
3210  break;
3211  case 170: /* function_end */
3212 /* Line 1393 of yacc.c */
3213 #line 331 "parse-tree/oct-parse.yy"
3214  { delete ((*yyvaluep).tree_statement_type); };
3215 /* Line 1393 of yacc.c */
3216 #line 3217 "parse-tree/oct-parse.cc"
3217  break;
3218  case 171: /* classdef_beg */
3219 /* Line 1393 of yacc.c */
3220 #line 305 "parse-tree/oct-parse.yy"
3221  { };
3222 /* Line 1393 of yacc.c */
3223 #line 3224 "parse-tree/oct-parse.cc"
3224  break;
3225  case 172: /* classdef_end */
3226 /* Line 1393 of yacc.c */
3227 #line 331 "parse-tree/oct-parse.yy"
3228  { delete ((*yyvaluep).tree_statement_type); };
3229 /* Line 1393 of yacc.c */
3230 #line 3231 "parse-tree/oct-parse.cc"
3231  break;
3232  case 173: /* classdef1 */
3233 /* Line 1393 of yacc.c */
3234 #line 333 "parse-tree/oct-parse.yy"
3235  { delete ((*yyvaluep).octave_user_function_type); };
3236 /* Line 1393 of yacc.c */
3237 #line 3238 "parse-tree/oct-parse.cc"
3238  break;
3239  case 174: /* classdef */
3240 /* Line 1393 of yacc.c */
3241 #line 321 "parse-tree/oct-parse.yy"
3242  { delete ((*yyvaluep).tree_command_type); };
3243 /* Line 1393 of yacc.c */
3244 #line 3245 "parse-tree/oct-parse.cc"
3245  break;
3246  case 175: /* opt_attr_list */
3247 /* Line 1393 of yacc.c */
3248 #line 306 "parse-tree/oct-parse.yy"
3249  { };
3250 /* Line 1393 of yacc.c */
3251 #line 3252 "parse-tree/oct-parse.cc"
3252  break;
3253  case 176: /* attr_list */
3254 /* Line 1393 of yacc.c */
3255 #line 306 "parse-tree/oct-parse.yy"
3256  { };
3257 /* Line 1393 of yacc.c */
3258 #line 3259 "parse-tree/oct-parse.cc"
3259  break;
3260  case 177: /* attr */
3261 /* Line 1393 of yacc.c */
3262 #line 306 "parse-tree/oct-parse.yy"
3263  { };
3264 /* Line 1393 of yacc.c */
3265 #line 3266 "parse-tree/oct-parse.cc"
3266  break;
3267  case 178: /* opt_superclasses */
3268 /* Line 1393 of yacc.c */
3269 #line 320 "parse-tree/oct-parse.yy"
3270  { delete ((*yyvaluep).tree_parameter_list_type); };
3271 /* Line 1393 of yacc.c */
3272 #line 3273 "parse-tree/oct-parse.cc"
3273  break;
3274  case 179: /* superclasses */
3275 /* Line 1393 of yacc.c */
3276 #line 320 "parse-tree/oct-parse.yy"
3277  { delete ((*yyvaluep).tree_parameter_list_type); };
3278 /* Line 1393 of yacc.c */
3279 #line 3280 "parse-tree/oct-parse.cc"
3280  break;
3281  case 180: /* class_body */
3282 /* Line 1393 of yacc.c */
3283 #line 306 "parse-tree/oct-parse.yy"
3284  { };
3285 /* Line 1393 of yacc.c */
3286 #line 3287 "parse-tree/oct-parse.cc"
3287  break;
3288  case 181: /* properties_beg */
3289 /* Line 1393 of yacc.c */
3290 #line 305 "parse-tree/oct-parse.yy"
3291  { };
3292 /* Line 1393 of yacc.c */
3293 #line 3294 "parse-tree/oct-parse.cc"
3294  break;
3295  case 182: /* properties_block */
3296 /* Line 1393 of yacc.c */
3297 #line 306 "parse-tree/oct-parse.yy"
3298  { };
3299 /* Line 1393 of yacc.c */
3300 #line 3301 "parse-tree/oct-parse.cc"
3301  break;
3302  case 183: /* properties_list */
3303 /* Line 1393 of yacc.c */
3304 #line 306 "parse-tree/oct-parse.yy"
3305  { };
3306 /* Line 1393 of yacc.c */
3307 #line 3308 "parse-tree/oct-parse.cc"
3308  break;
3309  case 184: /* class_property */
3310 /* Line 1393 of yacc.c */
3311 #line 306 "parse-tree/oct-parse.yy"
3312  { };
3313 /* Line 1393 of yacc.c */
3314 #line 3315 "parse-tree/oct-parse.cc"
3315  break;
3316  case 185: /* methods_beg */
3317 /* Line 1393 of yacc.c */
3318 #line 305 "parse-tree/oct-parse.yy"
3319  { };
3320 /* Line 1393 of yacc.c */
3321 #line 3322 "parse-tree/oct-parse.cc"
3322  break;
3323  case 186: /* methods_block */
3324 /* Line 1393 of yacc.c */
3325 #line 306 "parse-tree/oct-parse.yy"
3326  { };
3327 /* Line 1393 of yacc.c */
3328 #line 3329 "parse-tree/oct-parse.cc"
3329  break;
3330  case 187: /* methods_list */
3331 /* Line 1393 of yacc.c */
3332 #line 306 "parse-tree/oct-parse.yy"
3333  { };
3334 /* Line 1393 of yacc.c */
3335 #line 3336 "parse-tree/oct-parse.cc"
3336  break;
3337  case 188: /* events_beg */
3338 /* Line 1393 of yacc.c */
3339 #line 305 "parse-tree/oct-parse.yy"
3340  { };
3341 /* Line 1393 of yacc.c */
3342 #line 3343 "parse-tree/oct-parse.cc"
3343  break;
3344  case 189: /* events_block */
3345 /* Line 1393 of yacc.c */
3346 #line 306 "parse-tree/oct-parse.yy"
3347  { };
3348 /* Line 1393 of yacc.c */
3349 #line 3350 "parse-tree/oct-parse.cc"
3350  break;
3351  case 190: /* events_list */
3352 /* Line 1393 of yacc.c */
3353 #line 306 "parse-tree/oct-parse.yy"
3354  { };
3355 /* Line 1393 of yacc.c */
3356 #line 3357 "parse-tree/oct-parse.cc"
3357  break;
3358  case 191: /* class_event */
3359 /* Line 1393 of yacc.c */
3360 #line 306 "parse-tree/oct-parse.yy"
3361  { };
3362 /* Line 1393 of yacc.c */
3363 #line 3364 "parse-tree/oct-parse.cc"
3364  break;
3365  case 192: /* enum_beg */
3366 /* Line 1393 of yacc.c */
3367 #line 305 "parse-tree/oct-parse.yy"
3368  { };
3369 /* Line 1393 of yacc.c */
3370 #line 3371 "parse-tree/oct-parse.cc"
3371  break;
3372  case 193: /* enum_block */
3373 /* Line 1393 of yacc.c */
3374 #line 306 "parse-tree/oct-parse.yy"
3375  { };
3376 /* Line 1393 of yacc.c */
3377 #line 3378 "parse-tree/oct-parse.cc"
3378  break;
3379  case 194: /* enum_list */
3380 /* Line 1393 of yacc.c */
3381 #line 306 "parse-tree/oct-parse.yy"
3382  { };
3383 /* Line 1393 of yacc.c */
3384 #line 3385 "parse-tree/oct-parse.cc"
3385  break;
3386  case 195: /* class_enum */
3387 /* Line 1393 of yacc.c */
3388 #line 306 "parse-tree/oct-parse.yy"
3389  { };
3390 /* Line 1393 of yacc.c */
3391 #line 3392 "parse-tree/oct-parse.cc"
3392  break;
3393  case 196: /* stmt_begin */
3394 /* Line 1393 of yacc.c */
3395 #line 307 "parse-tree/oct-parse.yy"
3396  { };
3397 /* Line 1393 of yacc.c */
3398 #line 3399 "parse-tree/oct-parse.cc"
3399  break;
3400  case 197: /* stash_comment */
3401 /* Line 1393 of yacc.c */
3402 #line 305 "parse-tree/oct-parse.yy"
3403  { };
3404 /* Line 1393 of yacc.c */
3405 #line 3406 "parse-tree/oct-parse.cc"
3406  break;
3407  case 198: /* parse_error */
3408 /* Line 1393 of yacc.c */
3409 #line 307 "parse-tree/oct-parse.yy"
3410  { };
3411 /* Line 1393 of yacc.c */
3412 #line 3413 "parse-tree/oct-parse.cc"
3413  break;
3414  case 199: /* sep_no_nl */
3415 /* Line 1393 of yacc.c */
3416 #line 303 "parse-tree/oct-parse.yy"
3417  { };
3418 /* Line 1393 of yacc.c */
3419 #line 3420 "parse-tree/oct-parse.cc"
3420  break;
3421  case 200: /* opt_sep_no_nl */
3422 /* Line 1393 of yacc.c */
3423 #line 303 "parse-tree/oct-parse.yy"
3424  { };
3425 /* Line 1393 of yacc.c */
3426 #line 3427 "parse-tree/oct-parse.cc"
3427  break;
3428  case 201: /* opt_nl */
3429 /* Line 1393 of yacc.c */
3430 #line 303 "parse-tree/oct-parse.yy"
3431  { };
3432 /* Line 1393 of yacc.c */
3433 #line 3434 "parse-tree/oct-parse.cc"
3434  break;
3435  case 202: /* nl */
3436 /* Line 1393 of yacc.c */
3437 #line 303 "parse-tree/oct-parse.yy"
3438  { };
3439 /* Line 1393 of yacc.c */
3440 #line 3441 "parse-tree/oct-parse.cc"
3441  break;
3442  case 203: /* sep */
3443 /* Line 1393 of yacc.c */
3444 #line 303 "parse-tree/oct-parse.yy"
3445  { };
3446 /* Line 1393 of yacc.c */
3447 #line 3448 "parse-tree/oct-parse.cc"
3448  break;
3449  case 204: /* opt_sep */
3450 /* Line 1393 of yacc.c */
3451 #line 303 "parse-tree/oct-parse.yy"
3452  { };
3453 /* Line 1393 of yacc.c */
3454 #line 3455 "parse-tree/oct-parse.cc"
3455  break;
3456 
3457  default:
3458  break;
3459  }
3460 }
3461 
3462 
3463 
3464 struct yypstate
3465  {
3466  /* Number of syntax errors so far. */
3467  int yynerrs;
3468 
3469  int yystate;
3470  /* Number of tokens to shift before error messages enabled. */
3471  int yyerrstatus;
3472 
3473  /* The stacks and their tools:
3474  `yyss': related to states.
3475  `yyvs': related to semantic values.
3476 
3477  Refer to the stacks through separate pointers, to allow yyoverflow
3478  to reallocate them elsewhere. */
3479 
3480  /* The state stack. */
3481  yytype_int16 yyssa[YYINITDEPTH];
3482  yytype_int16 *yyss;
3483  yytype_int16 *yyssp;
3484 
3485  /* The semantic value stack. */
3486  YYSTYPE yyvsa[YYINITDEPTH];
3487  YYSTYPE *yyvs;
3488  YYSTYPE *yyvsp;
3489 
3490  YYSIZE_T yystacksize;
3491  /* Used to determine if this is the first time this instance has
3492  been used. */
3493  int yynew;
3494  };
3495 
3496 #if (defined __STDC__ || defined __C99__FUNC__ \
3497  || defined __cplusplus || defined _MSC_VER)
3498 int
3499 yyparse (octave_base_parser& parser)
3500 #else
3501 int
3502 yyparse (parser)
3503  octave_base_parser& parser;
3504 #endif
3505 {
3506  return yypull_parse (YY_NULL, parser);
3507 }
3508 
3509 #if (defined __STDC__ || defined __C99__FUNC__ \
3510  || defined __cplusplus || defined _MSC_VER)
3511 int
3512 yypull_parse (yypstate *yyps, octave_base_parser& parser)
3513 #else
3514 int
3515 yypull_parse (yyps, parser)
3516  yypstate *yyps;
3517  octave_base_parser& parser;
3518 #endif
3519 {
3520  int yystatus;
3521  yypstate *yyps_local;
3522  int yychar;
3523  YYSTYPE yylval;
3524  if (yyps)
3525  yyps_local = yyps;
3526  else
3527  {
3528  yyps_local = yypstate_new ();
3529  if (!yyps_local)
3530  {
3531  yyerror (parser, YY_("memory exhausted"));
3532  return 2;
3533  }
3534  }
3535  do {
3536  yychar = YYLEX;
3537  yystatus =
3538  yypush_parse (yyps_local, yychar, &yylval, parser);
3539  } while (yystatus == YYPUSH_MORE);
3540  if (!yyps)
3541  yypstate_delete (yyps_local);
3542  return yystatus;
3543 }
3544 
3545 /* Initialize the parser data structure. */
3546 #if (defined __STDC__ || defined __C99__FUNC__ \
3547  || defined __cplusplus || defined _MSC_VER)
3548 yypstate *
3549 yypstate_new (void)
3550 #else
3551 yypstate *
3552 yypstate_new ()
3553 
3554 #endif
3555 {
3556  yypstate *yyps;
3557  yyps = (yypstate *) malloc (sizeof *yyps);
3558  if (!yyps)
3559  return YY_NULL;
3560  yyps->yynew = 1;
3561  return yyps;
3562 }
3563 
3564 #if (defined __STDC__ || defined __C99__FUNC__ \
3565  || defined __cplusplus || defined _MSC_VER)
3566 void
3567 yypstate_delete (yypstate *yyps)
3568 #else
3569 void
3570 yypstate_delete (yyps)
3571  yypstate *yyps;
3572 #endif
3573 {
3574 #ifndef yyoverflow
3575  /* If the stack was reallocated but the parse did not complete, then the
3576  stack still needs to be freed. */
3577  if (!yyps->yynew && yyps->yyss != yyps->yyssa)
3578  YYSTACK_FREE (yyps->yyss);
3579 #endif
3580  free (yyps);
3581 }
3582 
3583 #define octave_nerrs yyps->octave_nerrs
3584 #define yystate yyps->yystate
3585 #define yyerrstatus yyps->yyerrstatus
3586 #define yyssa yyps->yyssa
3587 #define yyss yyps->yyss
3588 #define yyssp yyps->yyssp
3589 #define yyvsa yyps->yyvsa
3590 #define yyvs yyps->yyvs
3591 #define yyvsp yyps->yyvsp
3592 #define yystacksize yyps->yystacksize
3593 
3594 
3595 /*---------------.
3596 | yypush_parse. |
3597 `---------------*/
3598 
3599 #if (defined __STDC__ || defined __C99__FUNC__ \
3600  || defined __cplusplus || defined _MSC_VER)
3601 int
3602 yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val, octave_base_parser& parser)
3603 #else
3604 int
3605 yypush_parse (yyps, yypushed_char, yypushed_val, parser)
3606  yypstate *yyps;
3607  int yypushed_char;
3608  YYSTYPE const *yypushed_val;
3609  octave_base_parser& parser;
3610 #endif
3611 {
3612 /* The lookahead symbol. */
3613 int yychar;
3614 
3615 
3616 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
3617 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
3618 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
3619  _Pragma ("GCC diagnostic push") \
3620  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
3621  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
3622 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
3623  _Pragma ("GCC diagnostic pop")
3624 #else
3625 /* Default value used for initialization, for pacifying older GCCs
3626  or non-GCC compilers. */
3627 static YYSTYPE yyval_default;
3628 # define YY_INITIAL_VALUE(Value) = Value
3629 #endif
3630 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3631 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3632 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
3633 #endif
3634 #ifndef YY_INITIAL_VALUE
3635 # define YY_INITIAL_VALUE(Value) /* Nothing. */
3636 #endif
3637 
3638 /* The semantic value of the lookahead symbol. */
3639 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
3640 
3641  int yyn;
3642  int yyresult;
3643  /* Lookahead token as an internal (translated) token number. */
3644  int yytoken = 0;
3645  /* The variables used to return semantic value and location from the
3646  action routines. */
3647  YYSTYPE yyval;
3648 
3649 #if YYERROR_VERBOSE
3650  /* Buffer for error messages, and its allocated size. */
3651  char yymsgbuf[128];
3652  char *yymsg = yymsgbuf;
3653  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
3654 #endif
3655 
3656 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
3657 
3658  /* The number of symbols on the RHS of the reduced rule.
3659  Keep to zero when no symbol should be popped. */
3660  int yylen = 0;
3661 
3662  if (!yyps->yynew)
3663  {
3664  yyn = yypact[yystate];
3665  goto yyread_pushed_token;
3666  }
3667 
3668  yyssp = yyss = yyssa;
3669  yyvsp = yyvs = yyvsa;
3670  yystacksize = YYINITDEPTH;
3671 
3672  YYDPRINTF ((stderr, "Starting parse\n"));
3673 
3674  yystate = 0;
3675  yyerrstatus = 0;
3676  yynerrs = 0;
3677  yychar = YYEMPTY; /* Cause a token to be read. */
3678  goto yysetstate;
3679 
3680 /*------------------------------------------------------------.
3681 | yynewstate -- Push a new state, which is found in yystate. |
3682 `------------------------------------------------------------*/
3683  yynewstate:
3684  /* In all cases, when you get here, the value and location stacks
3685  have just been pushed. So pushing a state here evens the stacks. */
3686  yyssp++;
3687 
3688  yysetstate:
3689  *yyssp = yystate;
3690 
3691  if (yyss + yystacksize - 1 <= yyssp)
3692  {
3693  /* Get the current used size of the three stacks, in elements. */
3694  YYSIZE_T yysize = yyssp - yyss + 1;
3695 
3696 #ifdef yyoverflow
3697  {
3698  /* Give user a chance to reallocate the stack. Use copies of
3699  these so that the &'s don't force the real ones into
3700  memory. */
3701  YYSTYPE *yyvs1 = yyvs;
3702  yytype_int16 *yyss1 = yyss;
3703 
3704  /* Each stack pointer address is followed by the size of the
3705  data in use in that stack, in bytes. This used to be a
3706  conditional around just the two extra args, but that might
3707  be undefined if yyoverflow is a macro. */
3708  yyoverflow (YY_("memory exhausted"),
3709  &yyss1, yysize * sizeof (*yyssp),
3710  &yyvs1, yysize * sizeof (*yyvsp),
3711  &yystacksize);
3712 
3713  yyss = yyss1;
3714  yyvs = yyvs1;
3715  }
3716 #else /* no yyoverflow */
3717 # ifndef YYSTACK_RELOCATE
3718  goto yyexhaustedlab;
3719 # else
3720  /* Extend the stack our own way. */
3721  if (YYMAXDEPTH <= yystacksize)
3722  goto yyexhaustedlab;
3723  yystacksize *= 2;
3724  if (YYMAXDEPTH < yystacksize)
3725  yystacksize = YYMAXDEPTH;
3726 
3727  {
3728  yytype_int16 *yyss1 = yyss;
3729  union yyalloc *yyptr =
3730  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3731  if (! yyptr)
3732  goto yyexhaustedlab;
3733  YYSTACK_RELOCATE (yyss_alloc, yyss);
3734  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
3735 # undef YYSTACK_RELOCATE
3736  if (yyss1 != yyssa)
3737  YYSTACK_FREE (yyss1);
3738  }
3739 # endif
3740 #endif /* no yyoverflow */
3741 
3742  yyssp = yyss + yysize - 1;
3743  yyvsp = yyvs + yysize - 1;
3744 
3745  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3746  (unsigned long int) yystacksize));
3747 
3748  if (yyss + yystacksize - 1 <= yyssp)
3749  YYABORT;
3750  }
3751 
3752  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3753 
3754  if (yystate == YYFINAL)
3755  YYACCEPT;
3756 
3757  goto yybackup;
3758 
3759 /*-----------.
3760 | yybackup. |
3761 `-----------*/
3762 yybackup:
3763 
3764  /* Do appropriate processing given the current state. Read a
3765  lookahead token if we need one and don't already have one. */
3766 
3767  /* First try to decide what to do without reference to lookahead token. */
3768  yyn = yypact[yystate];
3769  if (yypact_value_is_default (yyn))
3770  goto yydefault;
3771 
3772  /* Not known => get a lookahead token if don't already have one. */
3773 
3774  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
3775  if (yychar == YYEMPTY)
3776  {
3777  if (!yyps->yynew)
3778  {
3779  YYDPRINTF ((stderr, "Return for a new token:\n"));
3780  yyresult = YYPUSH_MORE;
3781  goto yypushreturn;
3782  }
3783  yyps->yynew = 0;
3784 yyread_pushed_token:
3785  YYDPRINTF ((stderr, "Reading a token: "));
3786  yychar = yypushed_char;
3787  if (yypushed_val)
3788  yylval = *yypushed_val;
3789  }
3790 
3791  if (yychar <= YYEOF)
3792  {
3793  yychar = yytoken = YYEOF;
3794  YYDPRINTF ((stderr, "Now at end of input.\n"));
3795  }
3796  else
3797  {
3798  yytoken = YYTRANSLATE (yychar);
3799  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3800  }
3801 
3802  /* If the proper action on seeing token YYTOKEN is to reduce or to
3803  detect an error, take that action. */
3804  yyn += yytoken;
3805  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3806  goto yydefault;
3807  yyn = yytable[yyn];
3808  if (yyn <= 0)
3809  {
3810  if (yytable_value_is_error (yyn))
3811  goto yyerrlab;
3812  yyn = -yyn;
3813  goto yyreduce;
3814  }
3815 
3816  /* Count tokens shifted since error; after three, turn off error
3817  status. */
3818  if (yyerrstatus)
3819  yyerrstatus--;
3820 
3821  /* Shift the lookahead token. */
3822  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3823 
3824  /* Discard the shifted token. */
3825  yychar = YYEMPTY;
3826 
3827  yystate = yyn;
3828  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3829  *++yyvsp = yylval;
3830  YY_IGNORE_MAYBE_UNINITIALIZED_END
3831 
3832  goto yynewstate;
3833 
3834 
3835 /*-----------------------------------------------------------.
3836 | yydefault -- do the default action for the current state. |
3837 `-----------------------------------------------------------*/
3838 yydefault:
3839  yyn = yydefact[yystate];
3840  if (yyn == 0)
3841  goto yyerrlab;
3842  goto yyreduce;
3843 
3844 
3845 /*-----------------------------.
3846 | yyreduce -- Do a reduction. |
3847 `-----------------------------*/
3848 yyreduce:
3849  /* yyn is the number of a rule to reduce with. */
3850  yylen = yyr2[yyn];
3851 
3852  /* If YYLEN is nonzero, implement the default value of the action:
3853  `$$ = $1'.
3854 
3855  Otherwise, the following line sets YYVAL to garbage.
3856  This behavior is undocumented and Bison
3857  users should not rely upon it. Assigning to YYVAL
3858  unconditionally makes the parser a bit smaller, and it avoids a
3859  GCC warning that YYVAL may be used uninitialized. */
3860  yyval = yyvsp[1-yylen];
3861 
3862 
3863  YY_REDUCE_PRINT (yyn);
3864  switch (yyn)
3865  {
3866  case 2:
3867 /* Line 1787 of yacc.c */
3868 #line 351 "parse-tree/oct-parse.yy"
3869  {
3870  parser.stmt_list = (yyvsp[(1) - (2)].tree_statement_list_type);
3871  YYACCEPT;
3872  }
3873  break;
3874 
3875  case 3:
3876 /* Line 1787 of yacc.c */
3877 #line 356 "parse-tree/oct-parse.yy"
3878  {
3879  lexer.end_of_input = true;
3880  parser.stmt_list = (yyvsp[(1) - (2)].tree_statement_list_type);
3881  YYACCEPT;
3882  }
3883  break;
3884 
3885  case 4:
3886 /* Line 1787 of yacc.c */
3887 #line 362 "parse-tree/oct-parse.yy"
3888  { ABORT_PARSE; }
3889  break;
3890 
3891  case 5:
3892 /* Line 1787 of yacc.c */
3893 #line 366 "parse-tree/oct-parse.yy"
3894  { (yyval.tree_statement_list_type) = 0; }
3895  break;
3896 
3897  case 6:
3898 /* Line 1787 of yacc.c */
3899 #line 368 "parse-tree/oct-parse.yy"
3900  { (yyval.tree_statement_list_type) = parser.set_stmt_print_flag ((yyvsp[(1) - (2)].tree_statement_list_type), (yyvsp[(2) - (2)].sep_type), false); }
3901  break;
3902 
3903  case 7:
3904 /* Line 1787 of yacc.c */
3905 #line 372 "parse-tree/oct-parse.yy"
3906  { (yyval.tree_statement_list_type) = parser.make_statement_list ((yyvsp[(1) - (1)].tree_statement_type)); }
3907  break;
3908 
3909  case 8:
3910 /* Line 1787 of yacc.c */
3911 #line 374 "parse-tree/oct-parse.yy"
3912  { (yyval.tree_statement_list_type) = parser.append_statement_list ((yyvsp[(1) - (3)].tree_statement_list_type), (yyvsp[(2) - (3)].sep_type), (yyvsp[(3) - (3)].tree_statement_type), false); }
3913  break;
3914 
3915  case 9:
3916 /* Line 1787 of yacc.c */
3917 #line 378 "parse-tree/oct-parse.yy"
3918  { (yyval.tree_statement_list_type) = new tree_statement_list (); }
3919  break;
3920 
3921  case 10:
3922 /* Line 1787 of yacc.c */
3923 #line 380 "parse-tree/oct-parse.yy"
3924  { (yyval.tree_statement_list_type) = (yyvsp[(1) - (1)].tree_statement_list_type); }
3925  break;
3926 
3927  case 11:
3928 /* Line 1787 of yacc.c */
3929 #line 384 "parse-tree/oct-parse.yy"
3930  { (yyval.tree_statement_list_type) = parser.set_stmt_print_flag ((yyvsp[(1) - (2)].tree_statement_list_type), (yyvsp[(2) - (2)].sep_type), true); }
3931  break;
3932 
3933  case 12:
3934 /* Line 1787 of yacc.c */
3935 #line 388 "parse-tree/oct-parse.yy"
3936  { (yyval.tree_statement_list_type) = parser.make_statement_list ((yyvsp[(1) - (1)].tree_statement_type)); }
3937  break;
3938 
3939  case 13:
3940 /* Line 1787 of yacc.c */
3941 #line 390 "parse-tree/oct-parse.yy"
3942  { (yyval.tree_statement_list_type) = parser.append_statement_list ((yyvsp[(1) - (3)].tree_statement_list_type), (yyvsp[(2) - (3)].sep_type), (yyvsp[(3) - (3)].tree_statement_type), true); }
3943  break;
3944 
3945  case 14:
3946 /* Line 1787 of yacc.c */
3947 #line 394 "parse-tree/oct-parse.yy"
3948  { (yyval.tree_statement_type) = parser.make_statement ((yyvsp[(1) - (1)].tree_expression_type)); }
3949  break;
3950 
3951  case 15:
3952 /* Line 1787 of yacc.c */
3953 #line 396 "parse-tree/oct-parse.yy"
3954  { (yyval.tree_statement_type) = parser.make_statement ((yyvsp[(1) - (1)].tree_command_type)); }
3955  break;
3956 
3957  case 16:
3958 /* Line 1787 of yacc.c */
3959 #line 398 "parse-tree/oct-parse.yy"
3960  { (yyval.tree_statement_type) = parser.make_statement ((yyvsp[(1) - (1)].tree_index_expression_type)); }
3961  break;
3962 
3963  case 17:
3964 /* Line 1787 of yacc.c */
3965 #line 410 "parse-tree/oct-parse.yy"
3966  {
3967  (yyval.tree_index_expression_type) = parser.make_index_expression ((yyvsp[(1) - (2)].tree_identifier_type), (yyvsp[(2) - (2)].tree_argument_list_type), '(');
3968  if (! (yyval.tree_index_expression_type))
3969  {
3970  // make_index_expression deleted $1 and $2.
3971  ABORT_PARSE;
3972  }
3973  }
3974  break;
3975 
3976  case 18:
3977 /* Line 1787 of yacc.c */
3978 #line 421 "parse-tree/oct-parse.yy"
3979  { (yyval.tree_argument_list_type) = new tree_argument_list ((yyvsp[(1) - (1)].tree_constant_type)); }
3980  break;
3981 
3982  case 19:
3983 /* Line 1787 of yacc.c */
3984 #line 423 "parse-tree/oct-parse.yy"
3985  {
3986  (yyvsp[(1) - (2)].tree_argument_list_type)->append ((yyvsp[(2) - (2)].tree_constant_type));
3987  (yyval.tree_argument_list_type) = (yyvsp[(1) - (2)].tree_argument_list_type);
3988  }
3989  break;
3990 
3991  case 20:
3992 /* Line 1787 of yacc.c */
3993 #line 434 "parse-tree/oct-parse.yy"
3994  {
3995  symbol_table::symbol_record *sr = (yyvsp[(1) - (1)].tok_val)->sym_rec ();
3996  (yyval.tree_identifier_type) = new tree_identifier (*sr, (yyvsp[(1) - (1)].tok_val)->line (), (yyvsp[(1) - (1)].tok_val)->column ());
3997  }
3998  break;
3999 
4000  case 21:
4001 /* Line 1787 of yacc.c */
4002 #line 442 "parse-tree/oct-parse.yy"
4003  { (yyval.tree_identifier_type) = new tree_identifier ((yyvsp[(1) - (1)].tok_val)->line (), (yyvsp[(1) - (1)].tok_val)->column ()); }
4004  break;
4005 
4006  case 22:
4007 /* Line 1787 of yacc.c */
4008 #line 446 "parse-tree/oct-parse.yy"
4009  { (yyval.tree_identifier_type) = new tree_identifier ((yyvsp[(1) - (1)].tok_val)->line (), (yyvsp[(1) - (1)].tok_val)->column ()); }
4010  break;
4011 
4012  case 23:
4013 /* Line 1787 of yacc.c */
4014 #line 450 "parse-tree/oct-parse.yy"
4015  { (yyval.tree_constant_type) = parser.make_constant (DQ_STRING, (yyvsp[(1) - (1)].tok_val)); }
4016  break;
4017 
4018  case 24:
4019 /* Line 1787 of yacc.c */
4020 #line 452 "parse-tree/oct-parse.yy"
4021  { (yyval.tree_constant_type) = parser.make_constant (SQ_STRING, (yyvsp[(1) - (1)].tok_val)); }
4022  break;
4023 
4024  case 25:
4025 /* Line 1787 of yacc.c */
4026 #line 456 "parse-tree/oct-parse.yy"
4027  { (yyval.tree_constant_type) = parser.make_constant (NUM, (yyvsp[(1) - (1)].tok_val)); }
4028  break;
4029 
4030  case 26:
4031 /* Line 1787 of yacc.c */
4032 #line 458 "parse-tree/oct-parse.yy"
4033  { (yyval.tree_constant_type) = parser.make_constant (IMAG_NUM, (yyvsp[(1) - (1)].tok_val)); }
4034  break;
4035 
4036  case 27:
4037 /* Line 1787 of yacc.c */
4038 #line 460 "parse-tree/oct-parse.yy"
4039  { (yyval.tree_constant_type) = (yyvsp[(1) - (1)].tree_constant_type); }
4040  break;
4041 
4042  case 28:
4043 /* Line 1787 of yacc.c */
4044 #line 464 "parse-tree/oct-parse.yy"
4045  { (yyval.tree_expression_type) = parser.finish_matrix ((yyvsp[(2) - (3)].tree_matrix_type)); }
4046  break;
4047 
4048  case 29:
4049 /* Line 1787 of yacc.c */
4050 #line 468 "parse-tree/oct-parse.yy"
4051  { (yyval.tree_matrix_type) = (yyvsp[(1) - (1)].tree_argument_list_type) ? new tree_matrix ((yyvsp[(1) - (1)].tree_argument_list_type)) : 0; }
4052  break;
4053 
4054  case 30:
4055 /* Line 1787 of yacc.c */
4056 #line 470 "parse-tree/oct-parse.yy"
4057  {
4058  if ((yyvsp[(1) - (3)].tree_matrix_type))
4059  {
4060  if ((yyvsp[(3) - (3)].tree_argument_list_type))
4061  (yyvsp[(1) - (3)].tree_matrix_type)->append ((yyvsp[(3) - (3)].tree_argument_list_type));
4062 
4063  (yyval.tree_matrix_type) = (yyvsp[(1) - (3)].tree_matrix_type);
4064  }
4065  else
4066  (yyval.tree_matrix_type) = (yyvsp[(3) - (3)].tree_argument_list_type) ? new tree_matrix ((yyvsp[(3) - (3)].tree_argument_list_type)) : 0;
4067  }
4068  break;
4069 
4070  case 31:
4071 /* Line 1787 of yacc.c */
4072 #line 484 "parse-tree/oct-parse.yy"
4073  { (yyval.tree_expression_type) = parser.finish_cell ((yyvsp[(2) - (3)].tree_cell_type)); }
4074  break;
4075 
4076  case 32:
4077 /* Line 1787 of yacc.c */
4078 #line 488 "parse-tree/oct-parse.yy"
4079  { (yyval.tree_cell_type) = (yyvsp[(1) - (1)].tree_argument_list_type) ? new tree_cell ((yyvsp[(1) - (1)].tree_argument_list_type)) : 0; }
4080  break;
4081 
4082  case 33:
4083 /* Line 1787 of yacc.c */
4084 #line 490 "parse-tree/oct-parse.yy"
4085  {
4086  if ((yyvsp[(1) - (3)].tree_cell_type))
4087  {
4088  if ((yyvsp[(3) - (3)].tree_argument_list_type))
4089  (yyvsp[(1) - (3)].tree_cell_type)->append ((yyvsp[(3) - (3)].tree_argument_list_type));
4090 
4091  (yyval.tree_cell_type) = (yyvsp[(1) - (3)].tree_cell_type);
4092  }
4093  else
4094  (yyval.tree_cell_type) = (yyvsp[(3) - (3)].tree_argument_list_type) ? new tree_cell ((yyvsp[(3) - (3)].tree_argument_list_type)) : 0;
4095  }
4096  break;
4097 
4098  case 34:
4099 /* Line 1787 of yacc.c */
4100 #line 508 "parse-tree/oct-parse.yy"
4101  { (yyval.tree_argument_list_type) = 0; }
4102  break;
4103 
4104  case 35:
4105 /* Line 1787 of yacc.c */
4106 #line 510 "parse-tree/oct-parse.yy"
4107  { (yyval.tree_argument_list_type) = 0; }
4108  break;
4109 
4110  case 36:
4111 /* Line 1787 of yacc.c */
4112 #line 512 "parse-tree/oct-parse.yy"
4113  { (yyval.tree_argument_list_type) = (yyvsp[(1) - (1)].tree_argument_list_type); }
4114  break;
4115 
4116  case 37:
4117 /* Line 1787 of yacc.c */
4118 #line 514 "parse-tree/oct-parse.yy"
4119  { (yyval.tree_argument_list_type) = (yyvsp[(1) - (2)].tree_argument_list_type); }
4120  break;
4121 
4122  case 38:
4123 /* Line 1787 of yacc.c */
4124 #line 516 "parse-tree/oct-parse.yy"
4125  { (yyval.tree_argument_list_type) = (yyvsp[(2) - (2)].tree_argument_list_type); }
4126  break;
4127 
4128  case 39:
4129 /* Line 1787 of yacc.c */
4130 #line 518 "parse-tree/oct-parse.yy"
4131  { (yyval.tree_argument_list_type) = (yyvsp[(2) - (3)].tree_argument_list_type); }
4132  break;
4133 
4134  case 40:
4135 /* Line 1787 of yacc.c */
4136 #line 522 "parse-tree/oct-parse.yy"
4137  {
4138  (yyval.tree_fcn_handle_type) = parser.make_fcn_handle ((yyvsp[(2) - (2)].tok_val));
4139  lexer.looking_at_function_handle--;
4140  }
4141  break;
4142 
4143  case 41:
4144 /* Line 1787 of yacc.c */
4145 #line 529 "parse-tree/oct-parse.yy"
4146  {
4147  (yyval.tree_anon_fcn_handle_type) = parser.make_anon_fcn_handle ((yyvsp[(2) - (4)].tree_parameter_list_type), (yyvsp[(4) - (4)].tree_statement_type));
4148  lexer.nesting_level.remove ();
4149  }
4150  break;
4151 
4152  case 42:
4153 /* Line 1787 of yacc.c */
4154 #line 536 "parse-tree/oct-parse.yy"
4155  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_identifier_type); }
4156  break;
4157 
4158  case 43:
4159 /* Line 1787 of yacc.c */
4160 #line 538 "parse-tree/oct-parse.yy"
4161  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_constant_type); }
4162  break;
4163 
4164  case 44:
4165 /* Line 1787 of yacc.c */
4166 #line 540 "parse-tree/oct-parse.yy"
4167  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_fcn_handle_type); }
4168  break;
4169 
4170  case 45:
4171 /* Line 1787 of yacc.c */
4172 #line 542 "parse-tree/oct-parse.yy"
4173  {
4174  lexer.looking_at_matrix_or_assign_lhs = false;
4175  (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type);
4176  }
4177  break;
4178 
4179  case 46:
4180 /* Line 1787 of yacc.c */
4181 #line 547 "parse-tree/oct-parse.yy"
4182  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type); }
4183  break;
4184 
4185  case 47:
4186 /* Line 1787 of yacc.c */
4187 #line 549 "parse-tree/oct-parse.yy"
4188  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_identifier_type); }
4189  break;
4190 
4191  case 48:
4192 /* Line 1787 of yacc.c */
4193 #line 551 "parse-tree/oct-parse.yy"
4194  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_identifier_type); }
4195  break;
4196 
4197  case 49:
4198 /* Line 1787 of yacc.c */
4199 #line 553 "parse-tree/oct-parse.yy"
4200  { (yyval.tree_expression_type) = (yyvsp[(2) - (3)].tree_expression_type)->mark_in_parens (); }
4201  break;
4202 
4203  case 50:
4204 /* Line 1787 of yacc.c */
4205 #line 557 "parse-tree/oct-parse.yy"
4206  {
4207  octave_value tmp (octave_value::magic_colon_t);
4208  (yyval.tree_constant_type) = new tree_constant (tmp);
4209  }
4210  break;
4211 
4212  case 51:
4213 /* Line 1787 of yacc.c */
4214 #line 564 "parse-tree/oct-parse.yy"
4215  {
4216  (yyval.tree_identifier_type) = new tree_black_hole ();
4217  }
4218  break;
4219 
4220  case 52:
4221 /* Line 1787 of yacc.c */
4222 #line 570 "parse-tree/oct-parse.yy"
4223  { (yyval.tree_argument_list_type) = new tree_argument_list ((yyvsp[(1) - (1)].tree_expression_type)); }
4224  break;
4225 
4226  case 53:
4227 /* Line 1787 of yacc.c */
4228 #line 572 "parse-tree/oct-parse.yy"
4229  { (yyval.tree_argument_list_type) = new tree_argument_list ((yyvsp[(1) - (1)].tree_constant_type)); }
4230  break;
4231 
4232  case 54:
4233 /* Line 1787 of yacc.c */
4234 #line 574 "parse-tree/oct-parse.yy"
4235  { (yyval.tree_argument_list_type) = new tree_argument_list ((yyvsp[(1) - (1)].tree_identifier_type)); }
4236  break;
4237 
4238  case 55:
4239 /* Line 1787 of yacc.c */
4240 #line 576 "parse-tree/oct-parse.yy"
4241  {
4242  (yyvsp[(1) - (3)].tree_argument_list_type)->append ((yyvsp[(3) - (3)].tree_constant_type));
4243  (yyval.tree_argument_list_type) = (yyvsp[(1) - (3)].tree_argument_list_type);
4244  }
4245  break;
4246 
4247  case 56:
4248 /* Line 1787 of yacc.c */
4249 #line 581 "parse-tree/oct-parse.yy"
4250  {
4251  (yyvsp[(1) - (3)].tree_argument_list_type)->append ((yyvsp[(3) - (3)].tree_identifier_type));
4252  (yyval.tree_argument_list_type) = (yyvsp[(1) - (3)].tree_argument_list_type);
4253  }
4254  break;
4255 
4256  case 57:
4257 /* Line 1787 of yacc.c */
4258 #line 586 "parse-tree/oct-parse.yy"
4259  {
4260  (yyvsp[(1) - (3)].tree_argument_list_type)->append ((yyvsp[(3) - (3)].tree_expression_type));
4261  (yyval.tree_argument_list_type) = (yyvsp[(1) - (3)].tree_argument_list_type);
4262  }
4263  break;
4264 
4265  case 58:
4266 /* Line 1787 of yacc.c */
4267 #line 593 "parse-tree/oct-parse.yy"
4268  { lexer.looking_at_indirect_ref = true; }
4269  break;
4270 
4271  case 59:
4272 /* Line 1787 of yacc.c */
4273 #line 597 "parse-tree/oct-parse.yy"
4274  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type); }
4275  break;
4276 
4277  case 60:
4278 /* Line 1787 of yacc.c */
4279 #line 599 "parse-tree/oct-parse.yy"
4280  { (yyval.tree_expression_type) = parser.make_postfix_op (PLUS_PLUS, (yyvsp[(1) - (2)].tree_expression_type), (yyvsp[(2) - (2)].tok_val)); }
4281  break;
4282 
4283  case 61:
4284 /* Line 1787 of yacc.c */
4285 #line 601 "parse-tree/oct-parse.yy"
4286  { (yyval.tree_expression_type) = parser.make_postfix_op (MINUS_MINUS, (yyvsp[(1) - (2)].tree_expression_type), (yyvsp[(2) - (2)].tok_val)); }
4287  break;
4288 
4289  case 62:
4290 /* Line 1787 of yacc.c */
4291 #line 603 "parse-tree/oct-parse.yy"
4292  {
4293  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (3)].tree_expression_type), 0, '(');
4294  if (! (yyval.tree_expression_type))
4295  {
4296  // make_index_expression deleted $1.
4297  ABORT_PARSE;
4298  }
4299  }
4300  break;
4301 
4302  case 63:
4303 /* Line 1787 of yacc.c */
4304 #line 612 "parse-tree/oct-parse.yy"
4305  {
4306  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (4)].tree_expression_type), (yyvsp[(3) - (4)].tree_argument_list_type), '(');
4307  if (! (yyval.tree_expression_type))
4308  {
4309  // make_index_expression deleted $1 and $3.
4310  ABORT_PARSE;
4311  }
4312  }
4313  break;
4314 
4315  case 64:
4316 /* Line 1787 of yacc.c */
4317 #line 621 "parse-tree/oct-parse.yy"
4318  {
4319  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (3)].tree_expression_type), 0, '{');
4320  if (! (yyval.tree_expression_type))
4321  {
4322  // make_index_expression deleted $1.
4323  ABORT_PARSE;
4324  }
4325  }
4326  break;
4327 
4328  case 65:
4329 /* Line 1787 of yacc.c */
4330 #line 630 "parse-tree/oct-parse.yy"
4331  {
4332  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (4)].tree_expression_type), (yyvsp[(3) - (4)].tree_argument_list_type), '{');
4333  if (! (yyval.tree_expression_type))
4334  {
4335  // make_index_expression deleted $1 and $3.
4336  ABORT_PARSE;
4337  }
4338  }
4339  break;
4340 
4341  case 66:
4342 /* Line 1787 of yacc.c */
4343 #line 639 "parse-tree/oct-parse.yy"
4344  { (yyval.tree_expression_type) = parser.make_postfix_op (HERMITIAN, (yyvsp[(1) - (2)].tree_expression_type), (yyvsp[(2) - (2)].tok_val)); }
4345  break;
4346 
4347  case 67:
4348 /* Line 1787 of yacc.c */
4349 #line 641 "parse-tree/oct-parse.yy"
4350  { (yyval.tree_expression_type) = parser.make_postfix_op (TRANSPOSE, (yyvsp[(1) - (2)].tree_expression_type), (yyvsp[(2) - (2)].tok_val)); }
4351  break;
4352 
4353  case 68:
4354 /* Line 1787 of yacc.c */
4355 #line 643 "parse-tree/oct-parse.yy"
4356  { (yyval.tree_expression_type) = parser.make_indirect_ref ((yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(3) - (3)].tok_val)->text ()); }
4357  break;
4358 
4359  case 69:
4360 /* Line 1787 of yacc.c */
4361 #line 645 "parse-tree/oct-parse.yy"
4362  { (yyval.tree_expression_type) = parser.make_indirect_ref ((yyvsp[(1) - (5)].tree_expression_type), (yyvsp[(4) - (5)].tree_expression_type)); }
4363  break;
4364 
4365  case 70:
4366 /* Line 1787 of yacc.c */
4367 #line 647 "parse-tree/oct-parse.yy"
4368  { (yyval.tree_expression_type) = parser.make_prefix_op (PLUS_PLUS, (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4369  break;
4370 
4371  case 71:
4372 /* Line 1787 of yacc.c */
4373 #line 649 "parse-tree/oct-parse.yy"
4374  { (yyval.tree_expression_type) = parser.make_prefix_op (MINUS_MINUS, (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4375  break;
4376 
4377  case 72:
4378 /* Line 1787 of yacc.c */
4379 #line 651 "parse-tree/oct-parse.yy"
4380  { (yyval.tree_expression_type) = parser.make_prefix_op (EXPR_NOT, (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4381  break;
4382 
4383  case 73:
4384 /* Line 1787 of yacc.c */
4385 #line 653 "parse-tree/oct-parse.yy"
4386  { (yyval.tree_expression_type) = parser.make_prefix_op ('+', (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4387  break;
4388 
4389  case 74:
4390 /* Line 1787 of yacc.c */
4391 #line 655 "parse-tree/oct-parse.yy"
4392  { (yyval.tree_expression_type) = parser.make_prefix_op ('-', (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4393  break;
4394 
4395  case 75:
4396 /* Line 1787 of yacc.c */
4397 #line 657 "parse-tree/oct-parse.yy"
4398  { (yyval.tree_expression_type) = parser.make_binary_op (POW, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4399  break;
4400 
4401  case 76:
4402 /* Line 1787 of yacc.c */
4403 #line 659 "parse-tree/oct-parse.yy"
4404  { (yyval.tree_expression_type) = parser.make_binary_op (EPOW, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4405  break;
4406 
4407  case 77:
4408 /* Line 1787 of yacc.c */
4409 #line 661 "parse-tree/oct-parse.yy"
4410  { (yyval.tree_expression_type) = parser.make_binary_op ('+', (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4411  break;
4412 
4413  case 78:
4414 /* Line 1787 of yacc.c */
4415 #line 663 "parse-tree/oct-parse.yy"
4416  { (yyval.tree_expression_type) = parser.make_binary_op ('-', (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4417  break;
4418 
4419  case 79:
4420 /* Line 1787 of yacc.c */
4421 #line 665 "parse-tree/oct-parse.yy"
4422  { (yyval.tree_expression_type) = parser.make_binary_op ('*', (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4423  break;
4424 
4425  case 80:
4426 /* Line 1787 of yacc.c */
4427 #line 667 "parse-tree/oct-parse.yy"
4428  { (yyval.tree_expression_type) = parser.make_binary_op ('/', (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4429  break;
4430 
4431  case 81:
4432 /* Line 1787 of yacc.c */
4433 #line 669 "parse-tree/oct-parse.yy"
4434  { (yyval.tree_expression_type) = parser.make_binary_op ('+', (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4435  break;
4436 
4437  case 82:
4438 /* Line 1787 of yacc.c */
4439 #line 671 "parse-tree/oct-parse.yy"
4440  { (yyval.tree_expression_type) = parser.make_binary_op ('-', (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4441  break;
4442 
4443  case 83:
4444 /* Line 1787 of yacc.c */
4445 #line 673 "parse-tree/oct-parse.yy"
4446  { (yyval.tree_expression_type) = parser.make_binary_op (EMUL, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4447  break;
4448 
4449  case 84:
4450 /* Line 1787 of yacc.c */
4451 #line 675 "parse-tree/oct-parse.yy"
4452  { (yyval.tree_expression_type) = parser.make_binary_op (EDIV, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4453  break;
4454 
4455  case 85:
4456 /* Line 1787 of yacc.c */
4457 #line 677 "parse-tree/oct-parse.yy"
4458  { (yyval.tree_expression_type) = parser.make_binary_op (LEFTDIV, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4459  break;
4460 
4461  case 86:
4462 /* Line 1787 of yacc.c */
4463 #line 679 "parse-tree/oct-parse.yy"
4464  { (yyval.tree_expression_type) = parser.make_binary_op (ELEFTDIV, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4465  break;
4466 
4467  case 87:
4468 /* Line 1787 of yacc.c */
4469 #line 683 "parse-tree/oct-parse.yy"
4470  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type); }
4471  break;
4472 
4473  case 88:
4474 /* Line 1787 of yacc.c */
4475 #line 685 "parse-tree/oct-parse.yy"
4476  { (yyval.tree_expression_type) = parser.make_postfix_op (PLUS_PLUS, (yyvsp[(1) - (2)].tree_expression_type), (yyvsp[(2) - (2)].tok_val)); }
4477  break;
4478 
4479  case 89:
4480 /* Line 1787 of yacc.c */
4481 #line 687 "parse-tree/oct-parse.yy"
4482  { (yyval.tree_expression_type) = parser.make_postfix_op (MINUS_MINUS, (yyvsp[(1) - (2)].tree_expression_type), (yyvsp[(2) - (2)].tok_val)); }
4483  break;
4484 
4485  case 90:
4486 /* Line 1787 of yacc.c */
4487 #line 689 "parse-tree/oct-parse.yy"
4488  {
4489  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (3)].tree_expression_type), 0, '(');
4490  if (! (yyval.tree_expression_type))
4491  {
4492  // make_index_expression deleted $1.
4493  ABORT_PARSE;
4494  }
4495  }
4496  break;
4497 
4498  case 91:
4499 /* Line 1787 of yacc.c */
4500 #line 698 "parse-tree/oct-parse.yy"
4501  {
4502  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (4)].tree_expression_type), (yyvsp[(3) - (4)].tree_argument_list_type), '(');
4503  if (! (yyval.tree_expression_type))
4504  {
4505  // make_index_expression deleted $1 and $3.
4506  ABORT_PARSE;
4507  }
4508  }
4509  break;
4510 
4511  case 92:
4512 /* Line 1787 of yacc.c */
4513 #line 707 "parse-tree/oct-parse.yy"
4514  {
4515  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (3)].tree_expression_type), 0, '{');
4516  if (! (yyval.tree_expression_type))
4517  {
4518  // make_index_expression deleted $1.
4519  ABORT_PARSE;
4520  }
4521  }
4522  break;
4523 
4524  case 93:
4525 /* Line 1787 of yacc.c */
4526 #line 716 "parse-tree/oct-parse.yy"
4527  {
4528  (yyval.tree_expression_type) = parser.make_index_expression ((yyvsp[(1) - (4)].tree_expression_type), (yyvsp[(3) - (4)].tree_argument_list_type), '{');
4529  if (! (yyval.tree_expression_type))
4530  {
4531  // make_index_expression deleted $1 and $3.
4532  ABORT_PARSE;
4533  }
4534  }
4535  break;
4536 
4537  case 94:
4538 /* Line 1787 of yacc.c */
4539 #line 725 "parse-tree/oct-parse.yy"
4540  { (yyval.tree_expression_type) = parser.make_indirect_ref ((yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(3) - (3)].tok_val)->text ()); }
4541  break;
4542 
4543  case 95:
4544 /* Line 1787 of yacc.c */
4545 #line 727 "parse-tree/oct-parse.yy"
4546  { (yyval.tree_expression_type) = parser.make_indirect_ref ((yyvsp[(1) - (5)].tree_expression_type), (yyvsp[(4) - (5)].tree_expression_type)); }
4547  break;
4548 
4549  case 96:
4550 /* Line 1787 of yacc.c */
4551 #line 729 "parse-tree/oct-parse.yy"
4552  { (yyval.tree_expression_type) = parser.make_prefix_op (PLUS_PLUS, (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4553  break;
4554 
4555  case 97:
4556 /* Line 1787 of yacc.c */
4557 #line 731 "parse-tree/oct-parse.yy"
4558  { (yyval.tree_expression_type) = parser.make_prefix_op (MINUS_MINUS, (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4559  break;
4560 
4561  case 98:
4562 /* Line 1787 of yacc.c */
4563 #line 733 "parse-tree/oct-parse.yy"
4564  { (yyval.tree_expression_type) = parser.make_prefix_op (EXPR_NOT, (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4565  break;
4566 
4567  case 99:
4568 /* Line 1787 of yacc.c */
4569 #line 735 "parse-tree/oct-parse.yy"
4570  { (yyval.tree_expression_type) = parser.make_prefix_op ('+', (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4571  break;
4572 
4573  case 100:
4574 /* Line 1787 of yacc.c */
4575 #line 737 "parse-tree/oct-parse.yy"
4576  { (yyval.tree_expression_type) = parser.make_prefix_op ('-', (yyvsp[(2) - (2)].tree_expression_type), (yyvsp[(1) - (2)].tok_val)); }
4577  break;
4578 
4579  case 101:
4580 /* Line 1787 of yacc.c */
4581 #line 741 "parse-tree/oct-parse.yy"
4582  { (yyval.tree_expression_type) = parser.finish_colon_expression ((yyvsp[(1) - (1)].tree_colon_expression_type)); }
4583  break;
4584 
4585  case 102:
4586 /* Line 1787 of yacc.c */
4587 #line 745 "parse-tree/oct-parse.yy"
4588  { (yyval.tree_colon_expression_type) = new tree_colon_expression ((yyvsp[(1) - (1)].tree_expression_type)); }
4589  break;
4590 
4591  case 103:
4592 /* Line 1787 of yacc.c */
4593 #line 747 "parse-tree/oct-parse.yy"
4594  {
4595  if (! ((yyval.tree_colon_expression_type) = (yyvsp[(1) - (3)].tree_colon_expression_type)->append ((yyvsp[(3) - (3)].tree_expression_type))))
4596  {
4597  delete (yyvsp[(1) - (3)].tree_colon_expression_type);
4598  delete (yyvsp[(3) - (3)].tree_expression_type);
4599  ABORT_PARSE;
4600  }
4601  }
4602  break;
4603 
4604  case 104:
4605 /* Line 1787 of yacc.c */
4606 #line 758 "parse-tree/oct-parse.yy"
4607  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type); }
4608  break;
4609 
4610  case 105:
4611 /* Line 1787 of yacc.c */
4612 #line 760 "parse-tree/oct-parse.yy"
4613  { (yyval.tree_expression_type) = parser.make_binary_op (LSHIFT, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4614  break;
4615 
4616  case 106:
4617 /* Line 1787 of yacc.c */
4618 #line 762 "parse-tree/oct-parse.yy"
4619  { (yyval.tree_expression_type) = parser.make_binary_op (RSHIFT, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4620  break;
4621 
4622  case 107:
4623 /* Line 1787 of yacc.c */
4624 #line 764 "parse-tree/oct-parse.yy"
4625  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_LT, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4626  break;
4627 
4628  case 108:
4629 /* Line 1787 of yacc.c */
4630 #line 766 "parse-tree/oct-parse.yy"
4631  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_LE, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4632  break;
4633 
4634  case 109:
4635 /* Line 1787 of yacc.c */
4636 #line 768 "parse-tree/oct-parse.yy"
4637  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_EQ, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4638  break;
4639 
4640  case 110:
4641 /* Line 1787 of yacc.c */
4642 #line 770 "parse-tree/oct-parse.yy"
4643  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_GE, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4644  break;
4645 
4646  case 111:
4647 /* Line 1787 of yacc.c */
4648 #line 772 "parse-tree/oct-parse.yy"
4649  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_GT, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4650  break;
4651 
4652  case 112:
4653 /* Line 1787 of yacc.c */
4654 #line 774 "parse-tree/oct-parse.yy"
4655  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_NE, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4656  break;
4657 
4658  case 113:
4659 /* Line 1787 of yacc.c */
4660 #line 776 "parse-tree/oct-parse.yy"
4661  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_AND, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4662  break;
4663 
4664  case 114:
4665 /* Line 1787 of yacc.c */
4666 #line 778 "parse-tree/oct-parse.yy"
4667  { (yyval.tree_expression_type) = parser.make_binary_op (EXPR_OR, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4668  break;
4669 
4670  case 115:
4671 /* Line 1787 of yacc.c */
4672 #line 780 "parse-tree/oct-parse.yy"
4673  { (yyval.tree_expression_type) = parser.make_boolean_op (EXPR_AND_AND, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4674  break;
4675 
4676  case 116:
4677 /* Line 1787 of yacc.c */
4678 #line 782 "parse-tree/oct-parse.yy"
4679  { (yyval.tree_expression_type) = parser.make_boolean_op (EXPR_OR_OR, (yyvsp[(1) - (3)].tree_expression_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4680  break;
4681 
4682  case 117:
4683 /* Line 1787 of yacc.c */
4684 #line 786 "parse-tree/oct-parse.yy"
4685  {
4686  (yyval.tree_argument_list_type) = parser.validate_matrix_for_assignment ((yyvsp[(1) - (1)].tree_expression_type));
4687 
4688  if ((yyval.tree_argument_list_type))
4689  { lexer.looking_at_matrix_or_assign_lhs = false; }
4690  else
4691  {
4692  // validate_matrix_for_assignment deleted $1.
4693  ABORT_PARSE;
4694  }
4695  }
4696  break;
4697 
4698  case 118:
4699 /* Line 1787 of yacc.c */
4700 #line 800 "parse-tree/oct-parse.yy"
4701  { (yyval.tree_expression_type) = parser.make_assign_op ('=', (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4702  break;
4703 
4704  case 119:
4705 /* Line 1787 of yacc.c */
4706 #line 802 "parse-tree/oct-parse.yy"
4707  { (yyval.tree_expression_type) = parser.make_assign_op (ADD_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4708  break;
4709 
4710  case 120:
4711 /* Line 1787 of yacc.c */
4712 #line 804 "parse-tree/oct-parse.yy"
4713  { (yyval.tree_expression_type) = parser.make_assign_op (SUB_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4714  break;
4715 
4716  case 121:
4717 /* Line 1787 of yacc.c */
4718 #line 806 "parse-tree/oct-parse.yy"
4719  { (yyval.tree_expression_type) = parser.make_assign_op (MUL_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4720  break;
4721 
4722  case 122:
4723 /* Line 1787 of yacc.c */
4724 #line 808 "parse-tree/oct-parse.yy"
4725  { (yyval.tree_expression_type) = parser.make_assign_op (DIV_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4726  break;
4727 
4728  case 123:
4729 /* Line 1787 of yacc.c */
4730 #line 810 "parse-tree/oct-parse.yy"
4731  { (yyval.tree_expression_type) = parser.make_assign_op (LEFTDIV_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4732  break;
4733 
4734  case 124:
4735 /* Line 1787 of yacc.c */
4736 #line 812 "parse-tree/oct-parse.yy"
4737  { (yyval.tree_expression_type) = parser.make_assign_op (POW_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4738  break;
4739 
4740  case 125:
4741 /* Line 1787 of yacc.c */
4742 #line 814 "parse-tree/oct-parse.yy"
4743  { (yyval.tree_expression_type) = parser.make_assign_op (LSHIFT_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4744  break;
4745 
4746  case 126:
4747 /* Line 1787 of yacc.c */
4748 #line 816 "parse-tree/oct-parse.yy"
4749  { (yyval.tree_expression_type) = parser.make_assign_op (RSHIFT_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4750  break;
4751 
4752  case 127:
4753 /* Line 1787 of yacc.c */
4754 #line 818 "parse-tree/oct-parse.yy"
4755  { (yyval.tree_expression_type) = parser.make_assign_op (EMUL_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4756  break;
4757 
4758  case 128:
4759 /* Line 1787 of yacc.c */
4760 #line 820 "parse-tree/oct-parse.yy"
4761  { (yyval.tree_expression_type) = parser.make_assign_op (EDIV_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4762  break;
4763 
4764  case 129:
4765 /* Line 1787 of yacc.c */
4766 #line 822 "parse-tree/oct-parse.yy"
4767  { (yyval.tree_expression_type) = parser.make_assign_op (ELEFTDIV_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4768  break;
4769 
4770  case 130:
4771 /* Line 1787 of yacc.c */
4772 #line 824 "parse-tree/oct-parse.yy"
4773  { (yyval.tree_expression_type) = parser.make_assign_op (EPOW_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4774  break;
4775 
4776  case 131:
4777 /* Line 1787 of yacc.c */
4778 #line 826 "parse-tree/oct-parse.yy"
4779  { (yyval.tree_expression_type) = parser.make_assign_op (AND_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4780  break;
4781 
4782  case 132:
4783 /* Line 1787 of yacc.c */
4784 #line 828 "parse-tree/oct-parse.yy"
4785  { (yyval.tree_expression_type) = parser.make_assign_op (OR_EQ, (yyvsp[(1) - (3)].tree_argument_list_type), (yyvsp[(2) - (3)].tok_val), (yyvsp[(3) - (3)].tree_expression_type)); }
4786  break;
4787 
4788  case 133:
4789 /* Line 1787 of yacc.c */
4790 #line 832 "parse-tree/oct-parse.yy"
4791  {
4792  if ((yyvsp[(1) - (1)].tree_expression_type) && ((yyvsp[(1) - (1)].tree_expression_type)->is_matrix () || (yyvsp[(1) - (1)].tree_expression_type)->is_cell ()))
4793  {
4794  if (parser.validate_array_list ((yyvsp[(1) - (1)].tree_expression_type)))
4795  (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type);
4796  else
4797  {
4798  delete (yyvsp[(1) - (1)].tree_expression_type);
4799  ABORT_PARSE;
4800  }
4801  }
4802  else
4803  (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type);
4804  }
4805  break;
4806 
4807  case 134:
4808 /* Line 1787 of yacc.c */
4809 #line 847 "parse-tree/oct-parse.yy"
4810  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_expression_type); }
4811  break;
4812 
4813  case 135:
4814 /* Line 1787 of yacc.c */
4815 #line 849 "parse-tree/oct-parse.yy"
4816  { (yyval.tree_expression_type) = (yyvsp[(1) - (1)].tree_anon_fcn_handle_type); }
4817  break;
4818 
4819  case 136:
4820 /* Line 1787 of yacc.c */
4821 #line 857 "parse-tree/oct-parse.yy"
4822  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_decl_command_type); }
4823  break;
4824 
4825  case 137:
4826 /* Line 1787 of yacc.c */
4827 #line 859 "parse-tree/oct-parse.yy"
4828  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_command_type); }
4829  break;
4830 
4831  case 138:
4832 /* Line 1787 of yacc.c */
4833 #line 861 "parse-tree/oct-parse.yy"
4834  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_command_type); }
4835  break;
4836 
4837  case 139:
4838 /* Line 1787 of yacc.c */
4839 #line 863 "parse-tree/oct-parse.yy"
4840  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_command_type); }
4841  break;
4842 
4843  case 140:
4844 /* Line 1787 of yacc.c */
4845 #line 865 "parse-tree/oct-parse.yy"
4846  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_command_type); }
4847  break;
4848 
4849  case 141:
4850 /* Line 1787 of yacc.c */
4851 #line 867 "parse-tree/oct-parse.yy"
4852  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_command_type); }
4853  break;
4854 
4855  case 142:
4856 /* Line 1787 of yacc.c */
4857 #line 869 "parse-tree/oct-parse.yy"
4858  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_command_type); }
4859  break;
4860 
4861  case 143:
4862 /* Line 1787 of yacc.c */
4863 #line 871 "parse-tree/oct-parse.yy"
4864  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_command_type); }
4865  break;
4866 
4867  case 144:
4868 /* Line 1787 of yacc.c */
4869 #line 879 "parse-tree/oct-parse.yy"
4870  {
4871  (yyval.tree_decl_command_type) = parser.make_decl_command (GLOBAL, (yyvsp[(1) - (2)].tok_val), (yyvsp[(2) - (2)].tree_decl_init_list_type));
4872  lexer.looking_at_decl_list = false;
4873  }
4874  break;
4875 
4876  case 145:
4877 /* Line 1787 of yacc.c */
4878 #line 884 "parse-tree/oct-parse.yy"
4879  {
4880  (yyval.tree_decl_command_type) = parser.make_decl_command (PERSISTENT, (yyvsp[(1) - (2)].tok_val), (yyvsp[(2) - (2)].tree_decl_init_list_type));
4881  lexer.looking_at_decl_list = false;
4882  }
4883  break;
4884 
4885  case 146:
4886 /* Line 1787 of yacc.c */
4887 #line 891 "parse-tree/oct-parse.yy"
4888  { (yyval.tree_decl_init_list_type) = new tree_decl_init_list ((yyvsp[(1) - (1)].tree_decl_elt_type)); }
4889  break;
4890 
4891  case 147:
4892 /* Line 1787 of yacc.c */
4893 #line 893 "parse-tree/oct-parse.yy"
4894  {
4895  (yyvsp[(1) - (2)].tree_decl_init_list_type)->append ((yyvsp[(2) - (2)].tree_decl_elt_type));
4896  (yyval.tree_decl_init_list_type) = (yyvsp[(1) - (2)].tree_decl_init_list_type);
4897  }
4898  break;
4899 
4900  case 148:
4901 /* Line 1787 of yacc.c */
4902 #line 900 "parse-tree/oct-parse.yy"
4903  { lexer.looking_at_initializer_expression = true; }
4904  break;
4905 
4906  case 149:
4907 /* Line 1787 of yacc.c */
4908 #line 903 "parse-tree/oct-parse.yy"
4909  { (yyval.tree_decl_elt_type) = new tree_decl_elt ((yyvsp[(1) - (1)].tree_identifier_type)); }
4910  break;
4911 
4912  case 150:
4913 /* Line 1787 of yacc.c */
4914 #line 905 "parse-tree/oct-parse.yy"
4915  {
4916  lexer.looking_at_initializer_expression = false;
4917  (yyval.tree_decl_elt_type) = new tree_decl_elt ((yyvsp[(1) - (4)].tree_identifier_type), (yyvsp[(4) - (4)].tree_expression_type));
4918  }
4919  break;
4920 
4921  case 151:
4922 /* Line 1787 of yacc.c */
4923 #line 916 "parse-tree/oct-parse.yy"
4924  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_if_command_type); }
4925  break;
4926 
4927  case 152:
4928 /* Line 1787 of yacc.c */
4929 #line 918 "parse-tree/oct-parse.yy"
4930  { (yyval.tree_command_type) = (yyvsp[(1) - (1)].tree_switch_command_type); }
4931  break;
4932 
4933  case 153:
4934 /* Line 1787 of yacc.c */
4935 #line 926 "parse-tree/oct-parse.yy"
4936  {
4937  if (! ((yyval.tree_if_command_type) = parser.finish_if_command ((yyvsp[(1) - (4)].tok_val), (yyvsp[(3) - (4)].tree_if_command_list_type), (yyvsp[(4) - (4)].tok_val), (yyvsp[(2) - (4)].comment_type))))
4938  {
4939  // finish_if_command deleted $3.
4940  ABORT_PARSE;
4941  }
4942  }
4943  break;
4944 
4945  case 154:
4946 /* Line 1787 of yacc.c */
4947 #line 936 "parse-tree/oct-parse.yy"
4948  { (yyval.tree_if_command_list_type) = (yyvsp[(1) - (1)].tree_if_command_list_type); }
4949  break;
4950 
4951  case 155:
4952 /* Line 1787 of yacc.c */
4953 #line 938 "parse-tree/oct-parse.yy"
4954  {
4955  (yyvsp[(1) - (2)].tree_if_command_list_type)->append ((yyvsp[(2) - (2)].tree_if_clause_type));
4956  (yyval.tree_if_command_list_type) = (yyvsp[(1) - (2)].tree_if_command_list_type);
4957  }
4958  break;
4959 
4960  case 156:
4961 /* Line 1787 of yacc.c */
4962 #line 945 "parse-tree/oct-parse.yy"
4963  {
4964  (yyvsp[(1) - (4)].tree_expression_type)->mark_braindead_shortcircuit (lexer.fcn_file_full_name);
4965 
4966  (yyval.tree_if_command_list_type) = parser.start_if_command ((yyvsp[(1) - (4)].tree_expression_type), (yyvsp[(4) - (4)].tree_statement_list_type));
4967  }
4968  break;
4969 
4970  case 157:
4971 /* Line 1787 of yacc.c */
4972 #line 951 "parse-tree/oct-parse.yy"
4973  {
4974  (yyvsp[(1) - (2)].tree_if_command_list_type)->append ((yyvsp[(2) - (2)].tree_if_clause_type));
4975  (yyval.tree_if_command_list_type) = (yyvsp[(1) - (2)].tree_if_command_list_type);
4976  }
4977  break;
4978 
4979  case 158:
4980 /* Line 1787 of yacc.c */
4981 #line 958 "parse-tree/oct-parse.yy"
4982  {
4983  (yyvsp[(4) - (7)].tree_expression_type)->mark_braindead_shortcircuit (lexer.fcn_file_full_name);
4984 
4985  (yyval.tree_if_clause_type) = parser.make_elseif_clause ((yyvsp[(1) - (7)].tok_val), (yyvsp[(4) - (7)].tree_expression_type), (yyvsp[(7) - (7)].tree_statement_list_type), (yyvsp[(2) - (7)].comment_type));
4986  }
4987  break;
4988 
4989  case 159:
4990 /* Line 1787 of yacc.c */
4991 #line 966 "parse-tree/oct-parse.yy"
4992  { (yyval.tree_if_clause_type) = new tree_if_clause ((yyvsp[(4) - (4)].tree_statement_list_type), (yyvsp[(2) - (4)].comment_type)); }
4993  break;
4994 
4995  case 160:
4996 /* Line 1787 of yacc.c */
4997 #line 974 "parse-tree/oct-parse.yy"
4998  {
4999  if (! ((yyval.tree_switch_command_type) = parser.finish_switch_command ((yyvsp[(1) - (6)].tok_val), (yyvsp[(3) - (6)].tree_expression_type), (yyvsp[(5) - (6)].tree_switch_case_list_type), (yyvsp[(6) - (6)].tok_val), (yyvsp[(2) - (6)].comment_type))))
5000  {
5001  // finish_switch_command deleted $3 adn $5.
5002  ABORT_PARSE;
5003  }
5004  }
5005  break;
5006 
5007  case 161:
5008 /* Line 1787 of yacc.c */
5009 #line 984 "parse-tree/oct-parse.yy"
5010  { (yyval.tree_switch_case_list_type) = new tree_switch_case_list (); }
5011  break;
5012 
5013  case 162:
5014 /* Line 1787 of yacc.c */
5015 #line 986 "parse-tree/oct-parse.yy"
5016  { (yyval.tree_switch_case_list_type) = new tree_switch_case_list ((yyvsp[(1) - (1)].tree_switch_case_type)); }
5017  break;
5018 
5019  case 163:
5020 /* Line 1787 of yacc.c */
5021 #line 988 "parse-tree/oct-parse.yy"
5022  { (yyval.tree_switch_case_list_type) = (yyvsp[(1) - (1)].tree_switch_case_list_type); }
5023  break;
5024 
5025  case 164:
5026 /* Line 1787 of yacc.c */
5027 #line 990 "parse-tree/oct-parse.yy"
5028  {
5029  (yyvsp[(1) - (2)].tree_switch_case_list_type)->append ((yyvsp[(2) - (2)].tree_switch_case_type));
5030  (yyval.tree_switch_case_list_type) = (yyvsp[(1) - (2)].tree_switch_case_list_type);
5031  }
5032  break;
5033 
5034  case 165:
5035 /* Line 1787 of yacc.c */
5036 #line 997 "parse-tree/oct-parse.yy"
5037  { (yyval.tree_switch_case_list_type) = new tree_switch_case_list ((yyvsp[(1) - (1)].tree_switch_case_type)); }
5038  break;
5039 
5040  case 166:
5041 /* Line 1787 of yacc.c */
5042 #line 999 "parse-tree/oct-parse.yy"
5043  {
5044  (yyvsp[(1) - (2)].tree_switch_case_list_type)->append ((yyvsp[(2) - (2)].tree_switch_case_type));
5045  (yyval.tree_switch_case_list_type) = (yyvsp[(1) - (2)].tree_switch_case_list_type);
5046  }
5047  break;
5048 
5049  case 167:
5050 /* Line 1787 of yacc.c */
5051 #line 1006 "parse-tree/oct-parse.yy"
5052  { (yyval.tree_switch_case_type) = parser.make_switch_case ((yyvsp[(1) - (7)].tok_val), (yyvsp[(4) - (7)].tree_expression_type), (yyvsp[(7) - (7)].tree_statement_list_type), (yyvsp[(2) - (7)].comment_type)); }
5053  break;
5054 
5055  case 168:
5056 /* Line 1787 of yacc.c */
5057 #line 1010 "parse-tree/oct-parse.yy"
5058  {
5059  (yyval.tree_switch_case_type) = new tree_switch_case ((yyvsp[(4) - (4)].tree_statement_list_type), (yyvsp[(2) - (4)].comment_type));
5060  }
5061  break;
5062 
5063  case 169:
5064 /* Line 1787 of yacc.c */
5065 #line 1020 "parse-tree/oct-parse.yy"
5066  {
5067  (yyvsp[(3) - (7)].tree_expression_type)->mark_braindead_shortcircuit (lexer.fcn_file_full_name);
5068 
5069  if (! ((yyval.tree_command_type) = parser.make_while_command ((yyvsp[(1) - (7)].tok_val), (yyvsp[(3) - (7)].tree_expression_type), (yyvsp[(6) - (7)].tree_statement_list_type), (yyvsp[(7) - (7)].tok_val), (yyvsp[(2) - (7)].comment_type))))
5070  {
5071  // make_while_command deleted $3 and $6.
5072  ABORT_PARSE;
5073  }
5074  }
5075  break;
5076 
5077  case 170:
5078 /* Line 1787 of yacc.c */
5079 #line 1030 "parse-tree/oct-parse.yy"
5080  {
5081  (yyval.tree_command_type) = parser.make_do_until_command ((yyvsp[(5) - (6)].tok_val), (yyvsp[(4) - (6)].tree_statement_list_type), (yyvsp[(6) - (6)].tree_expression_type), (yyvsp[(2) - (6)].comment_type));
5082  }
5083  break;
5084 
5085  case 171:
5086 /* Line 1787 of yacc.c */
5087 #line 1034 "parse-tree/oct-parse.yy"
5088  {
5089  if (! ((yyval.tree_command_type) = parser.make_for_command (FOR, (yyvsp[(1) - (9)].tok_val), (yyvsp[(3) - (9)].tree_argument_list_type), (yyvsp[(5) - (9)].tree_expression_type), 0,
5090  (yyvsp[(8) - (9)].tree_statement_list_type), (yyvsp[(9) - (9)].tok_val), (yyvsp[(2) - (9)].comment_type))))
5091  {
5092  // make_for_command deleted $3, $5, and $8.
5093  ABORT_PARSE;
5094  }
5095  }
5096  break;
5097 
5098  case 172:
5099 /* Line 1787 of yacc.c */
5100 #line 1043 "parse-tree/oct-parse.yy"
5101  {
5102  if (! ((yyval.tree_command_type) = parser.make_for_command (FOR, (yyvsp[(1) - (10)].tok_val), (yyvsp[(4) - (10)].tree_argument_list_type), (yyvsp[(6) - (10)].tree_expression_type), 0,
5103  (yyvsp[(9) - (10)].tree_statement_list_type), (yyvsp[(10) - (10)].tok_val), (yyvsp[(2) - (10)].comment_type))))
5104  {
5105  // make_for_command deleted $4, $6, and $9.
5106  ABORT_PARSE;
5107  }
5108  }
5109  break;
5110 
5111  case 173:
5112 /* Line 1787 of yacc.c */
5113 #line 1052 "parse-tree/oct-parse.yy"
5114  {
5115  if (! ((yyval.tree_command_type) = parser.make_for_command (PARFOR, (yyvsp[(1) - (9)].tok_val), (yyvsp[(3) - (9)].tree_argument_list_type), (yyvsp[(5) - (9)].tree_expression_type),
5116  0, (yyvsp[(8) - (9)].tree_statement_list_type), (yyvsp[(9) - (9)].tok_val), (yyvsp[(2) - (9)].comment_type))))
5117  {
5118  // make_for_command deleted $3, $5, and $8.
5119  ABORT_PARSE;
5120  }
5121  }
5122  break;
5123 
5124  case 174:
5125 /* Line 1787 of yacc.c */
5126 #line 1061 "parse-tree/oct-parse.yy"
5127  {
5128  if (! ((yyval.tree_command_type) = parser.make_for_command (PARFOR, (yyvsp[(1) - (12)].tok_val), (yyvsp[(4) - (12)].tree_argument_list_type), (yyvsp[(6) - (12)].tree_expression_type),
5129  (yyvsp[(8) - (12)].tree_expression_type), (yyvsp[(11) - (12)].tree_statement_list_type), (yyvsp[(12) - (12)].tok_val), (yyvsp[(2) - (12)].comment_type))))
5130  {
5131  // make_for_command deleted $4, $6, $8, and $11.
5132  ABORT_PARSE;
5133  }
5134  }
5135  break;
5136 
5137  case 175:
5138 /* Line 1787 of yacc.c */
5139 #line 1076 "parse-tree/oct-parse.yy"
5140  { (yyval.tree_command_type) = parser.make_break_command ((yyvsp[(1) - (1)].tok_val)); }
5141  break;
5142 
5143  case 176:
5144 /* Line 1787 of yacc.c */
5145 #line 1078 "parse-tree/oct-parse.yy"
5146  { (yyval.tree_command_type) = parser.make_continue_command ((yyvsp[(1) - (1)].tok_val)); }
5147  break;
5148 
5149  case 177:
5150 /* Line 1787 of yacc.c */
5151 #line 1080 "parse-tree/oct-parse.yy"
5152  { (yyval.tree_command_type) = parser.make_return_command ((yyvsp[(1) - (1)].tok_val)); }
5153  break;
5154 
5155  case 178:
5156 /* Line 1787 of yacc.c */
5157 #line 1089 "parse-tree/oct-parse.yy"
5158  {
5159  if (! ((yyval.tree_command_type) = parser.make_unwind_command ((yyvsp[(1) - (9)].tok_val), (yyvsp[(4) - (9)].tree_statement_list_type), (yyvsp[(8) - (9)].tree_statement_list_type), (yyvsp[(9) - (9)].tok_val), (yyvsp[(2) - (9)].comment_type), (yyvsp[(6) - (9)].comment_type))))
5160  {
5161  // make_unwind_command deleted $4 and $8.
5162  ABORT_PARSE;
5163  }
5164  }
5165  break;
5166 
5167  case 179:
5168 /* Line 1787 of yacc.c */
5169 #line 1098 "parse-tree/oct-parse.yy"
5170  {
5171  if (! ((yyval.tree_command_type) = parser.make_try_command ((yyvsp[(1) - (9)].tok_val), (yyvsp[(4) - (9)].tree_statement_list_type), (yyvsp[(7) - (9)].sep_type), (yyvsp[(8) - (9)].tree_statement_list_type), (yyvsp[(9) - (9)].tok_val), (yyvsp[(2) - (9)].comment_type), (yyvsp[(6) - (9)].comment_type))))
5172  {
5173  // make_try_command deleted $4 and $8.
5174  ABORT_PARSE;
5175  }
5176  }
5177  break;
5178 
5179  case 180:
5180 /* Line 1787 of yacc.c */
5181 #line 1106 "parse-tree/oct-parse.yy"
5182  {
5183  if (! ((yyval.tree_command_type) = parser.make_try_command ((yyvsp[(1) - (5)].tok_val), (yyvsp[(4) - (5)].tree_statement_list_type), 0, 0, (yyvsp[(5) - (5)].tok_val), (yyvsp[(2) - (5)].comment_type), 0)))
5184  {
5185  // make_try_command deleted $4.
5186  ABORT_PARSE;
5187  }
5188  }
5189  break;
5190 
5191  case 181:
5192 /* Line 1787 of yacc.c */
5193 #line 1120 "parse-tree/oct-parse.yy"
5194  {
5195  parser.curr_fcn_depth++;
5196 
5197  if (parser.max_fcn_depth < parser.curr_fcn_depth)
5198  parser.max_fcn_depth = parser.curr_fcn_depth;
5199 
5200  lexer.symtab_context.push (symbol_table::alloc_scope ());
5201 
5202  parser.function_scopes.push_back
5203  (lexer.symtab_context.curr_scope ());
5204 
5205  if (! lexer.reading_script_file
5206  && parser.curr_fcn_depth == 1
5207  && ! parser.parsing_subfunctions)
5208  parser.primary_fcn_scope
5209  = lexer.symtab_context.curr_scope ();
5210 
5211  if (lexer.reading_script_file
5212  && parser.curr_fcn_depth > 1)
5213  parser.bison_error ("nested functions not implemented in this context");
5214  }
5215  break;
5216 
5217  case 182:
5218 /* Line 1787 of yacc.c */
5219 #line 1148 "parse-tree/oct-parse.yy"
5220  {
5221  lexer.looking_at_parameter_list = true;
5222 
5223  if (lexer.looking_at_function_handle)
5224  {
5225  lexer.symtab_context.push (symbol_table::alloc_scope ());
5226  lexer.looking_at_function_handle--;
5227  lexer.looking_at_anon_fcn_args = true;
5228  }
5229  }
5230  break;
5231 
5232  case 183:
5233 /* Line 1787 of yacc.c */
5234 #line 1161 "parse-tree/oct-parse.yy"
5235  {
5236  lexer.looking_at_parameter_list = false;
5237  lexer.looking_for_object_index = false;
5238  }
5239  break;
5240 
5241  case 184:
5242 /* Line 1787 of yacc.c */
5243 #line 1168 "parse-tree/oct-parse.yy"
5244  {
5245  if ((yyvsp[(2) - (3)].tree_parameter_list_type))
5246  lexer.mark_as_variables ((yyvsp[(2) - (3)].tree_parameter_list_type)->variable_names ());
5247 
5248  (yyval.tree_parameter_list_type) = (yyvsp[(2) - (3)].tree_parameter_list_type);
5249  }
5250  break;
5251 
5252  case 185:
5253 /* Line 1787 of yacc.c */
5254 #line 1175 "parse-tree/oct-parse.yy"
5255  {
5256  parser.bison_error ("invalid parameter list");
5257  (yyval.tree_parameter_list_type) = 0;
5258  ABORT_PARSE;
5259  }
5260  break;
5261 
5262  case 186:
5263 /* Line 1787 of yacc.c */
5264 #line 1183 "parse-tree/oct-parse.yy"
5265  { (yyval.tree_parameter_list_type) = 0; }
5266  break;
5267 
5268  case 187:
5269 /* Line 1787 of yacc.c */
5270 #line 1185 "parse-tree/oct-parse.yy"
5271  {
5272  (yyvsp[(1) - (1)].tree_parameter_list_type)->mark_as_formal_parameters ();
5273  if ((yyvsp[(1) - (1)].tree_parameter_list_type)->validate (tree_parameter_list::in))
5274  {
5275  lexer.mark_as_variables ((yyvsp[(1) - (1)].tree_parameter_list_type)->variable_names ());
5276  (yyval.tree_parameter_list_type) = (yyvsp[(1) - (1)].tree_parameter_list_type);
5277  }
5278  else
5279  {
5280  delete (yyvsp[(1) - (1)].tree_parameter_list_type);
5281  ABORT_PARSE;
5282  }
5283  }
5284  break;
5285 
5286  case 188:
5287 /* Line 1787 of yacc.c */
5288 #line 1201 "parse-tree/oct-parse.yy"
5289  { (yyval.tree_parameter_list_type) = new tree_parameter_list ((yyvsp[(1) - (1)].tree_decl_elt_type)); }
5290  break;
5291 
5292  case 189:
5293 /* Line 1787 of yacc.c */
5294 #line 1203 "parse-tree/oct-parse.yy"
5295  {
5296  (yyvsp[(1) - (3)].tree_parameter_list_type)->append ((yyvsp[(3) - (3)].tree_decl_elt_type));
5297  (yyval.tree_parameter_list_type) = (yyvsp[(1) - (3)].tree_parameter_list_type);
5298  }
5299  break;
5300 
5301  case 190:
5302 /* Line 1787 of yacc.c */
5303 #line 1210 "parse-tree/oct-parse.yy"
5304  { (yyval.tree_decl_elt_type) = (yyvsp[(1) - (1)].tree_decl_elt_type); }
5305  break;
5306 
5307  case 191:
5308 /* Line 1787 of yacc.c */
5309 #line 1212 "parse-tree/oct-parse.yy"
5310  { (yyval.tree_decl_elt_type) = new tree_decl_elt ((yyvsp[(1) - (1)].tree_identifier_type)); }
5311  break;
5312 
5313  case 192:
5314 /* Line 1787 of yacc.c */
5315 #line 1220 "parse-tree/oct-parse.yy"
5316  {
5317  lexer.looking_at_return_list = false;
5318 
5319  (yyval.tree_parameter_list_type) = new tree_parameter_list ();
5320  }
5321  break;
5322 
5323  case 193:
5324 /* Line 1787 of yacc.c */
5325 #line 1226 "parse-tree/oct-parse.yy"
5326  {
5327  lexer.looking_at_return_list = false;
5328 
5329  tree_parameter_list *tmp = new tree_parameter_list ((yyvsp[(1) - (1)].tree_identifier_type));
5330 
5331  // Even though this parameter list can contain only
5332  // a single identifier, we still need to validate it
5333  // to check for varargin or varargout.
5334 
5335  if (tmp->validate (tree_parameter_list::out))
5336  (yyval.tree_parameter_list_type) = tmp;
5337  else
5338  {
5339  delete tmp;
5340  ABORT_PARSE;
5341  }
5342  }
5343  break;
5344 
5345  case 194:
5346 /* Line 1787 of yacc.c */
5347 #line 1244 "parse-tree/oct-parse.yy"
5348  {
5349  lexer.looking_at_return_list = false;
5350 
5351  // Check for duplicate parameter names, varargin,
5352  // or varargout.
5353 
5354  if ((yyvsp[(2) - (3)].tree_parameter_list_type)->validate (tree_parameter_list::out))
5355  (yyval.tree_parameter_list_type) = (yyvsp[(2) - (3)].tree_parameter_list_type);
5356  else
5357  {
5358  delete (yyvsp[(2) - (3)].tree_parameter_list_type);
5359  ABORT_PARSE;
5360  }
5361  }
5362  break;
5363 
5364  case 195:
5365 /* Line 1787 of yacc.c */
5366 #line 1261 "parse-tree/oct-parse.yy"
5367  { (yyval.tree_parameter_list_type) = new tree_parameter_list (new tree_decl_elt ((yyvsp[(1) - (1)].tree_identifier_type))); }
5368  break;
5369 
5370  case 196:
5371 /* Line 1787 of yacc.c */
5372 #line 1263 "parse-tree/oct-parse.yy"
5373  {
5374  (yyvsp[(1) - (3)].tree_parameter_list_type)->append (new tree_decl_elt ((yyvsp[(3) - (3)].tree_identifier_type)));
5375  (yyval.tree_parameter_list_type) = (yyvsp[(1) - (3)].tree_parameter_list_type);
5376  }
5377  break;
5378 
5379  case 197:
5380 /* Line 1787 of yacc.c */
5381 #line 1274 "parse-tree/oct-parse.yy"
5382  {
5383  if (lexer.reading_fcn_file)
5384  {
5385  // Delete the dummy statement_list we created
5386  // after parsing the function. Any function
5387  // definitions found in the file have already
5388  // been stored in the symbol table or in
5389  // octave_base_parser::primary_fcn_ptr.
5390 
5391  delete (yyvsp[(3) - (4)].tree_statement_list_type);
5392  }
5393  else
5394  {
5395  tree_statement *end_of_script
5396  = parser.make_end ("endscript", true,
5397  lexer.input_line_number,
5398  lexer.current_input_column);
5399 
5400  parser.make_script ((yyvsp[(3) - (4)].tree_statement_list_type), end_of_script);
5401  }
5402 
5403  (yyval.tree_command_type) = 0;
5404  }
5405  break;
5406 
5407  case 198:
5408 /* Line 1787 of yacc.c */
5409 #line 1304 "parse-tree/oct-parse.yy"
5410  {
5411  (yyval.tok_val) = (yyvsp[(2) - (2)].tok_val);
5412  if (lexer.reading_classdef_file
5413  || lexer.parsing_classdef)
5414  lexer.maybe_classdef_get_set_method = true;
5415  }
5416  break;
5417 
5418  case 199:
5419 /* Line 1787 of yacc.c */
5420 #line 1313 "parse-tree/oct-parse.yy"
5421  {
5422  (yyval.tree_command_type) = parser.finish_function (0, (yyvsp[(3) - (3)].octave_user_function_type), (yyvsp[(2) - (3)].comment_type), (yyvsp[(1) - (3)].tok_val)->line (),
5423  (yyvsp[(1) - (3)].tok_val)->column ());
5424  parser.recover_from_parsing_function ();
5425  }
5426  break;
5427 
5428  case 200:
5429 /* Line 1787 of yacc.c */
5430 #line 1319 "parse-tree/oct-parse.yy"
5431  {
5432  (yyval.tree_command_type) = parser.finish_function ((yyvsp[(3) - (5)].tree_parameter_list_type), (yyvsp[(5) - (5)].octave_user_function_type), (yyvsp[(2) - (5)].comment_type), (yyvsp[(1) - (5)].tok_val)->line (),
5433  (yyvsp[(1) - (5)].tok_val)->column ());
5434  parser.recover_from_parsing_function ();
5435  }
5436  break;
5437 
5438  case 201:
5439 /* Line 1787 of yacc.c */
5440 #line 1327 "parse-tree/oct-parse.yy"
5441  {
5442  std::string id_name = (yyvsp[(1) - (1)].tree_identifier_type)->name ();
5443 
5444  lexer.parsed_function_name.top () = true;
5445  lexer.maybe_classdef_get_set_method = false;
5446 
5447  (yyval.tree_identifier_type) = (yyvsp[(1) - (1)].tree_identifier_type);
5448  }
5449  break;
5450 
5451  case 202:
5452 /* Line 1787 of yacc.c */
5453 #line 1336 "parse-tree/oct-parse.yy"
5454  {
5455  lexer.parsed_function_name.top () = true;
5456  lexer.maybe_classdef_get_set_method = false;
5457  (yyval.tree_identifier_type) = (yyvsp[(3) - (3)].tree_identifier_type);
5458  }
5459  break;
5460 
5461  case 203:
5462 /* Line 1787 of yacc.c */
5463 #line 1342 "parse-tree/oct-parse.yy"
5464  {
5465  lexer.parsed_function_name.top () = true;
5466  lexer.maybe_classdef_get_set_method = false;
5467  (yyval.tree_identifier_type) = (yyvsp[(3) - (3)].tree_identifier_type);
5468  }
5469  break;
5470 
5471  case 204:
5472 /* Line 1787 of yacc.c */
5473 #line 1350 "parse-tree/oct-parse.yy"
5474  {
5475  std::string fname = (yyvsp[(1) - (2)].tree_identifier_type)->name ();
5476 
5477  delete (yyvsp[(1) - (2)].tree_identifier_type);
5478 
5479  (yyval.octave_user_function_type) = parser.frob_function (fname, (yyvsp[(2) - (2)].octave_user_function_type));
5480  }
5481  break;
5482 
5483  case 205:
5484 /* Line 1787 of yacc.c */
5485 #line 1360 "parse-tree/oct-parse.yy"
5486  { (yyval.octave_user_function_type) = parser.start_function ((yyvsp[(1) - (4)].tree_parameter_list_type), (yyvsp[(3) - (4)].tree_statement_list_type), (yyvsp[(4) - (4)].tree_statement_type)); }
5487  break;
5488 
5489  case 206:
5490 /* Line 1787 of yacc.c */
5491 #line 1362 "parse-tree/oct-parse.yy"
5492  { (yyval.octave_user_function_type) = parser.start_function (0, (yyvsp[(2) - (3)].tree_statement_list_type), (yyvsp[(3) - (3)].tree_statement_type)); }
5493  break;
5494 
5495  case 207:
5496 /* Line 1787 of yacc.c */
5497 #line 1366 "parse-tree/oct-parse.yy"
5498  {
5499  parser.endfunction_found = true;
5500  if (parser.end_token_ok ((yyvsp[(1) - (1)].tok_val), token::function_end))
5501  (yyval.tree_statement_type) = parser.make_end ("endfunction", false,
5502  (yyvsp[(1) - (1)].tok_val)->line (), (yyvsp[(1) - (1)].tok_val)->column ());
5503  else
5504  ABORT_PARSE;
5505  }
5506  break;
5507 
5508  case 208:
5509 /* Line 1787 of yacc.c */
5510 #line 1375 "parse-tree/oct-parse.yy"
5511  {
5512 // A lot of tests are based on the assumption that this is OK
5513 // if (lexer.reading_script_file)
5514 // {
5515 // parser.bison_error ("function body open at end of script");
5516 // YYABORT;
5517 // }
5518 
5519  if (parser.endfunction_found)
5520  {
5521  parser.bison_error ("inconsistent function endings -- "
5522  "if one function is explicitly ended, "
5523  "so must all the others");
5524  YYABORT;
5525  }
5526 
5527  if (! (lexer.reading_fcn_file || lexer.reading_script_file
5528  || lexer.input_from_eval_string ()))
5529  {
5530  parser.bison_error ("function body open at end of input");
5531  YYABORT;
5532  }
5533 
5534  if (lexer.reading_classdef_file)
5535  {
5536  parser.bison_error ("classdef body open at end of input");
5537  YYABORT;
5538  }
5539 
5540  (yyval.tree_statement_type) = parser.make_end ("endfunction", true,
5541  lexer.input_line_number,
5542  lexer.current_input_column);
5543  }
5544  break;
5545 
5546  case 209:
5547 /* Line 1787 of yacc.c */
5548 #line 1415 "parse-tree/oct-parse.yy"
5549  {
5550  (yyval.comment_type) = 0;
5551  lexer.parsing_classdef = true;
5552  }
5553  break;
5554 
5555  case 210:
5556 /* Line 1787 of yacc.c */
5557 #line 1422 "parse-tree/oct-parse.yy"
5558  {
5559  lexer.parsing_classdef = false;
5560 
5561  if (parser.end_token_ok ((yyvsp[(1) - (1)].tok_val), token::classdef_end))
5562  (yyval.tree_statement_type) = parser.make_end ("endclassdef", false,
5563  (yyvsp[(1) - (1)].tok_val)->line (), (yyvsp[(1) - (1)].tok_val)->column ());
5564  else
5565  ABORT_PARSE;
5566  }
5567  break;
5568 
5569  case 211:
5570 /* Line 1787 of yacc.c */
5571 #line 1434 "parse-tree/oct-parse.yy"
5572  { (yyval.octave_user_function_type) = 0; }
5573  break;
5574 
5575  case 212:
5576 /* Line 1787 of yacc.c */
5577 #line 1438 "parse-tree/oct-parse.yy"
5578  { (yyval.tree_command_type) = 0; }
5579  break;
5580 
5581  case 213:
5582 /* Line 1787 of yacc.c */
5583 #line 1442 "parse-tree/oct-parse.yy"
5584  { (yyval.dummy_type) = 0; }
5585  break;
5586 
5587  case 214:
5588 /* Line 1787 of yacc.c */
5589 #line 1444 "parse-tree/oct-parse.yy"
5590  { (yyval.dummy_type) = 0; }
5591  break;
5592 
5593  case 215:
5594 /* Line 1787 of yacc.c */
5595 #line 1448 "parse-tree/oct-parse.yy"
5596  { (yyval.dummy_type) = 0; }
5597  break;
5598 
5599  case 216:
5600 /* Line 1787 of yacc.c */
5601 #line 1450 "parse-tree/oct-parse.yy"
5602  { (yyval.dummy_type) = 0; }
5603  break;
5604 
5605  case 217:
5606 /* Line 1787 of yacc.c */
5607 #line 1454 "parse-tree/oct-parse.yy"
5608  { (yyval.dummy_type) = 0; }
5609  break;
5610 
5611  case 218:
5612 /* Line 1787 of yacc.c */
5613 #line 1456 "parse-tree/oct-parse.yy"
5614  { (yyval.dummy_type) = 0; }
5615  break;
5616 
5617  case 219:
5618 /* Line 1787 of yacc.c */
5619 #line 1458 "parse-tree/oct-parse.yy"
5620  { (yyval.dummy_type) = 0; }
5621  break;
5622 
5623  case 220:
5624 /* Line 1787 of yacc.c */
5625 #line 1463 "parse-tree/oct-parse.yy"
5626  { (yyval.tree_parameter_list_type) = 0; }
5627  break;
5628 
5629  case 221:
5630 /* Line 1787 of yacc.c */
5631 #line 1465 "parse-tree/oct-parse.yy"
5632  { (yyval.tree_parameter_list_type) = 0; }
5633  break;
5634 
5635  case 222:
5636 /* Line 1787 of yacc.c */
5637 #line 1469 "parse-tree/oct-parse.yy"
5638  { (yyval.tree_parameter_list_type) = 0; }
5639  break;
5640 
5641  case 223:
5642 /* Line 1787 of yacc.c */
5643 #line 1471 "parse-tree/oct-parse.yy"
5644  { (yyval.tree_parameter_list_type) = 0; }
5645  break;
5646 
5647  case 224:
5648 /* Line 1787 of yacc.c */
5649 #line 1473 "parse-tree/oct-parse.yy"
5650  { (yyval.tree_parameter_list_type) = 0; }
5651  break;
5652 
5653  case 225:
5654 /* Line 1787 of yacc.c */
5655 #line 1475 "parse-tree/oct-parse.yy"
5656  { (yyval.tree_parameter_list_type) = 0; }
5657  break;
5658 
5659  case 226:
5660 /* Line 1787 of yacc.c */
5661 #line 1479 "parse-tree/oct-parse.yy"
5662  { (yyval.dummy_type) = 0; }
5663  break;
5664 
5665  case 227:
5666 /* Line 1787 of yacc.c */
5667 #line 1481 "parse-tree/oct-parse.yy"
5668  { (yyval.dummy_type) = 0; }
5669  break;
5670 
5671  case 228:
5672 /* Line 1787 of yacc.c */
5673 #line 1483 "parse-tree/oct-parse.yy"
5674  { (yyval.dummy_type) = 0; }
5675  break;
5676 
5677  case 229:
5678 /* Line 1787 of yacc.c */
5679 #line 1485 "parse-tree/oct-parse.yy"
5680  { (yyval.dummy_type) = 0; }
5681  break;
5682 
5683  case 230:
5684 /* Line 1787 of yacc.c */
5685 #line 1487 "parse-tree/oct-parse.yy"
5686  { (yyval.dummy_type) = 0; }
5687  break;
5688 
5689  case 231:
5690 /* Line 1787 of yacc.c */
5691 #line 1489 "parse-tree/oct-parse.yy"
5692  { (yyval.dummy_type) = 0; }
5693  break;
5694 
5695  case 232:
5696 /* Line 1787 of yacc.c */
5697 #line 1491 "parse-tree/oct-parse.yy"
5698  { (yyval.dummy_type) = 0; }
5699  break;
5700 
5701  case 233:
5702 /* Line 1787 of yacc.c */
5703 #line 1493 "parse-tree/oct-parse.yy"
5704  { (yyval.dummy_type) = 0; }
5705  break;
5706 
5707  case 234:
5708 /* Line 1787 of yacc.c */
5709 #line 1497 "parse-tree/oct-parse.yy"
5710  { (yyval.comment_type) = 0; }
5711  break;
5712 
5713  case 235:
5714 /* Line 1787 of yacc.c */
5715 #line 1502 "parse-tree/oct-parse.yy"
5716  { (yyval.dummy_type) = 0; }
5717  break;
5718 
5719  case 236:
5720 /* Line 1787 of yacc.c */
5721 #line 1507 "parse-tree/oct-parse.yy"
5722  { (yyval.dummy_type) = 0; }
5723  break;
5724 
5725  case 237:
5726 /* Line 1787 of yacc.c */
5727 #line 1509 "parse-tree/oct-parse.yy"
5728  { (yyval.dummy_type) = 0; }
5729  break;
5730 
5731  case 238:
5732 /* Line 1787 of yacc.c */
5733 #line 1513 "parse-tree/oct-parse.yy"
5734  { (yyval.dummy_type) = 0; }
5735  break;
5736 
5737  case 239:
5738 /* Line 1787 of yacc.c */
5739 #line 1515 "parse-tree/oct-parse.yy"
5740  { (yyval.dummy_type) = 0; }
5741  break;
5742 
5743  case 240:
5744 /* Line 1787 of yacc.c */
5745 #line 1519 "parse-tree/oct-parse.yy"
5746  { (yyval.comment_type) = 0; }
5747  break;
5748 
5749  case 241:
5750 /* Line 1787 of yacc.c */
5751 #line 1523 "parse-tree/oct-parse.yy"
5752  { (yyval.dummy_type) = 0; }
5753  break;
5754 
5755  case 242:
5756 /* Line 1787 of yacc.c */
5757 #line 1527 "parse-tree/oct-parse.yy"
5758  { (yyval.dummy_type) = 0; }
5759  break;
5760 
5761  case 243:
5762 /* Line 1787 of yacc.c */
5763 #line 1529 "parse-tree/oct-parse.yy"
5764  { (yyval.dummy_type) = 0; }
5765  break;
5766 
5767  case 244:
5768 /* Line 1787 of yacc.c */
5769 #line 1533 "parse-tree/oct-parse.yy"
5770  { (yyval.comment_type) = 0; }
5771  break;
5772 
5773  case 245:
5774 /* Line 1787 of yacc.c */
5775 #line 1537 "parse-tree/oct-parse.yy"
5776  { (yyval.dummy_type) = 0; }
5777  break;
5778 
5779  case 246:
5780 /* Line 1787 of yacc.c */
5781 #line 1541 "parse-tree/oct-parse.yy"
5782  { (yyval.dummy_type) = 0; }
5783  break;
5784 
5785  case 247:
5786 /* Line 1787 of yacc.c */
5787 #line 1543 "parse-tree/oct-parse.yy"
5788  { (yyval.dummy_type) = 0; }
5789  break;
5790 
5791  case 248:
5792 /* Line 1787 of yacc.c */
5793 #line 1547 "parse-tree/oct-parse.yy"
5794  { (yyval.dummy_type) = 0; }
5795  break;
5796 
5797  case 249:
5798 /* Line 1787 of yacc.c */
5799 #line 1551 "parse-tree/oct-parse.yy"
5800  { (yyval.comment_type) = 0; }
5801  break;
5802 
5803  case 250:
5804 /* Line 1787 of yacc.c */
5805 #line 1555 "parse-tree/oct-parse.yy"
5806  { (yyval.dummy_type) = 0; }
5807  break;
5808 
5809  case 251:
5810 /* Line 1787 of yacc.c */
5811 #line 1559 "parse-tree/oct-parse.yy"
5812  { (yyval.dummy_type) = 0; }
5813  break;
5814 
5815  case 252:
5816 /* Line 1787 of yacc.c */
5817 #line 1561 "parse-tree/oct-parse.yy"
5818  { (yyval.dummy_type) = 0; }
5819  break;
5820 
5821  case 253:
5822 /* Line 1787 of yacc.c */
5823 #line 1565 "parse-tree/oct-parse.yy"
5824  { (yyval.dummy_type) = 0; }
5825  break;
5826 
5827  case 254:
5828 /* Line 1787 of yacc.c */
5829 #line 1573 "parse-tree/oct-parse.yy"
5830  { lexer.at_beginning_of_statement = true; }
5831  break;
5832 
5833  case 255:
5834 /* Line 1787 of yacc.c */
5835 #line 1577 "parse-tree/oct-parse.yy"
5836  { (yyval.comment_type) = lexer.get_comment (); }
5837  break;
5838 
5839  case 256:
5840 /* Line 1787 of yacc.c */
5841 #line 1581 "parse-tree/oct-parse.yy"
5842  { parser.bison_error ("parse error"); }
5843  break;
5844 
5845  case 258:
5846 /* Line 1787 of yacc.c */
5847 #line 1586 "parse-tree/oct-parse.yy"
5848  { (yyval.sep_type) = ','; }
5849  break;
5850 
5851  case 259:
5852 /* Line 1787 of yacc.c */
5853 #line 1588 "parse-tree/oct-parse.yy"
5854  { (yyval.sep_type) = ';'; }
5855  break;
5856 
5857  case 260:
5858 /* Line 1787 of yacc.c */
5859 #line 1590 "parse-tree/oct-parse.yy"
5860  { (yyval.sep_type) = (yyvsp[(1) - (2)].sep_type); }
5861  break;
5862 
5863  case 261:
5864 /* Line 1787 of yacc.c */
5865 #line 1592 "parse-tree/oct-parse.yy"
5866  { (yyval.sep_type) = (yyvsp[(1) - (2)].sep_type); }
5867  break;
5868 
5869  case 262:
5870 /* Line 1787 of yacc.c */
5871 #line 1596 "parse-tree/oct-parse.yy"
5872  { (yyval.sep_type) = 0; }
5873  break;
5874 
5875  case 263:
5876 /* Line 1787 of yacc.c */
5877 #line 1598 "parse-tree/oct-parse.yy"
5878  { (yyval.sep_type) = (yyvsp[(1) - (1)].sep_type); }
5879  break;
5880 
5881  case 264:
5882 /* Line 1787 of yacc.c */
5883 #line 1602 "parse-tree/oct-parse.yy"
5884  { (yyval.sep_type) = 0; }
5885  break;
5886 
5887  case 265:
5888 /* Line 1787 of yacc.c */
5889 #line 1604 "parse-tree/oct-parse.yy"
5890  { (yyval.sep_type) = (yyvsp[(1) - (1)].sep_type); }
5891  break;
5892 
5893  case 266:
5894 /* Line 1787 of yacc.c */
5895 #line 1608 "parse-tree/oct-parse.yy"
5896  { (yyval.sep_type) = '\n'; }
5897  break;
5898 
5899  case 267:
5900 /* Line 1787 of yacc.c */
5901 #line 1610 "parse-tree/oct-parse.yy"
5902  { (yyval.sep_type) = (yyvsp[(1) - (2)].sep_type); }
5903  break;
5904 
5905  case 268:
5906 /* Line 1787 of yacc.c */
5907 #line 1614 "parse-tree/oct-parse.yy"
5908  { (yyval.sep_type) = ','; }
5909  break;
5910 
5911  case 269:
5912 /* Line 1787 of yacc.c */
5913 #line 1616 "parse-tree/oct-parse.yy"
5914  { (yyval.sep_type) = ';'; }
5915  break;
5916 
5917  case 270:
5918 /* Line 1787 of yacc.c */
5919 #line 1618 "parse-tree/oct-parse.yy"
5920  { (yyval.sep_type) = '\n'; }
5921  break;
5922 
5923  case 271:
5924 /* Line 1787 of yacc.c */
5925 #line 1620 "parse-tree/oct-parse.yy"
5926  { (yyval.sep_type) = (yyvsp[(1) - (2)].sep_type); }
5927  break;
5928 
5929  case 272:
5930 /* Line 1787 of yacc.c */
5931 #line 1622 "parse-tree/oct-parse.yy"
5932  { (yyval.sep_type) = (yyvsp[(1) - (2)].sep_type); }
5933  break;
5934 
5935  case 273:
5936 /* Line 1787 of yacc.c */
5937 #line 1624 "parse-tree/oct-parse.yy"
5938  { (yyval.sep_type) = (yyvsp[(1) - (2)].sep_type); }
5939  break;
5940 
5941  case 274:
5942 /* Line 1787 of yacc.c */
5943 #line 1628 "parse-tree/oct-parse.yy"
5944  { (yyval.sep_type) = 0; }
5945  break;
5946 
5947  case 275:
5948 /* Line 1787 of yacc.c */
5949 #line 1630 "parse-tree/oct-parse.yy"
5950  { (yyval.sep_type) = (yyvsp[(1) - (1)].sep_type); }
5951  break;
5952 
5953 
5954 /* Line 1787 of yacc.c */
5955 #line 5956 "parse-tree/oct-parse.cc"
5956  default: break;
5957  }
5958  /* User semantic actions sometimes alter yychar, and that requires
5959  that yytoken be updated with the new translation. We take the
5960  approach of translating immediately before every use of yytoken.
5961  One alternative is translating here after every semantic action,
5962  but that translation would be missed if the semantic action invokes
5963  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
5964  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
5965  incorrect destructor might then be invoked immediately. In the
5966  case of YYERROR or YYBACKUP, subsequent parser actions might lead
5967  to an incorrect destructor call or verbose syntax error message
5968  before the lookahead is translated. */
5969  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
5970 
5971  YYPOPSTACK (yylen);
5972  yylen = 0;
5973  YY_STACK_PRINT (yyss, yyssp);
5974 
5975  *++yyvsp = yyval;
5976 
5977  /* Now `shift' the result of the reduction. Determine what state
5978  that goes to, based on the state we popped back to and the rule
5979  number reduced by. */
5980 
5981  yyn = yyr1[yyn];
5982 
5983  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
5984  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
5985  yystate = yytable[yystate];
5986  else
5987  yystate = yydefgoto[yyn - YYNTOKENS];
5988 
5989  goto yynewstate;
5990 
5991 
5992 /*------------------------------------.
5993 | yyerrlab -- here on detecting error |
5994 `------------------------------------*/
5995 yyerrlab:
5996  /* Make sure we have latest lookahead translation. See comments at
5997  user semantic actions for why this is necessary. */
5998  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
5999 
6000  /* If not already recovering from an error, report this error. */
6001  if (!yyerrstatus)
6002  {
6003  ++yynerrs;
6004 #if ! YYERROR_VERBOSE
6005  yyerror (parser, YY_("syntax error"));
6006 #else
6007 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
6008  yyssp, yytoken)
6009  {
6010  char const *yymsgp = YY_("syntax error");
6011  int yysyntax_error_status;
6012  yysyntax_error_status = YYSYNTAX_ERROR;
6013  if (yysyntax_error_status == 0)
6014  yymsgp = yymsg;
6015  else if (yysyntax_error_status == 1)
6016  {
6017  if (yymsg != yymsgbuf)
6018  YYSTACK_FREE (yymsg);
6019  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
6020  if (!yymsg)
6021  {
6022  yymsg = yymsgbuf;
6023  yymsg_alloc = sizeof yymsgbuf;
6024  yysyntax_error_status = 2;
6025  }
6026  else
6027  {
6028  yysyntax_error_status = YYSYNTAX_ERROR;
6029  yymsgp = yymsg;
6030  }
6031  }
6032  yyerror (parser, yymsgp);
6033  if (yysyntax_error_status == 2)
6034  goto yyexhaustedlab;
6035  }
6036 # undef YYSYNTAX_ERROR
6037 #endif
6038  }
6039 
6040 
6041 
6042  if (yyerrstatus == 3)
6043  {
6044  /* If just tried and failed to reuse lookahead token after an
6045  error, discard it. */
6046 
6047  if (yychar <= YYEOF)
6048  {
6049  /* Return failure if at end of input. */
6050  if (yychar == YYEOF)
6051  YYABORT;
6052  }
6053  else
6054  {
6055  yydestruct ("Error: discarding",
6056  yytoken, &yylval, parser);
6057  yychar = YYEMPTY;
6058  }
6059  }
6060 
6061  /* Else will try to reuse lookahead token after shifting the error
6062  token. */
6063  goto yyerrlab1;
6064 
6065 
6066 /*---------------------------------------------------.
6067 | yyerrorlab -- error raised explicitly by YYERROR. |
6068 `---------------------------------------------------*/
6069 yyerrorlab:
60