Branch data Line data Source code
1 : : /* A Bison parser, made by GNU Bison 2.5. */
2 : :
3 : : /* Bison implementation for Yacc-like parsers in C
4 : :
5 : : Copyright (C) 1984, 1989-1990, 2000-2011 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.5"
48 : :
49 : : /* Skeleton name. */
50 : : #define YYSKELETON_NAME "yacc.c"
51 : :
52 : : /* Pure parsers. */
53 : : #define YYPURE 0
54 : :
55 : : /* Push parsers. */
56 : : #define YYPUSH 0
57 : :
58 : : /* Pull parsers. */
59 : : #define YYPULL 1
60 : :
61 : : /* Using locations. */
62 : : #define YYLSP_NEEDED 0
63 : :
64 : :
65 : :
66 : : /* Copy the first part of user declarations. */
67 : :
68 : : /* Line 268 of yacc.c */
69 : : #line 23 "/usr/local/src/libreoffice/idlc/source/parser.y"
70 : :
71 : : #include <string.h>
72 : :
73 : : #ifndef _IDLC_IDLC_HXX_
74 : : #include <idlc/idlc.hxx>
75 : : #endif
76 : : #ifndef _IDLC_ERRORHANDLER_HXX_
77 : : #include <idlc/errorhandler.hxx>
78 : : #endif
79 : : #ifndef _IDLC_FEHELPER_HXX_
80 : : #include <idlc/fehelper.hxx>
81 : : #endif
82 : : #ifndef _IDLC_EXPRESSION_HXX_
83 : : #include <idlc/astexpression.hxx>
84 : : #endif
85 : : #ifndef _IDLC_ASTCONSTANTS_HXX_
86 : : #include <idlc/astconstants.hxx>
87 : : #endif
88 : : #ifndef _IDLC_ASTCONSTANT_HXX_
89 : : #include <idlc/astconstant.hxx>
90 : : #endif
91 : : #ifndef _IDLC_ASTARRAY_HXX_
92 : : #include <idlc/astarray.hxx>
93 : : #endif
94 : : #ifndef _IDLC_ASTBASETYPE_HXX_
95 : : #include <idlc/astbasetype.hxx>
96 : : #endif
97 : : #ifndef _IDLC_ASTTYPEDEF_HXX_
98 : : #include <idlc/asttypedef.hxx>
99 : : #endif
100 : : #ifndef _IDLC_ASTEXCEPTION_HXX_
101 : : #include <idlc/astexception.hxx>
102 : : #endif
103 : : #ifndef _IDLC_ASTMEMBER_HXX_
104 : : #include <idlc/astmember.hxx>
105 : : #endif
106 : : #ifndef _IDLC_ASTENUM_HXX_
107 : : #include <idlc/astenum.hxx>
108 : : #endif
109 : : #ifndef _IDLC_ASTSEQUENCE_HXX_
110 : : #include <idlc/astsequence.hxx>
111 : : #endif
112 : : #ifndef _IDLC_ASTATTRIBUTE_HXX_
113 : : #include <idlc/astattribute.hxx>
114 : : #endif
115 : : #ifndef _IDLC_ASTOPERATION_HXX_
116 : : #include <idlc/astoperation.hxx>
117 : : #endif
118 : : #ifndef _IDLC_ASTPARAMETER_HXX_
119 : : #include <idlc/astparameter.hxx>
120 : : #endif
121 : : #ifndef _IDLC_ASTINTERFACEMEMBER_HXX_
122 : : #include <idlc/astinterfacemember.hxx>
123 : : #endif
124 : : #ifndef _IDLC_ASTSERVICEMEMBER_HXX_
125 : : #include <idlc/astservicemember.hxx>
126 : : #endif
127 : : #ifndef _IDLC_ASTOBSERVES_HXX_
128 : : #include <idlc/astobserves.hxx>
129 : : #endif
130 : : #ifndef _IDLC_ASTNEEDS_HXX_
131 : : #include <idlc/astneeds.hxx>
132 : : #endif
133 : : #ifndef _IDLC_ASTUNION_HXX_
134 : : #include <idlc/astunion.hxx>
135 : : #endif
136 : : #include "idlc/aststructinstance.hxx"
137 : :
138 : : #include "attributeexceptions.hxx"
139 : :
140 : : #include "rtl/strbuf.hxx"
141 : :
142 : : #include <algorithm>
143 : : #include <vector>
144 : :
145 : :
146 : : #define YYDEBUG 1
147 : : #if !(defined MACOSX && defined PPC)
148 : : #define YYERROR_VERBOSE 1
149 : : #endif
150 : :
151 : : using ::rtl::OUString;
152 : : using ::rtl::OString;
153 : : using ::rtl::OStringToOUString;
154 : : using ::rtl::OStringBuffer;
155 : :
156 : : extern int yylex(void);
157 : : void yyerror(char const *);
158 : :
159 : : void checkIdentifier(::rtl::OString* id)
160 : : {
161 : : static short check = 0;
162 : : if (check == 0) {
163 : : if (idlc()->getOptions()->isValid("-cid"))
164 : : check = 1;
165 : : else
166 : : check = 2;
167 : : }
168 : :
169 : : if ( id->indexOf('_') >= 0 )
170 : : if ( (id->pData->buffer[0] >= 97 && id->pData->buffer[0] <= 122)
171 : : || id->pData->buffer[0] == '_') {
172 : : if (check == 1) {
173 : : ::rtl::OStringBuffer msg(25 + id->getLength());
174 : : msg.append("mismatched identifier '");
175 : : msg.append(*id);
176 : : msg.append("'");
177 : : idlc()->error()->syntaxError(idlc()->getParseState(),
178 : : idlc()->getLineNumber(),
179 : : msg.getStr());
180 : : }
181 : : else
182 : : idlc()->error()->warning0(WIDL_WRONG_NAMING_CONV, id->getStr());
183 : : }
184 : : }
185 : :
186 : : void reportDoubleMemberDeclarations(
187 : : AstInterface::DoubleMemberDeclarations const & doubleMembers)
188 : : {
189 : : for (AstInterface::DoubleMemberDeclarations::const_iterator i(
190 : : doubleMembers.begin());
191 : : i != doubleMembers.end(); ++i)
192 : : {
193 : : idlc()->error()->error2(EIDL_DOUBLE_MEMBER, i->first, i->second);
194 : : }
195 : : }
196 : :
197 : : void addInheritedInterface(
198 : : AstInterface * ifc, rtl::OString const & name, bool optional,
199 : : rtl::OUString const & documentation)
200 : : {
201 : : AstDeclaration * decl = ifc->lookupByName(name);
202 : : AstDeclaration const * resolved = resolveTypedefs(decl);
203 : : if (resolved != 0 && resolved->getNodeType() == NT_interface) {
204 : : if (idlc()->error()->checkPublished(decl)) {
205 : : if (!static_cast< AstInterface const * >(resolved)->isDefined()) {
206 : : idlc()->error()->inheritanceError(
207 : : NT_interface, &ifc->getScopedName(), decl);
208 : : } else {
209 : : AstInterface::DoubleDeclarations doubleDecls(
210 : : ifc->checkInheritedInterfaceClashes(
211 : : static_cast< AstInterface const * >(resolved),
212 : : optional));
213 : : if (doubleDecls.interfaces.empty()
214 : : && doubleDecls.members.empty())
215 : : {
216 : : ifc->addInheritedInterface(
217 : : static_cast< AstType * >(decl), optional,
218 : : documentation);
219 : : } else {
220 : : for (AstInterface::DoubleInterfaceDeclarations::iterator i(
221 : : doubleDecls.interfaces.begin());
222 : : i != doubleDecls.interfaces.end(); ++i)
223 : : {
224 : : idlc()->error()->error1(
225 : : EIDL_DOUBLE_INHERITANCE, *i);
226 : : }
227 : : reportDoubleMemberDeclarations(doubleDecls.members);
228 : : }
229 : : }
230 : : }
231 : : } else {
232 : : idlc()->error()->lookupError(
233 : : EIDL_INTERFACEMEMBER_LOOKUP, name, scopeAsDecl(ifc));
234 : : }
235 : : }
236 : :
237 : : AstDeclaration const * createNamedType(
238 : : rtl::OString const * scopedName, DeclList const * typeArgs)
239 : : {
240 : : AstDeclaration * decl = idlc()->scopes()->topNonNull()->lookupByName(
241 : : *scopedName);
242 : : AstDeclaration const * resolved = resolveTypedefs(decl);
243 : : if (decl == 0) {
244 : : idlc()->error()->lookupError(*scopedName);
245 : : } else if (!idlc()->error()->checkPublished(decl)) {
246 : : decl = 0;
247 : : } else if (resolved->getNodeType() == NT_struct) {
248 : : if (static_cast< AstStruct const * >(resolved)->getTypeParameterCount()
249 : : != (typeArgs == 0 ? 0 : typeArgs->size()))
250 : : {
251 : : idlc()->error()->error0(EIDL_WRONG_NUMBER_OF_TYPE_ARGUMENTS);
252 : : decl = 0;
253 : : } else if (typeArgs != 0) {
254 : : AstScope * global = idlc()->scopes()->bottom();
255 : : AstDeclaration * inst = new AstStructInstance(
256 : : static_cast< AstType * >(decl), typeArgs, global);
257 : : decl = global->addDeclaration(inst);
258 : : if (decl != inst) {
259 : : delete inst;
260 : : }
261 : : }
262 : : } else if (decl->isType()) {
263 : : if (typeArgs != 0) {
264 : : idlc()->error()->error0(EIDL_WRONG_NUMBER_OF_TYPE_ARGUMENTS);
265 : : decl = 0;
266 : : }
267 : : } else {
268 : : idlc()->error()->noTypeError(decl);
269 : : decl = 0;
270 : : }
271 : : delete scopedName;
272 : : delete typeArgs;
273 : : return decl;
274 : : }
275 : :
276 : : bool includes(AstDeclaration const * type1, AstDeclaration const * type2) {
277 : : OSL_ASSERT(type2 != 0);
278 : : if (type1 != 0) {
279 : : if (type1->getNodeType() == NT_instantiated_struct) {
280 : : AstStructInstance const * inst
281 : : = static_cast< AstStructInstance const * >(type1);
282 : : if (inst->getTypeTemplate() == type2) {
283 : : return true;
284 : : }
285 : : for (DeclList::const_iterator i(inst->getTypeArgumentsBegin());
286 : : i != inst->getTypeArgumentsEnd(); ++i)
287 : : {
288 : : if (includes(*i, type2)) {
289 : : return true;
290 : : }
291 : : }
292 : : } else if (type1 == type2) {
293 : : return true;
294 : : }
295 : : }
296 : : return false;
297 : : }
298 : :
299 : : // Suppress any warnings from generated code:
300 : : #if defined __SUNPRO_CC
301 : : #pragma disable_warn
302 : : #elif defined _MSC_VER
303 : : #pragma warning(push, 1)
304 : : #pragma warning(disable: 4273 4701 4702 4706)
305 : : #endif
306 : :
307 : :
308 : : /* Line 268 of yacc.c */
309 : : #line 310 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/YaccTarget/idlc/source/parser.cxx"
310 : :
311 : : /* Enabling traces. */
312 : : #ifndef YYDEBUG
313 : : # define YYDEBUG 0
314 : : #endif
315 : :
316 : : /* Enabling verbose error messages. */
317 : : #ifdef YYERROR_VERBOSE
318 : : # undef YYERROR_VERBOSE
319 : : # define YYERROR_VERBOSE 1
320 : : #else
321 : : # define YYERROR_VERBOSE 0
322 : : #endif
323 : :
324 : : /* Enabling the token table. */
325 : : #ifndef YYTOKEN_TABLE
326 : : # define YYTOKEN_TABLE 0
327 : : #endif
328 : :
329 : :
330 : : /* Tokens. */
331 : : #ifndef YYTOKENTYPE
332 : : # define YYTOKENTYPE
333 : : /* Put the tokens into the symbol table, so that GDB and other debuggers
334 : : know about them. */
335 : : enum yytokentype {
336 : : IDL_IDENTIFIER = 258,
337 : : IDL_ATTRIBUTE = 259,
338 : : IDL_BOUND = 260,
339 : : IDL_CASE = 261,
340 : : IDL_CONST = 262,
341 : : IDL_CONSTANTS = 263,
342 : : IDL_CONSTRAINED = 264,
343 : : IDL_DEFAULT = 265,
344 : : IDL_ENUM = 266,
345 : : IDL_EXCEPTION = 267,
346 : : IDL_INTERFACE = 268,
347 : : IDL_MAYBEAMBIGUOUS = 269,
348 : : IDL_MAYBEDEFAULT = 270,
349 : : IDL_MAYBEVOID = 271,
350 : : IDL_MODULE = 272,
351 : : IDL_NEEDS = 273,
352 : : IDL_OBSERVES = 274,
353 : : IDL_OPTIONAL = 275,
354 : : IDL_PROPERTY = 276,
355 : : IDL_RAISES = 277,
356 : : IDL_READONLY = 278,
357 : : IDL_REMOVEABLE = 279,
358 : : IDL_SERVICE = 280,
359 : : IDL_SEQUENCE = 281,
360 : : IDL_SINGLETON = 282,
361 : : IDL_STRUCT = 283,
362 : : IDL_SWITCH = 284,
363 : : IDL_TYPEDEF = 285,
364 : : IDL_TRANSIENT = 286,
365 : : IDL_UNION = 287,
366 : : IDL_ANY = 288,
367 : : IDL_CHAR = 289,
368 : : IDL_BOOLEAN = 290,
369 : : IDL_BYTE = 291,
370 : : IDL_DOUBLE = 292,
371 : : IDL_FLOAT = 293,
372 : : IDL_HYPER = 294,
373 : : IDL_LONG = 295,
374 : : IDL_SHORT = 296,
375 : : IDL_VOID = 297,
376 : : IDL_STRING = 298,
377 : : IDL_TYPE = 299,
378 : : IDL_UNSIGNED = 300,
379 : : IDL_TRUE = 301,
380 : : IDL_FALSE = 302,
381 : : IDL_IN = 303,
382 : : IDL_OUT = 304,
383 : : IDL_INOUT = 305,
384 : : IDL_ONEWAY = 306,
385 : : IDL_GET = 307,
386 : : IDL_SET = 308,
387 : : IDL_PUBLISHED = 309,
388 : : IDL_ELLIPSIS = 310,
389 : : IDL_LEFTSHIFT = 311,
390 : : IDL_RIGHTSHIFT = 312,
391 : : IDL_SCOPESEPARATOR = 313,
392 : : IDL_INTEGER_LITERAL = 314,
393 : : IDL_INTEGER_ULITERAL = 315,
394 : : IDL_FLOATING_PT_LITERAL = 316
395 : : };
396 : : #endif
397 : :
398 : :
399 : :
400 : : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
401 : : typedef union YYSTYPE
402 : : {
403 : :
404 : : /* Line 293 of yacc.c */
405 : : #line 263 "/usr/local/src/libreoffice/idlc/source/parser.y"
406 : :
407 : : ExprType etval; /* Expression type */
408 : : AstDeclaration* dclval; /* Declaration */
409 : : AstDeclaration const * cdclval;
410 : : DeclList * dclsval;
411 : : AstExpression* exval; /* expression value */
412 : : ExprList* exlval; /* expression list value */
413 : : FeDeclarator* fdval; /* declarator value */
414 : : FeDeclList* dlval; /* declarator list value */
415 : : FeInheritanceHeader* ihval; /* inheritance header value */
416 : : ::rtl::OString* sval; /* OString value */
417 : : std::vector< rtl::OString > * svals;
418 : : sal_Char* strval; /* sal_Char* value */
419 : : sal_Bool bval; /* sal_Boolean* value */
420 : : sal_Int64 ival; /* sal_Int64 value */
421 : : sal_uInt64 uval; /* sal_uInt64 value */
422 : : sal_uInt32 ulval; /* sal_uInt32 value */
423 : : double dval; /* double value */
424 : : float fval; /* float value */
425 : : StringList* slval; /* StringList value */
426 : : LabelList* llval; /* LabelList value */
427 : : AstUnionLabel* lbval; /* union label value */
428 : : AstMember* mval; /* member value */
429 : : AttributeExceptions::Part attexcpval;
430 : : AttributeExceptions attexcval;
431 : :
432 : :
433 : :
434 : : /* Line 293 of yacc.c */
435 : : #line 436 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/YaccTarget/idlc/source/parser.cxx"
436 : : } YYSTYPE;
437 : : # define YYSTYPE_IS_TRIVIAL 1
438 : : # define yystype YYSTYPE /* obsolescent; will be withdrawn */
439 : : # define YYSTYPE_IS_DECLARED 1
440 : : #endif
441 : :
442 : :
443 : : /* Copy the second part of user declarations. */
444 : :
445 : :
446 : : /* Line 343 of yacc.c */
447 : : #line 448 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/YaccTarget/idlc/source/parser.cxx"
448 : :
449 : : #ifdef short
450 : : # undef short
451 : : #endif
452 : :
453 : : #ifdef YYTYPE_UINT8
454 : : typedef YYTYPE_UINT8 yytype_uint8;
455 : : #else
456 : : typedef unsigned char yytype_uint8;
457 : : #endif
458 : :
459 : : #ifdef YYTYPE_INT8
460 : : typedef YYTYPE_INT8 yytype_int8;
461 : : #elif (defined __STDC__ || defined __C99__FUNC__ \
462 : : || defined __cplusplus || defined _MSC_VER)
463 : : typedef signed char yytype_int8;
464 : : #else
465 : : typedef short int yytype_int8;
466 : : #endif
467 : :
468 : : #ifdef YYTYPE_UINT16
469 : : typedef YYTYPE_UINT16 yytype_uint16;
470 : : #else
471 : : typedef unsigned short int yytype_uint16;
472 : : #endif
473 : :
474 : : #ifdef YYTYPE_INT16
475 : : typedef YYTYPE_INT16 yytype_int16;
476 : : #else
477 : : typedef short int yytype_int16;
478 : : #endif
479 : :
480 : : #ifndef YYSIZE_T
481 : : # ifdef __SIZE_TYPE__
482 : : # define YYSIZE_T __SIZE_TYPE__
483 : : # elif defined size_t
484 : : # define YYSIZE_T size_t
485 : : # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
486 : : || defined __cplusplus || defined _MSC_VER)
487 : : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
488 : : # define YYSIZE_T size_t
489 : : # else
490 : : # define YYSIZE_T unsigned int
491 : : # endif
492 : : #endif
493 : :
494 : : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
495 : :
496 : : #ifndef YY_
497 : : # if defined YYENABLE_NLS && YYENABLE_NLS
498 : : # if ENABLE_NLS
499 : : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
500 : : # define YY_(msgid) dgettext ("bison-runtime", msgid)
501 : : # endif
502 : : # endif
503 : : # ifndef YY_
504 : : # define YY_(msgid) msgid
505 : : # endif
506 : : #endif
507 : :
508 : : /* Suppress unused-variable warnings by "using" E. */
509 : : #if ! defined lint || defined __GNUC__
510 : : # define YYUSE(e) ((void) (e))
511 : : #else
512 : : # define YYUSE(e) /* empty */
513 : : #endif
514 : :
515 : : /* Identity function, used to suppress warnings about constant conditions. */
516 : : #ifndef lint
517 : : # define YYID(n) (n)
518 : : #else
519 : : #if (defined __STDC__ || defined __C99__FUNC__ \
520 : : || defined __cplusplus || defined _MSC_VER)
521 : : static int
522 : : YYID (int yyi)
523 : : #else
524 : : static int
525 : : YYID (yyi)
526 : : int yyi;
527 : : #endif
528 : : {
529 : : return yyi;
530 : : }
531 : : #endif
532 : :
533 : : #if ! defined yyoverflow || YYERROR_VERBOSE
534 : :
535 : : /* The parser invokes alloca or malloc; define the necessary symbols. */
536 : :
537 : : # ifdef YYSTACK_USE_ALLOCA
538 : : # if YYSTACK_USE_ALLOCA
539 : : # ifdef __GNUC__
540 : : # define YYSTACK_ALLOC __builtin_alloca
541 : : # elif defined __BUILTIN_VA_ARG_INCR
542 : : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
543 : : # elif defined _AIX
544 : : # define YYSTACK_ALLOC __alloca
545 : : # elif defined _MSC_VER
546 : : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
547 : : # define alloca _alloca
548 : : # else
549 : : # define YYSTACK_ALLOC alloca
550 : : # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
551 : : || defined __cplusplus || defined _MSC_VER)
552 : : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
553 : : # ifndef EXIT_SUCCESS
554 : : # define EXIT_SUCCESS 0
555 : : # endif
556 : : # endif
557 : : # endif
558 : : # endif
559 : : # endif
560 : :
561 : : # ifdef YYSTACK_ALLOC
562 : : /* Pacify GCC's `empty if-body' warning. */
563 : : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
564 : : # ifndef YYSTACK_ALLOC_MAXIMUM
565 : : /* The OS might guarantee only one guard page at the bottom of the stack,
566 : : and a page size can be as small as 4096 bytes. So we cannot safely
567 : : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
568 : : to allow for a few compiler-allocated temporary stack slots. */
569 : : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
570 : : # endif
571 : : # else
572 : : # define YYSTACK_ALLOC YYMALLOC
573 : : # define YYSTACK_FREE YYFREE
574 : : # ifndef YYSTACK_ALLOC_MAXIMUM
575 : : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
576 : : # endif
577 : : # if (defined __cplusplus && ! defined EXIT_SUCCESS \
578 : : && ! ((defined YYMALLOC || defined malloc) \
579 : : && (defined YYFREE || defined free)))
580 : : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
581 : : # ifndef EXIT_SUCCESS
582 : : # define EXIT_SUCCESS 0
583 : : # endif
584 : : # endif
585 : : # ifndef YYMALLOC
586 : : # define YYMALLOC malloc
587 : : # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
588 : : || defined __cplusplus || defined _MSC_VER)
589 : : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
590 : : # endif
591 : : # endif
592 : : # ifndef YYFREE
593 : : # define YYFREE free
594 : : # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
595 : : || defined __cplusplus || defined _MSC_VER)
596 : : void free (void *); /* INFRINGES ON USER NAME SPACE */
597 : : # endif
598 : : # endif
599 : : # endif
600 : : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
601 : :
602 : :
603 : : #if (! defined yyoverflow \
604 : : && (! defined __cplusplus \
605 : : || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
606 : :
607 : : /* A type that is properly aligned for any stack member. */
608 : : union yyalloc
609 : : {
610 : : yytype_int16 yyss_alloc;
611 : : YYSTYPE yyvs_alloc;
612 : : };
613 : :
614 : : /* The size of the maximum gap between one aligned stack and the next. */
615 : : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
616 : :
617 : : /* The size of an array large to enough to hold all stacks, each with
618 : : N elements. */
619 : : # define YYSTACK_BYTES(N) \
620 : : ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
621 : : + YYSTACK_GAP_MAXIMUM)
622 : :
623 : : # define YYCOPY_NEEDED 1
624 : :
625 : : /* Relocate STACK from its old location to the new one. The
626 : : local variables YYSIZE and YYSTACKSIZE give the old and new number of
627 : : elements in the stack, and YYPTR gives the new location of the
628 : : stack. Advance YYPTR to a properly aligned location for the next
629 : : stack. */
630 : : # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
631 : : do \
632 : : { \
633 : : YYSIZE_T yynewbytes; \
634 : : YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
635 : : Stack = &yyptr->Stack_alloc; \
636 : : yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
637 : : yyptr += yynewbytes / sizeof (*yyptr); \
638 : : } \
639 : : while (YYID (0))
640 : :
641 : : #endif
642 : :
643 : : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
644 : : /* Copy COUNT objects from FROM to TO. The source and destination do
645 : : not overlap. */
646 : : # ifndef YYCOPY
647 : : # if defined __GNUC__ && 1 < __GNUC__
648 : : # define YYCOPY(To, From, Count) \
649 : : __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
650 : : # else
651 : : # define YYCOPY(To, From, Count) \
652 : : do \
653 : : { \
654 : : YYSIZE_T yyi; \
655 : : for (yyi = 0; yyi < (Count); yyi++) \
656 : : (To)[yyi] = (From)[yyi]; \
657 : : } \
658 : : while (YYID (0))
659 : : # endif
660 : : # endif
661 : : #endif /* !YYCOPY_NEEDED */
662 : :
663 : : /* YYFINAL -- State number of the termination state. */
664 : : #define YYFINAL 11
665 : : /* YYLAST -- Last index in YYTABLE. */
666 : : #define YYLAST 809
667 : :
668 : : /* YYNTOKENS -- Number of terminals. */
669 : : #define YYNTOKENS 83
670 : : /* YYNNTS -- Number of nonterminals. */
671 : : #define YYNNTS 229
672 : : /* YYNRULES -- Number of rules. */
673 : : #define YYNRULES 362
674 : : /* YYNRULES -- Number of states. */
675 : : #define YYNSTATES 520
676 : :
677 : : /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
678 : : #define YYUNDEFTOK 2
679 : : #define YYMAXUTOK 316
680 : :
681 : : #define YYTRANSLATE(YYX) \
682 : : ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
683 : :
684 : : /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
685 : : static const yytype_uint8 yytranslate[] =
686 : : {
687 : : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
688 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
689 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
690 : : 2, 2, 2, 2, 2, 2, 2, 79, 74, 2,
691 : : 69, 70, 77, 75, 68, 76, 2, 78, 2, 2,
692 : : 2, 2, 2, 2, 2, 2, 2, 2, 65, 62,
693 : : 81, 71, 82, 2, 2, 2, 2, 2, 2, 2,
694 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
695 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
696 : : 2, 66, 2, 67, 73, 2, 2, 2, 2, 2,
697 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
698 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
699 : : 2, 2, 2, 63, 72, 64, 80, 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, 2, 2, 2, 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, 2, 2, 2, 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, 1, 2, 3, 4,
713 : : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
714 : : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
715 : : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
716 : : 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
717 : : 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
718 : : 55, 56, 57, 58, 59, 60, 61
719 : : };
720 : :
721 : : #if YYDEBUG
722 : : /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
723 : : YYRHS. */
724 : : static const yytype_uint16 yyprhs[] =
725 : : {
726 : : 0, 0, 3, 5, 8, 9, 12, 13, 17, 20,
727 : : 22, 23, 24, 28, 29, 33, 34, 38, 39, 43,
728 : : 44, 48, 49, 53, 54, 58, 59, 60, 61, 62,
729 : : 72, 74, 76, 77, 81, 83, 84, 85, 86, 94,
730 : : 97, 100, 101, 105, 106, 109, 110, 111, 115, 116,
731 : : 120, 121, 125, 126, 127, 134, 138, 142, 144, 146,
732 : : 148, 150, 152, 154, 156, 158, 160, 162, 164, 166,
733 : : 169, 172, 173, 176, 179, 182, 185, 186, 188, 189,
734 : : 193, 195, 196, 197, 202, 203, 204, 205, 206, 207,
735 : : 220, 221, 226, 227, 229, 231, 233, 234, 239, 240,
736 : : 243, 244, 245, 254, 257, 259, 261, 263, 265, 266,
737 : : 268, 269, 270, 271, 278, 280, 284, 286, 287, 292,
738 : : 296, 297, 300, 301, 302, 306, 307, 308, 309, 310,
739 : : 320, 321, 322, 323, 324, 334, 336, 338, 340, 344,
740 : : 346, 350, 352, 356, 358, 362, 366, 368, 372, 376,
741 : : 378, 382, 386, 390, 392, 395, 398, 401, 403, 405,
742 : : 409, 411, 413, 415, 417, 419, 421, 423, 425, 427,
743 : : 429, 431, 433, 434, 435, 441, 442, 443, 444, 452,
744 : : 453, 458, 461, 464, 465, 469, 473, 477, 481, 484,
745 : : 486, 489, 491, 494, 495, 496, 502, 504, 506, 507,
746 : : 512, 514, 515, 519, 522, 523, 524, 525, 534, 535,
747 : : 536, 542, 544, 546, 549, 550, 551, 557, 558, 562,
748 : : 564, 566, 568, 569, 573, 576, 577, 582, 583, 585,
749 : : 587, 589, 591, 592, 596, 599, 602, 603, 604, 605,
750 : : 611, 614, 615, 620, 621, 623, 624, 628, 629, 634,
751 : : 636, 638, 640, 643, 645, 647, 651, 652, 654, 658,
752 : : 660, 662, 664, 666, 668, 670, 672, 674, 676, 678,
753 : : 680, 682, 684, 686, 689, 692, 695, 697, 699, 701,
754 : : 703, 705, 707, 709, 711, 713, 715, 717, 719, 721,
755 : : 722, 726, 727, 728, 729, 737, 740, 741, 742, 743,
756 : : 751, 752, 753, 760, 764, 765, 767, 771, 774, 777,
757 : : 778, 779, 780, 786, 789, 791, 794, 795, 796, 797,
758 : : 798, 808, 811, 812, 817, 818, 821, 823, 827, 828,
759 : : 829, 830, 831, 832, 833, 834, 835, 853, 855, 857,
760 : : 859, 861, 863, 866, 869, 870, 871, 875, 878, 881,
761 : : 882, 883, 887, 888, 889, 895, 896, 897, 903, 906,
762 : : 908, 910, 912
763 : : };
764 : :
765 : : /* YYRHS -- A `-1'-separated list of the rules' RHS. */
766 : : static const yytype_int16 yyrhs[] =
767 : : {
768 : : 84, 0, -1, 85, -1, 86, 85, -1, -1, 88,
769 : : 89, -1, -1, 97, 87, 62, -1, 1, 62, -1,
770 : : 54, -1, -1, -1, 216, 90, 62, -1, -1, 160,
771 : : 91, 62, -1, -1, 186, 92, 62, -1, -1, 102,
772 : : 93, 62, -1, -1, 196, 94, 62, -1, -1, 208,
773 : : 95, 62, -1, -1, 165, 96, 62, -1, -1, -1,
774 : : -1, -1, 17, 98, 311, 99, 63, 100, 85, 101,
775 : : 64, -1, 106, -1, 105, -1, -1, 13, 104, 311,
776 : : -1, 103, -1, -1, -1, -1, 110, 107, 63, 108,
777 : : 113, 109, 64, -1, 1, 64, -1, 103, 111, -1,
778 : : -1, 65, 112, 236, -1, -1, 113, 114, -1, -1,
779 : : -1, 118, 115, 62, -1, -1, 132, 116, 62, -1,
780 : : -1, 154, 117, 62, -1, -1, -1, 121, 240, 119,
781 : : 224, 120, 124, -1, 66, 122, 67, -1, 122, 68,
782 : : 123, -1, 123, -1, 4, -1, 21, -1, 23, -1,
783 : : 20, -1, 16, -1, 5, -1, 9, -1, 31, -1,
784 : : 14, -1, 15, -1, 24, -1, 1, 67, -1, 63,
785 : : 125, -1, -1, 126, 64, -1, 1, 64, -1, 128,
786 : : 129, -1, 130, 127, -1, -1, 128, -1, -1, 52,
787 : : 149, 62, -1, 130, -1, -1, -1, 53, 131, 149,
788 : : 62, -1, -1, -1, -1, -1, -1, 138, 140, 133,
789 : : 311, 134, 69, 135, 141, 136, 70, 137, 148, -1,
790 : : -1, 66, 51, 139, 67, -1, -1, 240, -1, 42,
791 : : -1, 143, -1, -1, 141, 68, 142, 143, -1, -1,
792 : : 1, 68, -1, -1, -1, 66, 146, 67, 144, 240,
793 : : 145, 147, 223, -1, 1, 240, -1, 48, -1, 49,
794 : : -1, 50, -1, 55, -1, -1, 149, -1, -1, -1,
795 : : -1, 22, 150, 69, 151, 152, 70, -1, 153, -1,
796 : : 152, 68, 153, -1, 236, -1, -1, 156, 13, 155,
797 : : 236, -1, 66, 20, 67, -1, -1, 158, 157, -1,
798 : : -1, -1, 160, 159, 62, -1, -1, -1, -1, -1,
799 : : 7, 161, 182, 162, 311, 163, 71, 164, 170, -1,
800 : : -1, -1, -1, -1, 8, 166, 311, 167, 63, 168,
801 : : 157, 169, 64, -1, 171, -1, 172, -1, 173, -1,
802 : : 172, 72, 173, -1, 174, -1, 173, 73, 174, -1,
803 : : 175, -1, 174, 74, 175, -1, 176, -1, 175, 56,
804 : : 176, -1, 175, 57, 176, -1, 177, -1, 176, 75,
805 : : 177, -1, 176, 76, 177, -1, 178, -1, 177, 77,
806 : : 178, -1, 177, 78, 178, -1, 177, 79, 178, -1,
807 : : 179, -1, 75, 179, -1, 76, 179, -1, 80, 179,
808 : : -1, 236, -1, 180, -1, 69, 171, 70, -1, 59,
809 : : -1, 60, -1, 61, -1, 46, -1, 47, -1, 171,
810 : : -1, 246, -1, 250, -1, 251, -1, 252, -1, 249,
811 : : -1, 236, -1, -1, -1, 12, 184, 311, 185, 111,
812 : : -1, -1, -1, -1, 183, 187, 63, 188, 274, 189,
813 : : 64, -1, -1, 121, 240, 191, 220, -1, 1, 62,
814 : : -1, 192, 193, -1, -1, 194, 233, 62, -1, 195,
815 : : 233, 62, -1, 19, 233, 62, -1, 18, 233, 62,
816 : : -1, 190, 62, -1, 13, -1, 121, 13, -1, 25,
817 : : -1, 121, 25, -1, -1, -1, 25, 197, 311, 198,
818 : : 199, -1, 200, -1, 213, -1, -1, 65, 236, 201,
819 : : 202, -1, 203, -1, -1, 63, 204, 64, -1, 204,
820 : : 205, -1, -1, -1, -1, 311, 206, 69, 141, 70,
821 : : 148, 207, 62, -1, -1, -1, 27, 209, 311, 210,
822 : : 211, -1, 212, -1, 213, -1, 65, 236, -1, -1,
823 : : -1, 63, 214, 192, 215, 64, -1, -1, 30, 217,
824 : : 218, -1, 264, -1, 288, -1, 279, -1, -1, 239,
825 : : 219, 220, -1, 223, 221, -1, -1, 221, 68, 222,
826 : : 223, -1, -1, 224, -1, 225, -1, 311, -1, 226,
827 : : -1, -1, 311, 227, 228, -1, 230, 229, -1, 229,
828 : : 230, -1, -1, -1, -1, 66, 231, 181, 232, 67,
829 : : -1, 236, 234, -1, -1, 234, 68, 235, 236, -1,
830 : : -1, 311, -1, -1, 58, 237, 311, -1, -1, 236,
831 : : 58, 238, 311, -1, 240, -1, 257, -1, 241, -1,
832 : : 236, 242, -1, 245, -1, 256, -1, 81, 243, 82,
833 : : -1, -1, 244, -1, 243, 68, 244, -1, 240, -1,
834 : : 246, -1, 249, -1, 250, -1, 252, -1, 251, -1,
835 : : 253, -1, 254, -1, 255, -1, 247, -1, 248, -1,
836 : : 40, -1, 39, -1, 41, -1, 45, 40, -1, 45,
837 : : 39, -1, 45, 41, -1, 37, -1, 38, -1, 34,
838 : : -1, 36, -1, 35, -1, 33, -1, 44, -1, 43,
839 : : -1, 260, -1, 258, -1, 264, -1, 288, -1, 279,
840 : : -1, -1, 240, 259, 228, -1, -1, -1, -1, 26,
841 : : 261, 81, 262, 240, 263, 82, -1, 1, 82, -1,
842 : : -1, -1, -1, 268, 265, 63, 266, 273, 267, 64,
843 : : -1, -1, -1, 28, 269, 311, 270, 271, 111, -1,
844 : : 81, 272, 82, -1, -1, 311, -1, 272, 68, 311,
845 : : -1, 275, 274, -1, 274, 275, -1, -1, -1, -1,
846 : : 278, 276, 220, 277, 62, -1, 1, 62, -1, 241,
847 : : -1, 236, 242, -1, -1, -1, -1, -1, 11, 280,
848 : : 311, 281, 63, 282, 284, 283, 64, -1, 287, 285,
849 : : -1, -1, 285, 68, 286, 287, -1, -1, 1, 68,
850 : : -1, 311, -1, 311, 71, 171, -1, -1, -1, -1,
851 : : -1, -1, -1, -1, -1, 32, 289, 311, 290, 29,
852 : : 291, 69, 292, 297, 293, 70, 294, 63, 295, 298,
853 : : 296, 64, -1, 246, -1, 250, -1, 252, -1, 279,
854 : : -1, 236, -1, 300, 299, -1, 299, 300, -1, -1,
855 : : -1, 302, 301, 308, -1, 304, 303, -1, 303, 304,
856 : : -1, -1, -1, 10, 305, 65, -1, -1, -1, 6,
857 : : 306, 171, 307, 65, -1, -1, -1, 239, 309, 223,
858 : : 310, 62, -1, 1, 62, -1, 3, -1, 52, -1,
859 : : 53, -1, 54, -1
860 : : };
861 : :
862 : : /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
863 : : static const yytype_uint16 yyrline[] =
864 : : {
865 : : 0, 414, 414, 417, 418, 422, 424, 423, 431, 439,
866 : : 440, 445, 444, 453, 452, 461, 460, 469, 468, 477,
867 : : 476, 485, 484, 493, 492, 504, 509, 544, 548, 503,
868 : : 562, 563, 568, 567, 580, 620, 700, 704, 619, 725,
869 : : 733, 744, 743, 752, 758, 759, 764, 763, 772, 771,
870 : : 780, 779, 792, 796, 790, 829, 837, 844, 851, 856,
871 : : 861, 866, 871, 876, 881, 886, 891, 896, 901, 906,
872 : : 914, 916, 925, 926, 938, 944, 951, 960, 961, 965,
873 : : 975, 976, 981, 980, 1000, 1004, 1042, 1046, 1050, 998,
874 : : 1078, 1076, 1087, 1093, 1094, 1101, 1104, 1102, 1108, 1109,
875 : : 1120, 1124, 1117, 1184, 1193, 1197, 1201, 1208, 1213, 1219,
876 : : 1221, 1228, 1232, 1227, 1244, 1249, 1257, 1280, 1278, 1300,
877 : : 1301, 1305, 1306, 1311, 1310, 1318, 1322, 1326, 1331, 1317,
878 : : 1358, 1362, 1367, 1391, 1357, 1404, 1406, 1409, 1410, 1417,
879 : : 1418, 1425, 1426, 1433, 1434, 1438, 1445, 1446, 1450, 1457,
880 : : 1458, 1462, 1466, 1473, 1474, 1478, 1482, 1488, 1497, 1498,
881 : : 1505, 1509, 1513, 1517, 1521, 1528, 1541, 1542, 1543, 1544,
882 : : 1545, 1546, 1577, 1581, 1576, 1596, 1616, 1620, 1595, 1634,
883 : : 1632, 1696, 1704, 1705, 1709, 1759, 1801, 1843, 1885, 1893,
884 : : 1898, 1909, 1914, 1926, 1930, 1925, 1959, 1960, 1965, 1964,
885 : : 1989, 1990, 1994, 2000, 2001, 2006, 2018, 2005, 2034, 2038,
886 : : 2033, 2067, 2068, 2072, 2091, 2097, 2090, 2112, 2111, 2116,
887 : : 2117, 2118, 2123, 2122, 2177, 2195, 2193, 2213, 2219, 2220,
888 : : 2224, 2243, 2251, 2250, 2264, 2280, 2294, 2301, 2305, 2300,
889 : : 2325, 2344, 2342, 2363, 2369, 2376, 2375, 2389, 2387, 2402,
890 : : 2403, 2407, 2408, 2415, 2419, 2423, 2424, 2428, 2433, 2441,
891 : : 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2462, 2463,
892 : : 2467, 2471, 2475, 2482, 2486, 2490, 2497, 2501, 2508, 2515,
893 : : 2522, 2529, 2536, 2543, 2550, 2551, 2555, 2556, 2557, 2562,
894 : : 2561, 2593, 2601, 2605, 2592, 2643, 2653, 2673, 2677, 2652,
895 : : 2690, 2694, 2689, 2726, 2727, 2731, 2737, 2748, 2751, 2752,
896 : : 2757, 2761, 2756, 2811, 2819, 2820, 2844, 2848, 2875, 2879,
897 : : 2843, 2898, 2903, 2901, 2907, 2908, 2916, 2940, 2977, 2981,
898 : : 2986, 2990, 2994, 2998, 3027, 3031, 2976, 3043, 3047, 3051,
899 : : 3055, 3056, 3124, 3127, 3128, 3133, 3132, 3171, 3187, 3201,
900 : : 3208, 3207, 3217, 3221, 3216, 3233, 3237, 3232, 3265, 3273,
901 : : 3274, 3275, 3276
902 : : };
903 : : #endif
904 : :
905 : : #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
906 : : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
907 : : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
908 : : static const char *const yytname[] =
909 : : {
910 : : "$end", "error", "$undefined", "IDL_IDENTIFIER", "IDL_ATTRIBUTE",
911 : : "IDL_BOUND", "IDL_CASE", "IDL_CONST", "IDL_CONSTANTS", "IDL_CONSTRAINED",
912 : : "IDL_DEFAULT", "IDL_ENUM", "IDL_EXCEPTION", "IDL_INTERFACE",
913 : : "IDL_MAYBEAMBIGUOUS", "IDL_MAYBEDEFAULT", "IDL_MAYBEVOID", "IDL_MODULE",
914 : : "IDL_NEEDS", "IDL_OBSERVES", "IDL_OPTIONAL", "IDL_PROPERTY",
915 : : "IDL_RAISES", "IDL_READONLY", "IDL_REMOVEABLE", "IDL_SERVICE",
916 : : "IDL_SEQUENCE", "IDL_SINGLETON", "IDL_STRUCT", "IDL_SWITCH",
917 : : "IDL_TYPEDEF", "IDL_TRANSIENT", "IDL_UNION", "IDL_ANY", "IDL_CHAR",
918 : : "IDL_BOOLEAN", "IDL_BYTE", "IDL_DOUBLE", "IDL_FLOAT", "IDL_HYPER",
919 : : "IDL_LONG", "IDL_SHORT", "IDL_VOID", "IDL_STRING", "IDL_TYPE",
920 : : "IDL_UNSIGNED", "IDL_TRUE", "IDL_FALSE", "IDL_IN", "IDL_OUT",
921 : : "IDL_INOUT", "IDL_ONEWAY", "IDL_GET", "IDL_SET", "IDL_PUBLISHED",
922 : : "IDL_ELLIPSIS", "IDL_LEFTSHIFT", "IDL_RIGHTSHIFT", "IDL_SCOPESEPARATOR",
923 : : "IDL_INTEGER_LITERAL", "IDL_INTEGER_ULITERAL", "IDL_FLOATING_PT_LITERAL",
924 : : "';'", "'{'", "'}'", "':'", "'['", "']'", "','", "'('", "')'", "'='",
925 : : "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", "'<'",
926 : : "'>'", "$accept", "start", "definitions", "definition", "$@1",
927 : : "opt_published", "publishable_definition", "$@2", "$@3", "$@4", "$@5",
928 : : "$@6", "$@7", "$@8", "module_dcl", "$@9", "$@10", "$@11", "$@12",
929 : : "interface", "interface_decl", "$@13", "forward_dcl", "interface_dcl",
930 : : "$@14", "$@15", "$@16", "interfaceheader", "inheritance_spec", "$@17",
931 : : "exports", "export", "$@18", "$@19", "$@20", "attribute", "$@21", "$@22",
932 : : "flag_header", "opt_attrflags", "opt_attrflag", "opt_attribute_block",
933 : : "attribute_block_rest", "opt_attribute_raises",
934 : : "opt_attribute_get_raises", "attribute_get_raises",
935 : : "opt_attribute_set_raises", "attribute_set_raises", "$@23", "operation",
936 : : "$@24", "$@25", "$@26", "$@27", "$@28", "operation_head", "$@29",
937 : : "op_type_spec", "parameters", "$@30", "parameter", "$@31", "$@32",
938 : : "direction", "opt_rest", "opt_raises", "raises", "$@33", "$@34",
939 : : "exception_list", "exception_name", "interface_inheritance_decl", "$@35",
940 : : "optional_inherited_interface", "constants_exports", "constants_export",
941 : : "$@36", "const_dcl", "$@37", "$@38", "$@39", "$@40", "constants_dcl",
942 : : "$@41", "$@42", "$@43", "$@44", "expression", "const_expr", "or_expr",
943 : : "xor_expr", "and_expr", "shift_expr", "add_expr", "mult_expr",
944 : : "unary_expr", "primary_expr", "literal", "positive_int_expr",
945 : : "const_type", "exception_header", "$@45", "$@46", "exception_dcl",
946 : : "$@47", "$@48", "$@49", "property", "$@50", "service_exports",
947 : : "service_export", "service_interface_header", "service_service_header",
948 : : "service_dcl", "$@51", "$@52", "service_dfn", "service_interface_dfn",
949 : : "$@53", "opt_service_body", "service_body", "constructors",
950 : : "constructor", "$@54", "$@55", "singleton_dcl", "$@56", "$@57",
951 : : "singleton_dfn", "singleton_interface_dfn", "service_obsolete_dfn",
952 : : "$@58", "$@59", "type_dcl", "$@60", "type_declarator", "$@61",
953 : : "at_least_one_declarator", "declarators", "$@62", "declarator",
954 : : "simple_declarator", "complex_declarator", "array_declarator", "$@63",
955 : : "at_least_one_array_dim", "array_dims", "array_dim", "$@64", "$@65",
956 : : "at_least_one_scoped_name", "scoped_names", "$@66", "scoped_name",
957 : : "$@67", "$@68", "type_spec", "simple_type_spec", "fundamental_type",
958 : : "opt_type_args", "type_args", "type_arg", "base_type_spec",
959 : : "integer_type", "signed_int", "unsigned_int", "floating_pt_type",
960 : : "char_type", "byte_type", "boolean_type", "any_type", "type_type",
961 : : "string_type", "template_type_spec", "constructed_type_spec",
962 : : "array_type", "$@69", "sequence_type_spec", "$@70", "$@71", "$@72",
963 : : "struct_type", "$@73", "$@74", "$@75", "structure_header", "$@76",
964 : : "$@77", "opt_type_params", "type_params", "at_least_one_member",
965 : : "members", "member", "$@78", "$@79", "type_or_parameter", "enum_type",
966 : : "$@80", "$@81", "$@82", "$@83", "at_least_one_enumerator", "enumerators",
967 : : "$@84", "enumerator", "union_type", "$@85", "$@86", "$@87", "$@88",
968 : : "$@89", "$@90", "$@91", "$@92", "switch_type_spec",
969 : : "at_least_one_case_branch", "case_branches", "case_branch", "$@93",
970 : : "at_least_one_case_label", "case_labels", "case_label", "$@94", "$@95",
971 : : "$@96", "element_spec", "$@97", "$@98", "identifier", 0
972 : : };
973 : : #endif
974 : :
975 : : # ifdef YYPRINT
976 : : /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
977 : : token YYLEX-NUM. */
978 : : static const yytype_uint16 yytoknum[] =
979 : : {
980 : : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
981 : : 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
982 : : 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
983 : : 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
984 : : 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
985 : : 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
986 : : 315, 316, 59, 123, 125, 58, 91, 93, 44, 40,
987 : : 41, 61, 124, 94, 38, 43, 45, 42, 47, 37,
988 : : 126, 60, 62
989 : : };
990 : : # endif
991 : :
992 : : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
993 : : static const yytype_uint16 yyr1[] =
994 : : {
995 : : 0, 83, 84, 85, 85, 86, 87, 86, 86, 88,
996 : : 88, 90, 89, 91, 89, 92, 89, 93, 89, 94,
997 : : 89, 95, 89, 96, 89, 98, 99, 100, 101, 97,
998 : : 102, 102, 104, 103, 105, 107, 108, 109, 106, 106,
999 : : 110, 112, 111, 111, 113, 113, 115, 114, 116, 114,
1000 : : 117, 114, 119, 120, 118, 121, 122, 122, 123, 123,
1001 : : 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1002 : : 124, 124, 125, 125, 126, 126, 126, 127, 127, 128,
1003 : : 129, 129, 131, 130, 133, 134, 135, 136, 137, 132,
1004 : : 139, 138, 138, 140, 140, 141, 142, 141, 141, 141,
1005 : : 144, 145, 143, 143, 146, 146, 146, 147, 147, 148,
1006 : : 148, 150, 151, 149, 152, 152, 153, 155, 154, 156,
1007 : : 156, 157, 157, 159, 158, 161, 162, 163, 164, 160,
1008 : : 166, 167, 168, 169, 165, 170, 171, 172, 172, 173,
1009 : : 173, 174, 174, 175, 175, 175, 176, 176, 176, 177,
1010 : : 177, 177, 177, 178, 178, 178, 178, 179, 179, 179,
1011 : : 180, 180, 180, 180, 180, 181, 182, 182, 182, 182,
1012 : : 182, 182, 184, 185, 183, 187, 188, 189, 186, 191,
1013 : : 190, 190, 192, 192, 193, 193, 193, 193, 193, 194,
1014 : : 194, 195, 195, 197, 198, 196, 199, 199, 201, 200,
1015 : : 202, 202, 203, 204, 204, 206, 207, 205, 209, 210,
1016 : : 208, 211, 211, 212, 214, 215, 213, 217, 216, 216,
1017 : : 216, 216, 219, 218, 220, 222, 221, 221, 223, 223,
1018 : : 224, 225, 227, 226, 228, 229, 229, 231, 232, 230,
1019 : : 233, 235, 234, 234, 236, 237, 236, 238, 236, 239,
1020 : : 239, 240, 240, 241, 241, 242, 242, 243, 243, 244,
1021 : : 245, 245, 245, 245, 245, 245, 245, 245, 246, 246,
1022 : : 247, 247, 247, 248, 248, 248, 249, 249, 250, 251,
1023 : : 252, 253, 254, 255, 256, 256, 257, 257, 257, 259,
1024 : : 258, 261, 262, 263, 260, 260, 265, 266, 267, 264,
1025 : : 269, 270, 268, 271, 271, 272, 272, 273, 274, 274,
1026 : : 276, 277, 275, 275, 278, 278, 280, 281, 282, 283,
1027 : : 279, 284, 286, 285, 285, 285, 287, 287, 289, 290,
1028 : : 291, 292, 293, 294, 295, 296, 288, 297, 297, 297,
1029 : : 297, 297, 298, 299, 299, 301, 300, 302, 303, 303,
1030 : : 305, 304, 306, 307, 304, 309, 310, 308, 308, 311,
1031 : : 311, 311, 311
1032 : : };
1033 : :
1034 : : /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1035 : : static const yytype_uint8 yyr2[] =
1036 : : {
1037 : : 0, 2, 1, 2, 0, 2, 0, 3, 2, 1,
1038 : : 0, 0, 3, 0, 3, 0, 3, 0, 3, 0,
1039 : : 3, 0, 3, 0, 3, 0, 0, 0, 0, 9,
1040 : : 1, 1, 0, 3, 1, 0, 0, 0, 7, 2,
1041 : : 2, 0, 3, 0, 2, 0, 0, 3, 0, 3,
1042 : : 0, 3, 0, 0, 6, 3, 3, 1, 1, 1,
1043 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
1044 : : 2, 0, 2, 2, 2, 2, 0, 1, 0, 3,
1045 : : 1, 0, 0, 4, 0, 0, 0, 0, 0, 12,
1046 : : 0, 4, 0, 1, 1, 1, 0, 4, 0, 2,
1047 : : 0, 0, 8, 2, 1, 1, 1, 1, 0, 1,
1048 : : 0, 0, 0, 6, 1, 3, 1, 0, 4, 3,
1049 : : 0, 2, 0, 0, 3, 0, 0, 0, 0, 9,
1050 : : 0, 0, 0, 0, 9, 1, 1, 1, 3, 1,
1051 : : 3, 1, 3, 1, 3, 3, 1, 3, 3, 1,
1052 : : 3, 3, 3, 1, 2, 2, 2, 1, 1, 3,
1053 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1054 : : 1, 1, 0, 0, 5, 0, 0, 0, 7, 0,
1055 : : 4, 2, 2, 0, 3, 3, 3, 3, 2, 1,
1056 : : 2, 1, 2, 0, 0, 5, 1, 1, 0, 4,
1057 : : 1, 0, 3, 2, 0, 0, 0, 8, 0, 0,
1058 : : 5, 1, 1, 2, 0, 0, 5, 0, 3, 1,
1059 : : 1, 1, 0, 3, 2, 0, 4, 0, 1, 1,
1060 : : 1, 1, 0, 3, 2, 2, 0, 0, 0, 5,
1061 : : 2, 0, 4, 0, 1, 0, 3, 0, 4, 1,
1062 : : 1, 1, 2, 1, 1, 3, 0, 1, 3, 1,
1063 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1064 : : 1, 1, 1, 2, 2, 2, 1, 1, 1, 1,
1065 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1066 : : 3, 0, 0, 0, 7, 2, 0, 0, 0, 7,
1067 : : 0, 0, 6, 3, 0, 1, 3, 2, 2, 0,
1068 : : 0, 0, 5, 2, 1, 2, 0, 0, 0, 0,
1069 : : 9, 2, 0, 4, 0, 2, 1, 3, 0, 0,
1070 : : 0, 0, 0, 0, 0, 0, 17, 1, 1, 1,
1071 : : 1, 1, 2, 2, 0, 0, 3, 2, 2, 0,
1072 : : 0, 3, 0, 0, 5, 0, 0, 5, 2, 1,
1073 : : 1, 1, 1
1074 : : };
1075 : :
1076 : : /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1077 : : Performed when YYTABLE doesn't specify something else to do. Zero
1078 : : means the default is an error. */
1079 : : static const yytype_uint16 yydefact[] =
1080 : : {
1081 : : 0, 0, 25, 9, 0, 2, 0, 0, 6, 8,
1082 : : 0, 1, 3, 0, 125, 130, 316, 172, 32, 193,
1083 : : 208, 300, 217, 328, 5, 17, 34, 31, 30, 35,
1084 : : 13, 23, 175, 15, 19, 21, 11, 219, 296, 221,
1085 : : 220, 0, 359, 360, 361, 362, 26, 39, 0, 0,
1086 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 41,
1087 : : 40, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1088 : : 7, 0, 278, 280, 279, 276, 277, 271, 270, 272,
1089 : : 0, 245, 126, 171, 166, 268, 269, 170, 167, 168,
1090 : : 169, 244, 131, 317, 173, 33, 194, 209, 301, 0,
1091 : : 291, 281, 283, 282, 218, 256, 222, 249, 251, 253,
1092 : : 260, 261, 262, 264, 263, 265, 266, 267, 254, 250,
1093 : : 285, 284, 286, 288, 287, 329, 18, 0, 36, 14,
1094 : : 24, 176, 16, 20, 22, 12, 297, 27, 274, 273,
1095 : : 275, 0, 0, 247, 0, 0, 43, 0, 0, 304,
1096 : : 295, 0, 0, 252, 0, 0, 0, 42, 45, 309,
1097 : : 0, 0, 246, 127, 0, 132, 318, 174, 214, 0,
1098 : : 195, 196, 197, 0, 210, 211, 212, 0, 43, 292,
1099 : : 259, 0, 257, 223, 227, 228, 229, 231, 230, 237,
1100 : : 290, 236, 330, 92, 0, 0, 256, 289, 314, 298,
1101 : : 309, 310, 28, 0, 248, 122, 0, 183, 198, 213,
1102 : : 0, 305, 302, 0, 0, 255, 224, 0, 0, 234,
1103 : : 0, 0, 0, 44, 46, 0, 48, 0, 50, 0,
1104 : : 0, 308, 313, 315, 0, 0, 0, 0, 128, 133,
1105 : : 122, 123, 319, 0, 326, 0, 201, 0, 303, 289,
1106 : : 258, 225, 233, 163, 164, 160, 161, 162, 0, 0,
1107 : : 0, 0, 165, 136, 137, 139, 141, 143, 146, 149,
1108 : : 153, 158, 238, 157, 235, 331, 0, 58, 63, 64,
1109 : : 66, 67, 62, 61, 59, 60, 68, 65, 90, 0,
1110 : : 57, 38, 0, 52, 0, 94, 84, 93, 0, 117,
1111 : : 178, 299, 311, 29, 0, 0, 121, 0, 0, 0,
1112 : : 321, 0, 0, 189, 0, 0, 191, 0, 0, 0,
1113 : : 182, 0, 0, 0, 204, 199, 200, 306, 0, 0,
1114 : : 0, 154, 155, 156, 0, 0, 0, 0, 0, 0,
1115 : : 0, 0, 0, 0, 0, 0, 69, 119, 0, 55,
1116 : : 0, 47, 0, 49, 0, 51, 0, 0, 129, 135,
1117 : : 134, 124, 320, 325, 322, 327, 181, 0, 243, 0,
1118 : : 61, 190, 192, 179, 188, 0, 0, 216, 0, 294,
1119 : : 226, 159, 138, 140, 142, 144, 145, 147, 148, 150,
1120 : : 151, 152, 239, 341, 337, 338, 339, 340, 332, 91,
1121 : : 56, 53, 230, 85, 118, 312, 0, 187, 240, 186,
1122 : : 0, 184, 185, 202, 203, 205, 0, 71, 0, 323,
1123 : : 241, 180, 0, 333, 0, 54, 86, 0, 0, 0,
1124 : : 0, 0, 82, 70, 0, 81, 78, 0, 242, 0,
1125 : : 0, 0, 95, 334, 73, 111, 0, 0, 72, 74,
1126 : : 80, 75, 77, 87, 99, 103, 104, 105, 106, 0,
1127 : : 96, 110, 0, 0, 79, 0, 0, 100, 0, 206,
1128 : : 109, 352, 350, 335, 344, 345, 349, 112, 83, 88,
1129 : : 0, 0, 97, 0, 0, 0, 0, 342, 0, 347,
1130 : : 0, 110, 101, 207, 353, 351, 336, 343, 0, 355,
1131 : : 346, 348, 0, 114, 116, 89, 108, 0, 358, 0,
1132 : : 0, 113, 107, 0, 354, 356, 115, 102, 0, 357
1133 : : };
1134 : :
1135 : : /* YYDEFGOTO[NTERM-NUM]. */
1136 : : static const yytype_int16 yydefgoto[] =
1137 : : {
1138 : : -1, 4, 5, 6, 41, 7, 24, 68, 62, 65,
1139 : : 58, 66, 67, 63, 8, 10, 71, 161, 237, 25,
1140 : : 26, 52, 27, 28, 61, 158, 222, 29, 60, 127,
1141 : : 193, 223, 292, 294, 298, 224, 352, 417, 225, 289,
1142 : : 290, 425, 433, 434, 451, 435, 449, 436, 447, 226,
1143 : : 354, 418, 437, 466, 491, 227, 348, 296, 441, 468,
1144 : : 442, 480, 506, 459, 513, 469, 470, 463, 490, 502,
1145 : : 503, 228, 356, 229, 239, 240, 307, 241, 48, 142,
1146 : : 203, 304, 31, 49, 144, 205, 305, 358, 262, 263,
1147 : : 264, 265, 266, 267, 268, 269, 270, 271, 272, 82,
1148 : : 32, 51, 146, 33, 64, 159, 230, 319, 410, 245,
1149 : : 320, 321, 322, 34, 53, 147, 170, 171, 246, 325,
1150 : : 326, 378, 414, 422, 483, 35, 54, 148, 174, 175,
1151 : : 172, 207, 323, 36, 56, 104, 154, 183, 216, 329,
1152 : : 184, 185, 186, 187, 217, 190, 219, 191, 218, 344,
1153 : : 367, 408, 427, 273, 141, 164, 106, 197, 108, 153,
1154 : : 181, 182, 109, 110, 85, 86, 111, 112, 113, 114,
1155 : : 115, 116, 117, 118, 119, 120, 155, 121, 151, 213,
1156 : : 328, 122, 69, 160, 234, 38, 55, 149, 178, 210,
1157 : : 199, 194, 231, 236, 357, 201, 123, 50, 145, 206,
1158 : : 308, 242, 310, 406, 243, 124, 57, 156, 220, 345,
1159 : : 416, 429, 462, 486, 398, 473, 487, 474, 488, 475,
1160 : : 489, 476, 485, 484, 507, 500, 509, 518, 91
1161 : : };
1162 : :
1163 : : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1164 : : STATE-NUM. */
1165 : : #define YYPACT_NINF -415
1166 : : static const yytype_int16 yypact[] =
1167 : : {
1168 : : 353, -8, -415, -415, 19, -415, 93, 748, -415, -415,
1169 : : 147, -415, -415, 8, -415, -415, -415, -415, -415, -415,
1170 : : -415, -415, -415, -415, -415, -415, -34, -415, -415, -415,
1171 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1172 : : -415, 15, -415, -415, -415, -415, -415, -415, 677, 147,
1173 : : 147, 147, 147, 147, 147, 147, 474, 147, 26, -415,
1174 : : -415, 33, 37, 46, 53, 60, 64, 68, 76, 83,
1175 : : -415, 85, -415, -415, -415, -415, -415, -415, -415, -415,
1176 : : -13, -415, -415, 17, -415, -415, -415, -415, -415, -415,
1177 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, 71,
1178 : : -415, -415, -415, -415, -415, -35, -415, 94, -415, -415,
1179 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1180 : : -415, -415, -415, -415, -415, -415, -415, 133, -415, -415,
1181 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1182 : : -415, 147, 147, -415, 101, 103, 106, 48, 54, 97,
1183 : : -415, 100, 623, -415, 147, 110, 155, 17, -415, -415,
1184 : : 652, 441, -415, -415, 147, -415, -415, -415, -415, 133,
1185 : : -415, -415, -415, 133, -415, -415, -415, 147, 106, -415,
1186 : : 94, -47, -415, -415, -415, -415, -415, -415, 123, -415,
1187 : : -415, -415, -415, 7, 294, -32, -35, -415, 129, -415,
1188 : : -415, -415, -415, 126, -415, 196, 147, -415, 17, 17,
1189 : : 27, -415, -415, 623, 623, -415, 136, 110, 9, 110,
1190 : : 137, 723, 141, -415, -415, 623, -415, 594, -415, 194,
1191 : : 144, -415, -415, 152, 158, 376, 147, 159, -415, -415,
1192 : : 196, -415, -415, 12, 153, 73, 162, 147, -415, 145,
1193 : : -415, -415, -415, -415, -415, -415, -415, -415, 9, 195,
1194 : : 195, 195, -415, 160, 163, 157, 95, -39, -20, -415,
1195 : : -415, -415, -415, 17, -415, -415, 168, -415, -415, -415,
1196 : : -415, -415, -415, 171, -415, -415, -415, -415, -415, 88,
1197 : : -415, -415, 177, 94, 178, -415, -415, 94, 183, -415,
1198 : : -415, -415, -415, -415, 9, 182, -415, 188, 193, 184,
1199 : : 190, 9, 197, -415, 133, 133, -415, 778, 565, 198,
1200 : : -415, 133, 133, 201, -415, -415, -415, -415, 179, 147,
1201 : : 192, -415, -415, -415, 9, 9, 9, 9, 9, 9,
1202 : : 9, 9, 9, 9, 199, 240, -415, -415, 200, -415,
1203 : : 778, -415, 147, -415, 147, -415, 133, 206, -415, -415,
1204 : : -415, -415, -415, -415, -415, -415, -415, 209, 17, 210,
1205 : : -415, -415, -415, 94, -415, 216, 220, -415, 109, -415,
1206 : : -415, -415, 163, 157, 95, -39, -39, -20, -20, -415,
1207 : : -415, -415, -415, 17, -415, -415, -415, -415, -415, -415,
1208 : : -415, -415, -415, -415, 17, -415, 147, -415, 215, -415,
1209 : : 147, -415, -415, -415, -415, -415, 214, 223, 218, -415,
1210 : : -415, -415, 219, -415, 50, -415, -415, 133, 13, 226,
1211 : : 227, 268, -415, -415, 232, 246, 252, 13, 17, 176,
1212 : : 16, 59, -415, -415, -415, -415, 243, 268, -415, -415,
1213 : : -415, -415, -415, 238, -415, 94, -415, -415, -415, 241,
1214 : : -415, 268, 28, 244, -415, 245, 239, -415, 21, -415,
1215 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1216 : : 623, 623, -415, 248, 9, 247, 250, 28, 519, 28,
1217 : : 133, 268, 94, -415, -415, -415, -415, -415, -30, -415,
1218 : : -415, -415, 75, -415, 17, -415, 260, 251, -415, 147,
1219 : : 133, -415, -415, 147, -415, -415, -415, -415, 255, -415
1220 : : };
1221 : :
1222 : : /* YYPGOTO[NTERM-NUM]. */
1223 : : static const yytype_int16 yypgoto[] =
1224 : : {
1225 : : -415, -415, 4, -415, -415, -415, -415, -415, -415, -415,
1226 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1227 : : -415, -415, -415, -415, -415, -415, -415, -415, -130, -415,
1228 : : -415, -415, -415, -415, -415, -415, -415, -415, 77, -415,
1229 : : -29, -415, -415, -415, -415, -118, -415, -112, -415, -415,
1230 : : -415, -415, -415, -415, -415, -415, -415, -415, -113, -415,
1231 : : -143, -415, -415, -415, -415, -165, -414, -415, -415, -415,
1232 : : -174, -415, -415, -415, 105, -415, -415, 334, -415, -415,
1233 : : -415, -415, -415, -415, -415, -415, -415, -415, -251, -415,
1234 : : 22, 14, 23, -163, -146, -208, -119, -415, -415, -415,
1235 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1236 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1237 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1238 : : 202, -415, -415, -415, -415, -415, -415, -227, -415, -415,
1239 : : -321, -9, -415, -415, -415, 134, -415, 138, -415, -415,
1240 : : -297, -415, -415, -45, -415, -415, -133, -55, -145, 166,
1241 : : -415, 149, -415, -44, -415, -415, 319, -43, 321, -42,
1242 : : -415, -415, -415, -415, -415, -415, -415, -415, -415, -415,
1243 : : -415, 364, -415, -415, -415, -415, -415, -415, -415, -415,
1244 : : -415, 172, 213, -415, -415, -415, -5, -415, -415, -415,
1245 : : -415, -415, -415, -415, -31, 367, -415, -415, -415, -415,
1246 : : -415, -415, -415, -415, -415, -415, -415, -111, -415, -415,
1247 : : -415, -103, -415, -415, -415, -415, -415, -415, -10
1248 : : };
1249 : :
1250 : : /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1251 : : positive, shift that token. If negative, reduce the rule which
1252 : : number is the opposite. If YYTABLE_NINF, syntax error. */
1253 : : #define YYTABLE_NINF -325
1254 : : static const yytype_int16 yytable[] =
1255 : : {
1256 : : 46, 107, 39, 83, 84, 88, 90, 330, 380, 302,
1257 : : 12, 105, 42, 309, 439, 198, 167, 446, 369, 11,
1258 : : -120, 214, 481, 143, 375, 376, 138, 139, 140, -43,
1259 : : 232, 59, 508, 465, 471, 215, 339, 340, 472, 92,
1260 : : 93, 94, 95, 96, 97, 98, 152, 125, 212, 198,
1261 : : 150, 430, 150, 359, 9, 253, 254, 341, 342, 343,
1262 : : 365, 43, 44, 45, 456, 457, 458, 81, 255, 256,
1263 : : 257, -37, 47, 221, 312, 143, -324, 70, 258, 440,
1264 : : -324, -98, 157, -98, 259, 260, 313, 440, 126, 261,
1265 : : 198, 314, 315, -4, 1, 247, 128, 180, 316, 129,
1266 : : -10, -10, 431, 432, -10, -10, -10, 105, 130, 248,
1267 : : 2, 168, 42, 169, -76, 196, 131, 168, -10, 173,
1268 : : -10, -10, 132, -10, 208, -10, 133, 460, 209, 461,
1269 : : 134, 162, 163, 389, 390, 391, 42, -215, 135, 317,
1270 : : 331, 332, 333, 510, 188, 511, 136, 3, 137, 196,
1271 : : 42, 337, 338, 150, 204, 349, 350, -4, 249, 180,
1272 : : -289, 43, 44, 45, 165, 202, 166, 211, 105, 105,
1273 : : 293, 59, 297, 413, 385, 386, 189, 99, 177, 42,
1274 : : 105, 179, 105, 421, 192, 43, 44, 45, 515, -232,
1275 : : 196, 81, 517, 387, 388, -251, 244, 238, 42, 43,
1276 : : 44, 45, 100, 14, 251, 291, 275, 299, 300, 101,
1277 : : 72, 73, 74, 75, 76, 77, 78, 79, -252, 102,
1278 : : 103, 80, 301, 303, 311, 324, 188, -293, 43, 44,
1279 : : 45, 336, 334, 494, 81, 346, 335, 327, 347, 351,
1280 : : 353, 253, 254, 42, 454, 355, 360, 43, 44, 45,
1281 : : 361, 16, 363, 81, 255, 256, 257, 362, 364, 366,
1282 : : 374, 379, 381, 373, 258, 377, 392, 399, 405, 368,
1283 : : 368, 407, 409, 105, 72, 73, 368, 368, 411, 77,
1284 : : 78, 79, 412, 420, 423, 80, 424, 426, 428, 443,
1285 : : 445, 444, 43, 44, 45, 195, 448, 42, 81, 432,
1286 : : 393, 394, 395, 396, 431, 464, 460, 478, 467, 479,
1287 : : 493, 404, 495, 477, 496, 512, 514, 519, 452, 188,
1288 : : 100, 400, 318, 450, 453, 482, 505, 101, 72, 73,
1289 : : 74, 75, 76, 77, 78, 79, 516, 102, 103, 80,
1290 : : 397, 30, 402, 401, 403, 306, 43, 44, 45, 383,
1291 : : 176, 252, 81, -4, 1, 499, 382, 274, -177, 384,
1292 : : -10, -10, 233, 250, -10, -10, -10, 87, 415, 89,
1293 : : 2, 37, 235, 200, 40, 419, 497, 195, -10, 42,
1294 : : -10, -10, 438, -10, 455, -10, 501, 0, 0, 0,
1295 : : 0, 0, 0, 0, 105, 0, 244, 0, 0, 0,
1296 : : 188, 0, 100, 0, 0, 0, 0, 3, 0, 101,
1297 : : 72, 73, 74, 75, 76, 77, 78, 79, 0, 102,
1298 : : 103, 80, 0, 0, 0, 492, 455, 0, 43, 44,
1299 : : 45, 0, 0, 107, 81, 105, 105, 0, 0, 0,
1300 : : -307, 0, 1, 105, 0, 504, 0, 0, -10, -10,
1301 : : 0, 0, -10, -10, -10, 0, 0, 0, 2, 0,
1302 : : 0, 0, 0, 0, 0, 504, -10, 0, -10, -10,
1303 : : 0, -10, 0, -10, 0, 99, 0, 42, 0, 0,
1304 : : 0, 0, 0, 0, 0, 16, 0, 0, 0, 0,
1305 : : 0, 0, 0, 0, 0, 3, 0, 0, 0, 188,
1306 : : 100, 0, 21, 188, 0, -4, 23, 101, 72, 73,
1307 : : 74, 75, 76, 77, 78, 79, 0, 102, 103, 80,
1308 : : 498, 0, 42, 0, 0, 0, 43, 44, 45, 0,
1309 : : 16, 0, 81, 0, 0, 0, 0, 0, 0, 0,
1310 : : 0, 0, 0, 0, 0, 100, 0, 21, 0, 0,
1311 : : 0, 23, 101, 72, 73, 74, 75, 76, 77, 78,
1312 : : 79, 0, 102, 103, 80, 0, 99, 0, 42, 0,
1313 : : 0, 43, 44, 45, 0, 0, 0, 81, 371, 0,
1314 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1315 : : 372, 100, 0, 0, 0, 99, 0, 42, 101, 72,
1316 : : 73, 74, 75, 76, 77, 78, 79, 0, 102, 103,
1317 : : 80, 0, 0, 0, 0, 0, 0, 43, 44, 45,
1318 : : 100, 0, 0, 81, 99, 0, 42, 101, 72, 73,
1319 : : 74, 75, 76, 77, 78, 79, 295, 102, 103, 80,
1320 : : 0, 0, 0, 0, 0, 0, 43, 44, 45, 100,
1321 : : 0, 0, 81, 195, 0, 42, 101, 72, 73, 74,
1322 : : 75, 76, 77, 78, 79, 0, 102, 103, 80, 0,
1323 : : 0, 0, 0, 0, 0, 43, 44, 45, 100, 0,
1324 : : 42, 81, 0, 0, 0, 101, 72, 73, 74, 75,
1325 : : 76, 77, 78, 79, 0, 102, 103, 80, 0, 0,
1326 : : 0, 0, 0, 0, 43, 44, 45, 0, 0, 0,
1327 : : 81, 72, 73, 74, 75, 76, 77, 78, 79, 0,
1328 : : 0, 0, 80, 0, 276, 0, 0, 277, 278, 43,
1329 : : 44, 45, 279, 0, 0, 81, 0, 280, 281, 282,
1330 : : 0, 0, 0, 283, 284, 0, 285, 286, 0, 13,
1331 : : 0, 0, 0, 0, 287, 14, 15, 0, 0, 16,
1332 : : 17, 18, 0, 0, 0, 0, 0, 0, 0, 0,
1333 : : 0, 0, 0, 19, 288, 20, 21, 0, 22, 276,
1334 : : 23, 0, 277, 278, 0, 0, 0, 279, 0, 0,
1335 : : 0, 0, 280, 281, 282, 0, 0, 0, 370, 284,
1336 : : 0, 285, 286, 0, 0, 0, 0, 0, 0, 287
1337 : : };
1338 : :
1339 : : #define yypact_value_is_default(yystate) \
1340 : : ((yystate) == (-415))
1341 : :
1342 : : #define yytable_value_is_error(yytable_value) \
1343 : : YYID (0)
1344 : :
1345 : : static const yytype_int16 yycheck[] =
1346 : : {
1347 : : 10, 56, 7, 48, 48, 48, 48, 258, 329, 236,
1348 : : 6, 56, 3, 1, 1, 160, 146, 431, 315, 0,
1349 : : 13, 68, 1, 58, 321, 322, 39, 40, 41, 63,
1350 : : 62, 65, 62, 447, 6, 82, 75, 76, 10, 49,
1351 : : 50, 51, 52, 53, 54, 55, 81, 57, 178, 194,
1352 : : 82, 1, 82, 304, 62, 46, 47, 77, 78, 79,
1353 : : 311, 52, 53, 54, 48, 49, 50, 58, 59, 60,
1354 : : 61, 64, 64, 66, 1, 58, 64, 62, 69, 66,
1355 : : 68, 68, 127, 70, 75, 76, 13, 66, 62, 80,
1356 : : 235, 18, 19, 0, 1, 68, 63, 152, 25, 62,
1357 : : 7, 8, 52, 53, 11, 12, 13, 152, 62, 82,
1358 : : 17, 63, 3, 65, 64, 160, 63, 63, 25, 65,
1359 : : 27, 28, 62, 30, 169, 32, 62, 68, 173, 70,
1360 : : 62, 141, 142, 341, 342, 343, 3, 64, 62, 66,
1361 : : 259, 260, 261, 68, 154, 70, 63, 54, 63, 194,
1362 : : 3, 56, 57, 82, 164, 67, 68, 64, 213, 214,
1363 : : 66, 52, 53, 54, 63, 161, 63, 177, 213, 214,
1364 : : 225, 65, 227, 64, 337, 338, 66, 1, 81, 3,
1365 : : 225, 81, 227, 410, 29, 52, 53, 54, 509, 66,
1366 : : 235, 58, 513, 339, 340, 66, 206, 71, 3, 52,
1367 : : 53, 54, 26, 7, 68, 64, 69, 13, 64, 33,
1368 : : 34, 35, 36, 37, 38, 39, 40, 41, 66, 43,
1369 : : 44, 45, 64, 64, 71, 63, 236, 82, 52, 53,
1370 : : 54, 74, 72, 484, 58, 67, 73, 247, 67, 62,
1371 : : 62, 46, 47, 3, 68, 62, 64, 52, 53, 54,
1372 : : 62, 11, 68, 58, 59, 60, 61, 64, 68, 62,
1373 : : 62, 82, 70, 318, 69, 64, 67, 67, 62, 314,
1374 : : 315, 62, 62, 318, 34, 35, 321, 322, 62, 39,
1375 : : 40, 41, 62, 68, 70, 45, 63, 69, 69, 63,
1376 : : 22, 64, 52, 53, 54, 1, 64, 3, 58, 53,
1377 : : 345, 345, 345, 345, 52, 62, 68, 62, 67, 70,
1378 : : 62, 356, 65, 69, 64, 55, 65, 62, 436, 329,
1379 : : 26, 350, 245, 435, 437, 468, 491, 33, 34, 35,
1380 : : 36, 37, 38, 39, 40, 41, 510, 43, 44, 45,
1381 : : 345, 7, 352, 352, 354, 240, 52, 53, 54, 335,
1382 : : 148, 217, 58, 0, 1, 488, 334, 219, 64, 336,
1383 : : 7, 8, 196, 214, 11, 12, 13, 48, 378, 48,
1384 : : 17, 7, 200, 160, 7, 406, 487, 1, 25, 3,
1385 : : 27, 28, 427, 30, 439, 32, 489, -1, -1, -1,
1386 : : -1, -1, -1, -1, 439, -1, 406, -1, -1, -1,
1387 : : 410, -1, 26, -1, -1, -1, -1, 54, -1, 33,
1388 : : 34, 35, 36, 37, 38, 39, 40, 41, -1, 43,
1389 : : 44, 45, -1, -1, -1, 480, 481, -1, 52, 53,
1390 : : 54, -1, -1, 488, 58, 480, 481, -1, -1, -1,
1391 : : 64, -1, 1, 488, -1, 490, -1, -1, 7, 8,
1392 : : -1, -1, 11, 12, 13, -1, -1, -1, 17, -1,
1393 : : -1, -1, -1, -1, -1, 510, 25, -1, 27, 28,
1394 : : -1, 30, -1, 32, -1, 1, -1, 3, -1, -1,
1395 : : -1, -1, -1, -1, -1, 11, -1, -1, -1, -1,
1396 : : -1, -1, -1, -1, -1, 54, -1, -1, -1, 509,
1397 : : 26, -1, 28, 513, -1, 64, 32, 33, 34, 35,
1398 : : 36, 37, 38, 39, 40, 41, -1, 43, 44, 45,
1399 : : 1, -1, 3, -1, -1, -1, 52, 53, 54, -1,
1400 : : 11, -1, 58, -1, -1, -1, -1, -1, -1, -1,
1401 : : -1, -1, -1, -1, -1, 26, -1, 28, -1, -1,
1402 : : -1, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1403 : : 41, -1, 43, 44, 45, -1, 1, -1, 3, -1,
1404 : : -1, 52, 53, 54, -1, -1, -1, 58, 13, -1,
1405 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1406 : : 25, 26, -1, -1, -1, 1, -1, 3, 33, 34,
1407 : : 35, 36, 37, 38, 39, 40, 41, -1, 43, 44,
1408 : : 45, -1, -1, -1, -1, -1, -1, 52, 53, 54,
1409 : : 26, -1, -1, 58, 1, -1, 3, 33, 34, 35,
1410 : : 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1411 : : -1, -1, -1, -1, -1, -1, 52, 53, 54, 26,
1412 : : -1, -1, 58, 1, -1, 3, 33, 34, 35, 36,
1413 : : 37, 38, 39, 40, 41, -1, 43, 44, 45, -1,
1414 : : -1, -1, -1, -1, -1, 52, 53, 54, 26, -1,
1415 : : 3, 58, -1, -1, -1, 33, 34, 35, 36, 37,
1416 : : 38, 39, 40, 41, -1, 43, 44, 45, -1, -1,
1417 : : -1, -1, -1, -1, 52, 53, 54, -1, -1, -1,
1418 : : 58, 34, 35, 36, 37, 38, 39, 40, 41, -1,
1419 : : -1, -1, 45, -1, 1, -1, -1, 4, 5, 52,
1420 : : 53, 54, 9, -1, -1, 58, -1, 14, 15, 16,
1421 : : -1, -1, -1, 20, 21, -1, 23, 24, -1, 1,
1422 : : -1, -1, -1, -1, 31, 7, 8, -1, -1, 11,
1423 : : 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
1424 : : -1, -1, -1, 25, 51, 27, 28, -1, 30, 1,
1425 : : 32, -1, 4, 5, -1, -1, -1, 9, -1, -1,
1426 : : -1, -1, 14, 15, 16, -1, -1, -1, 20, 21,
1427 : : -1, 23, 24, -1, -1, -1, -1, -1, -1, 31
1428 : : };
1429 : :
1430 : : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1431 : : symbol of state STATE-NUM. */
1432 : : static const yytype_uint16 yystos[] =
1433 : : {
1434 : : 0, 1, 17, 54, 84, 85, 86, 88, 97, 62,
1435 : : 98, 0, 85, 1, 7, 8, 11, 12, 13, 25,
1436 : : 27, 28, 30, 32, 89, 102, 103, 105, 106, 110,
1437 : : 160, 165, 183, 186, 196, 208, 216, 264, 268, 279,
1438 : : 288, 87, 3, 52, 53, 54, 311, 64, 161, 166,
1439 : : 280, 184, 104, 197, 209, 269, 217, 289, 93, 65,
1440 : : 111, 107, 91, 96, 187, 92, 94, 95, 90, 265,
1441 : : 62, 99, 34, 35, 36, 37, 38, 39, 40, 41,
1442 : : 45, 58, 182, 236, 246, 247, 248, 249, 250, 251,
1443 : : 252, 311, 311, 311, 311, 311, 311, 311, 311, 1,
1444 : : 26, 33, 43, 44, 218, 236, 239, 240, 241, 245,
1445 : : 246, 249, 250, 251, 252, 253, 254, 255, 256, 257,
1446 : : 258, 260, 264, 279, 288, 311, 62, 112, 63, 62,
1447 : : 62, 63, 62, 62, 62, 62, 63, 63, 39, 40,
1448 : : 41, 237, 162, 58, 167, 281, 185, 198, 210, 270,
1449 : : 82, 261, 81, 242, 219, 259, 290, 236, 108, 188,
1450 : : 266, 100, 311, 311, 238, 63, 63, 111, 63, 65,
1451 : : 199, 200, 213, 65, 211, 212, 213, 81, 271, 81,
1452 : : 240, 243, 244, 220, 223, 224, 225, 226, 311, 66,
1453 : : 228, 230, 29, 113, 274, 1, 236, 240, 241, 273,
1454 : : 275, 278, 85, 163, 311, 168, 282, 214, 236, 236,
1455 : : 272, 311, 111, 262, 68, 82, 221, 227, 231, 229,
1456 : : 291, 66, 109, 114, 118, 121, 132, 138, 154, 156,
1457 : : 189, 275, 62, 242, 267, 274, 276, 101, 71, 157,
1458 : : 158, 160, 284, 287, 311, 192, 201, 68, 82, 240,
1459 : : 244, 68, 228, 46, 47, 59, 60, 61, 69, 75,
1460 : : 76, 80, 171, 172, 173, 174, 175, 176, 177, 178,
1461 : : 179, 180, 181, 236, 230, 69, 1, 4, 5, 9,
1462 : : 14, 15, 16, 20, 21, 23, 24, 31, 51, 122,
1463 : : 123, 64, 115, 240, 116, 42, 140, 240, 117, 13,
1464 : : 64, 64, 220, 64, 164, 169, 157, 159, 283, 1,
1465 : : 285, 71, 1, 13, 18, 19, 25, 66, 121, 190,
1466 : : 193, 194, 195, 215, 63, 202, 203, 311, 263, 222,
1467 : : 171, 179, 179, 179, 72, 73, 74, 56, 57, 75,
1468 : : 76, 77, 78, 79, 232, 292, 67, 67, 139, 67,
1469 : : 68, 62, 119, 62, 133, 62, 155, 277, 170, 171,
1470 : : 64, 62, 64, 68, 68, 171, 62, 233, 236, 233,
1471 : : 20, 13, 25, 240, 62, 233, 233, 64, 204, 82,
1472 : : 223, 70, 173, 174, 175, 176, 176, 177, 177, 178,
1473 : : 178, 178, 67, 236, 246, 250, 252, 279, 297, 67,
1474 : : 123, 224, 311, 311, 236, 62, 286, 62, 234, 62,
1475 : : 191, 62, 62, 64, 205, 311, 293, 120, 134, 287,
1476 : : 68, 220, 206, 70, 63, 124, 69, 235, 69, 294,
1477 : : 1, 52, 53, 125, 126, 128, 130, 135, 236, 1,
1478 : : 66, 141, 143, 63, 64, 22, 149, 131, 64, 129,
1479 : : 130, 127, 128, 141, 68, 240, 48, 49, 50, 146,
1480 : : 68, 70, 295, 150, 62, 149, 136, 67, 142, 148,
1481 : : 149, 6, 10, 298, 300, 302, 304, 69, 62, 70,
1482 : : 144, 1, 143, 207, 306, 305, 296, 299, 301, 303,
1483 : : 151, 137, 240, 62, 171, 65, 64, 300, 1, 239,
1484 : : 308, 304, 152, 153, 236, 148, 145, 307, 62, 309,
1485 : : 68, 70, 55, 147, 65, 223, 153, 223, 310, 62
1486 : : };
1487 : :
1488 : : #define yyerrok (yyerrstatus = 0)
1489 : : #define yyclearin (yychar = YYEMPTY)
1490 : : #define YYEMPTY (-2)
1491 : : #define YYEOF 0
1492 : :
1493 : : #define YYACCEPT goto yyacceptlab
1494 : : #define YYABORT goto yyabortlab
1495 : : #define YYERROR goto yyerrorlab
1496 : :
1497 : :
1498 : : /* Like YYERROR except do call yyerror. This remains here temporarily
1499 : : to ease the transition to the new meaning of YYERROR, for GCC.
1500 : : Once GCC version 2 has supplanted version 1, this can go. However,
1501 : : YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1502 : : in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1503 : : discussed. */
1504 : :
1505 : : #define YYFAIL goto yyerrlab
1506 : : #if defined YYFAIL
1507 : : /* This is here to suppress warnings from the GCC cpp's
1508 : : -Wunused-macros. Normally we don't worry about that warning, but
1509 : : some users do, and we want to make it easy for users to remove
1510 : : YYFAIL uses, which will produce warnings from Bison 2.5. */
1511 : : #endif
1512 : :
1513 : : #define YYRECOVERING() (!!yyerrstatus)
1514 : :
1515 : : #define YYBACKUP(Token, Value) \
1516 : : do \
1517 : : if (yychar == YYEMPTY && yylen == 1) \
1518 : : { \
1519 : : yychar = (Token); \
1520 : : yylval = (Value); \
1521 : : YYPOPSTACK (1); \
1522 : : goto yybackup; \
1523 : : } \
1524 : : else \
1525 : : { \
1526 : : yyerror (YY_("syntax error: cannot back up")); \
1527 : : YYERROR; \
1528 : : } \
1529 : : while (YYID (0))
1530 : :
1531 : :
1532 : : #define YYTERROR 1
1533 : : #define YYERRCODE 256
1534 : :
1535 : :
1536 : : /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1537 : : If N is 0, then set CURRENT to the empty location which ends
1538 : : the previous symbol: RHS[0] (always defined). */
1539 : :
1540 : : #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1541 : : #ifndef YYLLOC_DEFAULT
1542 : : # define YYLLOC_DEFAULT(Current, Rhs, N) \
1543 : : do \
1544 : : if (YYID (N)) \
1545 : : { \
1546 : : (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1547 : : (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1548 : : (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1549 : : (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1550 : : } \
1551 : : else \
1552 : : { \
1553 : : (Current).first_line = (Current).last_line = \
1554 : : YYRHSLOC (Rhs, 0).last_line; \
1555 : : (Current).first_column = (Current).last_column = \
1556 : : YYRHSLOC (Rhs, 0).last_column; \
1557 : : } \
1558 : : while (YYID (0))
1559 : : #endif
1560 : :
1561 : :
1562 : : /* This macro is provided for backward compatibility. */
1563 : :
1564 : : #ifndef YY_LOCATION_PRINT
1565 : : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1566 : : #endif
1567 : :
1568 : :
1569 : : /* YYLEX -- calling `yylex' with the right arguments. */
1570 : :
1571 : : #ifdef YYLEX_PARAM
1572 : : # define YYLEX yylex (YYLEX_PARAM)
1573 : : #else
1574 : : # define YYLEX yylex ()
1575 : : #endif
1576 : :
1577 : : /* Enable debugging if requested. */
1578 : : #if YYDEBUG
1579 : :
1580 : : # ifndef YYFPRINTF
1581 : : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1582 : : # define YYFPRINTF fprintf
1583 : : # endif
1584 : :
1585 : : # define YYDPRINTF(Args) \
1586 : : do { \
1587 : : if (yydebug) \
1588 : : YYFPRINTF Args; \
1589 : : } while (YYID (0))
1590 : :
1591 : : # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1592 : : do { \
1593 : : if (yydebug) \
1594 : : { \
1595 : : YYFPRINTF (stderr, "%s ", Title); \
1596 : : yy_symbol_print (stderr, \
1597 : : Type, Value); \
1598 : : YYFPRINTF (stderr, "\n"); \
1599 : : } \
1600 : : } while (YYID (0))
1601 : :
1602 : :
1603 : : /*--------------------------------.
1604 : : | Print this symbol on YYOUTPUT. |
1605 : : `--------------------------------*/
1606 : :
1607 : : /*ARGSUSED*/
1608 : : #if (defined __STDC__ || defined __C99__FUNC__ \
1609 : : || defined __cplusplus || defined _MSC_VER)
1610 : : static void
1611 : 0 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1612 : : #else
1613 : : static void
1614 : : yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1615 : : FILE *yyoutput;
1616 : : int yytype;
1617 : : YYSTYPE const * const yyvaluep;
1618 : : #endif
1619 : : {
1620 [ # # ]: 0 : if (!yyvaluep)
1621 : 0 : return;
1622 : : # ifdef YYPRINT
1623 : : if (yytype < YYNTOKENS)
1624 : : YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1625 : : # else
1626 : : YYUSE (yyoutput);
1627 : : # endif
1628 : : switch (yytype)
1629 : : {
1630 : : default:
1631 : 0 : break;
1632 : : }
1633 : : }
1634 : :
1635 : :
1636 : : /*--------------------------------.
1637 : : | Print this symbol on YYOUTPUT. |
1638 : : `--------------------------------*/
1639 : :
1640 : : #if (defined __STDC__ || defined __C99__FUNC__ \
1641 : : || defined __cplusplus || defined _MSC_VER)
1642 : : static void
1643 : 0 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1644 : : #else
1645 : : static void
1646 : : yy_symbol_print (yyoutput, yytype, yyvaluep)
1647 : : FILE *yyoutput;
1648 : : int yytype;
1649 : : YYSTYPE const * const yyvaluep;
1650 : : #endif
1651 : : {
1652 [ # # ]: 0 : if (yytype < YYNTOKENS)
1653 : 0 : YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1654 : : else
1655 : 0 : YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1656 : :
1657 : 0 : yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1658 : 0 : YYFPRINTF (yyoutput, ")");
1659 : 0 : }
1660 : :
1661 : : /*------------------------------------------------------------------.
1662 : : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1663 : : | TOP (included). |
1664 : : `------------------------------------------------------------------*/
1665 : :
1666 : : #if (defined __STDC__ || defined __C99__FUNC__ \
1667 : : || defined __cplusplus || defined _MSC_VER)
1668 : : static void
1669 : 0 : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1670 : : #else
1671 : : static void
1672 : : yy_stack_print (yybottom, yytop)
1673 : : yytype_int16 *yybottom;
1674 : : yytype_int16 *yytop;
1675 : : #endif
1676 : : {
1677 : 0 : YYFPRINTF (stderr, "Stack now");
1678 [ # # ]: 0 : for (; yybottom <= yytop; yybottom++)
1679 : : {
1680 : 0 : int yybot = *yybottom;
1681 : 0 : YYFPRINTF (stderr, " %d", yybot);
1682 : : }
1683 : 0 : YYFPRINTF (stderr, "\n");
1684 : 0 : }
1685 : :
1686 : : # define YY_STACK_PRINT(Bottom, Top) \
1687 : : do { \
1688 : : if (yydebug) \
1689 : : yy_stack_print ((Bottom), (Top)); \
1690 : : } while (YYID (0))
1691 : :
1692 : :
1693 : : /*------------------------------------------------.
1694 : : | Report that the YYRULE is going to be reduced. |
1695 : : `------------------------------------------------*/
1696 : :
1697 : : #if (defined __STDC__ || defined __C99__FUNC__ \
1698 : : || defined __cplusplus || defined _MSC_VER)
1699 : : static void
1700 : 0 : yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1701 : : #else
1702 : : static void
1703 : : yy_reduce_print (yyvsp, yyrule)
1704 : : YYSTYPE *yyvsp;
1705 : : int yyrule;
1706 : : #endif
1707 : : {
1708 : 0 : int yynrhs = yyr2[yyrule];
1709 : : int yyi;
1710 : 0 : unsigned long int yylno = yyrline[yyrule];
1711 : : YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1712 : 0 : yyrule - 1, yylno);
1713 : : /* The symbols being reduced. */
1714 [ # # ]: 0 : for (yyi = 0; yyi < yynrhs; yyi++)
1715 : : {
1716 : 0 : YYFPRINTF (stderr, " $%d = ", yyi + 1);
1717 : 0 : yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1718 : : &(yyvsp[(yyi + 1) - (yynrhs)])
1719 : 0 : );
1720 : 0 : YYFPRINTF (stderr, "\n");
1721 : : }
1722 : 0 : }
1723 : :
1724 : : # define YY_REDUCE_PRINT(Rule) \
1725 : : do { \
1726 : : if (yydebug) \
1727 : : yy_reduce_print (yyvsp, Rule); \
1728 : : } while (YYID (0))
1729 : :
1730 : : /* Nonzero means print parse trace. It is left uninitialized so that
1731 : : multiple parsers can coexist. */
1732 : : int yydebug;
1733 : : #else /* !YYDEBUG */
1734 : : # define YYDPRINTF(Args)
1735 : : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1736 : : # define YY_STACK_PRINT(Bottom, Top)
1737 : : # define YY_REDUCE_PRINT(Rule)
1738 : : #endif /* !YYDEBUG */
1739 : :
1740 : :
1741 : : /* YYINITDEPTH -- initial size of the parser's stacks. */
1742 : : #ifndef YYINITDEPTH
1743 : : # define YYINITDEPTH 200
1744 : : #endif
1745 : :
1746 : : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1747 : : if the built-in stack extension method is used).
1748 : :
1749 : : Do not make this value too large; the results are undefined if
1750 : : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1751 : : evaluated with infinite-precision integer arithmetic. */
1752 : :
1753 : : #ifndef YYMAXDEPTH
1754 : : # define YYMAXDEPTH 10000
1755 : : #endif
1756 : :
1757 : :
1758 : : #if YYERROR_VERBOSE
1759 : :
1760 : : # ifndef yystrlen
1761 : : # if defined __GLIBC__ && defined _STRING_H
1762 : : # define yystrlen strlen
1763 : : # else
1764 : : /* Return the length of YYSTR. */
1765 : : #if (defined __STDC__ || defined __C99__FUNC__ \
1766 : : || defined __cplusplus || defined _MSC_VER)
1767 : : static YYSIZE_T
1768 : : yystrlen (const char *yystr)
1769 : : #else
1770 : : static YYSIZE_T
1771 : : yystrlen (yystr)
1772 : : const char *yystr;
1773 : : #endif
1774 : : {
1775 : : YYSIZE_T yylen;
1776 : : for (yylen = 0; yystr[yylen]; yylen++)
1777 : : continue;
1778 : : return yylen;
1779 : : }
1780 : : # endif
1781 : : # endif
1782 : :
1783 : : # ifndef yystpcpy
1784 : : # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1785 : : # define yystpcpy stpcpy
1786 : : # else
1787 : : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1788 : : YYDEST. */
1789 : : #if (defined __STDC__ || defined __C99__FUNC__ \
1790 : : || defined __cplusplus || defined _MSC_VER)
1791 : : static char *
1792 : : yystpcpy (char *yydest, const char *yysrc)
1793 : : #else
1794 : : static char *
1795 : : yystpcpy (yydest, yysrc)
1796 : : char *yydest;
1797 : : const char *yysrc;
1798 : : #endif
1799 : : {
1800 : : char *yyd = yydest;
1801 : : const char *yys = yysrc;
1802 : :
1803 : : while ((*yyd++ = *yys++) != '\0')
1804 : : continue;
1805 : :
1806 : : return yyd - 1;
1807 : : }
1808 : : # endif
1809 : : # endif
1810 : :
1811 : : # ifndef yytnamerr
1812 : : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1813 : : quotes and backslashes, so that it's suitable for yyerror. The
1814 : : heuristic is that double-quoting is unnecessary unless the string
1815 : : contains an apostrophe, a comma, or backslash (other than
1816 : : backslash-backslash). YYSTR is taken from yytname. If YYRES is
1817 : : null, do not copy; instead, return the length of what the result
1818 : : would have been. */
1819 : : static YYSIZE_T
1820 : 0 : yytnamerr (char *yyres, const char *yystr)
1821 : : {
1822 [ # # ]: 0 : if (*yystr == '"')
1823 : : {
1824 : 0 : YYSIZE_T yyn = 0;
1825 : 0 : char const *yyp = yystr;
1826 : :
1827 : 0 : for (;;)
1828 [ # # # # ]: 0 : switch (*++yyp)
1829 : : {
1830 : : case '\'':
1831 : : case ',':
1832 : 0 : goto do_not_strip_quotes;
1833 : :
1834 : : case '\\':
1835 [ # # ]: 0 : if (*++yyp != '\\')
1836 : 0 : goto do_not_strip_quotes;
1837 : : /* Fall through. */
1838 : : default:
1839 [ # # ]: 0 : if (yyres)
1840 : 0 : yyres[yyn] = *yyp;
1841 : 0 : yyn++;
1842 : 0 : break;
1843 : :
1844 : : case '"':
1845 [ # # ]: 0 : if (yyres)
1846 : 0 : yyres[yyn] = '\0';
1847 : 0 : return yyn;
1848 : : }
1849 : : do_not_strip_quotes: ;
1850 : : }
1851 : :
1852 [ # # ]: 0 : if (! yyres)
1853 : 0 : return yystrlen (yystr);
1854 : :
1855 : 0 : return yystpcpy (yyres, yystr) - yyres;
1856 : : }
1857 : : # endif
1858 : :
1859 : : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1860 : : about the unexpected token YYTOKEN for the state stack whose top is
1861 : : YYSSP.
1862 : :
1863 : : Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1864 : : not large enough to hold the message. In that case, also set
1865 : : *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1866 : : required number of bytes is too large to store. */
1867 : : static int
1868 : 0 : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1869 : : yytype_int16 *yyssp, int yytoken)
1870 : : {
1871 : 0 : YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1872 : 0 : YYSIZE_T yysize = yysize0;
1873 : : YYSIZE_T yysize1;
1874 : : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1875 : : /* Internationalized format string. */
1876 : 0 : const char *yyformat = 0;
1877 : : /* Arguments of yyformat. */
1878 : : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1879 : : /* Number of reported tokens (one for the "unexpected", one per
1880 : : "expected"). */
1881 : 0 : int yycount = 0;
1882 : :
1883 : : /* There are many possibilities here to consider:
1884 : : - Assume YYFAIL is not used. It's too flawed to consider. See
1885 : : <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1886 : : for details. YYERROR is fine as it does not invoke this
1887 : : function.
1888 : : - If this state is a consistent state with a default action, then
1889 : : the only way this function was invoked is if the default action
1890 : : is an error action. In that case, don't check for expected
1891 : : tokens because there are none.
1892 : : - The only way there can be no lookahead present (in yychar) is if
1893 : : this state is a consistent state with a default action. Thus,
1894 : : detecting the absence of a lookahead is sufficient to determine
1895 : : that there is no unexpected or expected token to report. In that
1896 : : case, just report a simple "syntax error".
1897 : : - Don't assume there isn't a lookahead just because this state is a
1898 : : consistent state with a default action. There might have been a
1899 : : previous inconsistent state, consistent state with a non-default
1900 : : action, or user semantic action that manipulated yychar.
1901 : : - Of course, the expected token list depends on states to have
1902 : : correct lookahead information, and it depends on the parser not
1903 : : to perform extra reductions after fetching a lookahead from the
1904 : : scanner and before detecting a syntax error. Thus, state merging
1905 : : (from LALR or IELR) and default reductions corrupt the expected
1906 : : token list. However, the list is correct for canonical LR with
1907 : : one exception: it will still contain any token that will not be
1908 : : accepted due to an error action in a later state.
1909 : : */
1910 [ # # ]: 0 : if (yytoken != YYEMPTY)
1911 : : {
1912 : 0 : int yyn = yypact[*yyssp];
1913 : 0 : yyarg[yycount++] = yytname[yytoken];
1914 [ # # ]: 0 : if (!yypact_value_is_default (yyn))
1915 : : {
1916 : : /* Start YYX at -YYN if negative to avoid negative indexes in
1917 : : YYCHECK. In other words, skip the first -YYN actions for
1918 : : this state because they are default actions. */
1919 [ # # ]: 0 : int yyxbegin = yyn < 0 ? -yyn : 0;
1920 : : /* Stay within bounds of both yycheck and yytname. */
1921 : 0 : int yychecklim = YYLAST - yyn + 1;
1922 : 0 : int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1923 : : int yyx;
1924 : :
1925 [ # # ]: 0 : for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1926 [ # # ][ # # ]: 0 : if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1927 : : && !yytable_value_is_error (yytable[yyx + yyn]))
1928 : : {
1929 [ # # ]: 0 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1930 : : {
1931 : 0 : yycount = 1;
1932 : 0 : yysize = yysize0;
1933 : 0 : break;
1934 : : }
1935 : 0 : yyarg[yycount++] = yytname[yyx];
1936 : 0 : yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1937 [ # # ]: 0 : if (! (yysize <= yysize1
1938 : : && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1939 : 0 : return 2;
1940 : 0 : yysize = yysize1;
1941 : : }
1942 : : }
1943 : : }
1944 : :
1945 [ # # # # : 0 : switch (yycount)
# # # ]
1946 : : {
1947 : : # define YYCASE_(N, S) \
1948 : : case N: \
1949 : : yyformat = S; \
1950 : : break
1951 : 0 : YYCASE_(0, YY_("syntax error"));
1952 : 0 : YYCASE_(1, YY_("syntax error, unexpected %s"));
1953 : 0 : YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1954 : 0 : YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1955 : 0 : YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1956 : 0 : YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1957 : : # undef YYCASE_
1958 : : }
1959 : :
1960 : 0 : yysize1 = yysize + yystrlen (yyformat);
1961 [ # # ]: 0 : if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1962 : 0 : return 2;
1963 : 0 : yysize = yysize1;
1964 : :
1965 [ # # ]: 0 : if (*yymsg_alloc < yysize)
1966 : : {
1967 : 0 : *yymsg_alloc = 2 * yysize;
1968 [ # # ]: 0 : if (! (yysize <= *yymsg_alloc
1969 : 0 : && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1970 : 0 : *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1971 : 0 : return 1;
1972 : : }
1973 : :
1974 : : /* Avoid sprintf, as that infringes on the user's name space.
1975 : : Don't have undefined behavior even if the translation
1976 : : produced a string with the wrong number of "%s"s. */
1977 : : {
1978 : 0 : char *yyp = *yymsg;
1979 : 0 : int yyi = 0;
1980 [ # # ]: 0 : while ((*yyp = *yyformat) != '\0')
1981 [ # # ][ # # ]: 0 : if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
[ # # ]
1982 : : {
1983 : 0 : yyp += yytnamerr (yyp, yyarg[yyi++]);
1984 : 0 : yyformat += 2;
1985 : : }
1986 : : else
1987 : : {
1988 : 0 : yyp++;
1989 : 0 : yyformat++;
1990 : : }
1991 : : }
1992 : 0 : return 0;
1993 : : }
1994 : : #endif /* YYERROR_VERBOSE */
1995 : :
1996 : : /*-----------------------------------------------.
1997 : : | Release the memory associated to this symbol. |
1998 : : `-----------------------------------------------*/
1999 : :
2000 : : /*ARGSUSED*/
2001 : : #if (defined __STDC__ || defined __C99__FUNC__ \
2002 : : || defined __cplusplus || defined _MSC_VER)
2003 : : static void
2004 : 11956 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2005 : : #else
2006 : : static void
2007 : : yydestruct (yymsg, yytype, yyvaluep)
2008 : : const char *yymsg;
2009 : : int yytype;
2010 : : YYSTYPE *yyvaluep;
2011 : : #endif
2012 : : {
2013 : : YYUSE (yyvaluep);
2014 : :
2015 [ - + ]: 11956 : if (!yymsg)
2016 : 0 : yymsg = "Deleting";
2017 [ - + ]: 11956 : YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2018 : :
2019 : : switch (yytype)
2020 : : {
2021 : :
2022 : : default:
2023 : 11956 : break;
2024 : : }
2025 : 11956 : }
2026 : :
2027 : :
2028 : : /* Prevent warnings from -Wmissing-prototypes. */
2029 : : #ifdef YYPARSE_PARAM
2030 : : #if defined __STDC__ || defined __cplusplus
2031 : : int yyparse (void *YYPARSE_PARAM);
2032 : : #else
2033 : : int yyparse ();
2034 : : #endif
2035 : : #else /* ! YYPARSE_PARAM */
2036 : : #if defined __STDC__ || defined __cplusplus
2037 : : int yyparse (void);
2038 : : #else
2039 : : int yyparse ();
2040 : : #endif
2041 : : #endif /* ! YYPARSE_PARAM */
2042 : :
2043 : :
2044 : : /* The lookahead symbol. */
2045 : : int yychar;
2046 : :
2047 : : /* The semantic value of the lookahead symbol. */
2048 : : YYSTYPE yylval;
2049 : :
2050 : : /* Number of syntax errors so far. */
2051 : : int yynerrs;
2052 : :
2053 : :
2054 : : /*----------.
2055 : : | yyparse. |
2056 : : `----------*/
2057 : :
2058 : : #ifdef YYPARSE_PARAM
2059 : : #if (defined __STDC__ || defined __C99__FUNC__ \
2060 : : || defined __cplusplus || defined _MSC_VER)
2061 : : int
2062 : : yyparse (void *YYPARSE_PARAM)
2063 : : #else
2064 : : int
2065 : : yyparse (YYPARSE_PARAM)
2066 : : void *YYPARSE_PARAM;
2067 : : #endif
2068 : : #else /* ! YYPARSE_PARAM */
2069 : : #if (defined __STDC__ || defined __C99__FUNC__ \
2070 : : || defined __cplusplus || defined _MSC_VER)
2071 : : int
2072 : 5978 : yyparse (void)
2073 : : #else
2074 : : int
2075 : : yyparse ()
2076 : :
2077 : : #endif
2078 : : #endif
2079 : : {
2080 : : int yystate;
2081 : : /* Number of tokens to shift before error messages enabled. */
2082 : : int yyerrstatus;
2083 : :
2084 : : /* The stacks and their tools:
2085 : : `yyss': related to states.
2086 : : `yyvs': related to semantic values.
2087 : :
2088 : : Refer to the stacks thru separate pointers, to allow yyoverflow
2089 : : to reallocate them elsewhere. */
2090 : :
2091 : : /* The state stack. */
2092 : : yytype_int16 yyssa[YYINITDEPTH];
2093 : : yytype_int16 *yyss;
2094 : : yytype_int16 *yyssp;
2095 : :
2096 : : /* The semantic value stack. */
2097 : : YYSTYPE yyvsa[YYINITDEPTH];
2098 : : YYSTYPE *yyvs;
2099 : : YYSTYPE *yyvsp;
2100 : :
2101 : : YYSIZE_T yystacksize;
2102 : :
2103 : : int yyn;
2104 : : int yyresult;
2105 : : /* Lookahead token as an internal (translated) token number. */
2106 : : int yytoken;
2107 : : /* The variables used to return semantic value and location from the
2108 : : action routines. */
2109 : : YYSTYPE yyval;
2110 : :
2111 : : #if YYERROR_VERBOSE
2112 : : /* Buffer for error messages, and its allocated size. */
2113 : : char yymsgbuf[128];
2114 : 5978 : char *yymsg = yymsgbuf;
2115 : 5978 : YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2116 : : #endif
2117 : :
2118 : : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2119 : :
2120 : : /* The number of symbols on the RHS of the reduced rule.
2121 : : Keep to zero when no symbol should be popped. */
2122 : 5978 : int yylen = 0;
2123 : :
2124 : 5978 : yytoken = 0;
2125 : 5978 : yyss = yyssa;
2126 : 5978 : yyvs = yyvsa;
2127 : 5978 : yystacksize = YYINITDEPTH;
2128 : :
2129 [ - + ][ # # ]: 5978 : YYDPRINTF ((stderr, "Starting parse\n"));
2130 : :
2131 : 5978 : yystate = 0;
2132 : 5978 : yyerrstatus = 0;
2133 : 5978 : yynerrs = 0;
2134 : 5978 : yychar = YYEMPTY; /* Cause a token to be read. */
2135 : :
2136 : : /* Initialize stack pointers.
2137 : : Waste one element of value and location stack
2138 : : so that they stay on the same level as the state stack.
2139 : : The wasted elements are never initialized. */
2140 : 5978 : yyssp = yyss;
2141 : 5978 : yyvsp = yyvs;
2142 : :
2143 : 5978 : goto yysetstate;
2144 : :
2145 : : /*------------------------------------------------------------.
2146 : : | yynewstate -- Push a new state, which is found in yystate. |
2147 : : `------------------------------------------------------------*/
2148 : : yynewstate:
2149 : : /* In all cases, when you get here, the value and location stacks
2150 : : have just been pushed. So pushing a state here evens the stacks. */
2151 : 16610998 : yyssp++;
2152 : :
2153 : : yysetstate:
2154 : 16616976 : *yyssp = yystate;
2155 : :
2156 [ + + ]: 16616976 : if (yyss + yystacksize - 1 <= yyssp)
2157 : : {
2158 : : /* Get the current used size of the three stacks, in elements. */
2159 : 10 : YYSIZE_T yysize = yyssp - yyss + 1;
2160 : :
2161 : : #ifdef yyoverflow
2162 : : {
2163 : : /* Give user a chance to reallocate the stack. Use copies of
2164 : : these so that the &'s don't force the real ones into
2165 : : memory. */
2166 : : YYSTYPE *yyvs1 = yyvs;
2167 : : yytype_int16 *yyss1 = yyss;
2168 : :
2169 : : /* Each stack pointer address is followed by the size of the
2170 : : data in use in that stack, in bytes. This used to be a
2171 : : conditional around just the two extra args, but that might
2172 : : be undefined if yyoverflow is a macro. */
2173 : : yyoverflow (YY_("memory exhausted"),
2174 : : &yyss1, yysize * sizeof (*yyssp),
2175 : : &yyvs1, yysize * sizeof (*yyvsp),
2176 : : &yystacksize);
2177 : :
2178 : : yyss = yyss1;
2179 : : yyvs = yyvs1;
2180 : : }
2181 : : #else /* no yyoverflow */
2182 : : # ifndef YYSTACK_RELOCATE
2183 : : goto yyexhaustedlab;
2184 : : # else
2185 : : /* Extend the stack our own way. */
2186 [ - + ]: 10 : if (YYMAXDEPTH <= yystacksize)
2187 : 0 : goto yyexhaustedlab;
2188 : 10 : yystacksize *= 2;
2189 [ - + ]: 10 : if (YYMAXDEPTH < yystacksize)
2190 : 0 : yystacksize = YYMAXDEPTH;
2191 : :
2192 : : {
2193 : 10 : yytype_int16 *yyss1 = yyss;
2194 : : union yyalloc *yyptr =
2195 : 10 : (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2196 [ - + ]: 10 : if (! yyptr)
2197 : 0 : goto yyexhaustedlab;
2198 : 10 : YYSTACK_RELOCATE (yyss_alloc, yyss);
2199 : 10 : YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2200 : : # undef YYSTACK_RELOCATE
2201 [ + + ]: 10 : if (yyss1 != yyssa)
2202 : 1 : YYSTACK_FREE (yyss1);
2203 : : }
2204 : : # endif
2205 : : #endif /* no yyoverflow */
2206 : :
2207 : 10 : yyssp = yyss + yysize - 1;
2208 : 10 : yyvsp = yyvs + yysize - 1;
2209 : :
2210 [ - + ][ # # ]: 10 : YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2211 : : (unsigned long int) yystacksize));
2212 : :
2213 [ - + ]: 10 : if (yyss + yystacksize - 1 <= yyssp)
2214 : 0 : YYABORT;
2215 : : }
2216 : :
2217 [ - + ][ # # ]: 16616976 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2218 : :
2219 [ + + ]: 16616976 : if (yystate == YYFINAL)
2220 : 5978 : YYACCEPT;
2221 : :
2222 : 16610998 : goto yybackup;
2223 : :
2224 : : /*-----------.
2225 : : | yybackup. |
2226 : : `-----------*/
2227 : : yybackup:
2228 : :
2229 : : /* Do appropriate processing given the current state. Read a
2230 : : lookahead token if we need one and don't already have one. */
2231 : :
2232 : : /* First try to decide what to do without reference to lookahead token. */
2233 : 16610998 : yyn = yypact[yystate];
2234 [ + + ]: 16610998 : if (yypact_value_is_default (yyn))
2235 : 9700086 : goto yydefault;
2236 : :
2237 : : /* Not known => get a lookahead token if don't already have one. */
2238 : :
2239 : : /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2240 [ + + ]: 6910912 : if (yychar == YYEMPTY)
2241 : : {
2242 [ - + ][ # # ]: 5129753 : YYDPRINTF ((stderr, "Reading a token: "));
2243 [ + - ]: 5129753 : yychar = YYLEX;
2244 : : }
2245 : :
2246 [ + + ]: 6910912 : if (yychar <= YYEOF)
2247 : : {
2248 : 11956 : yychar = yytoken = YYEOF;
2249 [ - + ][ # # ]: 11956 : YYDPRINTF ((stderr, "Now at end of input.\n"));
2250 : : }
2251 : : else
2252 : : {
2253 [ + - ]: 6898956 : yytoken = YYTRANSLATE (yychar);
2254 [ - + ][ # # ]: 6898956 : YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
[ # # ][ # # ]
2255 : : }
2256 : :
2257 : : /* If the proper action on seeing token YYTOKEN is to reduce or to
2258 : : detect an error, take that action. */
2259 : 6910912 : yyn += yytoken;
2260 [ + + ][ + - ]: 6910912 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
[ + + ]
2261 : : goto yydefault;
2262 : 5569756 : yyn = yytable[yyn];
2263 [ + + ]: 5569756 : if (yyn <= 0)
2264 : : {
2265 : : if (yytable_value_is_error (yyn))
2266 : : goto yyerrlab;
2267 : 440003 : yyn = -yyn;
2268 : 440003 : goto yyreduce;
2269 : : }
2270 : :
2271 : : /* Count tokens shifted since error; after three, turn off error
2272 : : status. */
2273 [ - + ]: 5129753 : if (yyerrstatus)
2274 : 0 : yyerrstatus--;
2275 : :
2276 : : /* Shift the lookahead token. */
2277 [ - + ][ # # ]: 5129753 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
[ # # ][ # # ]
2278 : :
2279 : : /* Discard the shifted token. */
2280 : 5129753 : yychar = YYEMPTY;
2281 : :
2282 : 5129753 : yystate = yyn;
2283 : 5129753 : *++yyvsp = yylval;
2284 : :
2285 : 5129753 : goto yynewstate;
2286 : :
2287 : :
2288 : : /*-----------------------------------------------------------.
2289 : : | yydefault -- do the default action for the current state. |
2290 : : `-----------------------------------------------------------*/
2291 : : yydefault:
2292 : 11041242 : yyn = yydefact[yystate];
2293 [ - + ]: 11041242 : if (yyn == 0)
2294 : 0 : goto yyerrlab;
2295 : 11041242 : goto yyreduce;
2296 : :
2297 : :
2298 : : /*-----------------------------.
2299 : : | yyreduce -- Do a reduction. |
2300 : : `-----------------------------*/
2301 : : yyreduce:
2302 : : /* yyn is the number of a rule to reduce with. */
2303 : 11481245 : yylen = yyr2[yyn];
2304 : :
2305 : : /* If YYLEN is nonzero, implement the default value of the action:
2306 : : `$$ = $1'.
2307 : :
2308 : : Otherwise, the following line sets YYVAL to garbage.
2309 : : This behavior is undocumented and Bison
2310 : : users should not rely upon it. Assigning to YYVAL
2311 : : unconditionally makes the parser a bit smaller, and it avoids a
2312 : : GCC warning that YYVAL may be used uninitialized. */
2313 : 11481245 : yyval = yyvsp[1-yylen];
2314 : :
2315 : :
2316 [ - + ][ # # ]: 11481245 : YY_REDUCE_PRINT (yyn);
2317 [ + + - + : 11481245 : switch (yyn)
+ + + - -
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + - + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
- + - + -
- + + - +
+ - + + +
+ + + + +
+ + + + +
+ + + - +
+ + - + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + - - -
- + - - -
- - - - +
- + + + -
- - + + +
+ + + + +
+ + - + +
- - + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ - + + +
+ - - + +
- - - - -
- - - - +
- - + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + -
- + + + +
- + + + +
+ + + + +
+ + + + +
- + + + +
+ + + - +
+ - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - + +
- + ]
2318 : : {
2319 : : case 6:
2320 : :
2321 : : /* Line 1806 of yacc.c */
2322 : : #line 424 "/usr/local/src/libreoffice/idlc/source/parser.y"
2323 : : {
2324 : : idlc()->setParseState(PS_ModuleDeclSeen);
2325 : : }
2326 : : break;
2327 : :
2328 : : case 7:
2329 : :
2330 : : /* Line 1806 of yacc.c */
2331 : : #line 428 "/usr/local/src/libreoffice/idlc/source/parser.y"
2332 : : {
2333 : : idlc()->setParseState(PS_NoState);
2334 : : }
2335 : : break;
2336 : :
2337 : : case 8:
2338 : :
2339 : : /* Line 1806 of yacc.c */
2340 : : #line 432 "/usr/local/src/libreoffice/idlc/source/parser.y"
2341 : : {
2342 : : yyerror("definitions");
2343 : : yyerrok;
2344 : : }
2345 : : break;
2346 : :
2347 : : case 9:
2348 : :
2349 : : /* Line 1806 of yacc.c */
2350 : : #line 439 "/usr/local/src/libreoffice/idlc/source/parser.y"
2351 : : { idlc()->setPublished(true); }
2352 : : break;
2353 : :
2354 : : case 10:
2355 : :
2356 : : /* Line 1806 of yacc.c */
2357 : : #line 440 "/usr/local/src/libreoffice/idlc/source/parser.y"
2358 : : { idlc()->setPublished(false); }
2359 : : break;
2360 : :
2361 : : case 11:
2362 : :
2363 : : /* Line 1806 of yacc.c */
2364 : : #line 445 "/usr/local/src/libreoffice/idlc/source/parser.y"
2365 : : {
2366 : : idlc()->setParseState(PS_TypeDeclSeen);
2367 : : }
2368 : : break;
2369 : :
2370 : : case 12:
2371 : :
2372 : : /* Line 1806 of yacc.c */
2373 : : #line 449 "/usr/local/src/libreoffice/idlc/source/parser.y"
2374 : : {
2375 : : idlc()->setParseState(PS_NoState);
2376 : : }
2377 : : break;
2378 : :
2379 : : case 13:
2380 : :
2381 : : /* Line 1806 of yacc.c */
2382 : : #line 453 "/usr/local/src/libreoffice/idlc/source/parser.y"
2383 : : {
2384 : : idlc()->setParseState(PS_ConstantDeclSeen);
2385 : : }
2386 : : break;
2387 : :
2388 : : case 14:
2389 : :
2390 : : /* Line 1806 of yacc.c */
2391 : : #line 457 "/usr/local/src/libreoffice/idlc/source/parser.y"
2392 : : {
2393 : : idlc()->setParseState(PS_NoState);
2394 : : }
2395 : : break;
2396 : :
2397 : : case 15:
2398 : :
2399 : : /* Line 1806 of yacc.c */
2400 : : #line 461 "/usr/local/src/libreoffice/idlc/source/parser.y"
2401 : : {
2402 : : idlc()->setParseState(PS_ExceptionDeclSeen);
2403 : : }
2404 : : break;
2405 : :
2406 : : case 16:
2407 : :
2408 : : /* Line 1806 of yacc.c */
2409 : : #line 465 "/usr/local/src/libreoffice/idlc/source/parser.y"
2410 : : {
2411 : : idlc()->setParseState(PS_NoState);
2412 : : }
2413 : : break;
2414 : :
2415 : : case 17:
2416 : :
2417 : : /* Line 1806 of yacc.c */
2418 : : #line 469 "/usr/local/src/libreoffice/idlc/source/parser.y"
2419 : : {
2420 : : idlc()->setParseState(PS_InterfaceDeclSeen);
2421 : : }
2422 : : break;
2423 : :
2424 : : case 18:
2425 : :
2426 : : /* Line 1806 of yacc.c */
2427 : : #line 473 "/usr/local/src/libreoffice/idlc/source/parser.y"
2428 : : {
2429 : : idlc()->setParseState(PS_NoState);
2430 : : }
2431 : : break;
2432 : :
2433 : : case 19:
2434 : :
2435 : : /* Line 1806 of yacc.c */
2436 : : #line 477 "/usr/local/src/libreoffice/idlc/source/parser.y"
2437 : : {
2438 : : idlc()->setParseState(PS_ServiceDeclSeen);
2439 : : }
2440 : : break;
2441 : :
2442 : : case 20:
2443 : :
2444 : : /* Line 1806 of yacc.c */
2445 : : #line 481 "/usr/local/src/libreoffice/idlc/source/parser.y"
2446 : : {
2447 : : idlc()->setParseState(PS_NoState);
2448 : : }
2449 : : break;
2450 : :
2451 : : case 21:
2452 : :
2453 : : /* Line 1806 of yacc.c */
2454 : : #line 485 "/usr/local/src/libreoffice/idlc/source/parser.y"
2455 : : {
2456 : : idlc()->setParseState(PS_SingletonDeclSeen);
2457 : : }
2458 : : break;
2459 : :
2460 : : case 22:
2461 : :
2462 : : /* Line 1806 of yacc.c */
2463 : : #line 489 "/usr/local/src/libreoffice/idlc/source/parser.y"
2464 : : {
2465 : : idlc()->setParseState(PS_NoState);
2466 : : }
2467 : : break;
2468 : :
2469 : : case 23:
2470 : :
2471 : : /* Line 1806 of yacc.c */
2472 : : #line 493 "/usr/local/src/libreoffice/idlc/source/parser.y"
2473 : : {
2474 : : idlc()->setParseState(PS_ConstantsDeclSeen);
2475 : : }
2476 : : break;
2477 : :
2478 : : case 24:
2479 : :
2480 : : /* Line 1806 of yacc.c */
2481 : : #line 497 "/usr/local/src/libreoffice/idlc/source/parser.y"
2482 : : {
2483 : : idlc()->setParseState(PS_NoState);
2484 : : }
2485 : : break;
2486 : :
2487 : : case 25:
2488 : :
2489 : : /* Line 1806 of yacc.c */
2490 : : #line 504 "/usr/local/src/libreoffice/idlc/source/parser.y"
2491 : : {
2492 : : idlc()->setParseState(PS_ModuleSeen);
2493 : : idlc()->setPublished(false);
2494 : : }
2495 : : break;
2496 : :
2497 : : case 26:
2498 : :
2499 : : /* Line 1806 of yacc.c */
2500 : : #line 509 "/usr/local/src/libreoffice/idlc/source/parser.y"
2501 : : {
2502 : : idlc()->setParseState(PS_ModuleIDSeen);
2503 : : checkIdentifier((yyvsp[(3) - (3)].sval));
2504 : :
2505 : : AstScope* pScope = idlc()->scopes()->topNonNull();
2506 : : AstModule* pModule = NULL;
2507 : : AstDeclaration* pExists = NULL;
2508 : :
2509 : : if ( pScope )
2510 : : {
2511 : : pModule = new AstModule(*(yyvsp[(3) - (3)].sval), pScope);
2512 : : if( (pExists = pScope->lookupForAdd(pModule)) )
2513 : : {
2514 : : pExists->setInMainfile(idlc()->isInMainFile());
2515 : : pExists->setFileName(pModule->getFileName());
2516 : : if (pExists->isPredefined())
2517 : : {
2518 : : pExists->setPredefined(false);
2519 : : if (pExists->getDocumentation().getLength() == 0 &&
2520 : : pModule->getDocumentation().getLength() > 0)
2521 : : {
2522 : : pExists->setDocumentation(pModule->getDocumentation());
2523 : : }
2524 : : }
2525 : : delete(pModule);
2526 : : pModule = (AstModule*)pExists;
2527 : : } else
2528 : : {
2529 : : pScope->addDeclaration(pModule);
2530 : : }
2531 : : idlc()->scopes()->push(pModule);
2532 : : }
2533 : : delete (yyvsp[(3) - (3)].sval);
2534 : : }
2535 : : break;
2536 : :
2537 : : case 27:
2538 : :
2539 : : /* Line 1806 of yacc.c */
2540 : : #line 544 "/usr/local/src/libreoffice/idlc/source/parser.y"
2541 : : {
2542 : : idlc()->setParseState(PS_ModuleSqSeen);
2543 : : }
2544 : : break;
2545 : :
2546 : : case 28:
2547 : :
2548 : : /* Line 1806 of yacc.c */
2549 : : #line 548 "/usr/local/src/libreoffice/idlc/source/parser.y"
2550 : : {
2551 : : idlc()->setParseState(PS_ModuleBodySeen);
2552 : : }
2553 : : break;
2554 : :
2555 : : case 29:
2556 : :
2557 : : /* Line 1806 of yacc.c */
2558 : : #line 552 "/usr/local/src/libreoffice/idlc/source/parser.y"
2559 : : {
2560 : : idlc()->setParseState(PS_ModuleQsSeen);
2561 : : /*
2562 : : * Finished with this module - pop it from the scope stack
2563 : : */
2564 : : idlc()->scopes()->pop();
2565 : : }
2566 : : break;
2567 : :
2568 : : case 32:
2569 : :
2570 : : /* Line 1806 of yacc.c */
2571 : : #line 568 "/usr/local/src/libreoffice/idlc/source/parser.y"
2572 : : {
2573 : : idlc()->setParseState(PS_InterfaceSeen);
2574 : : }
2575 : : break;
2576 : :
2577 : : case 33:
2578 : :
2579 : : /* Line 1806 of yacc.c */
2580 : : #line 572 "/usr/local/src/libreoffice/idlc/source/parser.y"
2581 : : {
2582 : : idlc()->setParseState(PS_InterfaceIDSeen);
2583 : : checkIdentifier((yyvsp[(3) - (3)].sval));
2584 : : (yyval.sval) = (yyvsp[(3) - (3)].sval);
2585 : : }
2586 : : break;
2587 : :
2588 : : case 34:
2589 : :
2590 : : /* Line 1806 of yacc.c */
2591 : : #line 581 "/usr/local/src/libreoffice/idlc/source/parser.y"
2592 : : {
2593 : : idlc()->setParseState(PS_ForwardDeclSeen);
2594 : :
2595 : : AstScope* pScope = idlc()->scopes()->topNonNull();
2596 : : AstInterface* pForward = NULL;
2597 : : AstDeclaration* pDecl = NULL;
2598 : :
2599 : : /*
2600 : : * Make a new forward interface node and add it to its enclosing scope
2601 : : */
2602 : : if ( pScope && (yyvsp[(1) - (1)].sval) )
2603 : : {
2604 : : pForward = new AstInterface(*(yyvsp[(1) - (1)].sval), NULL, pScope);
2605 : :
2606 : : pDecl = pScope->lookupByName(pForward->getScopedName());
2607 : : if ( pDecl )
2608 : : {
2609 : : if ( (pDecl != pForward) &&
2610 : : (pDecl->getNodeType() == NT_interface) )
2611 : : {
2612 : : delete pForward;
2613 : : } else
2614 : : {
2615 : : idlc()->error()->error2(EIDL_REDEF_SCOPE, scopeAsDecl(pScope), pDecl);
2616 : : }
2617 : : } else
2618 : : {
2619 : : /*
2620 : : * Add the interface to its definition scope
2621 : : */
2622 : : pScope->addDeclaration(pForward);
2623 : : }
2624 : : }
2625 : : delete (yyvsp[(1) - (1)].sval);
2626 : : }
2627 : : break;
2628 : :
2629 : : case 35:
2630 : :
2631 : : /* Line 1806 of yacc.c */
2632 : : #line 620 "/usr/local/src/libreoffice/idlc/source/parser.y"
2633 : : {
2634 : : idlc()->setParseState(PS_InterfaceHeadSeen);
2635 : :
2636 : : AstScope* pScope = idlc()->scopes()->topNonNull();
2637 : : AstInterface* pInterface = NULL;
2638 : : AstInterface* pForward = NULL;
2639 : : AstDeclaration* pDecl = NULL;
2640 : :
2641 : : /*
2642 : : * Make a new interface node and add it to its enclosing scope
2643 : : */
2644 : : if ( pScope && (yyvsp[(1) - (1)].ihval) )
2645 : : {
2646 : : pInterface = new AstInterface(
2647 : : *(yyvsp[(1) - (1)].ihval)->getName(),
2648 : : static_cast< AstInterface * >((yyvsp[(1) - (1)].ihval)->getInherits()), pScope);
2649 : : if ( pInterface &&
2650 : : (pDecl = pScope->lookupByName(pInterface->getScopedName())) )
2651 : : {
2652 : : /*
2653 : : * See if we're defining a forward declared interface.
2654 : : */
2655 : : if (pDecl->getNodeType() == NT_interface)
2656 : : {
2657 : : pForward = (AstInterface*)pDecl;
2658 : : if ( !pForward->isDefined() )
2659 : : {
2660 : : /*
2661 : : * Check if redefining in same scope
2662 : : */
2663 : : if ( pForward->getScope() != pScope )
2664 : : {
2665 : : if ( pForward->getScopedName() != pInterface->getScopedName() )
2666 : : {
2667 : : idlc()->error()->error3(EIDL_SCOPE_CONFLICT,
2668 : : pInterface, pForward, scopeAsDecl(pScope));
2669 : : }
2670 : : }
2671 : : else if ( !pInterface->isPublished()
2672 : : && pForward->isPublished() )
2673 : : {
2674 : : idlc()->error()->error0(EIDL_PUBLISHED_FORWARD);
2675 : : }
2676 : : /*
2677 : : * All OK, set full definition
2678 : : */
2679 : : else
2680 : : {
2681 : : pForward->forwardDefined(*pInterface);
2682 : : delete pInterface;
2683 : : pInterface = pForward;
2684 : : }
2685 : : } else {
2686 : : // special handling for XInterface because it is predefined
2687 : : if ( pForward->isPredefined() &&
2688 : : pForward->getScopedName() == "com::sun::star::uno::XInterface")
2689 : : {
2690 : : /* replace the predefined XInterface */
2691 : : *pForward = *pInterface;
2692 : : delete pInterface;
2693 : : pInterface = pForward;
2694 : : }
2695 : :
2696 : : }
2697 : : }
2698 : : } else
2699 : : {
2700 : : /*
2701 : : * Add the interface to its definition scope
2702 : : */
2703 : : pScope->addDeclaration(pInterface);
2704 : : }
2705 : : }
2706 : : /*
2707 : : * Push it on the scope stack
2708 : : */
2709 : : idlc()->scopes()->push(pInterface);
2710 : : delete((yyvsp[(1) - (1)].ihval));
2711 : : }
2712 : : break;
2713 : :
2714 : : case 36:
2715 : :
2716 : : /* Line 1806 of yacc.c */
2717 : : #line 700 "/usr/local/src/libreoffice/idlc/source/parser.y"
2718 : : {
2719 : : idlc()->setParseState(PS_InterfaceSqSeen);
2720 : : }
2721 : : break;
2722 : :
2723 : : case 37:
2724 : :
2725 : : /* Line 1806 of yacc.c */
2726 : : #line 704 "/usr/local/src/libreoffice/idlc/source/parser.y"
2727 : : {
2728 : : AstInterface * ifc = static_cast< AstInterface * >(
2729 : : idlc()->scopes()->topNonNull());
2730 : : if (!ifc->hasMandatoryInheritedInterfaces()
2731 : : && ifc->getScopedName() != "com::sun::star::uno::XInterface")
2732 : : {
2733 : : addInheritedInterface(
2734 : : ifc, rtl::OString("::com::sun::star::uno::XInterface"), false,
2735 : : rtl::OUString());
2736 : : }
2737 : : ifc->setDefined();
2738 : : idlc()->setParseState(PS_InterfaceBodySeen);
2739 : : }
2740 : : break;
2741 : :
2742 : : case 38:
2743 : :
2744 : : /* Line 1806 of yacc.c */
2745 : : #line 718 "/usr/local/src/libreoffice/idlc/source/parser.y"
2746 : : {
2747 : : idlc()->setParseState(PS_InterfaceQsSeen);
2748 : : /*
2749 : : * Done with this interface - pop it off the scopes stack
2750 : : */
2751 : : idlc()->scopes()->pop();
2752 : : }
2753 : : break;
2754 : :
2755 : : case 39:
2756 : :
2757 : : /* Line 1806 of yacc.c */
2758 : : #line 726 "/usr/local/src/libreoffice/idlc/source/parser.y"
2759 : : {
2760 : : yyerror("interface definition");
2761 : : yyerrok;
2762 : : }
2763 : : break;
2764 : :
2765 : : case 40:
2766 : :
2767 : : /* Line 1806 of yacc.c */
2768 : : #line 734 "/usr/local/src/libreoffice/idlc/source/parser.y"
2769 : : {
2770 : : idlc()->setParseState(PS_InheritSpecSeen);
2771 : :
2772 : : (yyval.ihval) = new FeInheritanceHeader(NT_interface, (yyvsp[(1) - (2)].sval), (yyvsp[(2) - (2)].sval), 0);
2773 : : delete (yyvsp[(2) - (2)].sval);
2774 : : }
2775 : : break;
2776 : :
2777 : : case 41:
2778 : :
2779 : : /* Line 1806 of yacc.c */
2780 : : #line 744 "/usr/local/src/libreoffice/idlc/source/parser.y"
2781 : : {
2782 : : idlc()->setParseState(PS_InheritColonSeen);
2783 : : }
2784 : : break;
2785 : :
2786 : : case 42:
2787 : :
2788 : : /* Line 1806 of yacc.c */
2789 : : #line 748 "/usr/local/src/libreoffice/idlc/source/parser.y"
2790 : : {
2791 : : (yyval.sval) = (yyvsp[(3) - (3)].sval);
2792 : : }
2793 : : break;
2794 : :
2795 : : case 43:
2796 : :
2797 : : /* Line 1806 of yacc.c */
2798 : : #line 752 "/usr/local/src/libreoffice/idlc/source/parser.y"
2799 : : {
2800 : : (yyval.sval) = NULL;
2801 : : }
2802 : : break;
2803 : :
2804 : : case 46:
2805 : :
2806 : : /* Line 1806 of yacc.c */
2807 : : #line 764 "/usr/local/src/libreoffice/idlc/source/parser.y"
2808 : : {
2809 : : idlc()->setParseState(PS_AttributeDeclSeen);
2810 : : }
2811 : : break;
2812 : :
2813 : : case 47:
2814 : :
2815 : : /* Line 1806 of yacc.c */
2816 : : #line 768 "/usr/local/src/libreoffice/idlc/source/parser.y"
2817 : : {
2818 : : idlc()->setParseState(PS_NoState);
2819 : : }
2820 : : break;
2821 : :
2822 : : case 48:
2823 : :
2824 : : /* Line 1806 of yacc.c */
2825 : : #line 772 "/usr/local/src/libreoffice/idlc/source/parser.y"
2826 : : {
2827 : : idlc()->setParseState(PS_OperationDeclSeen);
2828 : : }
2829 : : break;
2830 : :
2831 : : case 49:
2832 : :
2833 : : /* Line 1806 of yacc.c */
2834 : : #line 776 "/usr/local/src/libreoffice/idlc/source/parser.y"
2835 : : {
2836 : : idlc()->setParseState(PS_NoState);
2837 : : }
2838 : : break;
2839 : :
2840 : : case 50:
2841 : :
2842 : : /* Line 1806 of yacc.c */
2843 : : #line 780 "/usr/local/src/libreoffice/idlc/source/parser.y"
2844 : : {
2845 : : idlc()->setParseState(PS_InterfaceInheritanceDeclSeen);
2846 : : }
2847 : : break;
2848 : :
2849 : : case 51:
2850 : :
2851 : : /* Line 1806 of yacc.c */
2852 : : #line 784 "/usr/local/src/libreoffice/idlc/source/parser.y"
2853 : : {
2854 : : idlc()->setParseState(PS_NoState);
2855 : : }
2856 : : break;
2857 : :
2858 : : case 52:
2859 : :
2860 : : /* Line 1806 of yacc.c */
2861 : : #line 792 "/usr/local/src/libreoffice/idlc/source/parser.y"
2862 : : {
2863 : : idlc()->setParseState(PS_AttrTypeSeen);
2864 : : }
2865 : : break;
2866 : :
2867 : : case 53:
2868 : :
2869 : : /* Line 1806 of yacc.c */
2870 : : #line 796 "/usr/local/src/libreoffice/idlc/source/parser.y"
2871 : : {
2872 : : idlc()->setParseState(PS_AttrCompleted);
2873 : : if (((yyvsp[(1) - (4)].ulval) & ~(AF_BOUND | AF_READONLY)) != AF_ATTRIBUTE) {
2874 : : idlc()->error()->flagError(EIDL_BAD_ATTRIBUTE_FLAGS, (yyvsp[(1) - (4)].ulval));
2875 : : }
2876 : : AstInterface * scope = static_cast< AstInterface * >(
2877 : : idlc()->scopes()->top());
2878 : : AstAttribute * attr = new AstAttribute(
2879 : : (yyvsp[(1) - (4)].ulval), (yyvsp[(4) - (4)].fdval)->compose((yyvsp[(2) - (4)].cdclval)), (yyvsp[(4) - (4)].fdval)->getName(), scope);
2880 : : delete (yyvsp[(4) - (4)].fdval);
2881 : : AstInterface::DoubleMemberDeclarations doubleMembers(
2882 : : scope->checkMemberClashes(attr));
2883 : : if (doubleMembers.empty()) {
2884 : : scope->addMember(attr);
2885 : : } else {
2886 : : reportDoubleMemberDeclarations(doubleMembers);
2887 : : }
2888 : : idlc()->scopes()->push(attr);
2889 : : }
2890 : : break;
2891 : :
2892 : : case 54:
2893 : :
2894 : : /* Line 1806 of yacc.c */
2895 : : #line 816 "/usr/local/src/libreoffice/idlc/source/parser.y"
2896 : : {
2897 : : static_cast< AstAttribute * >(idlc()->scopes()->top())->setExceptions(
2898 : : (yyvsp[(6) - (6)].attexcval).get.documentation, (yyvsp[(6) - (6)].attexcval).get.exceptions, (yyvsp[(6) - (6)].attexcval).set.documentation,
2899 : : (yyvsp[(6) - (6)].attexcval).set.exceptions);
2900 : : delete (yyvsp[(6) - (6)].attexcval).get.documentation;
2901 : : delete (yyvsp[(6) - (6)].attexcval).get.exceptions;
2902 : : delete (yyvsp[(6) - (6)].attexcval).set.documentation;
2903 : : delete (yyvsp[(6) - (6)].attexcval).set.exceptions;
2904 : : idlc()->scopes()->pop();
2905 : : }
2906 : : break;
2907 : :
2908 : : case 55:
2909 : :
2910 : : /* Line 1806 of yacc.c */
2911 : : #line 830 "/usr/local/src/libreoffice/idlc/source/parser.y"
2912 : : {
2913 : : idlc()->setParseState(PS_FlagHeaderSeen);
2914 : : (yyval.ulval) = (yyvsp[(2) - (3)].ulval);
2915 : : }
2916 : : break;
2917 : :
2918 : : case 56:
2919 : :
2920 : : /* Line 1806 of yacc.c */
2921 : : #line 838 "/usr/local/src/libreoffice/idlc/source/parser.y"
2922 : : {
2923 : : if ( ((yyvsp[(1) - (3)].ulval) & (yyvsp[(3) - (3)].ulval)) == (yyvsp[(3) - (3)].ulval) )
2924 : : idlc()->error()->flagError(EIDL_DEFINED_ATTRIBUTEFLAG, (yyvsp[(3) - (3)].ulval));
2925 : :
2926 : : (yyval.ulval) = (yyvsp[(1) - (3)].ulval) | (yyvsp[(3) - (3)].ulval);
2927 : : }
2928 : : break;
2929 : :
2930 : : case 57:
2931 : :
2932 : : /* Line 1806 of yacc.c */
2933 : : #line 845 "/usr/local/src/libreoffice/idlc/source/parser.y"
2934 : : {
2935 : : (yyval.ulval) = (yyvsp[(1) - (1)].ulval);
2936 : : }
2937 : : break;
2938 : :
2939 : : case 58:
2940 : :
2941 : : /* Line 1806 of yacc.c */
2942 : : #line 852 "/usr/local/src/libreoffice/idlc/source/parser.y"
2943 : : {
2944 : : idlc()->setParseState(PS_AttrSeen);
2945 : : (yyval.ulval) = AF_ATTRIBUTE;
2946 : : }
2947 : : break;
2948 : :
2949 : : case 59:
2950 : :
2951 : : /* Line 1806 of yacc.c */
2952 : : #line 857 "/usr/local/src/libreoffice/idlc/source/parser.y"
2953 : : {
2954 : : idlc()->setParseState(PS_PropertySeen);
2955 : : (yyval.ulval) = AF_PROPERTY;
2956 : : }
2957 : : break;
2958 : :
2959 : : case 60:
2960 : :
2961 : : /* Line 1806 of yacc.c */
2962 : : #line 862 "/usr/local/src/libreoffice/idlc/source/parser.y"
2963 : : {
2964 : : idlc()->setParseState(PS_ReadOnlySeen);
2965 : : (yyval.ulval) = AF_READONLY;
2966 : : }
2967 : : break;
2968 : :
2969 : : case 61:
2970 : :
2971 : : /* Line 1806 of yacc.c */
2972 : : #line 867 "/usr/local/src/libreoffice/idlc/source/parser.y"
2973 : : {
2974 : : idlc()->setParseState(PS_OptionalSeen);
2975 : : (yyval.ulval) = AF_OPTIONAL;
2976 : : }
2977 : : break;
2978 : :
2979 : : case 62:
2980 : :
2981 : : /* Line 1806 of yacc.c */
2982 : : #line 872 "/usr/local/src/libreoffice/idlc/source/parser.y"
2983 : : {
2984 : : idlc()->setParseState(PS_MayBeVoidSeen);
2985 : : (yyval.ulval) = AF_MAYBEVOID;
2986 : : }
2987 : : break;
2988 : :
2989 : : case 63:
2990 : :
2991 : : /* Line 1806 of yacc.c */
2992 : : #line 877 "/usr/local/src/libreoffice/idlc/source/parser.y"
2993 : : {
2994 : : idlc()->setParseState(PS_BoundSeen);
2995 : : (yyval.ulval) = AF_BOUND;
2996 : : }
2997 : : break;
2998 : :
2999 : : case 64:
3000 : :
3001 : : /* Line 1806 of yacc.c */
3002 : : #line 882 "/usr/local/src/libreoffice/idlc/source/parser.y"
3003 : : {
3004 : : idlc()->setParseState(PS_ConstrainedSeen);
3005 : : (yyval.ulval) = AF_CONSTRAINED;
3006 : : }
3007 : : break;
3008 : :
3009 : : case 65:
3010 : :
3011 : : /* Line 1806 of yacc.c */
3012 : : #line 887 "/usr/local/src/libreoffice/idlc/source/parser.y"
3013 : : {
3014 : : idlc()->setParseState(PS_TransientSeen);
3015 : : (yyval.ulval) = AF_TRANSIENT;
3016 : : }
3017 : : break;
3018 : :
3019 : : case 66:
3020 : :
3021 : : /* Line 1806 of yacc.c */
3022 : : #line 892 "/usr/local/src/libreoffice/idlc/source/parser.y"
3023 : : {
3024 : : idlc()->setParseState(PS_MayBeAmbigiousSeen);
3025 : : (yyval.ulval) = AF_MAYBEAMBIGUOUS;
3026 : : }
3027 : : break;
3028 : :
3029 : : case 67:
3030 : :
3031 : : /* Line 1806 of yacc.c */
3032 : : #line 897 "/usr/local/src/libreoffice/idlc/source/parser.y"
3033 : : {
3034 : : idlc()->setParseState(PS_MayBeDefaultSeen);
3035 : : (yyval.ulval) = AF_MAYBEDEFAULT;
3036 : : }
3037 : : break;
3038 : :
3039 : : case 68:
3040 : :
3041 : : /* Line 1806 of yacc.c */
3042 : : #line 902 "/usr/local/src/libreoffice/idlc/source/parser.y"
3043 : : {
3044 : : idlc()->setParseState(PS_RemoveableSeen);
3045 : : (yyval.ulval) = AF_REMOVEABLE;
3046 : : }
3047 : : break;
3048 : :
3049 : : case 69:
3050 : :
3051 : : /* Line 1806 of yacc.c */
3052 : : #line 907 "/usr/local/src/libreoffice/idlc/source/parser.y"
3053 : : {
3054 : : yyerror("unknown property|attribute flag");
3055 : : yyerrok;
3056 : : }
3057 : : break;
3058 : :
3059 : : case 70:
3060 : :
3061 : : /* Line 1806 of yacc.c */
3062 : : #line 914 "/usr/local/src/libreoffice/idlc/source/parser.y"
3063 : : { (yyval.attexcval) = (yyvsp[(2) - (2)].attexcval); }
3064 : : break;
3065 : :
3066 : : case 71:
3067 : :
3068 : : /* Line 1806 of yacc.c */
3069 : : #line 916 "/usr/local/src/libreoffice/idlc/source/parser.y"
3070 : : {
3071 : : (yyval.attexcval).get.documentation = 0;
3072 : : (yyval.attexcval).get.exceptions = 0;
3073 : : (yyval.attexcval).set.documentation = 0;
3074 : : (yyval.attexcval).set.exceptions = 0;
3075 : : }
3076 : : break;
3077 : :
3078 : : case 73:
3079 : :
3080 : : /* Line 1806 of yacc.c */
3081 : : #line 927 "/usr/local/src/libreoffice/idlc/source/parser.y"
3082 : : {
3083 : : yyerror("bad attribute raises block");
3084 : : yyerrok;
3085 : : (yyval.attexcval).get.documentation = 0;
3086 : : (yyval.attexcval).get.exceptions = 0;
3087 : : (yyval.attexcval).set.documentation = 0;
3088 : : (yyval.attexcval).set.exceptions = 0;
3089 : : }
3090 : : break;
3091 : :
3092 : : case 74:
3093 : :
3094 : : /* Line 1806 of yacc.c */
3095 : : #line 940 "/usr/local/src/libreoffice/idlc/source/parser.y"
3096 : : {
3097 : : (yyval.attexcval).get = (yyvsp[(1) - (2)].attexcpval);
3098 : : (yyval.attexcval).set = (yyvsp[(2) - (2)].attexcpval);
3099 : : }
3100 : : break;
3101 : :
3102 : : case 75:
3103 : :
3104 : : /* Line 1806 of yacc.c */
3105 : : #line 946 "/usr/local/src/libreoffice/idlc/source/parser.y"
3106 : : {
3107 : : (yyval.attexcval).get = (yyvsp[(2) - (2)].attexcpval);
3108 : : (yyval.attexcval).set = (yyvsp[(1) - (2)].attexcpval);
3109 : : }
3110 : : break;
3111 : :
3112 : : case 76:
3113 : :
3114 : : /* Line 1806 of yacc.c */
3115 : : #line 951 "/usr/local/src/libreoffice/idlc/source/parser.y"
3116 : : {
3117 : : (yyval.attexcval).get.documentation = 0;
3118 : : (yyval.attexcval).get.exceptions = 0;
3119 : : (yyval.attexcval).set.documentation = 0;
3120 : : (yyval.attexcval).set.exceptions = 0;
3121 : : }
3122 : : break;
3123 : :
3124 : : case 78:
3125 : :
3126 : : /* Line 1806 of yacc.c */
3127 : : #line 961 "/usr/local/src/libreoffice/idlc/source/parser.y"
3128 : : { (yyval.attexcpval).documentation = 0; (yyval.attexcpval).exceptions = 0; }
3129 : : break;
3130 : :
3131 : : case 79:
3132 : :
3133 : : /* Line 1806 of yacc.c */
3134 : : #line 966 "/usr/local/src/libreoffice/idlc/source/parser.y"
3135 : : {
3136 : : (yyval.attexcpval).documentation = new rtl::OUString(
3137 : : rtl::OStringToOUString(
3138 : : idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8));
3139 : : (yyval.attexcpval).exceptions = (yyvsp[(2) - (3)].dclsval);
3140 : : }
3141 : : break;
3142 : :
3143 : : case 81:
3144 : :
3145 : : /* Line 1806 of yacc.c */
3146 : : #line 976 "/usr/local/src/libreoffice/idlc/source/parser.y"
3147 : : { (yyval.attexcpval).documentation = 0; (yyval.attexcpval).exceptions = 0; }
3148 : : break;
3149 : :
3150 : : case 82:
3151 : :
3152 : : /* Line 1806 of yacc.c */
3153 : : #line 981 "/usr/local/src/libreoffice/idlc/source/parser.y"
3154 : : {
3155 : : if (static_cast< AstAttribute * >(idlc()->scopes()->top())->
3156 : : isReadonly())
3157 : : {
3158 : : idlc()->error()->error0(EIDL_READONLY_ATTRIBUTE_SET_EXCEPTIONS);
3159 : : }
3160 : : }
3161 : : break;
3162 : :
3163 : : case 83:
3164 : :
3165 : : /* Line 1806 of yacc.c */
3166 : : #line 989 "/usr/local/src/libreoffice/idlc/source/parser.y"
3167 : : {
3168 : : (yyval.attexcpval).documentation = new rtl::OUString(
3169 : : rtl::OStringToOUString(
3170 : : idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8));
3171 : : (yyval.attexcpval).exceptions = (yyvsp[(3) - (4)].dclsval);
3172 : : }
3173 : : break;
3174 : :
3175 : : case 84:
3176 : :
3177 : : /* Line 1806 of yacc.c */
3178 : : #line 1000 "/usr/local/src/libreoffice/idlc/source/parser.y"
3179 : : {
3180 : : idlc()->setParseState(PS_OpTypeSeen);
3181 : : }
3182 : : break;
3183 : :
3184 : : case 85:
3185 : :
3186 : : /* Line 1806 of yacc.c */
3187 : : #line 1004 "/usr/local/src/libreoffice/idlc/source/parser.y"
3188 : : {
3189 : : idlc()->setParseState(PS_OpIDSeen);
3190 : : checkIdentifier((yyvsp[(4) - (4)].sval));
3191 : :
3192 : : AstInterface * pScope = static_cast< AstInterface * >(
3193 : : idlc()->scopes()->top());
3194 : : AstOperation* pOp = NULL;
3195 : :
3196 : : /*
3197 : : * Create a node representing an operation on an interface
3198 : : * and add it to its enclosing scope
3199 : : */
3200 : : if ( pScope && (yyvsp[(2) - (4)].cdclval) )
3201 : : {
3202 : : AstType *pType = (AstType*)(yyvsp[(2) - (4)].cdclval);
3203 : : if ( !pType || (pType->getNodeType() == NT_exception) )
3204 : : {
3205 : : // type ERROR
3206 : : } else
3207 : : {
3208 : : pOp = new AstOperation((yyvsp[(1) - (4)].ulval), pType, *(yyvsp[(4) - (4)].sval), pScope);
3209 : :
3210 : : AstInterface::DoubleMemberDeclarations doubleMembers(
3211 : : pScope->checkMemberClashes(pOp));
3212 : : if (doubleMembers.empty()) {
3213 : : pScope->addMember(pOp);
3214 : : } else {
3215 : : reportDoubleMemberDeclarations(doubleMembers);
3216 : : }
3217 : : }
3218 : : }
3219 : : delete (yyvsp[(4) - (4)].sval);
3220 : : /*
3221 : : * Push the operation scope onto the scopes stack
3222 : : */
3223 : : idlc()->scopes()->push(pOp);
3224 : : }
3225 : : break;
3226 : :
3227 : : case 86:
3228 : :
3229 : : /* Line 1806 of yacc.c */
3230 : : #line 1042 "/usr/local/src/libreoffice/idlc/source/parser.y"
3231 : : {
3232 : : idlc()->setParseState(PS_OpSqSeen);
3233 : : }
3234 : : break;
3235 : :
3236 : : case 87:
3237 : :
3238 : : /* Line 1806 of yacc.c */
3239 : : #line 1046 "/usr/local/src/libreoffice/idlc/source/parser.y"
3240 : : {
3241 : : idlc()->setParseState(PS_OpParsCompleted);
3242 : : }
3243 : : break;
3244 : :
3245 : : case 88:
3246 : :
3247 : : /* Line 1806 of yacc.c */
3248 : : #line 1050 "/usr/local/src/libreoffice/idlc/source/parser.y"
3249 : : {
3250 : : idlc()->setParseState(PS_OpQsSeen);
3251 : : }
3252 : : break;
3253 : :
3254 : : case 89:
3255 : :
3256 : : /* Line 1806 of yacc.c */
3257 : : #line 1054 "/usr/local/src/libreoffice/idlc/source/parser.y"
3258 : : {
3259 : : AstScope* pScope = idlc()->scopes()->topNonNull();
3260 : : AstOperation* pOp = NULL;
3261 : : /*
3262 : : * Add exceptions and context to the operation
3263 : : */
3264 : : if ( pScope && pScope->getScopeNodeType() == NT_operation)
3265 : : {
3266 : : pOp = (AstOperation*)pScope;
3267 : :
3268 : : if ( pOp )
3269 : : pOp->setExceptions((yyvsp[(12) - (12)].dclsval));
3270 : : }
3271 : : delete (yyvsp[(12) - (12)].dclsval);
3272 : : /*
3273 : : * Done with this operation. Pop its scope from the scopes stack
3274 : : */
3275 : : idlc()->scopes()->pop();
3276 : : }
3277 : : break;
3278 : :
3279 : : case 90:
3280 : :
3281 : : /* Line 1806 of yacc.c */
3282 : : #line 1078 "/usr/local/src/libreoffice/idlc/source/parser.y"
3283 : : {
3284 : : idlc()->setParseState(PS_OpOnewaySeen);
3285 : : }
3286 : : break;
3287 : :
3288 : : case 91:
3289 : :
3290 : : /* Line 1806 of yacc.c */
3291 : : #line 1082 "/usr/local/src/libreoffice/idlc/source/parser.y"
3292 : : {
3293 : : idlc()->setParseState(PS_OpHeadSeen);
3294 : : (yyval.ulval) = OP_ONEWAY;
3295 : : }
3296 : : break;
3297 : :
3298 : : case 92:
3299 : :
3300 : : /* Line 1806 of yacc.c */
3301 : : #line 1087 "/usr/local/src/libreoffice/idlc/source/parser.y"
3302 : : {
3303 : : (yyval.ulval) = OP_NONE;
3304 : : }
3305 : : break;
3306 : :
3307 : : case 94:
3308 : :
3309 : : /* Line 1806 of yacc.c */
3310 : : #line 1095 "/usr/local/src/libreoffice/idlc/source/parser.y"
3311 : : {
3312 : : (yyval.cdclval) = idlc()->scopes()->bottom()->lookupPrimitiveType(ET_void);
3313 : : }
3314 : : break;
3315 : :
3316 : : case 96:
3317 : :
3318 : : /* Line 1806 of yacc.c */
3319 : : #line 1104 "/usr/local/src/libreoffice/idlc/source/parser.y"
3320 : : {
3321 : : idlc()->setParseState(PS_OpParCommaSeen);
3322 : : }
3323 : : break;
3324 : :
3325 : : case 99:
3326 : :
3327 : : /* Line 1806 of yacc.c */
3328 : : #line 1110 "/usr/local/src/libreoffice/idlc/source/parser.y"
3329 : : {
3330 : : yyerror("parameter definition");
3331 : : yyerrok;
3332 : : }
3333 : : break;
3334 : :
3335 : : case 100:
3336 : :
3337 : : /* Line 1806 of yacc.c */
3338 : : #line 1120 "/usr/local/src/libreoffice/idlc/source/parser.y"
3339 : : {
3340 : : idlc()->setParseState(PS_OpParDirSeen);
3341 : : }
3342 : : break;
3343 : :
3344 : : case 101:
3345 : :
3346 : : /* Line 1806 of yacc.c */
3347 : : #line 1124 "/usr/local/src/libreoffice/idlc/source/parser.y"
3348 : : {
3349 : : idlc()->setParseState(PS_OpParTypeSeen);
3350 : : }
3351 : : break;
3352 : :
3353 : : case 102:
3354 : :
3355 : : /* Line 1806 of yacc.c */
3356 : : #line 1129 "/usr/local/src/libreoffice/idlc/source/parser.y"
3357 : : {
3358 : : idlc()->setParseState(PS_OpParDeclSeen);
3359 : :
3360 : : AstOperation * pScope = static_cast< AstOperation * >(
3361 : : idlc()->scopes()->top());
3362 : : AstParameter* pParam = NULL;
3363 : :
3364 : : /*
3365 : : * Create a node representing an argument to an operation
3366 : : * Add it to the enclosing scope (the operation scope)
3367 : : */
3368 : : if ( pScope && (yyvsp[(5) - (8)].cdclval) && (yyvsp[(8) - (8)].fdval) )
3369 : : {
3370 : : AstType const * pType = (yyvsp[(8) - (8)].fdval)->compose((yyvsp[(5) - (8)].cdclval));
3371 : : if ( pType )
3372 : : {
3373 : : if (pScope->isConstructor() && (yyvsp[(2) - (8)].ulval) != DIR_IN) {
3374 : : idlc()->error()->error0(EIDL_CONSTRUCTOR_PARAMETER_NOT_IN);
3375 : : }
3376 : : if (pScope->isVariadic()) {
3377 : : idlc()->error()->error0(EIDL_REST_PARAMETER_NOT_LAST);
3378 : : }
3379 : : if ((yyvsp[(7) - (8)].bval)) {
3380 : : AstDeclaration const * type = resolveTypedefs(pType);
3381 : : if (type->getNodeType() != NT_predefined
3382 : : || (static_cast< AstBaseType const * >(type)->
3383 : : getExprType() != ET_any))
3384 : : {
3385 : : idlc()->error()->error0(EIDL_REST_PARAMETER_NOT_ANY);
3386 : : }
3387 : : if (pScope->isConstructor()) {
3388 : : if (pScope->getIteratorBegin()
3389 : : != pScope->getIteratorEnd())
3390 : : {
3391 : : idlc()->error()->error0(
3392 : : EIDL_CONSTRUCTOR_REST_PARAMETER_NOT_FIRST);
3393 : : }
3394 : : } else {
3395 : : idlc()->error()->error0(EIDL_METHOD_HAS_REST_PARAMETER);
3396 : : }
3397 : : }
3398 : :
3399 : : pParam = new AstParameter(
3400 : : static_cast< Direction >((yyvsp[(2) - (8)].ulval)), (yyvsp[(7) - (8)].bval), pType, (yyvsp[(8) - (8)].fdval)->getName(),
3401 : : pScope);
3402 : :
3403 : : if ( !(yyvsp[(8) - (8)].fdval)->checkType((yyvsp[(5) - (8)].cdclval)) )
3404 : : {
3405 : : // WARNING
3406 : : }
3407 : :
3408 : : pScope->addDeclaration(pParam);
3409 : : }
3410 : : }
3411 : : }
3412 : : break;
3413 : :
3414 : : case 103:
3415 : :
3416 : : /* Line 1806 of yacc.c */
3417 : : #line 1186 "/usr/local/src/libreoffice/idlc/source/parser.y"
3418 : : {
3419 : : idlc()->setParseState(PS_NoState);
3420 : : yyerrok;
3421 : : }
3422 : : break;
3423 : :
3424 : : case 104:
3425 : :
3426 : : /* Line 1806 of yacc.c */
3427 : : #line 1194 "/usr/local/src/libreoffice/idlc/source/parser.y"
3428 : : {
3429 : : (yyval.ulval) = DIR_IN;
3430 : : }
3431 : : break;
3432 : :
3433 : : case 105:
3434 : :
3435 : : /* Line 1806 of yacc.c */
3436 : : #line 1198 "/usr/local/src/libreoffice/idlc/source/parser.y"
3437 : : {
3438 : : (yyval.ulval) = DIR_OUT;
3439 : : }
3440 : : break;
3441 : :
3442 : : case 106:
3443 : :
3444 : : /* Line 1806 of yacc.c */
3445 : : #line 1202 "/usr/local/src/libreoffice/idlc/source/parser.y"
3446 : : {
3447 : : (yyval.ulval) = DIR_INOUT;
3448 : : }
3449 : : break;
3450 : :
3451 : : case 107:
3452 : :
3453 : : /* Line 1806 of yacc.c */
3454 : : #line 1209 "/usr/local/src/libreoffice/idlc/source/parser.y"
3455 : : {
3456 : : (yyval.bval) = true;
3457 : : }
3458 : : break;
3459 : :
3460 : : case 108:
3461 : :
3462 : : /* Line 1806 of yacc.c */
3463 : : #line 1213 "/usr/local/src/libreoffice/idlc/source/parser.y"
3464 : : {
3465 : : (yyval.bval) = false;
3466 : : }
3467 : : break;
3468 : :
3469 : : case 110:
3470 : :
3471 : : /* Line 1806 of yacc.c */
3472 : : #line 1221 "/usr/local/src/libreoffice/idlc/source/parser.y"
3473 : : {
3474 : : (yyval.dclsval) = 0;
3475 : : }
3476 : : break;
3477 : :
3478 : : case 111:
3479 : :
3480 : : /* Line 1806 of yacc.c */
3481 : : #line 1228 "/usr/local/src/libreoffice/idlc/source/parser.y"
3482 : : {
3483 : : idlc()->setParseState(PS_RaiseSeen);
3484 : : }
3485 : : break;
3486 : :
3487 : : case 112:
3488 : :
3489 : : /* Line 1806 of yacc.c */
3490 : : #line 1232 "/usr/local/src/libreoffice/idlc/source/parser.y"
3491 : : {
3492 : : idlc()->setParseState(PS_RaiseSqSeen);
3493 : : }
3494 : : break;
3495 : :
3496 : : case 113:
3497 : :
3498 : : /* Line 1806 of yacc.c */
3499 : : #line 1237 "/usr/local/src/libreoffice/idlc/source/parser.y"
3500 : : {
3501 : : idlc()->setParseState(PS_RaiseQsSeen);
3502 : : (yyval.dclsval) = (yyvsp[(5) - (6)].dclsval);
3503 : : }
3504 : : break;
3505 : :
3506 : : case 114:
3507 : :
3508 : : /* Line 1806 of yacc.c */
3509 : : #line 1245 "/usr/local/src/libreoffice/idlc/source/parser.y"
3510 : : {
3511 : : (yyval.dclsval) = new DeclList;
3512 : : (yyval.dclsval)->push_back((yyvsp[(1) - (1)].dclval));
3513 : : }
3514 : : break;
3515 : :
3516 : : case 115:
3517 : :
3518 : : /* Line 1806 of yacc.c */
3519 : : #line 1250 "/usr/local/src/libreoffice/idlc/source/parser.y"
3520 : : {
3521 : : (yyvsp[(1) - (3)].dclsval)->push_back((yyvsp[(3) - (3)].dclval));
3522 : : (yyval.dclsval) = (yyvsp[(1) - (3)].dclsval);
3523 : : }
3524 : : break;
3525 : :
3526 : : case 116:
3527 : :
3528 : : /* Line 1806 of yacc.c */
3529 : : #line 1258 "/usr/local/src/libreoffice/idlc/source/parser.y"
3530 : : {
3531 : : // The topmost scope is either an AstOperation (for interface methods
3532 : : // and service constructors) or an AstAttribute (for interface
3533 : : // attributes), so look up exception names in the next-to-topmost scope:
3534 : : AstDeclaration * decl = idlc()->scopes()->nextToTop()->lookupByName(
3535 : : *(yyvsp[(1) - (1)].sval));
3536 : : if (decl == 0) {
3537 : : idlc()->error()->lookupError(*(yyvsp[(1) - (1)].sval));
3538 : : } else if (!idlc()->error()->checkPublished(decl)) {
3539 : : decl = 0;
3540 : : } else if (decl->getNodeType() != NT_exception) {
3541 : : idlc()->error()->error1(EIDL_ILLEGAL_RAISES, decl);
3542 : : decl = 0;
3543 : : }
3544 : : delete (yyvsp[(1) - (1)].sval);
3545 : : (yyval.dclval) = decl;
3546 : : }
3547 : : break;
3548 : :
3549 : : case 117:
3550 : :
3551 : : /* Line 1806 of yacc.c */
3552 : : #line 1280 "/usr/local/src/libreoffice/idlc/source/parser.y"
3553 : : {
3554 : : idlc()->setParseState(PS_ServiceIFHeadSeen);
3555 : : }
3556 : : break;
3557 : :
3558 : : case 118:
3559 : :
3560 : : /* Line 1806 of yacc.c */
3561 : : #line 1284 "/usr/local/src/libreoffice/idlc/source/parser.y"
3562 : : {
3563 : : AstInterface * ifc = static_cast< AstInterface * >(
3564 : : idlc()->scopes()->top());
3565 : : if (ifc->usesSingleInheritance()) {
3566 : : idlc()->error()->error0(EIDL_MIXED_INHERITANCE);
3567 : : } else {
3568 : : addInheritedInterface(
3569 : : ifc, *(yyvsp[(4) - (4)].sval), (yyvsp[(1) - (4)].bval),
3570 : : rtl::OStringToOUString(
3571 : : idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8));
3572 : : }
3573 : : delete (yyvsp[(4) - (4)].sval);
3574 : : }
3575 : : break;
3576 : :
3577 : : case 119:
3578 : :
3579 : : /* Line 1806 of yacc.c */
3580 : : #line 1300 "/usr/local/src/libreoffice/idlc/source/parser.y"
3581 : : { (yyval.bval) = true; }
3582 : : break;
3583 : :
3584 : : case 120:
3585 : :
3586 : : /* Line 1806 of yacc.c */
3587 : : #line 1301 "/usr/local/src/libreoffice/idlc/source/parser.y"
3588 : : { (yyval.bval) = false; }
3589 : : break;
3590 : :
3591 : : case 123:
3592 : :
3593 : : /* Line 1806 of yacc.c */
3594 : : #line 1311 "/usr/local/src/libreoffice/idlc/source/parser.y"
3595 : : {
3596 : : idlc()->setParseState(PS_ConstantDeclSeen);
3597 : : }
3598 : : break;
3599 : :
3600 : : case 124:
3601 : :
3602 : : /* Line 1806 of yacc.c */
3603 : : #line 1314 "/usr/local/src/libreoffice/idlc/source/parser.y"
3604 : : {}
3605 : : break;
3606 : :
3607 : : case 125:
3608 : :
3609 : : /* Line 1806 of yacc.c */
3610 : : #line 1318 "/usr/local/src/libreoffice/idlc/source/parser.y"
3611 : : {
3612 : : idlc()->setParseState(PS_ConstSeen);
3613 : : }
3614 : : break;
3615 : :
3616 : : case 126:
3617 : :
3618 : : /* Line 1806 of yacc.c */
3619 : : #line 1322 "/usr/local/src/libreoffice/idlc/source/parser.y"
3620 : : {
3621 : : idlc()->setParseState(PS_ConstTypeSeen);
3622 : : }
3623 : : break;
3624 : :
3625 : : case 127:
3626 : :
3627 : : /* Line 1806 of yacc.c */
3628 : : #line 1326 "/usr/local/src/libreoffice/idlc/source/parser.y"
3629 : : {
3630 : : idlc()->setParseState(PS_ConstIDSeen);
3631 : : checkIdentifier((yyvsp[(5) - (5)].sval));
3632 : : }
3633 : : break;
3634 : :
3635 : : case 128:
3636 : :
3637 : : /* Line 1806 of yacc.c */
3638 : : #line 1331 "/usr/local/src/libreoffice/idlc/source/parser.y"
3639 : : {
3640 : : idlc()->setParseState(PS_ConstAssignSeen);
3641 : : }
3642 : : break;
3643 : :
3644 : : case 129:
3645 : :
3646 : : /* Line 1806 of yacc.c */
3647 : : #line 1335 "/usr/local/src/libreoffice/idlc/source/parser.y"
3648 : : {
3649 : : idlc()->setParseState(PS_ConstExprSeen);
3650 : :
3651 : : AstScope* pScope = idlc()->scopes()->topNonNull();
3652 : : AstConstant* pConstant = NULL;
3653 : :
3654 : : if ( (yyvsp[(9) - (9)].exval) && pScope )
3655 : : {
3656 : : if ( !(yyvsp[(9) - (9)].exval)->coerce((yyvsp[(3) - (9)].etval)) )
3657 : : {
3658 : : idlc()->error()->coercionError((yyvsp[(9) - (9)].exval), (yyvsp[(3) - (9)].etval));
3659 : : } else
3660 : : {
3661 : : pConstant = new AstConstant((yyvsp[(3) - (9)].etval), (yyvsp[(9) - (9)].exval), *(yyvsp[(5) - (9)].sval), pScope);
3662 : : pScope->addDeclaration(pConstant);
3663 : : }
3664 : : }
3665 : : delete (yyvsp[(5) - (9)].sval);
3666 : : }
3667 : : break;
3668 : :
3669 : : case 130:
3670 : :
3671 : : /* Line 1806 of yacc.c */
3672 : : #line 1358 "/usr/local/src/libreoffice/idlc/source/parser.y"
3673 : : {
3674 : : idlc()->setParseState(PS_ConstantsSeen);
3675 : : }
3676 : : break;
3677 : :
3678 : : case 131:
3679 : :
3680 : : /* Line 1806 of yacc.c */
3681 : : #line 1362 "/usr/local/src/libreoffice/idlc/source/parser.y"
3682 : : {
3683 : : idlc()->setParseState(PS_ConstantsIDSeen);
3684 : : checkIdentifier((yyvsp[(3) - (3)].sval));
3685 : : }
3686 : : break;
3687 : :
3688 : : case 132:
3689 : :
3690 : : /* Line 1806 of yacc.c */
3691 : : #line 1367 "/usr/local/src/libreoffice/idlc/source/parser.y"
3692 : : {
3693 : : idlc()->setParseState(PS_ConstantsSqSeen);
3694 : :
3695 : : AstScope* pScope = idlc()->scopes()->topNonNull();
3696 : : AstConstants* pConstants = NULL;
3697 : : AstDeclaration* pExists = NULL;
3698 : :
3699 : : if ( pScope )
3700 : : {
3701 : : pConstants = new AstConstants(*(yyvsp[(3) - (5)].sval), pScope);
3702 : : if( (pExists = pScope->lookupForAdd(pConstants)) )
3703 : : {
3704 : : pExists->setInMainfile(idlc()->isInMainFile());
3705 : : delete(pConstants);
3706 : : pConstants = (AstConstants*)pExists;
3707 : : } else
3708 : : {
3709 : : pScope->addDeclaration(pConstants);
3710 : : }
3711 : : idlc()->scopes()->push(pConstants);
3712 : : }
3713 : : delete (yyvsp[(3) - (5)].sval);
3714 : : }
3715 : : break;
3716 : :
3717 : : case 133:
3718 : :
3719 : : /* Line 1806 of yacc.c */
3720 : : #line 1391 "/usr/local/src/libreoffice/idlc/source/parser.y"
3721 : : {
3722 : : idlc()->setParseState(PS_ConstantsBodySeen);
3723 : : }
3724 : : break;
3725 : :
3726 : : case 134:
3727 : :
3728 : : /* Line 1806 of yacc.c */
3729 : : #line 1395 "/usr/local/src/libreoffice/idlc/source/parser.y"
3730 : : {
3731 : : idlc()->setParseState(PS_ConstantsQsSeen);
3732 : : /*
3733 : : * Finished with this constants - pop it from the scope stack
3734 : : */
3735 : : idlc()->scopes()->pop();
3736 : : }
3737 : : break;
3738 : :
3739 : : case 138:
3740 : :
3741 : : /* Line 1806 of yacc.c */
3742 : : #line 1411 "/usr/local/src/libreoffice/idlc/source/parser.y"
3743 : : {
3744 : : (yyval.exval) = new AstExpression(EC_or, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3745 : : }
3746 : : break;
3747 : :
3748 : : case 140:
3749 : :
3750 : : /* Line 1806 of yacc.c */
3751 : : #line 1419 "/usr/local/src/libreoffice/idlc/source/parser.y"
3752 : : {
3753 : : (yyval.exval) = new AstExpression(EC_xor, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3754 : : }
3755 : : break;
3756 : :
3757 : : case 142:
3758 : :
3759 : : /* Line 1806 of yacc.c */
3760 : : #line 1427 "/usr/local/src/libreoffice/idlc/source/parser.y"
3761 : : {
3762 : : (yyval.exval) = new AstExpression(EC_and, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3763 : : }
3764 : : break;
3765 : :
3766 : : case 144:
3767 : :
3768 : : /* Line 1806 of yacc.c */
3769 : : #line 1435 "/usr/local/src/libreoffice/idlc/source/parser.y"
3770 : : {
3771 : : (yyval.exval) = new AstExpression(EC_left, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3772 : : }
3773 : : break;
3774 : :
3775 : : case 145:
3776 : :
3777 : : /* Line 1806 of yacc.c */
3778 : : #line 1439 "/usr/local/src/libreoffice/idlc/source/parser.y"
3779 : : {
3780 : : (yyval.exval) = new AstExpression(EC_right, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3781 : : }
3782 : : break;
3783 : :
3784 : : case 147:
3785 : :
3786 : : /* Line 1806 of yacc.c */
3787 : : #line 1447 "/usr/local/src/libreoffice/idlc/source/parser.y"
3788 : : {
3789 : : (yyval.exval) = new AstExpression(EC_add, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3790 : : }
3791 : : break;
3792 : :
3793 : : case 148:
3794 : :
3795 : : /* Line 1806 of yacc.c */
3796 : : #line 1451 "/usr/local/src/libreoffice/idlc/source/parser.y"
3797 : : {
3798 : : (yyval.exval) = new AstExpression(EC_minus, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3799 : : }
3800 : : break;
3801 : :
3802 : : case 150:
3803 : :
3804 : : /* Line 1806 of yacc.c */
3805 : : #line 1459 "/usr/local/src/libreoffice/idlc/source/parser.y"
3806 : : {
3807 : : (yyval.exval) = new AstExpression(EC_mul, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3808 : : }
3809 : : break;
3810 : :
3811 : : case 151:
3812 : :
3813 : : /* Line 1806 of yacc.c */
3814 : : #line 1463 "/usr/local/src/libreoffice/idlc/source/parser.y"
3815 : : {
3816 : : (yyval.exval) = new AstExpression(EC_div, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3817 : : }
3818 : : break;
3819 : :
3820 : : case 152:
3821 : :
3822 : : /* Line 1806 of yacc.c */
3823 : : #line 1467 "/usr/local/src/libreoffice/idlc/source/parser.y"
3824 : : {
3825 : : (yyval.exval) = new AstExpression(EC_mod, (yyvsp[(1) - (3)].exval), (yyvsp[(3) - (3)].exval));
3826 : : }
3827 : : break;
3828 : :
3829 : : case 154:
3830 : :
3831 : : /* Line 1806 of yacc.c */
3832 : : #line 1475 "/usr/local/src/libreoffice/idlc/source/parser.y"
3833 : : {
3834 : : (yyval.exval) = new AstExpression(EC_u_plus, (yyvsp[(2) - (2)].exval), NULL);
3835 : : }
3836 : : break;
3837 : :
3838 : : case 155:
3839 : :
3840 : : /* Line 1806 of yacc.c */
3841 : : #line 1479 "/usr/local/src/libreoffice/idlc/source/parser.y"
3842 : : {
3843 : : (yyval.exval) = new AstExpression(EC_u_minus, (yyvsp[(2) - (2)].exval), NULL);
3844 : : }
3845 : : break;
3846 : :
3847 : : case 156:
3848 : :
3849 : : /* Line 1806 of yacc.c */
3850 : : #line 1483 "/usr/local/src/libreoffice/idlc/source/parser.y"
3851 : : {
3852 : : }
3853 : : break;
3854 : :
3855 : : case 157:
3856 : :
3857 : : /* Line 1806 of yacc.c */
3858 : : #line 1489 "/usr/local/src/libreoffice/idlc/source/parser.y"
3859 : : {
3860 : : /*
3861 : : * An expression which is a scoped name is not resolved now,
3862 : : * but only when it is evaluated (such as when it is assigned
3863 : : * as a constant value)
3864 : : */
3865 : : (yyval.exval) = new AstExpression((yyvsp[(1) - (1)].sval));
3866 : : }
3867 : : break;
3868 : :
3869 : : case 159:
3870 : :
3871 : : /* Line 1806 of yacc.c */
3872 : : #line 1499 "/usr/local/src/libreoffice/idlc/source/parser.y"
3873 : : {
3874 : : (yyval.exval) = (yyvsp[(2) - (3)].exval);
3875 : : }
3876 : : break;
3877 : :
3878 : : case 160:
3879 : :
3880 : : /* Line 1806 of yacc.c */
3881 : : #line 1506 "/usr/local/src/libreoffice/idlc/source/parser.y"
3882 : : {
3883 : : (yyval.exval) = new AstExpression((yyvsp[(1) - (1)].ival));
3884 : : }
3885 : : break;
3886 : :
3887 : : case 161:
3888 : :
3889 : : /* Line 1806 of yacc.c */
3890 : : #line 1510 "/usr/local/src/libreoffice/idlc/source/parser.y"
3891 : : {
3892 : : (yyval.exval) = new AstExpression((yyvsp[(1) - (1)].uval));
3893 : : }
3894 : : break;
3895 : :
3896 : : case 162:
3897 : :
3898 : : /* Line 1806 of yacc.c */
3899 : : #line 1514 "/usr/local/src/libreoffice/idlc/source/parser.y"
3900 : : {
3901 : : (yyval.exval) = new AstExpression((yyvsp[(1) - (1)].dval));
3902 : : }
3903 : : break;
3904 : :
3905 : : case 163:
3906 : :
3907 : : /* Line 1806 of yacc.c */
3908 : : #line 1518 "/usr/local/src/libreoffice/idlc/source/parser.y"
3909 : : {
3910 : : (yyval.exval) = new AstExpression((sal_Int32)1, ET_boolean);
3911 : : }
3912 : : break;
3913 : :
3914 : : case 164:
3915 : :
3916 : : /* Line 1806 of yacc.c */
3917 : : #line 1522 "/usr/local/src/libreoffice/idlc/source/parser.y"
3918 : : {
3919 : : (yyval.exval) = new AstExpression((sal_Int32)0, ET_boolean);
3920 : : }
3921 : : break;
3922 : :
3923 : : case 165:
3924 : :
3925 : : /* Line 1806 of yacc.c */
3926 : : #line 1529 "/usr/local/src/libreoffice/idlc/source/parser.y"
3927 : : {
3928 : : (yyvsp[(1) - (1)].exval)->evaluate(EK_const);
3929 : : if ( !(yyvsp[(1) - (1)].exval)->coerce(ET_ulong) )
3930 : : {
3931 : : idlc()->error()->coercionError((yyvsp[(1) - (1)].exval), ET_ulong);
3932 : : delete (yyvsp[(1) - (1)].exval);
3933 : : (yyval.exval) = NULL;
3934 : : }
3935 : : }
3936 : : break;
3937 : :
3938 : : case 171:
3939 : :
3940 : : /* Line 1806 of yacc.c */
3941 : : #line 1547 "/usr/local/src/libreoffice/idlc/source/parser.y"
3942 : : {
3943 : : AstScope* pScope = idlc()->scopes()->topNonNull();
3944 : : AstDeclaration const * type = 0;
3945 : :
3946 : : /*
3947 : : * If the constant's type is a scoped name, it must resolve
3948 : : * to a scalar constant type
3949 : : */
3950 : : if ( pScope && (type = pScope->lookupByName(*(yyvsp[(1) - (1)].sval))) ) {
3951 : : if (!idlc()->error()->checkPublished(type))
3952 : : {
3953 : : type = 0;
3954 : : }
3955 : : else
3956 : : {
3957 : : type = resolveTypedefs(type);
3958 : : if (type->getNodeType() == NT_predefined)
3959 : : {
3960 : : (yyval.etval) = static_cast< AstBaseType const * >(type)->
3961 : : getExprType();
3962 : : } else
3963 : : (yyval.etval) = ET_any;
3964 : : }
3965 : : } else
3966 : : (yyval.etval) = ET_any;
3967 : : }
3968 : : break;
3969 : :
3970 : : case 172:
3971 : :
3972 : : /* Line 1806 of yacc.c */
3973 : : #line 1577 "/usr/local/src/libreoffice/idlc/source/parser.y"
3974 : : {
3975 : : idlc()->setParseState(PS_ExceptSeen);
3976 : : }
3977 : : break;
3978 : :
3979 : : case 173:
3980 : :
3981 : : /* Line 1806 of yacc.c */
3982 : : #line 1581 "/usr/local/src/libreoffice/idlc/source/parser.y"
3983 : : {
3984 : : idlc()->setParseState(PS_ExceptIDSeen);
3985 : : checkIdentifier((yyvsp[(3) - (3)].sval));
3986 : : }
3987 : : break;
3988 : :
3989 : : case 174:
3990 : :
3991 : : /* Line 1806 of yacc.c */
3992 : : #line 1586 "/usr/local/src/libreoffice/idlc/source/parser.y"
3993 : : {
3994 : : idlc()->setParseState(PS_InheritSpecSeen);
3995 : :
3996 : : (yyval.ihval) = new FeInheritanceHeader(NT_exception, (yyvsp[(3) - (5)].sval), (yyvsp[(5) - (5)].sval), 0);
3997 : : delete (yyvsp[(5) - (5)].sval);
3998 : : }
3999 : : break;
4000 : :
4001 : : case 175:
4002 : :
4003 : : /* Line 1806 of yacc.c */
4004 : : #line 1596 "/usr/local/src/libreoffice/idlc/source/parser.y"
4005 : : {
4006 : : idlc()->setParseState(PS_ExceptHeaderSeen);
4007 : :
4008 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4009 : : AstException* pExcept = NULL;
4010 : :
4011 : : if ( pScope )
4012 : : {
4013 : : AstException* pBase = static_cast< AstException* >(
4014 : : (yyvsp[(1) - (1)].ihval)->getInherits());
4015 : : pExcept = new AstException(*(yyvsp[(1) - (1)].ihval)->getName(), pBase, pScope);
4016 : : pScope->addDeclaration(pExcept);
4017 : : }
4018 : : /*
4019 : : * Push the scope of the exception on the scopes stack
4020 : : */
4021 : : idlc()->scopes()->push(pExcept);
4022 : : delete (yyvsp[(1) - (1)].ihval);
4023 : : }
4024 : : break;
4025 : :
4026 : : case 176:
4027 : :
4028 : : /* Line 1806 of yacc.c */
4029 : : #line 1616 "/usr/local/src/libreoffice/idlc/source/parser.y"
4030 : : {
4031 : : idlc()->setParseState(PS_ExceptSqSeen);
4032 : : }
4033 : : break;
4034 : :
4035 : : case 177:
4036 : :
4037 : : /* Line 1806 of yacc.c */
4038 : : #line 1620 "/usr/local/src/libreoffice/idlc/source/parser.y"
4039 : : {
4040 : : idlc()->setParseState(PS_ExceptBodySeen);
4041 : : }
4042 : : break;
4043 : :
4044 : : case 178:
4045 : :
4046 : : /* Line 1806 of yacc.c */
4047 : : #line 1624 "/usr/local/src/libreoffice/idlc/source/parser.y"
4048 : : {
4049 : : idlc()->setParseState(PS_ExceptQsSeen);
4050 : : /* this exception is finished, pop its scope from the stack */
4051 : : idlc()->scopes()->pop();
4052 : : }
4053 : : break;
4054 : :
4055 : : case 179:
4056 : :
4057 : : /* Line 1806 of yacc.c */
4058 : : #line 1634 "/usr/local/src/libreoffice/idlc/source/parser.y"
4059 : : {
4060 : : idlc()->setParseState(PS_PropertyTypeSeen);
4061 : : }
4062 : : break;
4063 : :
4064 : : case 180:
4065 : :
4066 : : /* Line 1806 of yacc.c */
4067 : : #line 1638 "/usr/local/src/libreoffice/idlc/source/parser.y"
4068 : : {
4069 : : idlc()->setParseState(PS_PropertyCompleted);
4070 : :
4071 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4072 : : AstAttribute* pAttr = NULL;
4073 : : FeDeclList* pList = (yyvsp[(4) - (4)].dlval);
4074 : : FeDeclarator* pDecl = NULL;
4075 : : AstType const * pType = NULL;
4076 : :
4077 : : if ( pScope->getScopeNodeType() == NT_singleton )
4078 : : {
4079 : : idlc()->error()->error0(EIDL_ILLEGAL_ADD);
4080 : : } else
4081 : : {
4082 : : if ( ((yyvsp[(1) - (4)].ulval) & AF_ATTRIBUTE) == AF_ATTRIBUTE )
4083 : : idlc()->error()->flagError(EIDL_WRONGATTRIBUTEKEYWORD, AF_ATTRIBUTE);
4084 : :
4085 : : if ( ((yyvsp[(1) - (4)].ulval) & AF_PROPERTY) != AF_PROPERTY )
4086 : : idlc()->error()->flagError(EIDL_MISSINGATTRIBUTEKEYWORD, AF_PROPERTY);
4087 : :
4088 : : /*
4089 : : * Create nodes representing attributes and add them to the
4090 : : * enclosing scope
4091 : : */
4092 : : if ( pScope && (yyvsp[(2) - (4)].cdclval) && pList )
4093 : : {
4094 : : FeDeclList::iterator iter = pList->begin();
4095 : : FeDeclList::iterator end = pList->end();
4096 : :
4097 : : while (iter != end)
4098 : : {
4099 : : pDecl = (*iter);
4100 : : if ( !pDecl )
4101 : : {
4102 : : iter++;
4103 : : continue;
4104 : : }
4105 : :
4106 : : pType = pDecl->compose((yyvsp[(2) - (4)].cdclval));
4107 : :
4108 : : if ( !pType )
4109 : : {
4110 : : iter++;
4111 : : continue;
4112 : : }
4113 : :
4114 : : pAttr = new AstAttribute(NT_property, (yyvsp[(1) - (4)].ulval), pType, pDecl->getName(), pScope);
4115 : :
4116 : : pScope->addDeclaration(pAttr);
4117 : : iter++;
4118 : : delete pDecl;
4119 : : }
4120 : : }
4121 : : }
4122 : :
4123 : : if ( pList )
4124 : : delete pList;
4125 : : }
4126 : : break;
4127 : :
4128 : : case 181:
4129 : :
4130 : : /* Line 1806 of yacc.c */
4131 : : #line 1697 "/usr/local/src/libreoffice/idlc/source/parser.y"
4132 : : {
4133 : : yyerror("property");
4134 : : yyerrok;
4135 : : }
4136 : : break;
4137 : :
4138 : : case 184:
4139 : :
4140 : : /* Line 1806 of yacc.c */
4141 : : #line 1712 "/usr/local/src/libreoffice/idlc/source/parser.y"
4142 : : {
4143 : : idlc()->setParseState(PS_ServiceMemberSeen);
4144 : :
4145 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4146 : : AstDeclaration* pDecl = NULL;
4147 : : AstInterfaceMember* pIMember = NULL;
4148 : :
4149 : : if ( pScope->getScopeNodeType() == NT_singleton )
4150 : : {
4151 : : idlc()->error()->error0(EIDL_ILLEGAL_ADD);
4152 : : } else
4153 : : {
4154 : : /*
4155 : : * Create a node representing a class member.
4156 : : * Store it in the enclosing scope
4157 : : */
4158 : : if ( pScope && (yyvsp[(2) - (3)].slval) )
4159 : : {
4160 : : StringList::iterator iter = (yyvsp[(2) - (3)].slval)->begin();
4161 : : StringList::iterator end = (yyvsp[(2) - (3)].slval)->end();
4162 : :
4163 : : while ( iter != end )
4164 : : {
4165 : : pDecl = pScope->lookupByName(*iter);
4166 : : if ( pDecl && (pDecl->getNodeType() == NT_interface) )
4167 : : {
4168 : : /* we relax the strict published check and allow to add new
4169 : : * interfaces if they are optional
4170 : : */
4171 : : bool bOptional = (((yyvsp[(1) - (3)].ulval) & AF_OPTIONAL) == AF_OPTIONAL);
4172 : : if ( idlc()->error()->checkPublished(pDecl, bOptional) )
4173 : : {
4174 : : pIMember = new AstInterfaceMember(
4175 : : (yyvsp[(1) - (3)].ulval), (AstInterface*)pDecl, *iter, pScope);
4176 : : pScope->addDeclaration(pIMember);
4177 : : }
4178 : : } else
4179 : : {
4180 : : idlc()->error()->
4181 : : lookupError(EIDL_INTERFACEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope));
4182 : : }
4183 : : iter++;
4184 : : }
4185 : : }
4186 : : }
4187 : : delete (yyvsp[(2) - (3)].slval);
4188 : : }
4189 : : break;
4190 : :
4191 : : case 185:
4192 : :
4193 : : /* Line 1806 of yacc.c */
4194 : : #line 1762 "/usr/local/src/libreoffice/idlc/source/parser.y"
4195 : : {
4196 : : idlc()->setParseState(PS_ServiceMemberSeen);
4197 : :
4198 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4199 : : AstDeclaration* pDecl = NULL;
4200 : : AstServiceMember* pSMember = NULL;
4201 : :
4202 : : /*
4203 : : * Create a node representing a class member.
4204 : : * Store it in the enclosing scope
4205 : : */
4206 : : if ( pScope && (yyvsp[(2) - (3)].slval) )
4207 : : {
4208 : : StringList::iterator iter = (yyvsp[(2) - (3)].slval)->begin();
4209 : : StringList::iterator end = (yyvsp[(2) - (3)].slval)->end();
4210 : :
4211 : : while ( iter != end )
4212 : : {
4213 : : pDecl = pScope->lookupByName(*iter);
4214 : : if ( pDecl && (pDecl->getNodeType() == NT_service) )
4215 : : {
4216 : : if ( pScope->getScopeNodeType() == NT_singleton && pScope->nMembers() > 0 )
4217 : : idlc()->error()->error0(EIDL_ILLEGAL_ADD);
4218 : : else if ( idlc()->error()->checkPublished(pDecl) )
4219 : : {
4220 : : pSMember = new AstServiceMember(
4221 : : (yyvsp[(1) - (3)].ulval), (AstService*)pDecl, *iter, pScope);
4222 : : pScope->addDeclaration(pSMember);
4223 : : }
4224 : : } else
4225 : : {
4226 : : idlc()->error()->
4227 : : lookupError(EIDL_SERVICEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope));
4228 : : }
4229 : : iter++;
4230 : : }
4231 : : }
4232 : : delete (yyvsp[(2) - (3)].slval);
4233 : : }
4234 : : break;
4235 : :
4236 : : case 186:
4237 : :
4238 : : /* Line 1806 of yacc.c */
4239 : : #line 1804 "/usr/local/src/libreoffice/idlc/source/parser.y"
4240 : : {
4241 : : idlc()->setParseState(PS_ServiceMemberSeen);
4242 : :
4243 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4244 : : AstDeclaration* pDecl = NULL;
4245 : : AstObserves* pObserves = NULL;
4246 : :
4247 : : if ( pScope->getScopeNodeType() == NT_singleton )
4248 : : {
4249 : : idlc()->error()->error0(EIDL_ILLEGAL_ADD);
4250 : : } else
4251 : : {
4252 : : /*
4253 : : * Create a node representing a class member.
4254 : : * Store it in the enclosing scope
4255 : : */
4256 : : if ( pScope && (yyvsp[(2) - (3)].slval) )
4257 : : {
4258 : : StringList::iterator iter = (yyvsp[(2) - (3)].slval)->begin();
4259 : : StringList::iterator end = (yyvsp[(2) - (3)].slval)->end();
4260 : :
4261 : : while ( iter != end )
4262 : : {
4263 : : pDecl = pScope->lookupByName(*iter);
4264 : : if ( pDecl && (pDecl->getNodeType() == NT_interface) )
4265 : : {
4266 : : pObserves = new AstObserves((AstInterface*)pDecl, *iter, pScope);
4267 : : pScope->addDeclaration(pObserves);
4268 : : } else
4269 : : {
4270 : : idlc()->error()->
4271 : : lookupError(EIDL_INTERFACEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope));
4272 : : }
4273 : : iter++;
4274 : : }
4275 : : }
4276 : : }
4277 : : delete (yyvsp[(2) - (3)].slval);
4278 : : }
4279 : : break;
4280 : :
4281 : : case 187:
4282 : :
4283 : : /* Line 1806 of yacc.c */
4284 : : #line 1846 "/usr/local/src/libreoffice/idlc/source/parser.y"
4285 : : {
4286 : : idlc()->setParseState(PS_ServiceMemberSeen);
4287 : :
4288 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4289 : : AstDeclaration* pDecl = NULL;
4290 : : AstNeeds* pNeeds = NULL;
4291 : :
4292 : : if ( pScope->getScopeNodeType() == NT_singleton )
4293 : : {
4294 : : idlc()->error()->error0(EIDL_ILLEGAL_ADD);
4295 : : } else
4296 : : {
4297 : : /*
4298 : : * Create a node representing a class member.
4299 : : * Store it in the enclosing scope
4300 : : */
4301 : : if ( pScope && (yyvsp[(2) - (3)].slval) )
4302 : : {
4303 : : StringList::iterator iter = (yyvsp[(2) - (3)].slval)->begin();
4304 : : StringList::iterator end = (yyvsp[(2) - (3)].slval)->end();
4305 : :
4306 : : while ( iter != end )
4307 : : {
4308 : : pDecl = pScope->lookupByName(*iter);
4309 : : if ( pDecl && (pDecl->getNodeType() == NT_service) )
4310 : : {
4311 : : pNeeds = new AstNeeds((AstService*)pDecl, *iter, pScope);
4312 : : pScope->addDeclaration(pNeeds);
4313 : : } else
4314 : : {
4315 : : idlc()->error()->
4316 : : lookupError(EIDL_SERVICEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope));
4317 : : }
4318 : : iter++;
4319 : : }
4320 : : }
4321 : : }
4322 : : delete (yyvsp[(2) - (3)].slval);
4323 : : }
4324 : : break;
4325 : :
4326 : : case 188:
4327 : :
4328 : : /* Line 1806 of yacc.c */
4329 : : #line 1887 "/usr/local/src/libreoffice/idlc/source/parser.y"
4330 : : {
4331 : : idlc()->setParseState(PS_PropertyDeclSeen);
4332 : : }
4333 : : break;
4334 : :
4335 : : case 189:
4336 : :
4337 : : /* Line 1806 of yacc.c */
4338 : : #line 1894 "/usr/local/src/libreoffice/idlc/source/parser.y"
4339 : : {
4340 : : idlc()->setParseState(PS_ServiceIFHeadSeen);
4341 : : (yyval.ulval) = AF_INVALID;
4342 : : }
4343 : : break;
4344 : :
4345 : : case 190:
4346 : :
4347 : : /* Line 1806 of yacc.c */
4348 : : #line 1900 "/usr/local/src/libreoffice/idlc/source/parser.y"
4349 : : {
4350 : : idlc()->setParseState(PS_ServiceIFHeadSeen);
4351 : : if ( (AF_OPTIONAL != (yyvsp[(1) - (2)].ulval)) && ( AF_INVALID != (yyvsp[(1) - (2)].ulval)) )
4352 : : idlc()->error()->flagError(EIDL_OPTIONALEXPECTED, (yyvsp[(1) - (2)].ulval));
4353 : : (yyval.ulval) = (yyvsp[(1) - (2)].ulval);
4354 : : }
4355 : : break;
4356 : :
4357 : : case 191:
4358 : :
4359 : : /* Line 1806 of yacc.c */
4360 : : #line 1910 "/usr/local/src/libreoffice/idlc/source/parser.y"
4361 : : {
4362 : : idlc()->setParseState(PS_ServiceSHeadSeen);
4363 : : (yyval.ulval) = AF_INVALID;
4364 : : }
4365 : : break;
4366 : :
4367 : : case 192:
4368 : :
4369 : : /* Line 1806 of yacc.c */
4370 : : #line 1916 "/usr/local/src/libreoffice/idlc/source/parser.y"
4371 : : {
4372 : : idlc()->setParseState(PS_ServiceSHeadSeen);
4373 : : if ( (AF_OPTIONAL != (yyvsp[(1) - (2)].ulval)) && ( AF_INVALID != (yyvsp[(1) - (2)].ulval)) )
4374 : : idlc()->error()->flagError(EIDL_OPTIONALEXPECTED, (yyvsp[(1) - (2)].ulval));
4375 : : (yyval.ulval) = (yyvsp[(1) - (2)].ulval);
4376 : : }
4377 : : break;
4378 : :
4379 : : case 193:
4380 : :
4381 : : /* Line 1806 of yacc.c */
4382 : : #line 1926 "/usr/local/src/libreoffice/idlc/source/parser.y"
4383 : : {
4384 : : idlc()->setParseState(PS_ServiceSeen);
4385 : : }
4386 : : break;
4387 : :
4388 : : case 194:
4389 : :
4390 : : /* Line 1806 of yacc.c */
4391 : : #line 1930 "/usr/local/src/libreoffice/idlc/source/parser.y"
4392 : : {
4393 : : idlc()->setParseState(PS_ServiceIDSeen);
4394 : : checkIdentifier((yyvsp[(3) - (3)].sval));
4395 : :
4396 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4397 : : AstService* pService = NULL;
4398 : :
4399 : : /*
4400 : : * Make a new service and add it to the enclosing scope
4401 : : */
4402 : : if (pScope != NULL)
4403 : : {
4404 : : pService = new AstService(*(yyvsp[(3) - (3)].sval), pScope);
4405 : : pScope->addDeclaration(pService);
4406 : : }
4407 : : delete (yyvsp[(3) - (3)].sval);
4408 : : /*
4409 : : * Push it on the stack
4410 : : */
4411 : : idlc()->scopes()->push(pService);
4412 : : }
4413 : : break;
4414 : :
4415 : : case 195:
4416 : :
4417 : : /* Line 1806 of yacc.c */
4418 : : #line 1952 "/usr/local/src/libreoffice/idlc/source/parser.y"
4419 : : {
4420 : : /* this service is finished, pop its scope from the stack */
4421 : : idlc()->scopes()->pop();
4422 : : }
4423 : : break;
4424 : :
4425 : : case 198:
4426 : :
4427 : : /* Line 1806 of yacc.c */
4428 : : #line 1965 "/usr/local/src/libreoffice/idlc/source/parser.y"
4429 : : {
4430 : : AstScope * scope = idlc()->scopes()->nextToTop();
4431 : : // skip the scope pushed by service_dcl
4432 : : AstDeclaration * decl = scope->lookupByName(*(yyvsp[(2) - (2)].sval));
4433 : : if (decl != 0 && resolveTypedefs(decl)->getNodeType() == NT_interface) {
4434 : : if (idlc()->error()->checkPublished(decl)) {
4435 : : idlc()->scopes()->top()->addDeclaration(decl);
4436 : : }
4437 : : } else {
4438 : : idlc()->error()->lookupError(
4439 : : EIDL_INTERFACEMEMBER_LOOKUP, *(yyvsp[(2) - (2)].sval), scopeAsDecl(scope));
4440 : : }
4441 : : delete (yyvsp[(2) - (2)].sval);
4442 : : }
4443 : : break;
4444 : :
4445 : : case 199:
4446 : :
4447 : : /* Line 1806 of yacc.c */
4448 : : #line 1980 "/usr/local/src/libreoffice/idlc/source/parser.y"
4449 : : {
4450 : : AstService * s = static_cast< AstService * >(idlc()->scopes()->top());
4451 : : if (s != 0) {
4452 : : s->setDefaultConstructor(!(yyvsp[(4) - (4)].bval));
4453 : : }
4454 : : }
4455 : : break;
4456 : :
4457 : : case 200:
4458 : :
4459 : : /* Line 1806 of yacc.c */
4460 : : #line 1989 "/usr/local/src/libreoffice/idlc/source/parser.y"
4461 : : { (yyval.bval) = true; }
4462 : : break;
4463 : :
4464 : : case 201:
4465 : :
4466 : : /* Line 1806 of yacc.c */
4467 : : #line 1990 "/usr/local/src/libreoffice/idlc/source/parser.y"
4468 : : { (yyval.bval) = false; }
4469 : : break;
4470 : :
4471 : : case 205:
4472 : :
4473 : : /* Line 1806 of yacc.c */
4474 : : #line 2006 "/usr/local/src/libreoffice/idlc/source/parser.y"
4475 : : {
4476 : : checkIdentifier((yyvsp[(1) - (1)].sval));
4477 : : AstScope * scope = idlc()->scopes()->top();
4478 : : AstOperation * ctor = new AstOperation(OP_NONE, 0, *(yyvsp[(1) - (1)].sval), scope);
4479 : : delete (yyvsp[(1) - (1)].sval);
4480 : : scope->addDeclaration(ctor);
4481 : : idlc()->scopes()->push(ctor);
4482 : : }
4483 : : break;
4484 : :
4485 : : case 206:
4486 : :
4487 : : /* Line 1806 of yacc.c */
4488 : : #line 2018 "/usr/local/src/libreoffice/idlc/source/parser.y"
4489 : : {
4490 : : static_cast< AstOperation * >(idlc()->scopes()->top())->setExceptions(
4491 : : (yyvsp[(6) - (6)].dclsval));
4492 : : delete (yyvsp[(6) - (6)].dclsval);
4493 : : idlc()->scopes()->pop();
4494 : : if (static_cast< AstService * >(idlc()->scopes()->top())->
4495 : : checkLastConstructor())
4496 : : {
4497 : : idlc()->error()->error0(EIDL_SIMILAR_CONSTRUCTORS);
4498 : : }
4499 : : }
4500 : : break;
4501 : :
4502 : : case 208:
4503 : :
4504 : : /* Line 1806 of yacc.c */
4505 : : #line 2034 "/usr/local/src/libreoffice/idlc/source/parser.y"
4506 : : {
4507 : : idlc()->setParseState(PS_SingletonSeen);
4508 : : }
4509 : : break;
4510 : :
4511 : : case 209:
4512 : :
4513 : : /* Line 1806 of yacc.c */
4514 : : #line 2038 "/usr/local/src/libreoffice/idlc/source/parser.y"
4515 : : {
4516 : : idlc()->setParseState(PS_SingletonIDSeen);
4517 : : checkIdentifier((yyvsp[(3) - (3)].sval));
4518 : :
4519 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4520 : : AstService* pService = NULL;
4521 : :
4522 : : /*
4523 : : * Make a new service and add it to the enclosing scope
4524 : : */
4525 : : if (pScope != NULL)
4526 : : {
4527 : : pService = new AstService(NT_singleton, *(yyvsp[(3) - (3)].sval), pScope);
4528 : : pScope->addDeclaration(pService);
4529 : : }
4530 : : delete (yyvsp[(3) - (3)].sval);
4531 : : /*
4532 : : * Push it on the stack
4533 : : */
4534 : : idlc()->scopes()->push(pService);
4535 : : }
4536 : : break;
4537 : :
4538 : : case 210:
4539 : :
4540 : : /* Line 1806 of yacc.c */
4541 : : #line 2060 "/usr/local/src/libreoffice/idlc/source/parser.y"
4542 : : {
4543 : : /* this singelton is finished, pop its scope from the stack */
4544 : : idlc()->scopes()->pop();
4545 : : }
4546 : : break;
4547 : :
4548 : : case 213:
4549 : :
4550 : : /* Line 1806 of yacc.c */
4551 : : #line 2073 "/usr/local/src/libreoffice/idlc/source/parser.y"
4552 : : {
4553 : : AstScope * scope = idlc()->scopes()->nextToTop();
4554 : : // skip the scope (needlessly) pushed by singleton_dcl
4555 : : AstDeclaration * decl = scope->lookupByName(*(yyvsp[(2) - (2)].sval));
4556 : : if (decl != 0 && resolveTypedefs(decl)->getNodeType() == NT_interface) {
4557 : : if (idlc()->error()->checkPublished(decl)) {
4558 : : idlc()->scopes()->top()->addDeclaration(decl);
4559 : : }
4560 : : } else {
4561 : : idlc()->error()->lookupError(
4562 : : EIDL_INTERFACEMEMBER_LOOKUP, *(yyvsp[(2) - (2)].sval), scopeAsDecl(scope));
4563 : : }
4564 : : delete (yyvsp[(2) - (2)].sval);
4565 : : }
4566 : : break;
4567 : :
4568 : : case 214:
4569 : :
4570 : : /* Line 1806 of yacc.c */
4571 : : #line 2091 "/usr/local/src/libreoffice/idlc/source/parser.y"
4572 : : {
4573 : : idlc()->setParseState(
4574 : : idlc()->scopes()->top()->getScopeNodeType() == NT_service
4575 : : ? PS_ServiceSqSeen : PS_SingletonSqSeen);
4576 : : }
4577 : : break;
4578 : :
4579 : : case 215:
4580 : :
4581 : : /* Line 1806 of yacc.c */
4582 : : #line 2097 "/usr/local/src/libreoffice/idlc/source/parser.y"
4583 : : {
4584 : : idlc()->setParseState(
4585 : : idlc()->scopes()->top()->getScopeNodeType() == NT_service
4586 : : ? PS_ServiceBodySeen : PS_SingletonBodySeen);
4587 : : }
4588 : : break;
4589 : :
4590 : : case 216:
4591 : :
4592 : : /* Line 1806 of yacc.c */
4593 : : #line 2103 "/usr/local/src/libreoffice/idlc/source/parser.y"
4594 : : {
4595 : : idlc()->setParseState(
4596 : : idlc()->scopes()->top()->getScopeNodeType() == NT_service
4597 : : ? PS_ServiceQsSeen : PS_SingletonQsSeen);
4598 : : }
4599 : : break;
4600 : :
4601 : : case 217:
4602 : :
4603 : : /* Line 1806 of yacc.c */
4604 : : #line 2112 "/usr/local/src/libreoffice/idlc/source/parser.y"
4605 : : {
4606 : : idlc()->setParseState(PS_TypedefSeen);
4607 : : }
4608 : : break;
4609 : :
4610 : : case 218:
4611 : :
4612 : : /* Line 1806 of yacc.c */
4613 : : #line 2115 "/usr/local/src/libreoffice/idlc/source/parser.y"
4614 : : {}
4615 : : break;
4616 : :
4617 : : case 219:
4618 : :
4619 : : /* Line 1806 of yacc.c */
4620 : : #line 2116 "/usr/local/src/libreoffice/idlc/source/parser.y"
4621 : : {}
4622 : : break;
4623 : :
4624 : : case 220:
4625 : :
4626 : : /* Line 1806 of yacc.c */
4627 : : #line 2117 "/usr/local/src/libreoffice/idlc/source/parser.y"
4628 : : {}
4629 : : break;
4630 : :
4631 : : case 221:
4632 : :
4633 : : /* Line 1806 of yacc.c */
4634 : : #line 2118 "/usr/local/src/libreoffice/idlc/source/parser.y"
4635 : : {}
4636 : : break;
4637 : :
4638 : : case 222:
4639 : :
4640 : : /* Line 1806 of yacc.c */
4641 : : #line 2123 "/usr/local/src/libreoffice/idlc/source/parser.y"
4642 : : {
4643 : : idlc()->setParseState(PS_TypeSpecSeen);
4644 : : if ((yyvsp[(1) - (1)].cdclval) != 0 && (yyvsp[(1) - (1)].cdclval)->getNodeType() == NT_instantiated_struct) {
4645 : : idlc()->error()->error0(EIDL_INSTANTIATED_STRUCT_TYPE_TYPEDEF);
4646 : : }
4647 : : }
4648 : : break;
4649 : :
4650 : : case 223:
4651 : :
4652 : : /* Line 1806 of yacc.c */
4653 : : #line 2130 "/usr/local/src/libreoffice/idlc/source/parser.y"
4654 : : {
4655 : : idlc()->setParseState(PS_DeclaratorsSeen);
4656 : :
4657 : : AstScope* pScope = idlc()->scopes()->topNonNull();
4658 : : AstTypeDef* pTypeDef = NULL;
4659 : : FeDeclList* pList = (yyvsp[(3) - (3)].dlval);
4660 : : FeDeclarator* pDecl = NULL;
4661 : : AstType const * pType = NULL;
4662 : :
4663 : : /*
4664 : : * Create nodes representing typedefs and add them to the
4665 : : * enclosing scope
4666 : : */
4667 : : if ( pScope && (yyvsp[(1) - (3)].cdclval) && pList )
4668 : : {
4669 : : FeDeclList::iterator iter = pList->begin();
4670 : : FeDeclList::iterator end = pList->end();
4671 : :
4672 : : while (iter != end)
4673 : : {
4674 : : pDecl = (*iter);
4675 : : if ( !pDecl )
4676 : : {
4677 : : iter++;
4678 : : continue;
4679 : : }
4680 : :
4681 : : pType = pDecl->compose((yyvsp[(1) - (3)].cdclval));
4682 : :
4683 : : if ( !pType )
4684 : : {
4685 : : iter++;
4686 : : continue;
4687 : : }
4688 : :
4689 : : pTypeDef = new AstTypeDef(pType, pDecl->getName(), pScope);
4690 : :
4691 : : pScope->addDeclaration(pTypeDef);
4692 : : iter++;
4693 : : delete pDecl;
4694 : : }
4695 : : delete pList;
4696 : : }
4697 : : }
4698 : : break;
4699 : :
4700 : : case 224:
4701 : :
4702 : : /* Line 1806 of yacc.c */
4703 : : #line 2178 "/usr/local/src/libreoffice/idlc/source/parser.y"
4704 : : {
4705 : : if ( (yyvsp[(2) - (2)].dlval) )
4706 : : {
4707 : : (yyvsp[(2) - (2)].dlval)->push_back((yyvsp[(1) - (2)].fdval));
4708 : : (yyval.dlval) = (yyvsp[(2) - (2)].dlval);
4709 : : } else
4710 : : {
4711 : : FeDeclList* pList = new FeDeclList();
4712 : : pList->push_back((yyvsp[(1) - (2)].fdval));
4713 : : (yyval.dlval) = pList;
4714 : : }
4715 : : }
4716 : : break;
4717 : :
4718 : : case 225:
4719 : :
4720 : : /* Line 1806 of yacc.c */
4721 : : #line 2195 "/usr/local/src/libreoffice/idlc/source/parser.y"
4722 : : {
4723 : : idlc()->setParseState(PS_DeclsCommaSeen);
4724 : : }
4725 : : break;
4726 : :
4727 : : case 226:
4728 : :
4729 : : /* Line 1806 of yacc.c */
4730 : : #line 2199 "/usr/local/src/libreoffice/idlc/source/parser.y"
4731 : : {
4732 : : idlc()->setParseState(PS_DeclsDeclSeen);
4733 : : if ( (yyvsp[(1) - (4)].dlval) )
4734 : : {
4735 : : (yyvsp[(1) - (4)].dlval)->push_back((yyvsp[(4) - (4)].fdval));
4736 : : (yyval.dlval) = (yyvsp[(1) - (4)].dlval);
4737 : : } else
4738 : : {
4739 : : FeDeclList* pList = new FeDeclList();
4740 : : pList->push_back((yyvsp[(4) - (4)].fdval));
4741 : : (yyval.dlval) = pList;
4742 : : }
4743 : : }
4744 : : break;
4745 : :
4746 : : case 227:
4747 : :
4748 : : /* Line 1806 of yacc.c */
4749 : : #line 2213 "/usr/local/src/libreoffice/idlc/source/parser.y"
4750 : : {
4751 : : (yyval.dlval) = NULL;
4752 : : }
4753 : : break;
4754 : :
4755 : : case 230:
4756 : :
4757 : : /* Line 1806 of yacc.c */
4758 : : #line 2225 "/usr/local/src/libreoffice/idlc/source/parser.y"
4759 : : {
4760 : : // For historic reasons, the struct com.sun.star.uno.Uik contains
4761 : : // members with illegal names (of the form "m_DataN"); avoid useless
4762 : : // warnings about them:
4763 : : AstScope * scope = idlc()->scopes()->top();
4764 : : if (scope == 0 || scope->getScopeNodeType() != NT_struct
4765 : : || (scopeAsDecl(scope)->getScopedName()
4766 : : != "com::sun::star::uno::Uik"))
4767 : : {
4768 : : checkIdentifier((yyvsp[(1) - (1)].sval));
4769 : : }
4770 : :
4771 : : (yyval.fdval) = new FeDeclarator(*(yyvsp[(1) - (1)].sval), FeDeclarator::FD_simple, NULL);
4772 : : delete (yyvsp[(1) - (1)].sval);
4773 : : }
4774 : : break;
4775 : :
4776 : : case 231:
4777 : :
4778 : : /* Line 1806 of yacc.c */
4779 : : #line 2244 "/usr/local/src/libreoffice/idlc/source/parser.y"
4780 : : {
4781 : : (yyval.fdval) = new FeDeclarator((yyvsp[(1) - (1)].dclval)->getLocalName(), FeDeclarator::FD_complex, (yyvsp[(1) - (1)].dclval));
4782 : : }
4783 : : break;
4784 : :
4785 : : case 232:
4786 : :
4787 : : /* Line 1806 of yacc.c */
4788 : : #line 2251 "/usr/local/src/libreoffice/idlc/source/parser.y"
4789 : : {
4790 : : idlc()->setParseState(PS_ArrayIDSeen);
4791 : : checkIdentifier((yyvsp[(1) - (1)].sval));
4792 : : }
4793 : : break;
4794 : :
4795 : : case 233:
4796 : :
4797 : : /* Line 1806 of yacc.c */
4798 : : #line 2256 "/usr/local/src/libreoffice/idlc/source/parser.y"
4799 : : {
4800 : : idlc()->setParseState(PS_ArrayCompleted);
4801 : : (yyval.dclval) = new AstArray(*(yyvsp[(1) - (3)].sval), NULL, *(yyvsp[(3) - (3)].exlval), idlc()->scopes()->bottom());
4802 : : delete (yyvsp[(1) - (3)].sval);
4803 : : }
4804 : : break;
4805 : :
4806 : : case 234:
4807 : :
4808 : : /* Line 1806 of yacc.c */
4809 : : #line 2265 "/usr/local/src/libreoffice/idlc/source/parser.y"
4810 : : {
4811 : : if( (yyvsp[(2) - (2)].exlval) )
4812 : : {
4813 : : (yyvsp[(2) - (2)].exlval)->push_front((yyvsp[(1) - (2)].exval));
4814 : : (yyval.exlval) = (yyvsp[(2) - (2)].exlval);
4815 : : } else
4816 : : {
4817 : : ExprList* pList = new ExprList();
4818 : : pList->push_back((yyvsp[(1) - (2)].exval));
4819 : : (yyval.exlval) = pList;
4820 : : }
4821 : : }
4822 : : break;
4823 : :
4824 : : case 235:
4825 : :
4826 : : /* Line 1806 of yacc.c */
4827 : : #line 2281 "/usr/local/src/libreoffice/idlc/source/parser.y"
4828 : : {
4829 : : if( (yyvsp[(1) - (2)].exlval) )
4830 : : {
4831 : : (yyvsp[(1) - (2)].exlval)->push_back((yyvsp[(2) - (2)].exval));
4832 : : (yyval.exlval) = (yyvsp[(1) - (2)].exlval);
4833 : : } else
4834 : : {
4835 : : ExprList* pList = new ExprList();
4836 : : pList->push_back((yyvsp[(2) - (2)].exval));
4837 : : (yyval.exlval) = pList;
4838 : : }
4839 : : }
4840 : : break;
4841 : :
4842 : : case 236:
4843 : :
4844 : : /* Line 1806 of yacc.c */
4845 : : #line 2294 "/usr/local/src/libreoffice/idlc/source/parser.y"
4846 : : {
4847 : : (yyval.exlval) = NULL;
4848 : : }
4849 : : break;
4850 : :
4851 : : case 237:
4852 : :
4853 : : /* Line 1806 of yacc.c */
4854 : : #line 2301 "/usr/local/src/libreoffice/idlc/source/parser.y"
4855 : : {
4856 : : idlc()->setParseState(PS_DimSqSeen);
4857 : : }
4858 : : break;
4859 : :
4860 : : case 238:
4861 : :
4862 : : /* Line 1806 of yacc.c */
4863 : : #line 2305 "/usr/local/src/libreoffice/idlc/source/parser.y"
4864 : : {
4865 : : idlc()->setParseState(PS_DimExprSeen);
4866 : : }
4867 : : break;
4868 : :
4869 : : case 239:
4870 : :
4871 : : /* Line 1806 of yacc.c */
4872 : : #line 2309 "/usr/local/src/libreoffice/idlc/source/parser.y"
4873 : : {
4874 : : idlc()->setParseState(PS_DimQsSeen);
4875 : : /*
4876 : : * Array dimensions are expressions which must be coerced to
4877 : : * positive integers
4878 : : */
4879 : : if ( !(yyvsp[(3) - (5)].exval) || !(yyvsp[(3) - (5)].exval)->coerce(ET_uhyper) )
4880 : : {
4881 : : idlc()->error()->coercionError((yyvsp[(3) - (5)].exval), ET_uhyper);
4882 : : (yyval.exval) = NULL;
4883 : : } else
4884 : : (yyval.exval) = (yyvsp[(3) - (5)].exval);
4885 : : }
4886 : : break;
4887 : :
4888 : : case 240:
4889 : :
4890 : : /* Line 1806 of yacc.c */
4891 : : #line 2326 "/usr/local/src/libreoffice/idlc/source/parser.y"
4892 : : {
4893 : : if ((yyvsp[(2) - (2)].slval))
4894 : : {
4895 : : (yyvsp[(2) - (2)].slval)->push_front(*(yyvsp[(1) - (2)].sval));
4896 : : (yyval.slval) = (yyvsp[(2) - (2)].slval);
4897 : : } else
4898 : : {
4899 : : StringList* pNames = new StringList();
4900 : : pNames->push_back(*(yyvsp[(1) - (2)].sval));
4901 : : (yyval.slval) = pNames;
4902 : : }
4903 : : delete((yyvsp[(1) - (2)].sval));
4904 : : }
4905 : : break;
4906 : :
4907 : : case 241:
4908 : :
4909 : : /* Line 1806 of yacc.c */
4910 : : #line 2344 "/usr/local/src/libreoffice/idlc/source/parser.y"
4911 : : {
4912 : : idlc()->setParseState(PS_SNListCommaSeen);
4913 : : }
4914 : : break;
4915 : :
4916 : : case 242:
4917 : :
4918 : : /* Line 1806 of yacc.c */
4919 : : #line 2348 "/usr/local/src/libreoffice/idlc/source/parser.y"
4920 : : {
4921 : : idlc()->setParseState(PS_ScopedNameSeen);
4922 : : if ((yyvsp[(1) - (4)].slval))
4923 : : {
4924 : : (yyvsp[(1) - (4)].slval)->push_back(*(yyvsp[(4) - (4)].sval));
4925 : : (yyval.slval) = (yyvsp[(1) - (4)].slval);
4926 : : } else
4927 : : {
4928 : : StringList* pNames = new StringList();
4929 : : pNames->push_back(*(yyvsp[(4) - (4)].sval));
4930 : : (yyval.slval) = pNames;
4931 : : }
4932 : : delete((yyvsp[(4) - (4)].sval));
4933 : : }
4934 : : break;
4935 : :
4936 : : case 243:
4937 : :
4938 : : /* Line 1806 of yacc.c */
4939 : : #line 2363 "/usr/local/src/libreoffice/idlc/source/parser.y"
4940 : : {
4941 : : (yyval.slval) = NULL;
4942 : : }
4943 : : break;
4944 : :
4945 : : case 244:
4946 : :
4947 : : /* Line 1806 of yacc.c */
4948 : : #line 2370 "/usr/local/src/libreoffice/idlc/source/parser.y"
4949 : : {
4950 : : idlc()->setParseState(PS_SN_IDSeen);
4951 : : checkIdentifier((yyvsp[(1) - (1)].sval));
4952 : : (yyval.sval) = (yyvsp[(1) - (1)].sval);
4953 : : }
4954 : : break;
4955 : :
4956 : : case 245:
4957 : :
4958 : : /* Line 1806 of yacc.c */
4959 : : #line 2376 "/usr/local/src/libreoffice/idlc/source/parser.y"
4960 : : {
4961 : : idlc()->setParseState(PS_ScopeDelimSeen);
4962 : : }
4963 : : break;
4964 : :
4965 : : case 246:
4966 : :
4967 : : /* Line 1806 of yacc.c */
4968 : : #line 2380 "/usr/local/src/libreoffice/idlc/source/parser.y"
4969 : : {
4970 : : checkIdentifier((yyvsp[(3) - (3)].sval));
4971 : : OString* pName = new OString("::");
4972 : : *pName += *(yyvsp[(3) - (3)].sval);
4973 : : delete (yyvsp[(3) - (3)].sval);
4974 : : (yyval.sval) = pName;
4975 : : }
4976 : : break;
4977 : :
4978 : : case 247:
4979 : :
4980 : : /* Line 1806 of yacc.c */
4981 : : #line 2389 "/usr/local/src/libreoffice/idlc/source/parser.y"
4982 : : {
4983 : : }
4984 : : break;
4985 : :
4986 : : case 248:
4987 : :
4988 : : /* Line 1806 of yacc.c */
4989 : : #line 2392 "/usr/local/src/libreoffice/idlc/source/parser.y"
4990 : : {
4991 : : checkIdentifier((yyvsp[(4) - (4)].sval));
4992 : : *(yyvsp[(1) - (4)].sval) += ::rtl::OString("::");
4993 : : *(yyvsp[(1) - (4)].sval) += *(yyvsp[(4) - (4)].sval);
4994 : : delete (yyvsp[(4) - (4)].sval);
4995 : : (yyval.sval) = (yyvsp[(1) - (4)].sval);
4996 : : }
4997 : : break;
4998 : :
4999 : : case 252:
5000 : :
5001 : : /* Line 1806 of yacc.c */
5002 : : #line 2409 "/usr/local/src/libreoffice/idlc/source/parser.y"
5003 : : {
5004 : : (yyval.cdclval) = createNamedType((yyvsp[(1) - (2)].sval), (yyvsp[(2) - (2)].dclsval));
5005 : : }
5006 : : break;
5007 : :
5008 : : case 253:
5009 : :
5010 : : /* Line 1806 of yacc.c */
5011 : : #line 2416 "/usr/local/src/libreoffice/idlc/source/parser.y"
5012 : : {
5013 : : (yyval.cdclval) = idlc()->scopes()->bottom()->lookupPrimitiveType((yyvsp[(1) - (1)].etval));
5014 : : }
5015 : : break;
5016 : :
5017 : : case 255:
5018 : :
5019 : : /* Line 1806 of yacc.c */
5020 : : #line 2423 "/usr/local/src/libreoffice/idlc/source/parser.y"
5021 : : { (yyval.dclsval) = (yyvsp[(2) - (3)].dclsval); }
5022 : : break;
5023 : :
5024 : : case 256:
5025 : :
5026 : : /* Line 1806 of yacc.c */
5027 : : #line 2424 "/usr/local/src/libreoffice/idlc/source/parser.y"
5028 : : { (yyval.dclsval) = 0; }
5029 : : break;
5030 : :
5031 : : case 257:
5032 : :
5033 : : /* Line 1806 of yacc.c */
5034 : : #line 2429 "/usr/local/src/libreoffice/idlc/source/parser.y"
5035 : : {
5036 : : (yyval.dclsval) = new DeclList;
5037 : : (yyval.dclsval)->push_back(const_cast< AstDeclaration * >((yyvsp[(1) - (1)].cdclval))); //TODO: const_cast
5038 : : }
5039 : : break;
5040 : :
5041 : : case 258:
5042 : :
5043 : : /* Line 1806 of yacc.c */
5044 : : #line 2434 "/usr/local/src/libreoffice/idlc/source/parser.y"
5045 : : {
5046 : : (yyvsp[(1) - (3)].dclsval)->push_back(const_cast< AstDeclaration * >((yyvsp[(3) - (3)].cdclval))); //TODO: const_cast
5047 : : (yyval.dclsval) = (yyvsp[(1) - (3)].dclsval);
5048 : : }
5049 : : break;
5050 : :
5051 : : case 259:
5052 : :
5053 : : /* Line 1806 of yacc.c */
5054 : : #line 2442 "/usr/local/src/libreoffice/idlc/source/parser.y"
5055 : : {
5056 : : if ((yyvsp[(1) - (1)].cdclval) != 0 && static_cast< AstType const * >((yyvsp[(1) - (1)].cdclval))->isUnsigned()) {
5057 : : idlc()->error()->error0(EIDL_UNSIGNED_TYPE_ARGUMENT);
5058 : : }
5059 : : (yyval.cdclval) = (yyvsp[(1) - (1)].cdclval);
5060 : : }
5061 : : break;
5062 : :
5063 : : case 270:
5064 : :
5065 : : /* Line 1806 of yacc.c */
5066 : : #line 2468 "/usr/local/src/libreoffice/idlc/source/parser.y"
5067 : : {
5068 : : (yyval.etval) = ET_long;
5069 : : }
5070 : : break;
5071 : :
5072 : : case 271:
5073 : :
5074 : : /* Line 1806 of yacc.c */
5075 : : #line 2472 "/usr/local/src/libreoffice/idlc/source/parser.y"
5076 : : {
5077 : : (yyval.etval) = ET_hyper;
5078 : : }
5079 : : break;
5080 : :
5081 : : case 272:
5082 : :
5083 : : /* Line 1806 of yacc.c */
5084 : : #line 2476 "/usr/local/src/libreoffice/idlc/source/parser.y"
5085 : : {
5086 : : (yyval.etval) = ET_short;
5087 : : }
5088 : : break;
5089 : :
5090 : : case 273:
5091 : :
5092 : : /* Line 1806 of yacc.c */
5093 : : #line 2483 "/usr/local/src/libreoffice/idlc/source/parser.y"
5094 : : {
5095 : : (yyval.etval) = ET_ulong;
5096 : : }
5097 : : break;
5098 : :
5099 : : case 274:
5100 : :
5101 : : /* Line 1806 of yacc.c */
5102 : : #line 2487 "/usr/local/src/libreoffice/idlc/source/parser.y"
5103 : : {
5104 : : (yyval.etval) = ET_uhyper;
5105 : : }
5106 : : break;
5107 : :
5108 : : case 275:
5109 : :
5110 : : /* Line 1806 of yacc.c */
5111 : : #line 2491 "/usr/local/src/libreoffice/idlc/source/parser.y"
5112 : : {
5113 : : (yyval.etval) = ET_ushort;
5114 : : }
5115 : : break;
5116 : :
5117 : : case 276:
5118 : :
5119 : : /* Line 1806 of yacc.c */
5120 : : #line 2498 "/usr/local/src/libreoffice/idlc/source/parser.y"
5121 : : {
5122 : : (yyval.etval) = ET_double;
5123 : : }
5124 : : break;
5125 : :
5126 : : case 277:
5127 : :
5128 : : /* Line 1806 of yacc.c */
5129 : : #line 2502 "/usr/local/src/libreoffice/idlc/source/parser.y"
5130 : : {
5131 : : (yyval.etval) = ET_float;
5132 : : }
5133 : : break;
5134 : :
5135 : : case 278:
5136 : :
5137 : : /* Line 1806 of yacc.c */
5138 : : #line 2509 "/usr/local/src/libreoffice/idlc/source/parser.y"
5139 : : {
5140 : : (yyval.etval) = ET_char;
5141 : : }
5142 : : break;
5143 : :
5144 : : case 279:
5145 : :
5146 : : /* Line 1806 of yacc.c */
5147 : : #line 2516 "/usr/local/src/libreoffice/idlc/source/parser.y"
5148 : : {
5149 : : (yyval.etval) = ET_byte;
5150 : : }
5151 : : break;
5152 : :
5153 : : case 280:
5154 : :
5155 : : /* Line 1806 of yacc.c */
5156 : : #line 2523 "/usr/local/src/libreoffice/idlc/source/parser.y"
5157 : : {
5158 : : (yyval.etval) = ET_boolean;
5159 : : }
5160 : : break;
5161 : :
5162 : : case 281:
5163 : :
5164 : : /* Line 1806 of yacc.c */
5165 : : #line 2530 "/usr/local/src/libreoffice/idlc/source/parser.y"
5166 : : {
5167 : : (yyval.etval) = ET_any;
5168 : : }
5169 : : break;
5170 : :
5171 : : case 282:
5172 : :
5173 : : /* Line 1806 of yacc.c */
5174 : : #line 2537 "/usr/local/src/libreoffice/idlc/source/parser.y"
5175 : : {
5176 : : (yyval.etval) = ET_type;
5177 : : }
5178 : : break;
5179 : :
5180 : : case 283:
5181 : :
5182 : : /* Line 1806 of yacc.c */
5183 : : #line 2544 "/usr/local/src/libreoffice/idlc/source/parser.y"
5184 : : {
5185 : : (yyval.etval) = ET_string;
5186 : : }
5187 : : break;
5188 : :
5189 : : case 289:
5190 : :
5191 : : /* Line 1806 of yacc.c */
5192 : : #line 2562 "/usr/local/src/libreoffice/idlc/source/parser.y"
5193 : : {
5194 : : idlc()->setParseState(PS_ArrayTypeSeen);
5195 : : }
5196 : : break;
5197 : :
5198 : : case 290:
5199 : :
5200 : : /* Line 1806 of yacc.c */
5201 : : #line 2566 "/usr/local/src/libreoffice/idlc/source/parser.y"
5202 : : {
5203 : : idlc()->setParseState(PS_ArrayCompleted);
5204 : :
5205 : : AstScope* pScope = idlc()->scopes()->bottom();
5206 : : AstDeclaration* pDecl = NULL;
5207 : : AstDeclaration* pArray = NULL;
5208 : :
5209 : : if ( (yyvsp[(1) - (3)].cdclval) )
5210 : : {
5211 : : pArray = new AstArray((AstType*)(yyvsp[(1) - (3)].cdclval), *(yyvsp[(3) - (3)].exlval), idlc()->scopes()->bottom());
5212 : : if ( pScope )
5213 : : {
5214 : : pDecl = pScope->addDeclaration(pArray);
5215 : : if ( pArray != pDecl )
5216 : : {
5217 : : // if array type already defined then use it
5218 : : delete pArray;
5219 : : pArray = pDecl;
5220 : : }
5221 : : }
5222 : : }
5223 : : (yyval.cdclval) = pArray;
5224 : : }
5225 : : break;
5226 : :
5227 : : case 291:
5228 : :
5229 : : /* Line 1806 of yacc.c */
5230 : : #line 2593 "/usr/local/src/libreoffice/idlc/source/parser.y"
5231 : : {
5232 : : idlc()->setParseState(PS_SequenceSeen);
5233 : : /*
5234 : : * Push a sequence marker on scopes stack
5235 : : */
5236 : : idlc()->scopes()->push(NULL);
5237 : : }
5238 : : break;
5239 : :
5240 : : case 292:
5241 : :
5242 : : /* Line 1806 of yacc.c */
5243 : : #line 2601 "/usr/local/src/libreoffice/idlc/source/parser.y"
5244 : : {
5245 : : idlc()->setParseState(PS_SequenceSqSeen);
5246 : : }
5247 : : break;
5248 : :
5249 : : case 293:
5250 : :
5251 : : /* Line 1806 of yacc.c */
5252 : : #line 2605 "/usr/local/src/libreoffice/idlc/source/parser.y"
5253 : : {
5254 : : idlc()->setParseState(PS_SequenceTypeSeen);
5255 : : }
5256 : : break;
5257 : :
5258 : : case 294:
5259 : :
5260 : : /* Line 1806 of yacc.c */
5261 : : #line 2609 "/usr/local/src/libreoffice/idlc/source/parser.y"
5262 : : {
5263 : : idlc()->setParseState(PS_SequenceQsSeen);
5264 : : /*
5265 : : * Remove sequence marker from scopes stack
5266 : : */
5267 : : if (idlc()->scopes()->top() == NULL)
5268 : : idlc()->scopes()->pop();
5269 : : /*
5270 : : * Create a node representing a sequence
5271 : : */
5272 : : AstScope* pScope = idlc()->scopes()->bottom();
5273 : : AstDeclaration* pDecl = NULL;
5274 : : AstDeclaration* pSeq = NULL;
5275 : :
5276 : : if ( (yyvsp[(5) - (7)].cdclval) )
5277 : : {
5278 : : AstType *pType = (AstType*)(yyvsp[(5) - (7)].cdclval);
5279 : : if ( pType )
5280 : : {
5281 : : pSeq = new AstSequence(pType, pScope);
5282 : : /*
5283 : : * Add this AstSequence to the types defined in the global scope
5284 : : */
5285 : : pDecl = pScope->addDeclaration(pSeq);
5286 : : if ( pSeq != pDecl )
5287 : : {
5288 : : // if sequence type already defined then use it
5289 : : delete pSeq;
5290 : : pSeq = pDecl;
5291 : : }
5292 : : }
5293 : : }
5294 : : (yyval.cdclval) = pSeq;
5295 : : }
5296 : : break;
5297 : :
5298 : : case 295:
5299 : :
5300 : : /* Line 1806 of yacc.c */
5301 : : #line 2644 "/usr/local/src/libreoffice/idlc/source/parser.y"
5302 : : {
5303 : : yyerror("sequence declaration");
5304 : : yyerrok;
5305 : : (yyval.cdclval) = 0;
5306 : : }
5307 : : break;
5308 : :
5309 : : case 296:
5310 : :
5311 : : /* Line 1806 of yacc.c */
5312 : : #line 2653 "/usr/local/src/libreoffice/idlc/source/parser.y"
5313 : : {
5314 : : idlc()->setParseState(PS_StructHeaderSeen);
5315 : :
5316 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5317 : : AstStruct* pStruct = NULL;
5318 : :
5319 : : if ( pScope )
5320 : : {
5321 : : AstStruct* pBase= static_cast< AstStruct* >((yyvsp[(1) - (1)].ihval)->getInherits());
5322 : : pStruct = new AstStruct(
5323 : : *(yyvsp[(1) - (1)].ihval)->getName(), (yyvsp[(1) - (1)].ihval)->getTypeParameters(), pBase, pScope);
5324 : : pScope->addDeclaration(pStruct);
5325 : : }
5326 : : /*
5327 : : * Push the scope of the struct on the scopes stack
5328 : : */
5329 : : idlc()->scopes()->push(pStruct);
5330 : : delete (yyvsp[(1) - (1)].ihval);
5331 : : }
5332 : : break;
5333 : :
5334 : : case 297:
5335 : :
5336 : : /* Line 1806 of yacc.c */
5337 : : #line 2673 "/usr/local/src/libreoffice/idlc/source/parser.y"
5338 : : {
5339 : : idlc()->setParseState(PS_StructSqSeen);
5340 : : }
5341 : : break;
5342 : :
5343 : : case 298:
5344 : :
5345 : : /* Line 1806 of yacc.c */
5346 : : #line 2677 "/usr/local/src/libreoffice/idlc/source/parser.y"
5347 : : {
5348 : : idlc()->setParseState(PS_StructBodySeen);
5349 : : }
5350 : : break;
5351 : :
5352 : : case 299:
5353 : :
5354 : : /* Line 1806 of yacc.c */
5355 : : #line 2681 "/usr/local/src/libreoffice/idlc/source/parser.y"
5356 : : {
5357 : : idlc()->setParseState(PS_StructQsSeen);
5358 : : /* this exception is finished, pop its scope from the stack */
5359 : : idlc()->scopes()->pop();
5360 : : }
5361 : : break;
5362 : :
5363 : : case 300:
5364 : :
5365 : : /* Line 1806 of yacc.c */
5366 : : #line 2690 "/usr/local/src/libreoffice/idlc/source/parser.y"
5367 : : {
5368 : : idlc()->setParseState(PS_StructSeen);
5369 : : }
5370 : : break;
5371 : :
5372 : : case 301:
5373 : :
5374 : : /* Line 1806 of yacc.c */
5375 : : #line 2694 "/usr/local/src/libreoffice/idlc/source/parser.y"
5376 : : {
5377 : : idlc()->setParseState(PS_StructIDSeen);
5378 : : checkIdentifier((yyvsp[(3) - (3)].sval));
5379 : : }
5380 : : break;
5381 : :
5382 : : case 302:
5383 : :
5384 : : /* Line 1806 of yacc.c */
5385 : : #line 2700 "/usr/local/src/libreoffice/idlc/source/parser.y"
5386 : : {
5387 : : idlc()->setParseState(PS_InheritSpecSeen);
5388 : :
5389 : : // Polymorphic struct type templates with base types would cause various
5390 : : // problems in language bindings, so forbid them here. For example,
5391 : : // GCC prior to version 3.4 fails with code like
5392 : : //
5393 : : // struct Base { ... };
5394 : : // template< typename typeparam_T > struct Derived: public Base {
5395 : : // int member1 CPPU_GCC3_ALIGN(Base);
5396 : : // ... };
5397 : : //
5398 : : // (Note that plain struct types with instantiated polymorphic struct
5399 : : // type bases, which might also cause problems in language bindings, are
5400 : : // already rejected on a syntactic level.)
5401 : : if ((yyvsp[(5) - (6)].svals) != 0 && (yyvsp[(6) - (6)].sval) != 0) {
5402 : : idlc()->error()->error0(EIDL_STRUCT_TYPE_TEMPLATE_WITH_BASE);
5403 : : }
5404 : :
5405 : : (yyval.ihval) = new FeInheritanceHeader(NT_struct, (yyvsp[(3) - (6)].sval), (yyvsp[(6) - (6)].sval), (yyvsp[(5) - (6)].svals));
5406 : : delete (yyvsp[(5) - (6)].svals);
5407 : : delete (yyvsp[(6) - (6)].sval);
5408 : : }
5409 : : break;
5410 : :
5411 : : case 303:
5412 : :
5413 : : /* Line 1806 of yacc.c */
5414 : : #line 2726 "/usr/local/src/libreoffice/idlc/source/parser.y"
5415 : : { (yyval.svals) = (yyvsp[(2) - (3)].svals); }
5416 : : break;
5417 : :
5418 : : case 304:
5419 : :
5420 : : /* Line 1806 of yacc.c */
5421 : : #line 2727 "/usr/local/src/libreoffice/idlc/source/parser.y"
5422 : : { (yyval.svals) = 0; }
5423 : : break;
5424 : :
5425 : : case 305:
5426 : :
5427 : : /* Line 1806 of yacc.c */
5428 : : #line 2732 "/usr/local/src/libreoffice/idlc/source/parser.y"
5429 : : {
5430 : : (yyval.svals) = new std::vector< rtl::OString >;
5431 : : (yyval.svals)->push_back(*(yyvsp[(1) - (1)].sval));
5432 : : delete (yyvsp[(1) - (1)].sval);
5433 : : }
5434 : : break;
5435 : :
5436 : : case 306:
5437 : :
5438 : : /* Line 1806 of yacc.c */
5439 : : #line 2738 "/usr/local/src/libreoffice/idlc/source/parser.y"
5440 : : {
5441 : : if (std::find((yyvsp[(1) - (3)].svals)->begin(), (yyvsp[(1) - (3)].svals)->end(), *(yyvsp[(3) - (3)].sval)) != (yyvsp[(1) - (3)].svals)->end()) {
5442 : : idlc()->error()->error0(EIDL_IDENTICAL_TYPE_PARAMETERS);
5443 : : }
5444 : : (yyvsp[(1) - (3)].svals)->push_back(*(yyvsp[(3) - (3)].sval));
5445 : : delete (yyvsp[(3) - (3)].sval);
5446 : : (yyval.svals) = (yyvsp[(1) - (3)].svals);
5447 : : }
5448 : : break;
5449 : :
5450 : : case 310:
5451 : :
5452 : : /* Line 1806 of yacc.c */
5453 : : #line 2757 "/usr/local/src/libreoffice/idlc/source/parser.y"
5454 : : {
5455 : : idlc()->setParseState(PS_MemberTypeSeen);
5456 : : }
5457 : : break;
5458 : :
5459 : : case 311:
5460 : :
5461 : : /* Line 1806 of yacc.c */
5462 : : #line 2761 "/usr/local/src/libreoffice/idlc/source/parser.y"
5463 : : {
5464 : : idlc()->setParseState(PS_MemberDeclsSeen);
5465 : : }
5466 : : break;
5467 : :
5468 : : case 312:
5469 : :
5470 : : /* Line 1806 of yacc.c */
5471 : : #line 2765 "/usr/local/src/libreoffice/idlc/source/parser.y"
5472 : : {
5473 : : idlc()->setParseState(PS_MemberDeclsCompleted);
5474 : :
5475 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5476 : : AstMember* pMember = NULL;
5477 : : FeDeclList* pList = (yyvsp[(3) - (5)].dlval);
5478 : : FeDeclarator* pDecl = NULL;
5479 : : AstType const * pType = NULL;
5480 : :
5481 : : // !!! check recursive type
5482 : :
5483 : : if ( pScope && pList && (yyvsp[(1) - (5)].cdclval) )
5484 : : {
5485 : : FeDeclList::iterator iter = pList->begin();
5486 : : FeDeclList::iterator end = pList->end();
5487 : : while (iter != end)
5488 : : {
5489 : : pDecl = (*iter);
5490 : : if ( !pDecl )
5491 : : {
5492 : : iter++;
5493 : : continue;
5494 : : }
5495 : :
5496 : : pType = pDecl->compose((yyvsp[(1) - (5)].cdclval));
5497 : :
5498 : : if ( !pType )
5499 : : {
5500 : : iter++;
5501 : : continue;
5502 : : }
5503 : :
5504 : : pMember = new AstMember(pType, pDecl->getName(), pScope);
5505 : :
5506 : : if ( !pDecl->checkType((yyvsp[(1) - (5)].cdclval)) )
5507 : : {
5508 : : // WARNING
5509 : : }
5510 : :
5511 : : pScope->addDeclaration(pMember);
5512 : : iter++;
5513 : : delete pDecl;
5514 : : }
5515 : : delete pList;
5516 : : }
5517 : : }
5518 : : break;
5519 : :
5520 : : case 313:
5521 : :
5522 : : /* Line 1806 of yacc.c */
5523 : : #line 2812 "/usr/local/src/libreoffice/idlc/source/parser.y"
5524 : : {
5525 : : yyerror("member definition");
5526 : : yyerrok;
5527 : : }
5528 : : break;
5529 : :
5530 : : case 315:
5531 : :
5532 : : /* Line 1806 of yacc.c */
5533 : : #line 2821 "/usr/local/src/libreoffice/idlc/source/parser.y"
5534 : : {
5535 : : AstDeclaration const * decl = 0;
5536 : : AstStruct * scope = static_cast< AstStruct * >(idlc()->scopes()->top());
5537 : : if (scope != 0 && (yyvsp[(2) - (2)].dclsval) == 0) {
5538 : : decl = scope->findTypeParameter(*(yyvsp[(1) - (2)].sval));
5539 : : }
5540 : : if (decl != 0) {
5541 : : delete (yyvsp[(1) - (2)].sval);
5542 : : delete (yyvsp[(2) - (2)].dclsval);
5543 : : } else {
5544 : : decl = createNamedType((yyvsp[(1) - (2)].sval), (yyvsp[(2) - (2)].dclsval));
5545 : : if (scope != 0 && includes(decl, scopeAsDecl(scope))) {
5546 : : idlc()->error()->error1(
5547 : : EIDL_RECURSIVE_TYPE, scopeAsDecl(scope));
5548 : : decl = 0;
5549 : : }
5550 : : }
5551 : : (yyval.cdclval) = decl;
5552 : : }
5553 : : break;
5554 : :
5555 : : case 316:
5556 : :
5557 : : /* Line 1806 of yacc.c */
5558 : : #line 2844 "/usr/local/src/libreoffice/idlc/source/parser.y"
5559 : : {
5560 : : idlc()->setParseState(PS_EnumSeen);
5561 : : }
5562 : : break;
5563 : :
5564 : : case 317:
5565 : :
5566 : : /* Line 1806 of yacc.c */
5567 : : #line 2848 "/usr/local/src/libreoffice/idlc/source/parser.y"
5568 : : {
5569 : : idlc()->setParseState(PS_EnumIDSeen);
5570 : : checkIdentifier((yyvsp[(3) - (3)].sval));
5571 : :
5572 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5573 : : AstEnum* pEnum = NULL;
5574 : :
5575 : : /*
5576 : : * Create a node representing an enum and add it to its
5577 : : * enclosing scope
5578 : : */
5579 : : if (pScope != NULL)
5580 : : {
5581 : : pEnum = new AstEnum(*(yyvsp[(3) - (3)].sval), pScope);
5582 : : /*
5583 : : * Add it to its defining scope
5584 : : */
5585 : : pScope->addDeclaration(pEnum);
5586 : : }
5587 : : delete (yyvsp[(3) - (3)].sval);
5588 : : /*
5589 : : * Push the enum scope on the scopes stack
5590 : : */
5591 : : idlc()->scopes()->push(pEnum);
5592 : :
5593 : : }
5594 : : break;
5595 : :
5596 : : case 318:
5597 : :
5598 : : /* Line 1806 of yacc.c */
5599 : : #line 2875 "/usr/local/src/libreoffice/idlc/source/parser.y"
5600 : : {
5601 : : idlc()->setParseState(PS_EnumSqSeen);
5602 : : }
5603 : : break;
5604 : :
5605 : : case 319:
5606 : :
5607 : : /* Line 1806 of yacc.c */
5608 : : #line 2879 "/usr/local/src/libreoffice/idlc/source/parser.y"
5609 : : {
5610 : : idlc()->setParseState(PS_EnumBodySeen);
5611 : : }
5612 : : break;
5613 : :
5614 : : case 320:
5615 : :
5616 : : /* Line 1806 of yacc.c */
5617 : : #line 2883 "/usr/local/src/libreoffice/idlc/source/parser.y"
5618 : : {
5619 : : idlc()->setParseState(PS_EnumQsSeen);
5620 : : /*
5621 : : * Done with this enum. Pop its scope from the scopes stack
5622 : : */
5623 : : if (idlc()->scopes()->top() == NULL)
5624 : : (yyval.cdclval) = NULL;
5625 : : else
5626 : : {
5627 : : (yyval.cdclval) = (AstEnum*)idlc()->scopes()->topNonNull();
5628 : : idlc()->scopes()->pop();
5629 : : }
5630 : : }
5631 : : break;
5632 : :
5633 : : case 322:
5634 : :
5635 : : /* Line 1806 of yacc.c */
5636 : : #line 2903 "/usr/local/src/libreoffice/idlc/source/parser.y"
5637 : : {
5638 : : idlc()->setParseState(PS_EnumCommaSeen);
5639 : : }
5640 : : break;
5641 : :
5642 : : case 325:
5643 : :
5644 : : /* Line 1806 of yacc.c */
5645 : : #line 2909 "/usr/local/src/libreoffice/idlc/source/parser.y"
5646 : : {
5647 : : yyerror("enumerator definition");
5648 : : yyerrok;
5649 : : }
5650 : : break;
5651 : :
5652 : : case 326:
5653 : :
5654 : : /* Line 1806 of yacc.c */
5655 : : #line 2917 "/usr/local/src/libreoffice/idlc/source/parser.y"
5656 : : {
5657 : : checkIdentifier((yyvsp[(1) - (1)].sval));
5658 : :
5659 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5660 : : AstEnum* pEnum = NULL;
5661 : : AstConstant* pEnumVal = NULL;
5662 : :
5663 : : if ( pScope && pScope->getScopeNodeType() == NT_enum)
5664 : : {
5665 : : pEnum = (AstEnum*)pScope;
5666 : : if (pEnum && (yyvsp[(1) - (1)].sval))
5667 : : {
5668 : : AstExpression* pExpr = new AstExpression(pEnum->getEnumValueCount());
5669 : : pEnumVal = new AstConstant(ET_long , NT_enum_val,
5670 : : pExpr, *(yyvsp[(1) - (1)].sval), pScope);
5671 : : }
5672 : : if ( pEnum->checkValue(pEnumVal->getConstValue()) )
5673 : : idlc()->error()->error1(EIDL_EVAL_ERROR, pEnum);
5674 : :
5675 : : pScope->addDeclaration(pEnumVal);
5676 : : }
5677 : : delete (yyvsp[(1) - (1)].sval);
5678 : : }
5679 : : break;
5680 : :
5681 : : case 327:
5682 : :
5683 : : /* Line 1806 of yacc.c */
5684 : : #line 2943 "/usr/local/src/libreoffice/idlc/source/parser.y"
5685 : : {
5686 : : checkIdentifier((yyvsp[(1) - (3)].sval));
5687 : :
5688 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5689 : : AstEnum* pEnum = NULL;
5690 : : AstConstant* pEnumVal = NULL;
5691 : :
5692 : : if ( (yyvsp[(3) - (3)].exval) && pScope && pScope->getScopeNodeType() == NT_enum)
5693 : : {
5694 : : (yyvsp[(3) - (3)].exval)->evaluate(EK_const);
5695 : : if ( (yyvsp[(3) - (3)].exval)->coerce(ET_long) )
5696 : : {
5697 : : pEnum = (AstEnum*)pScope;
5698 : : if (pEnum)
5699 : : {
5700 : : pEnumVal = new AstConstant(ET_long , NT_enum_val,
5701 : : (yyvsp[(3) - (3)].exval), *(yyvsp[(1) - (3)].sval), pScope);
5702 : : }
5703 : : if ( pEnum->checkValue(pEnumVal->getConstValue()) )
5704 : : idlc()->error()->error1(EIDL_EVAL_ERROR, pEnum);
5705 : :
5706 : : pScope->addDeclaration(pEnumVal);
5707 : : } else
5708 : : {
5709 : : idlc()->error()->coercionError((yyvsp[(3) - (3)].exval), ET_long);
5710 : : delete (yyvsp[(3) - (3)].exval);
5711 : : }
5712 : : }
5713 : : delete (yyvsp[(1) - (3)].sval);
5714 : : }
5715 : : break;
5716 : :
5717 : : case 328:
5718 : :
5719 : : /* Line 1806 of yacc.c */
5720 : : #line 2977 "/usr/local/src/libreoffice/idlc/source/parser.y"
5721 : : {
5722 : : idlc()->setParseState(PS_UnionSeen);
5723 : : }
5724 : : break;
5725 : :
5726 : : case 329:
5727 : :
5728 : : /* Line 1806 of yacc.c */
5729 : : #line 2981 "/usr/local/src/libreoffice/idlc/source/parser.y"
5730 : : {
5731 : : idlc()->setParseState(PS_UnionIDSeen);
5732 : : checkIdentifier((yyvsp[(3) - (3)].sval));
5733 : : }
5734 : : break;
5735 : :
5736 : : case 330:
5737 : :
5738 : : /* Line 1806 of yacc.c */
5739 : : #line 2986 "/usr/local/src/libreoffice/idlc/source/parser.y"
5740 : : {
5741 : : idlc()->setParseState(PS_SwitchSeen);
5742 : : }
5743 : : break;
5744 : :
5745 : : case 331:
5746 : :
5747 : : /* Line 1806 of yacc.c */
5748 : : #line 2990 "/usr/local/src/libreoffice/idlc/source/parser.y"
5749 : : {
5750 : : idlc()->setParseState(PS_SwitchOpenParSeen);
5751 : : }
5752 : : break;
5753 : :
5754 : : case 332:
5755 : :
5756 : : /* Line 1806 of yacc.c */
5757 : : #line 2994 "/usr/local/src/libreoffice/idlc/source/parser.y"
5758 : : {
5759 : : idlc()->setParseState(PS_SwitchTypeSeen);
5760 : : }
5761 : : break;
5762 : :
5763 : : case 333:
5764 : :
5765 : : /* Line 1806 of yacc.c */
5766 : : #line 2998 "/usr/local/src/libreoffice/idlc/source/parser.y"
5767 : : {
5768 : : idlc()->setParseState(PS_SwitchCloseParSeen);
5769 : :
5770 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5771 : : AstUnion* pUnion = NULL;
5772 : :
5773 : : /*
5774 : : * Create a node representing a union. Add it to its enclosing
5775 : : * scope
5776 : : */
5777 : : if ( (yyvsp[(9) - (11)].cdclval) && pScope )
5778 : : {
5779 : : AstType* pType = (AstType*)(yyvsp[(9) - (11)].cdclval);
5780 : : if ( !pType)
5781 : : {
5782 : : idlc()->error()->noTypeError((yyvsp[(9) - (11)].cdclval));
5783 : : } else
5784 : : {
5785 : : pUnion = new AstUnion(*(yyvsp[(3) - (11)].sval), pType, pScope);
5786 : : pScope->addDeclaration(pUnion);
5787 : : }
5788 : : }
5789 : : delete (yyvsp[(3) - (11)].sval);
5790 : : /*
5791 : : * Push the scope of the union on the scopes stack
5792 : : */
5793 : : idlc()->scopes()->push(pUnion);
5794 : : }
5795 : : break;
5796 : :
5797 : : case 334:
5798 : :
5799 : : /* Line 1806 of yacc.c */
5800 : : #line 3027 "/usr/local/src/libreoffice/idlc/source/parser.y"
5801 : : {
5802 : : idlc()->setParseState(PS_UnionSqSeen);
5803 : : }
5804 : : break;
5805 : :
5806 : : case 335:
5807 : :
5808 : : /* Line 1806 of yacc.c */
5809 : : #line 3031 "/usr/local/src/libreoffice/idlc/source/parser.y"
5810 : : {
5811 : : idlc()->setParseState(PS_UnionBodySeen);
5812 : : }
5813 : : break;
5814 : :
5815 : : case 336:
5816 : :
5817 : : /* Line 1806 of yacc.c */
5818 : : #line 3035 "/usr/local/src/libreoffice/idlc/source/parser.y"
5819 : : {
5820 : : idlc()->setParseState(PS_UnionQsSeen);
5821 : : /* this union is finished, pop its scope from the stack */
5822 : : idlc()->scopes()->pop();
5823 : : }
5824 : : break;
5825 : :
5826 : : case 337:
5827 : :
5828 : : /* Line 1806 of yacc.c */
5829 : : #line 3044 "/usr/local/src/libreoffice/idlc/source/parser.y"
5830 : : {
5831 : : (yyval.cdclval) = idlc()->scopes()->bottom()->lookupPrimitiveType((yyvsp[(1) - (1)].etval));
5832 : : }
5833 : : break;
5834 : :
5835 : : case 338:
5836 : :
5837 : : /* Line 1806 of yacc.c */
5838 : : #line 3048 "/usr/local/src/libreoffice/idlc/source/parser.y"
5839 : : {
5840 : : (yyval.cdclval) = idlc()->scopes()->bottom()->lookupPrimitiveType((yyvsp[(1) - (1)].etval));
5841 : : }
5842 : : break;
5843 : :
5844 : : case 339:
5845 : :
5846 : : /* Line 1806 of yacc.c */
5847 : : #line 3052 "/usr/local/src/libreoffice/idlc/source/parser.y"
5848 : : {
5849 : : (yyval.cdclval) = idlc()->scopes()->bottom()->lookupPrimitiveType((yyvsp[(1) - (1)].etval));
5850 : : }
5851 : : break;
5852 : :
5853 : : case 341:
5854 : :
5855 : : /* Line 1806 of yacc.c */
5856 : : #line 3057 "/usr/local/src/libreoffice/idlc/source/parser.y"
5857 : : {
5858 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5859 : : AstBaseType* pBaseType = NULL;
5860 : : AstDeclaration const * pDecl = NULL;
5861 : : AstTypeDef* pTypeDef = NULL;
5862 : : sal_Bool bFound = sal_False;
5863 : : /*
5864 : : * If the constant's type is a scoped name, it must resolve
5865 : : * to a scalar constant type
5866 : : */
5867 : : if ( pScope && (pDecl = pScope->lookupByName(*(yyvsp[(1) - (1)].sval))) )
5868 : : {
5869 : : /*
5870 : : * Look through typedefs
5871 : : */
5872 : : while ( !bFound )
5873 : : {
5874 : : switch (pDecl->getNodeType())
5875 : : {
5876 : : case NT_enum:
5877 : : (yyval.cdclval) = pDecl;
5878 : : bFound = sal_True;
5879 : : break;
5880 : : case NT_predefined:
5881 : : pBaseType = (AstBaseType*)pDecl;
5882 : : if ( pBaseType )
5883 : : {
5884 : : switch (pBaseType->getExprType())
5885 : : {
5886 : : case ET_short:
5887 : : case ET_ushort:
5888 : : case ET_long:
5889 : : case ET_ulong:
5890 : : case ET_hyper:
5891 : : case ET_uhyper:
5892 : : case ET_char:
5893 : : case ET_byte:
5894 : : case ET_boolean:
5895 : : (yyval.cdclval) = pBaseType;
5896 : : bFound = sal_True;
5897 : : break;
5898 : : default:
5899 : : (yyval.cdclval) = NULL;
5900 : : bFound = sal_True;
5901 : : break;
5902 : : }
5903 : : }
5904 : : break;
5905 : : case NT_typedef:
5906 : : pTypeDef = (AstTypeDef*)pDecl;
5907 : : if ( pTypeDef )
5908 : : pDecl = pTypeDef->getBaseType();
5909 : : break;
5910 : : default:
5911 : : (yyval.cdclval) = NULL;
5912 : : bFound = sal_True;
5913 : : break;
5914 : : }
5915 : : }
5916 : : } else
5917 : : (yyval.cdclval) = NULL;
5918 : :
5919 : : if ((yyval.cdclval) == NULL)
5920 : : idlc()->error()->lookupError(*(yyvsp[(1) - (1)].sval));
5921 : : }
5922 : : break;
5923 : :
5924 : : case 345:
5925 : :
5926 : : /* Line 1806 of yacc.c */
5927 : : #line 3133 "/usr/local/src/libreoffice/idlc/source/parser.y"
5928 : : {
5929 : : idlc()->setParseState(PS_UnionLabelSeen);
5930 : : }
5931 : : break;
5932 : :
5933 : : case 346:
5934 : :
5935 : : /* Line 1806 of yacc.c */
5936 : : #line 3137 "/usr/local/src/libreoffice/idlc/source/parser.y"
5937 : : {
5938 : : idlc()->setParseState(PS_UnionElemSeen);
5939 : :
5940 : : AstScope* pScope = idlc()->scopes()->topNonNull();
5941 : : AstUnionLabel* pLabel = NULL;
5942 : : AstUnionBranch* pBranch = NULL;
5943 : : AstMember* pMember = (yyvsp[(3) - (3)].mval);
5944 : :
5945 : : /*
5946 : : * Create several nodes representing branches of a union.
5947 : : * Add them to the enclosing scope (the union scope)
5948 : : */
5949 : : if ( pScope && (yyvsp[(1) - (3)].llval) && (yyvsp[(3) - (3)].mval) )
5950 : : {
5951 : : LabelList::iterator iter = (yyvsp[(1) - (3)].llval)->begin();
5952 : : LabelList::iterator end = (yyvsp[(1) - (3)].llval)->end();
5953 : : for (;iter != end; iter++)
5954 : : {
5955 : : pLabel = *iter;
5956 : : if ( !pLabel )
5957 : : {
5958 : : iter++;
5959 : : continue;
5960 : : }
5961 : : pBranch = new AstUnionBranch(pLabel, pMember->getType(),
5962 : : pMember->getLocalName(), pScope);
5963 : : pScope->addDeclaration(pBranch);
5964 : : }
5965 : : }
5966 : : if ( (yyvsp[(1) - (3)].llval) ) delete((yyvsp[(1) - (3)].llval));
5967 : : }
5968 : : break;
5969 : :
5970 : : case 347:
5971 : :
5972 : : /* Line 1806 of yacc.c */
5973 : : #line 3172 "/usr/local/src/libreoffice/idlc/source/parser.y"
5974 : : {
5975 : : if ( (yyvsp[(2) - (2)].llval) )
5976 : : {
5977 : : (yyvsp[(2) - (2)].llval)->push_front((yyvsp[(1) - (2)].lbval));
5978 : : (yyval.llval) = (yyvsp[(2) - (2)].llval);
5979 : : } else
5980 : : {
5981 : : LabelList* pLabels = new LabelList();
5982 : : pLabels->push_back((yyvsp[(1) - (2)].lbval));
5983 : : (yyval.llval) = pLabels;
5984 : : }
5985 : : }
5986 : : break;
5987 : :
5988 : : case 348:
5989 : :
5990 : : /* Line 1806 of yacc.c */
5991 : : #line 3188 "/usr/local/src/libreoffice/idlc/source/parser.y"
5992 : : {
5993 : : if ( (yyvsp[(1) - (2)].llval) )
5994 : : {
5995 : : (yyvsp[(1) - (2)].llval)->push_back((yyvsp[(2) - (2)].lbval));
5996 : : (yyval.llval) = (yyvsp[(1) - (2)].llval);
5997 : : } else
5998 : : {
5999 : : LabelList* pLabels = new LabelList();
6000 : : pLabels->push_back((yyvsp[(2) - (2)].lbval));
6001 : : (yyval.llval) = pLabels;
6002 : : }
6003 : : }
6004 : : break;
6005 : :
6006 : : case 349:
6007 : :
6008 : : /* Line 1806 of yacc.c */
6009 : : #line 3201 "/usr/local/src/libreoffice/idlc/source/parser.y"
6010 : : {
6011 : : (yyval.llval) = NULL;
6012 : : }
6013 : : break;
6014 : :
6015 : : case 350:
6016 : :
6017 : : /* Line 1806 of yacc.c */
6018 : : #line 3208 "/usr/local/src/libreoffice/idlc/source/parser.y"
6019 : : {
6020 : : idlc()->setParseState(PS_DefaultSeen);
6021 : : }
6022 : : break;
6023 : :
6024 : : case 351:
6025 : :
6026 : : /* Line 1806 of yacc.c */
6027 : : #line 3212 "/usr/local/src/libreoffice/idlc/source/parser.y"
6028 : : {
6029 : : idlc()->setParseState(PS_LabelColonSeen);
6030 : : (yyval.lbval) = new AstUnionLabel(UL_default, NULL);
6031 : : }
6032 : : break;
6033 : :
6034 : : case 352:
6035 : :
6036 : : /* Line 1806 of yacc.c */
6037 : : #line 3217 "/usr/local/src/libreoffice/idlc/source/parser.y"
6038 : : {
6039 : : idlc()->setParseState(PS_CaseSeen);
6040 : : }
6041 : : break;
6042 : :
6043 : : case 353:
6044 : :
6045 : : /* Line 1806 of yacc.c */
6046 : : #line 3221 "/usr/local/src/libreoffice/idlc/source/parser.y"
6047 : : {
6048 : : idlc()->setParseState(PS_LabelExprSeen);
6049 : : }
6050 : : break;
6051 : :
6052 : : case 354:
6053 : :
6054 : : /* Line 1806 of yacc.c */
6055 : : #line 3225 "/usr/local/src/libreoffice/idlc/source/parser.y"
6056 : : {
6057 : : idlc()->setParseState(PS_LabelColonSeen);
6058 : : (yyval.lbval) = new AstUnionLabel(UL_label, (yyvsp[(3) - (5)].exval));
6059 : : }
6060 : : break;
6061 : :
6062 : : case 355:
6063 : :
6064 : : /* Line 1806 of yacc.c */
6065 : : #line 3233 "/usr/local/src/libreoffice/idlc/source/parser.y"
6066 : : {
6067 : : idlc()->setParseState(PS_UnionElemTypeSeen);
6068 : : }
6069 : : break;
6070 : :
6071 : : case 356:
6072 : :
6073 : : /* Line 1806 of yacc.c */
6074 : : #line 3237 "/usr/local/src/libreoffice/idlc/source/parser.y"
6075 : : {
6076 : : idlc()->setParseState(PS_UnionElemDeclSeen);
6077 : : }
6078 : : break;
6079 : :
6080 : : case 357:
6081 : :
6082 : : /* Line 1806 of yacc.c */
6083 : : #line 3241 "/usr/local/src/libreoffice/idlc/source/parser.y"
6084 : : {
6085 : : idlc()->setParseState(PS_UnionElemCompleted);
6086 : :
6087 : : AstScope* pScope = idlc()->scopes()->topNonNull();
6088 : : /*
6089 : : * Check for illegal recursive use of type
6090 : : */
6091 : : // if ( $1 && AST_illegal_recursive_type($1))
6092 : : // idlc()->error()->error1(EIDL_RECURSIVE_TYPE, $1);
6093 : : /*
6094 : : * Create a field in a union branch
6095 : : */
6096 : : if ( (yyvsp[(1) - (5)].cdclval) && (yyvsp[(3) - (5)].fdval) )
6097 : : {
6098 : : AstType const * pType = (yyvsp[(3) - (5)].fdval)->compose((yyvsp[(1) - (5)].cdclval));
6099 : : if ( !pType )
6100 : : (yyval.mval) = NULL;
6101 : : else
6102 : : (yyval.mval) = new AstMember(pType, (yyvsp[(3) - (5)].fdval)->getName(), pScope);
6103 : : } else
6104 : : (yyval.mval) = NULL;
6105 : :
6106 : : if ( (yyvsp[(3) - (5)].fdval) ) delete (yyvsp[(3) - (5)].fdval);
6107 : : }
6108 : : break;
6109 : :
6110 : : case 358:
6111 : :
6112 : : /* Line 1806 of yacc.c */
6113 : : #line 3267 "/usr/local/src/libreoffice/idlc/source/parser.y"
6114 : : {
6115 : : (yyval.mval) = NULL;
6116 : : }
6117 : : break;
6118 : :
6119 : : case 360:
6120 : :
6121 : : /* Line 1806 of yacc.c */
6122 : : #line 3274 "/usr/local/src/libreoffice/idlc/source/parser.y"
6123 : : { (yyval.sval) = new OString("get"); }
6124 : : break;
6125 : :
6126 : : case 361:
6127 : :
6128 : : /* Line 1806 of yacc.c */
6129 : : #line 3275 "/usr/local/src/libreoffice/idlc/source/parser.y"
6130 : : { (yyval.sval) = new OString("set"); }
6131 : : break;
6132 : :
6133 : : case 362:
6134 : :
6135 : : /* Line 1806 of yacc.c */
6136 : : #line 3276 "/usr/local/src/libreoffice/idlc/source/parser.y"
6137 : : { (yyval.sval) = new OString("published"); }
6138 : : break;
6139 : :
6140 : :
6141 : :
6142 : : /* Line 1806 of yacc.c */
6143 : : #line 6144 "/usr/local/src/libreoffice/workdir/unxlngi6.pro/YaccTarget/idlc/source/parser.cxx"
6144 : 3727313 : default: break;
6145 : : }
6146 : : /* User semantic actions sometimes alter yychar, and that requires
6147 : : that yytoken be updated with the new translation. We take the
6148 : : approach of translating immediately before every use of yytoken.
6149 : : One alternative is translating here after every semantic action,
6150 : : but that translation would be missed if the semantic action invokes
6151 : : YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
6152 : : if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
6153 : : incorrect destructor might then be invoked immediately. In the
6154 : : case of YYERROR or YYBACKUP, subsequent parser actions might lead
6155 : : to an incorrect destructor call or verbose syntax error message
6156 : : before the lookahead is translated. */
6157 [ - + ][ # # ]: 11481245 : YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
[ # # ][ # # ]
6158 : :
6159 : 11481245 : YYPOPSTACK (yylen);
6160 : 11481245 : yylen = 0;
6161 [ - + ][ # # ]: 11481245 : YY_STACK_PRINT (yyss, yyssp);
6162 : :
6163 : 11481245 : *++yyvsp = yyval;
6164 : :
6165 : : /* Now `shift' the result of the reduction. Determine what state
6166 : : that goes to, based on the state we popped back to and the rule
6167 : : number reduced by. */
6168 : :
6169 : 11481245 : yyn = yyr1[yyn];
6170 : :
6171 : 11481245 : yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6172 [ + + ][ + - ]: 11481245 : if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
[ + + ]
6173 : 3791060 : yystate = yytable[yystate];
6174 : : else
6175 : 7690185 : yystate = yydefgoto[yyn - YYNTOKENS];
6176 : :
6177 : 11481245 : goto yynewstate;
6178 : :
6179 : :
6180 : : /*------------------------------------.
6181 : : | yyerrlab -- here on detecting error |
6182 : : `------------------------------------*/
6183 : : yyerrlab:
6184 : : /* Make sure we have latest lookahead translation. See comments at
6185 : : user semantic actions for why this is necessary. */
6186 [ # # ][ # # ]: 0 : yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
6187 : :
6188 : : /* If not already recovering from an error, report this error. */
6189 [ # # ]: 0 : if (!yyerrstatus)
6190 : : {
6191 : 0 : ++yynerrs;
6192 : : #if ! YYERROR_VERBOSE
6193 : : yyerror (YY_("syntax error"));
6194 : : #else
6195 : : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
6196 : : yyssp, yytoken)
6197 : : {
6198 : 0 : char const *yymsgp = YY_("syntax error");
6199 : : int yysyntax_error_status;
6200 : 0 : yysyntax_error_status = YYSYNTAX_ERROR;
6201 [ # # ]: 0 : if (yysyntax_error_status == 0)
6202 : 0 : yymsgp = yymsg;
6203 [ # # ]: 0 : else if (yysyntax_error_status == 1)
6204 : : {
6205 [ # # ]: 0 : if (yymsg != yymsgbuf)
6206 : 0 : YYSTACK_FREE (yymsg);
6207 : 0 : yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
6208 [ # # ]: 0 : if (!yymsg)
6209 : : {
6210 : 0 : yymsg = yymsgbuf;
6211 : 0 : yymsg_alloc = sizeof yymsgbuf;
6212 : 0 : yysyntax_error_status = 2;
6213 : : }
6214 : : else
6215 : : {
6216 : 0 : yysyntax_error_status = YYSYNTAX_ERROR;
6217 : 0 : yymsgp = yymsg;
6218 : : }
6219 : : }
6220 [ # # ]: 0 : yyerror (yymsgp);
6221 [ # # ]: 0 : if (yysyntax_error_status == 2)
6222 : 0 : goto yyexhaustedlab;
6223 : : }
6224 : : # undef YYSYNTAX_ERROR
6225 : : #endif
6226 : : }
6227 : :
6228 : :
6229 : :
6230 [ # # ]: 0 : if (yyerrstatus == 3)
6231 : : {
6232 : : /* If just tried and failed to reuse lookahead token after an
6233 : : error, discard it. */
6234 : :
6235 [ # # ]: 0 : if (yychar <= YYEOF)
6236 : : {
6237 : : /* Return failure if at end of input. */
6238 [ # # ]: 0 : if (yychar == YYEOF)
6239 : 0 : YYABORT;
6240 : : }
6241 : : else
6242 : : {
6243 : : yydestruct ("Error: discarding",
6244 [ # # ]: 0 : yytoken, &yylval);
6245 : 0 : yychar = YYEMPTY;
6246 : : }
6247 : : }
6248 : :
6249 : : /* Else will try to reuse lookahead token after shifting the error
6250 : : token. */
6251 : 0 : goto yyerrlab1;
6252 : :
6253 : :
6254 : : /*---------------------------------------------------.
6255 : : | yyerrorlab -- error raised explicitly by YYERROR. |
6256 : : `---------------------------------------------------*/
6257 : : yyerrorlab:
6258 : :
6259 : : /* Pacify compilers like GCC when the user code never invokes
6260 : : YYERROR and the label yyerrorlab therefore never appears in user
6261 : : code. */
6262 : : if (/*CONSTCOND*/ 0)
6263 : : goto yyerrorlab;
6264 : :
6265 : : /* Do not reclaim the symbols of the rule which action triggered
6266 : : this YYERROR. */
6267 : : YYPOPSTACK (yylen);
6268 : : yylen = 0;
6269 : : YY_STACK_PRINT (yyss, yyssp);
6270 : : yystate = *yyssp;
6271 : : goto yyerrlab1;
6272 : :
6273 : :
6274 : : /*-------------------------------------------------------------.
6275 : : | yyerrlab1 -- common code for both syntax error and YYERROR. |
6276 : : `-------------------------------------------------------------*/
6277 : : yyerrlab1:
6278 : 0 : yyerrstatus = 3; /* Each real token shifted decrements this. */
6279 : :
6280 : 0 : for (;;)
6281 : : {
6282 : 0 : yyn = yypact[yystate];
6283 [ # # ]: 0 : if (!yypact_value_is_default (yyn))
6284 : : {
6285 : 0 : yyn += YYTERROR;
6286 [ # # ][ # # ]: 0 : if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
[ # # ]
6287 : : {
6288 : 0 : yyn = yytable[yyn];
6289 [ # # ]: 0 : if (0 < yyn)
6290 : 0 : break;
6291 : : }
6292 : : }
6293 : :
6294 : : /* Pop the current state because it cannot handle the error token. */
6295 [ # # ]: 0 : if (yyssp == yyss)
6296 : 0 : YYABORT;
6297 : :
6298 : :
6299 : : yydestruct ("Error: popping",
6300 [ # # ]: 0 : yystos[yystate], yyvsp);
6301 : 0 : YYPOPSTACK (1);
6302 : 0 : yystate = *yyssp;
6303 [ # # ][ # # ]: 0 : YY_STACK_PRINT (yyss, yyssp);
6304 : : }
6305 : :
6306 : 0 : *++yyvsp = yylval;
6307 : :
6308 : :
6309 : : /* Shift the error token. */
6310 [ # # ][ # # ]: 0 : YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
[ # # ][ # # ]
6311 : :
6312 : 0 : yystate = yyn;
6313 : 0 : goto yynewstate;
6314 : :
6315 : :
6316 : : /*-------------------------------------.
6317 : : | yyacceptlab -- YYACCEPT comes here. |
6318 : : `-------------------------------------*/
6319 : : yyacceptlab:
6320 : 5978 : yyresult = 0;
6321 : 5978 : goto yyreturn;
6322 : :
6323 : : /*-----------------------------------.
6324 : : | yyabortlab -- YYABORT comes here. |
6325 : : `-----------------------------------*/
6326 : : yyabortlab:
6327 : 0 : yyresult = 1;
6328 : 0 : goto yyreturn;
6329 : :
6330 : : #if !defined(yyoverflow) || YYERROR_VERBOSE
6331 : : /*-------------------------------------------------.
6332 : : | yyexhaustedlab -- memory exhaustion comes here. |
6333 : : `-------------------------------------------------*/
6334 : : yyexhaustedlab:
6335 [ # # ]: 0 : yyerror (YY_("memory exhausted"));
6336 : 0 : yyresult = 2;
6337 : : /* Fall through. */
6338 : : #endif
6339 : :
6340 : : yyreturn:
6341 [ - + ]: 5978 : if (yychar != YYEMPTY)
6342 : : {
6343 : : /* Make sure we have latest lookahead translation. See comments at
6344 : : user semantic actions for why this is necessary. */
6345 [ # # ]: 0 : yytoken = YYTRANSLATE (yychar);
6346 : : yydestruct ("Cleanup: discarding lookahead",
6347 [ # # ]: 0 : yytoken, &yylval);
6348 : : }
6349 : : /* Do not reclaim the symbols of the rule which action triggered
6350 : : this YYABORT or YYACCEPT. */
6351 : 5978 : YYPOPSTACK (yylen);
6352 [ - + ][ # # ]: 5978 : YY_STACK_PRINT (yyss, yyssp);
6353 [ + + ]: 17934 : while (yyssp != yyss)
6354 : : {
6355 : : yydestruct ("Cleanup: popping",
6356 [ + - ]: 11956 : yystos[*yyssp], yyvsp);
6357 : 11956 : YYPOPSTACK (1);
6358 : : }
6359 : : #ifndef yyoverflow
6360 [ + + ]: 5978 : if (yyss != yyssa)
6361 : 9 : YYSTACK_FREE (yyss);
6362 : : #endif
6363 : : #if YYERROR_VERBOSE
6364 [ - + ]: 5978 : if (yymsg != yymsgbuf)
6365 : 0 : YYSTACK_FREE (yymsg);
6366 : : #endif
6367 : : /* Make sure YYID is used. */
6368 : 5978 : return YYID (yyresult);
6369 : : }
6370 : :
6371 : :
6372 : :
6373 : : /* Line 2067 of yacc.c */
6374 : : #line 3279 "/usr/local/src/libreoffice/idlc/source/parser.y"
6375 : :
6376 : :
6377 : : /*
6378 : : * Report an error situation discovered in a production
6379 : : */
6380 : : void yyerror(char const *errmsg)
6381 : : {
6382 : : idlc()->error()->syntaxError(idlc()->getParseState(), idlc()->getLineNumber(), errmsg);
6383 : : idlc()->setParseState(PS_NoState);
6384 : : }
6385 : :
|
